solver_interface.h

Go to the documentation of this file.

/******************************************************************************
 *
 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
 * All code distributed as part of El'Beem is covered by the version 2 of the 
 * GNU General Public License. See the file COPYING for details.
 * Copyright 2003-2006 Nils Thuerey
 *
 * Header for Combined 2D/3D Lattice Boltzmann Interface Class
 * 
 *****************************************************************************/
#ifndef LBMINTERFACE_H
#define LBMINTERFACE_H

#ifndef NOGUI
#define LBM_USE_GUI      1
#else
#define LBM_USE_GUI      0
#endif

#if LBM_USE_GUI==1
#define USE_GLUTILITIES
// for debug display
//#include <GL/gl.h>
#include "../gui/guifuncs.h"
#endif

#include <sstream>
#include "utilities.h"
#include "ntl_bsptree.h"
#include "ntl_geometryobject.h"
#include "parametrizer.h"
#include "attributes.h"
#include "isosurface.h"
class ParticleTracer;
class ParticleObject;

// use which fp-precision for LBM? 1=float, 2=double
#ifdef PRECISION_LBM_SINGLE
#define LBM_PRECISION 1
#else
#ifdef PRECISION_LBM_DOUBLE
#define LBM_PRECISION 2
#else
// default to floats
#define LBM_PRECISION 1
#endif
#endif

#if LBM_PRECISION==1
/* low precision for LBM solver */
typedef float LbmFloat;
typedef ntlVec3f LbmVec;
#define LBM_EPSILON (1e-5)
#else
/* standard precision for LBM solver */
typedef double LbmFloat;
typedef ntlVec3d LbmVec;
#define LBM_EPSILON (1e-10)
#endif

// long integer, needed e.g. for memory calculations
#ifndef USE_MSVC6FIXES
#define LONGINT long long int
#else
#define LONGINT _int64
#endif


// default to 3dim
#ifndef LBMDIM
#define LBMDIM 3
#endif // LBMDIM

#if LBMDIM==2
#define LBM_DFNUM 9
#else
#define LBM_DFNUM 19
#endif

// conversions (lbm and parametrizer)
template<class T> inline LbmVec     vec2L(T v) { return LbmVec(v[0],v[1],v[2]); }
template<class T> inline ParamVec   vec2P(T v) { return ParamVec(v[0],v[1],v[2]); }

template<class Scalar> class ntlMatrix4x4;


// bubble id type
typedef int BubbleId;

// basic cell type distinctions
#define CFUnused              (1<< 0)
#define CFEmpty               (1<< 1)
#define CFBnd                 (1<< 2)
#define CFMbndInflow          (1<< 3)
#define CFMbndOutflow         (1<< 4)
#define CFFluid               (1<< 5)
#define CFInter               (1<< 6)
// additional for fluid (needed separately for adaptive grids)
#define CFNoBndFluid          (1<< 7)
#define CFNoDelete            (1<< 8)

// additional bnd add flags
#define CFBndNoslip           (1<< 9)
#define CFBndFreeslip         (1<<10)
#define CFBndPartslip         (1<<11)
#define CFBndMoving           (1<<12)

// additional for fluid/interface
// force symmetry for flag reinit 
#define CFNoInterpolSrc       (1<<13) 
#define CFNoNbFluid           (1<<14)
#define CFNoNbEmpty           (1<<15)
    
// cell treated normally on coarser grids
#define CFGrNorm              (1<<16)
#define CFGrCoarseInited      (1<<17)

// (the following values shouldnt overlap to ensure
// proper coarsening)
// border cells to be interpolated from finer grid
#define CFGrFromFine          (1<<18)
// 32k aux border marker 
#define CFGrToFine            (1<<19)
// also needed on finest level
#define CFGrFromCoarse        (1<<20)
// additional refinement tags (coarse grids only?)
// */

// above 24 is used to encode in/outflow object type
#define CFPersistMask (0xFF000000 | CFMbndInflow | CFMbndOutflow)
#define CFNoPersistMask (~CFPersistMask)


// nk
#define CFInvalid             (CellFlagType)(1<<31)

// use 32bit flag types
//#ifdef __x86_64__
 //typedef int cfINT32;
//#else
 //typedef long cfINT32;
//#endif // defined (_IA64)  
//#define CellFlagType cfINT32
#define CellFlagType int
#define CellFlagTypeSize 4


// aux. field indices (same for 2d)
#define dFfrac 19
#define dMass 20
#define dFlux 21
// max. no. of cell values for 3d
#define dTotalNum 22


