initializer.h

Go to the documentation of this file.

#ifndef __INITIALIZER_H__
#define __INITIALIZER_H__

#include <cstddef>
#include <fstream>
#include <vector>

class EOS;
class Geometry;
class State;


class BoundingBox {
public:
    BoundingBox(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax): 
        m_fXmin(xmin), m_fXmax(xmax), m_fYmin(ymin), m_fYmax(ymax), m_fZmin(zmin), m_fZmax(zmax),
        m_iStartIndex(0), m_iNumber(0) {}
    
    double getXmin() {return m_fXmin;}
    
    double getXmax() {return m_fXmax;}
    
    double getYmin() {return m_fYmin;}
    
    double getYmax() {return m_fYmax;}
    
    double getZmin() {return m_fZmin;}
    
    double getZmax() {return m_fZmax;}
    
    size_t getStartIndex() {return m_iStartIndex;}
    
    size_t getNumber() {return m_iNumber;}
    
    
    void setXmin(double xmin) {m_fXmin=xmin;}
    
    void setXmax(double xmax) {m_fXmax=xmax;}
    
    void setYmin(double ymin) {m_fYmin=ymin;}
    
    void setYmax(double ymax) {m_fYmax=ymax;}
    
    void setZmin(double zmin) {m_fZmin=zmin;}
    
    void setZmax(double zmax) {m_fZmax=zmax;}
    
    void setStartIndex(size_t index) {m_iStartIndex=index;}
    
    void setNumber(size_t num) {m_iNumber=num;}
private:
    double m_fXmin, m_fXmax, m_fYmin, m_fYmax, m_fZmin, m_fZmax;
    size_t m_iStartIndex;
    size_t m_iNumber;
};










class Initializer {
public:
    Initializer(const std::string& inputfileName, const std::string& debugfileName="debug", bool ifDebug=false);    
    ~Initializer();
    
    bool getIfDebug() const {return m_iIfDebug;}
    
    std::string getDebugfileName() const {return m_sDebugfileName;}

    int getNumThreads() const {return m_iNumThreads;}
    
    double getStartTime() const {return m_fStartTime;}
    
    double getEndTime() const {return m_fEndTime;}
    
    double getWriteTimeInterval() const {return m_fWriteTimeInterval;}
    
    double getCFLCoeff() const {return m_fCFLCoeff;}
    
    int getDimension() const {return m_iDimension;} 
    
    bool getRandomDirSplitOrder() const {return m_iRandomDirSplitOrder;}
    
    int getLPFOrder() const {return m_iLPFOrder;}   
    
    int getEOSChoice() const {return m_iEOSChoice;} //TODO
    
    double getInitParticleSpacing() const {return m_fInitParticleSpacing;}
    
    double getGravity() const {return m_fGravity;}
    
    bool getMovingBoxForGhostParticle() const {return m_iMovingBoxForGhostParticle;}
    
    bool getUseLimiter() const {return m_iUseLimiter;}
    
    double getThresholdP() const {return m_fThresholdP;}


    std::size_t getMaxNeighbourNum() const {return m_iMaxNeighbourNum;}
    
    std::size_t getMaxNeighbourNumInOneDir() const {return m_iMaxNeighbourNumInOneDir;}
    
    std::size_t getNumRow2ndOrder() const {return m_iNumRow2ndOrder;}
    
    std::size_t getNumRow1stOrder() const {return m_iNumRow1stOrder;}
    
    std::size_t getNumCol2ndOrder() const {return m_iNumCol2ndOrder;}
    
    std::size_t getNumCol1stOrder() const {return m_iNumCol1stOrder;}
    
    double getNeiSearchRadius() const {return m_fNeiSearchRadius;}
    
    double getInvalidPressure() const {return m_fInvalidPressure;}
    
    double getInvalidVolume() const {return m_fInvalidVolume;}
    
    int getTreeDepth() const {return m_iTreeDepth;}
    
    double getContactLength() const {return m_fContactLength;}
    
    std::size_t getCapacity() const {return m_iCapacity;}
    
    std::size_t getFluidNum() const {return m_iFluidNum;}
    
    std::size_t getBoundaryNum() const {return m_iBoundaryNum;}
    
    std::size_t getFluidStartIndex() const {return m_iFluidStartIndex;}
    
    std::size_t getBoundaryStartIndex() const {return m_iBoundaryStartIndex;}
    
    std::size_t getGhostStartIndex() const {return m_iGhostStartIndex;}
    
    std::size_t getNumParticleWithinSearchRadius() const {return m_iNumParticleWithinSearchRadius;} 


    double* getPositionX() const {return m_vPositionX;}
    
    double* getPositionY() const {return m_vPositionY;}
    