/*****************************************************************************/
/*  the template is only needed for 
 *  dimension dependend constants e.g. 
 *  number of df's in model */
class LbmCellContents {
    public:
        LbmFloat     df[ 27 ]; // be on the safe side here...
    LbmFloat     rho;
        LbmVec       vel;
    LbmFloat     mass;
        CellFlagType flag;
        BubbleId     bubble;
    LbmFloat     ffrac;
};

/* struct for the coordinates of a cell in the grid */
typedef struct {
  int x,y,z;
    int flag; // special handling?
} LbmPoint;

/* struct for the coordinates of a cell in the grid */
typedef struct {
    char active;            // bubble in use, oder may be overwritten?
  LbmFloat volume;          // volume of this bubble (0 vor atmosphere)
    LbmFloat mass;            // "mass" of bubble 
    int i,j,k;              // index of a cell in the bubble
} LbmBubble;




#define FLUIDDISPINVALID    0
#define FLUIDDISPNothing    1
#define FLUIDDISPCelltypes  2
#define FLUIDDISPVelocities 3
#define FLUIDDISPCellfills  4
#define FLUIDDISPDensity    5
#define FLUIDDISPGrid       6
#define FLUIDDISPSurface    7



/*****************************************************************************/
class CellIdentifierInterface {
    public:
        CellIdentifierInterface():mEnd(false) { };
        virtual ~CellIdentifierInterface() {};

        virtual string getAsString() = 0;

        virtual bool equal(CellIdentifierInterface* other) = 0;

        inline void setEnd(bool set){ mEnd = set;  }
        inline bool getEnd( )       { return mEnd; }

        bool mEnd;

};



/*****************************************************************************/
/*  has to provide iterating functionality */
class LbmSolverInterface 
{
    public:
        LbmSolverInterface();
        virtual ~LbmSolverInterface();
        virtual string getIdString() = 0;

        // multi step solver init
        virtual bool initializeSolverMemory() =0;
        virtual bool initializeSolverGrids() =0;
        virtual bool initializeSolverPostinit() =0;
        
        virtual void notifySolverOfDump(int dumptype, int frameNr,char *frameNrStr,string outfilename) = 0;

        CellFlagType readBoundaryFlagInt(string name, int defaultValue, string source,string target, bool needed);
        void parseStdAttrList();
        virtual void parseAttrList() = 0;

        virtual void step() = 0;
        virtual void prepareVisualization() { /* by default off */ };

        virtual int initParticles() = 0;
        virtual void advanceParticles() = 0;
        IsoSurface* getSurfaceGeoObj() { return mpIso; }

        virtual vector<ntlGeometryObject*> getDebugObjects() { vector<ntlGeometryObject*> empty(0); return empty; }

        /* surface generation settings */
        virtual void setSurfGenSettings(short value) = 0;

#if LBM_USE_GUI==1

        virtual void debugDisplay(int) = 0;
#endif

        void initGeoTree();
        void freeGeoTree();
        bool geoInitCheckPointInside(ntlVec3Gfx org, int flags, int &OId, gfxReal &distance,int shootDir=0);
        bool geoInitCheckPointInside(ntlVec3Gfx org, ntlVec3Gfx dir, int flags, int &OId, gfxReal &distance, 
                const gfxReal halfCellsize, bool &thinHit, bool recurse);
        void setRenderGlobals(ntlRenderGlobals *glob) { mpGlob = glob; };
        ntlVec3Gfx getGeoMaxMovementVelocity(LbmFloat simtime, LbmFloat stepsize);

        /* rt interface functions */
        unsigned int getIsoVertexCount()  { return mpIso->getIsoVertexCount(); }
        unsigned int getIsoIndexCount()   { return mpIso->getIsoIndexCount(); }
        char* getIsoVertexArray()         { return mpIso->getIsoVertexArray(); }
        unsigned int *getIsoIndexArray()  { return mpIso->getIsoIndexArray(); }
        void triangulateSurface()         { mpIso->triangulate(); }

        /* access functions */

        int getSizeX( void ) { return mSizex; }
        int getSizeY( void ) { return mSizey; }
        int getSizeZ( void ) { return mSizez; }
        void setSizeX( int ns ) { mSizex = ns; }
        void setSizeY( int ns ) { mSizey = ns; }
        void setSizeZ( int ns ) { mSizez = ns; }
        void setAllfluid(bool set) { mAllfluid=set; }
        bool getAllfluid()         { return mAllfluid; }

        void setAttrList(AttributeList *set) { mpSifAttrs = set; }
        inline AttributeList *getAttributeList() { return mpSifAttrs; }
        void setSwsAttrList(AttributeList *set) { mpSifSwsAttrs = set; }
        inline AttributeList *getSwsAttributeList() { return mpSifSwsAttrs; }

        inline void setParametrizer(Parametrizer *set) { mpParam = set; }
        inline Parametrizer *getParametrizer() { return mpParam; }
        inline void setParticleTracer(ParticleTracer *set) { mpParticles = set; }
        inline ParticleTracer *getParticleTracer() { return mpParticles; }

        inline void setInitDensityGradient(bool set) { mInitDensityGradient = set; }

        inline void setGeoStart(ntlVec3Gfx set) { mvGeoStart = set; }
        inline ntlVec3Gfx getGeoStart() const   { return mvGeoStart; }

        inline void setGeoEnd(ntlVec3Gfx set)   { mvGeoEnd = set; }
        inline ntlVec3Gfx getGeoEnd() const { return mvGeoEnd; }

        inline void setLbmInitId(int set)   { mLbmInitId = set; }
        inline int getLbmInitId() const { return mLbmInitId; }

        void initDomainTrafo(float *mat);
        inline ntlMatrix4x4<gfxReal> *getDomainTrafo() { return mpSimTrafo; }

        inline void setName(string set) { mName = set; }
        inline string getName() const   { return mName; }

        inline string getNodeInfoString() const { return mNodeInfoString; }

        inline bool getPanic() { return mPanic; }

        inline void setSilent(bool set){ mSilent = set; }

        inline void setSmoothing(float setss,float setns){ mSmoothSurface=setss; mSmoothNormals=setns; }
        inline void setIsoSubdivs(int s){ mIsoSubdivs=s; }
        inline void setPreviewSize(int set){ mOutputSurfacePreview = set; }
        inline void setRefinementDesired(int set){ mRefinementDesired = set; }

        inline void setDumpVelocities(bool set) { mDumpVelocities = set; }
        inline bool getDumpVelocities() const   { return mDumpVelocities; }

        inline void setGenerateParticles(LbmFloat set)  { mPartGenProb = set; }
        inline LbmFloat getGenerateParticles() const    { return mPartGenProb; }

        inline void setDomainBound(string set)  { mDomainBound = set; }
        inline string getDomainBound() const    { return mDomainBound; }
        inline void setDomainPartSlip(LbmFloat set) { mDomainPartSlipValue = set; }
        inline LbmFloat getDomainPartSlip() const   { return mDomainPartSlipValue; }
        inline void setFarFieldSize(LbmFloat set)   { mFarFieldSize = set; }
        inline LbmFloat getFarFieldSize() const { return mFarFieldSize; }
        inline void setCpStage(int set) { mCppfStage = set; }
        inline int getCpStage() const   { return mCppfStage; }
        inline void setDumpRawText(bool set)    { mDumpRawText = set; }
        inline bool getDumpRawText() const  { return mDumpRawText; }
        inline void setDumpRawBinary(bool set)  { mDumpRawBinary = set; }
        inline bool getDumpRawBinary() const    { return mDumpRawBinary; }
        inline void setDumpRawBinaryZip(bool set)   { mDumpRawBinaryZip = set; }
        inline bool getDumpRawBinaryZip() const { return mDumpRawBinaryZip; }
        inline void setDebugVelScale(LbmFloat set)  { mDebugVelScale = set; }
        inline LbmFloat getDebugVelScale() const    { return mDebugVelScale; }

        // cell iterator interface
        
        // cell id type
        typedef CellIdentifierInterface* CellIdentifier;

        virtual CellIdentifierInterface* getFirstCell( ) = 0;
        virtual void advanceCell( CellIdentifierInterface* ) = 0;
        virtual bool noEndCell( CellIdentifierInterface* ) = 0;
        virtual void deleteCellIterator( CellIdentifierInterface** ) = 0;

        virtual CellIdentifierInterface* getCellAt( ntlVec3Gfx pos ) = 0;