    double* getPositionZ() const {return m_vPositionZ;}
    
    double* getVelocityU() const {return m_vVelocityU;}
    
    double* getVelocityV() const {return m_vVelocityV;}
    
    double* getVelocityW() const {return m_vVelocityW;}
    
    double* getVolume() const {return m_vVolume;}
    
    double* getPressure() const {return m_vPressure;}
    
    double* getSoundSpeed() const {return m_vSoundSpeed;}
    
    int* getObjectTag() const {return m_vObjectTag;} 
    
    EOS* getEOS() const {return m_pEOS;}
    
    const std::vector<BoundingBox*>& getFluidBoundingBox() const {return m_vFluidBoundingBox;}  
    
    const std::vector<std::string>& getBoundaryObjTypes() const {return m_vBoundaryObjTypes;}
private:
    
    //--------------------------Data from arg list--------------------------------
    const std::string m_sDebugfileName; 
    bool m_iIfDebug; 

    //----------------------------------------------------------------------------

    //--------------------------Data from the inputfile---------------------------  
    
    int m_iNumThreads;
    double m_fStartTime;
    double m_fEndTime; 
    double m_fWriteTimeInterval;
    double m_fCFLCoeff;
    int m_iDimension;
    int m_iFluidObjNum;
    int m_iBoundaryObjNum;
    bool m_iRandomDirSplitOrder;
    int m_iLPFOrder;
    int m_iEOSChoice;
    double m_fGamma;
    double m_fPinf;
    double m_fEinf;
    double m_fInitParticleSpacing;
    double m_fGravity;
    bool m_iMovingBoxForGhostParticle;
    bool m_iUseLimiter;
    double m_fThresholdP;
    //-----------------------------------------------------------------------------

    
    //-------------Predetermined parameters specified in this class----------------
    
    std::size_t m_iMaxNeighbourNum;
    std::size_t m_iMaxNeighbourNumInOneDir;
    std::size_t m_iNumRow2ndOrder;
    std::size_t m_iNumRow1stOrder;
    std::size_t m_iNumCol2ndOrder;//TODO///< the number of columns of A when solving 2nd order LPF  
    std::size_t  m_iNumCol1stOrder;//TODO///< the number of columns of A when solving 1st order LPF
    double m_fNeiSearchRadius;
    double m_fInvalidPressure;
    double m_fInvalidVolume;
    int m_iTreeDepth;
    double m_fContactLength;
    
    // ----------------------------------------------------------------------------

    
    //------Parameters computed by the input parameters after initialization------- 
    
    std::size_t m_iCapacity;
    std::size_t m_iFluidNum;
    std::size_t m_iBoundaryNum;
    //std::size_t m_iGhostNum; ///< NUmber of ghost particles
    //std::size_t m_iTotalNum;///< Number of all particles
    std::size_t m_iFluidStartIndex;
    std::size_t m_iBoundaryStartIndex;
    std::size_t m_iGhostStartIndex;
    std::vector<BoundingBox*> m_vFluidBoundingBox;
    std::vector<Geometry*> m_vFluidObj;
    std::vector<BoundingBox*> m_vBoundaryBoundingBox;
    std::vector<Geometry*> m_vBoundaryObj;
    std::vector<State*> m_vFluidObjState;
    std::vector<std::string> m_vFluidObjNames; 
    std::vector<std::string> m_vFluidObjStateNames; 
    std::vector<std::string> m_vBoundaryObjNames; 
    std::vector<std::string> m_vBoundaryObjTypes; 

    size_t m_iNumParticleWithinSearchRadius;

    //----------------------------------------------------------------------------
    
    //----------------------------Array data--------------------------------------
    
    double* m_vPositionX;
    double* m_vPositionY;
    double* m_vPositionZ;
    double* m_vVelocityU;
    double* m_vVelocityV;
    double* m_vVelocityW;
    double* m_vVolume;
    double* m_vPressure;
    double* m_vSoundSpeed;
    //double* m_vEnergy;///< energy
    int* m_vObjectTag;
    
    //-----------------------------------------------------------------------------
    
    EOS* m_pEOS;
    std::ofstream debug;

private:
    //--------------------------------Methods--------------------------------------
    
    void initParticleDataMemory(); 
    
    void setParams(); 
    
    void computeInitBoundingBox();
    
    void initGeometryAndState();        
    
    size_t initGeometryAndState1D(bool saveData);

    size_t initGeometryAndStateOnHexPacking(bool saveData, const std::string& kind);
    
    void computeNumParticleWithinSearchRadius();
    
    void setBoundingBoxStartIndex();
    
    void setObjectTag();
};






#endif // __INITIALIZER_H__