        virtual int        getCellSet      ( CellIdentifierInterface* ) = 0;
        virtual ntlVec3Gfx getCellOrigin   ( CellIdentifierInterface* ) = 0;
        virtual ntlVec3Gfx getCellSize     ( CellIdentifierInterface* ) = 0;
        virtual int        getCellLevel    ( CellIdentifierInterface* ) = 0;
        virtual LbmFloat   getCellDensity  ( CellIdentifierInterface*,int ) = 0;
        virtual LbmVec     getCellVelocity ( CellIdentifierInterface*,int ) = 0;
        virtual LbmFloat   getEquilDf      ( int ) = 0;
        virtual LbmFloat   getCellDf       ( CellIdentifierInterface* ,int set, int dir) = 0;
        virtual LbmFloat   getCellMass     ( CellIdentifierInterface* ,int set) = 0;
        virtual LbmFloat   getCellFill     ( CellIdentifierInterface* ,int set) = 0;
        virtual CellFlagType getCellFlag   ( CellIdentifierInterface* ,int set) = 0;

        virtual ntlVec3Gfx getVelocityAt(float x, float y, float z) = 0;

        // gui/output debugging functions
#if LBM_USE_GUI==1
        virtual void debugDisplayNode(int dispset, CellIdentifier cell ) = 0;
        virtual void lbmDebugDisplay(int dispset) = 0;
        virtual void lbmMarkedCellDisplay() = 0;
#endif // LBM_USE_GUI==1
        virtual void debugPrintNodeInfo(CellIdentifier cell, int forceSet=-1) = 0;

        // debugging cell marker functions

        void addCellToMarkedList( CellIdentifierInterface *cid );
        CellIdentifierInterface* markedGetFirstCell( );
        CellIdentifierInterface* markedAdvanceCell();
        void markedClearList();


    protected:

        bool mPanic;


        int mSizex, mSizey, mSizez;
        bool mAllfluid;


        int mStepCnt;

        LbmFloat mFixMass;

        // deprecated param vars
        LbmFloat mOmega;
        LbmVec mGravity;
        LbmFloat mSurfaceTension;


        /* boundary inits */
        CellFlagType mBoundaryEast, mBoundaryWest, 
          mBoundaryNorth, mBoundarySouth, 
          mBoundaryTop, mBoundaryBottom;

        int mInitDone;

        bool mInitDensityGradient;

        AttributeList *mpSifAttrs;
        AttributeList *mpSifSwsAttrs;

        Parametrizer *mpParam;
        ParticleTracer *mpParticles;

        int mNumParticlesLost;
        int mNumInvalidDfs;
        int mNumFilledCells, mNumEmptiedCells;
        int mNumUsedCells;
        LbmFloat mMLSUPS;
        LbmFloat mDebugVelScale;
        string mNodeInfoString;

        // geo init vars
        // TODO deprecate SimulationObject vars

        ntlVec3Gfx mvGeoStart, mvGeoEnd;
        ntlMatrix4x4<gfxReal> *mpSimTrafo;

        bool mAccurateGeoinit;

        string mName;

        IsoSurface *mpIso;
        LbmFloat mIsoValue;

        bool mSilent;

        int mLbmInitId;
        ntlTree *mpGiTree;
        vector<ntlGeometryObject*> *mpGiObjects;
        vector<int> mGiObjInside;
        vector<gfxReal> mGiObjDistance;
        vector<gfxReal> mGiObjSecondDist;
        ntlRenderGlobals *mpGlob;
        
        int mRefinementDesired;

        int mOutputSurfacePreview;
        LbmFloat mPreviewFactor;

        float mSmoothSurface;
        float mSmoothNormals;
        int mIsoSubdivs;

        LbmFloat mPartGenProb;

        bool mDumpVelocities;

        // list for marked cells
        vector<CellIdentifierInterface *> mMarkedCells;
        int mMarkedCellIndex;

        string mDomainBound;
        LbmFloat mDomainPartSlipValue;

        // size of far field area
        LbmFloat mFarFieldSize;
        // amount of drop mass to subtract
        LbmFloat mPartDropMassSub;
        // use physical drop model for particles?
        bool mPartUsePhysModel;

        // strength of applied force
        LbmFloat mTForceStrength;
        int mCppfStage;

        bool mDumpRawText;
        bool mDumpRawBinary;
        bool mDumpRawBinaryZip;
};


// helper function to create consistent grid resolutions
void initGridSizes(int &mSizex, int &mSizey, int &mSizez,
        ntlVec3Gfx &mvGeoStart, ntlVec3Gfx &mvGeoEnd, 
        int mMaxRefine, bool parallel);
// return the amount of memory required in total (reqret)
// and for the finest grid only (reqretFine, can be NULL)
void calculateMemreqEstimate(int resx,int resy,int resz, int refine,
        float farfieldsize, double *reqret, double *reqretFine, string *reqstr);

string convertCellFlagType2String( CellFlagType flag );
string convertSingleFlag2String(CellFlagType cflag);

#endif // LBMINTERFACE_H