Elbeem: fix memory leak and add guarded allocator directives
[blender.git] / intern / elbeem / intern / solver_interface.h
1 /** \file elbeem/intern/solver_interface.h
2  *  \ingroup elbeem
3  */
4 /******************************************************************************
5  *
6  * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
7  * All code distributed as part of El'Beem is covered by the version 2 of the 
8  * GNU General Public License. See the file COPYING for details.
9  * Copyright 2003-2006 Nils Thuerey
10  *
11  * Header for Combined 2D/3D Lattice Boltzmann Interface Class
12  * 
13  *****************************************************************************/
14 #ifndef LBMINTERFACE_H
15 #define LBMINTERFACE_H
16
17 //! include gui support?
18 #ifndef NOGUI
19 #define LBM_USE_GUI      1
20 #else
21 #define LBM_USE_GUI      0
22 #endif
23
24 #if LBM_USE_GUI==1
25 #define USE_GLUTILITIES
26 // for debug display
27 //#include <GL/gl.h>
28 #include "../gui/guifuncs.h"
29 #endif
30
31 #include <sstream>
32 #include "utilities.h"
33 #include "ntl_bsptree.h"
34 #include "ntl_geometryobject.h"
35 #include "parametrizer.h"
36 #include "attributes.h"
37 #include "isosurface.h"
38
39 #ifdef WITH_CXX_GUARDEDALLOC
40 #  include "MEM_guardedalloc.h"
41 #endif
42
43 class ParticleTracer;
44 class ParticleObject;
45
46 // use which fp-precision for LBM? 1=float, 2=double
47 #ifdef PRECISION_LBM_SINGLE
48 #define LBM_PRECISION 1
49 #else
50 #ifdef PRECISION_LBM_DOUBLE
51 #define LBM_PRECISION 2
52 #else
53 // default to floats
54 #define LBM_PRECISION 1
55 #endif
56 #endif
57
58 #if LBM_PRECISION==1
59 /* low precision for LBM solver */
60 typedef float LbmFloat;
61 typedef ntlVec3f LbmVec;
62 #define LBM_EPSILON (1e-5)
63 #else
64 /* standard precision for LBM solver */
65 typedef double LbmFloat;
66 typedef ntlVec3d LbmVec;
67 #define LBM_EPSILON (1e-10)
68 #endif
69
70 // long integer, needed e.g. for memory calculations
71 #ifndef USE_MSVC6FIXES
72 #define LONGINT long long int
73 #else
74 #define LONGINT _int64
75 #endif
76
77
78 // default to 3dim
79 #ifndef LBMDIM
80 #define LBMDIM 3
81 #endif // LBMDIM
82
83 #if LBMDIM==2
84 #define LBM_DFNUM 9
85 #else
86 #define LBM_DFNUM 19
87 #endif
88
89 // conversions (lbm and parametrizer)
90 template<class T> inline LbmVec     vec2L(T v) { return LbmVec(v[0],v[1],v[2]); }
91 template<class T> inline ParamVec   vec2P(T v) { return ParamVec(v[0],v[1],v[2]); }
92
93 template<class Scalar> class ntlMatrix4x4;
94
95
96 // bubble id type
97 typedef int BubbleId;
98
99 // basic cell type distinctions
100 #define CFUnused              (1<< 0)
101 #define CFEmpty               (1<< 1)
102 #define CFBnd                 (1<< 2)
103 #define CFMbndInflow          (1<< 3)
104 #define CFMbndOutflow         (1<< 4)
105 #define CFFluid               (1<< 5)
106 #define CFInter               (1<< 6)
107 // additional for fluid (needed separately for adaptive grids)
108 #define CFNoBndFluid          (1<< 7)
109 #define CFNoDelete            (1<< 8)
110
111 // additional bnd add flags
112 #define CFBndNoslip           (1<< 9)
113 #define CFBndFreeslip         (1<<10)
114 #define CFBndPartslip         (1<<11)
115 #define CFBndMoving           (1<<12)
116
117 // additional for fluid/interface
118 // force symmetry for flag reinit 
119 #define CFNoInterpolSrc       (1<<13) 
120 #define CFNoNbFluid           (1<<14)
121 #define CFNoNbEmpty           (1<<15)
122         
123 // cell treated normally on coarser grids
124 #define CFGrNorm              (1<<16)
125 #define CFGrCoarseInited      (1<<17)
126
127 // (the following values shouldnt overlap to ensure
128 // proper coarsening)
129 // border cells to be interpolated from finer grid
130 #define CFGrFromFine          (1<<18)
131 // 32k aux border marker 
132 #define CFGrToFine            (1<<19)
133 // also needed on finest level
134 #define CFGrFromCoarse        (1<<20)
135 // additional refinement tags (coarse grids only?)
136 // */
137
138 // above 24 is used to encode in/outflow object type
139 #define CFPersistMask (0xFF000000 | CFMbndInflow | CFMbndOutflow)
140 #define CFNoPersistMask (~CFPersistMask)
141
142
143 // nk
144 #define CFInvalid             (CellFlagType)(1<<31)
145
146 // use 32bit flag types
147 //#ifdef __x86_64__
148  //typedef int cfINT32;
149 //#else
150  //typedef long cfINT32;
151 //#endif // defined (_IA64)  
152 //#define CellFlagType cfINT32
153 #define CellFlagType int
154 #define CellFlagTypeSize 4
155
156
157 // aux. field indices (same for 2d)
158 #define dFfrac 19
159 #define dMass 20
160 #define dFlux 21
161 // max. no. of cell values for 3d
162 #define dTotalNum 22
163
164
165 /*****************************************************************************/
166 /*! a single lbm cell */
167 /*  the template is only needed for 
168  *  dimension dependend constants e.g. 
169  *  number of df's in model */
170 class LbmCellContents {
171         public:
172                 LbmFloat     df[ 27 ]; // be on the safe side here...
173         LbmFloat     rho;
174                 LbmVec       vel;
175         LbmFloat     mass;
176                 CellFlagType flag;
177                 BubbleId     bubble;
178         LbmFloat     ffrac;
179
180 private:
181 #ifdef WITH_CXX_GUARDEDALLOC
182         MEM_CXX_CLASS_ALLOC_FUNCS("ELBEEM:LbmCellContents")
183 #endif
184 };
185
186 /* struct for the coordinates of a cell in the grid */
187 typedef struct {
188   int x,y,z;
189         int flag; // special handling?
190 } LbmPoint;
191
192 /* struct for the coordinates of a cell in the grid */
193 typedef struct {
194         char active;            // bubble in use, oder may be overwritten?
195   LbmFloat volume;          // volume of this bubble (0 vor atmosphere)
196         LbmFloat mass;            // "mass" of bubble 
197         int i,j,k;              // index of a cell in the bubble
198 } LbmBubble;
199
200
201
202
203 //! choose which data to display
204 #define FLUIDDISPINVALID    0
205 #define FLUIDDISPNothing    1
206 #define FLUIDDISPCelltypes  2
207 #define FLUIDDISPVelocities 3
208 #define FLUIDDISPCellfills  4
209 #define FLUIDDISPDensity    5
210 #define FLUIDDISPGrid       6
211 #define FLUIDDISPSurface    7
212
213
214
215 /*****************************************************************************/
216 //! cell identifier interface
217 class CellIdentifierInterface {
218         public:
219                 //! reset constructor
220                 CellIdentifierInterface():mEnd(false) { };
221                 //! virtual destructor
222                 virtual ~CellIdentifierInterface() {};
223
224                 //! return node as string (with some basic info)
225                 virtual string getAsString() = 0;
226
227                 //! compare cids
228                 virtual bool equal(CellIdentifierInterface* other) = 0;
229
230                 //! set/get end flag for grid traversal (not needed for marked cells)
231                 inline void setEnd(bool set){ mEnd = set;  }
232                 inline bool getEnd( )       { return mEnd; }
233
234                 //! has the grid been traversed?
235                 bool mEnd;
236
237 private:
238 #ifdef WITH_CXX_GUARDEDALLOC
239         MEM_CXX_CLASS_ALLOC_FUNCS("ELBEEM:CellIdentifierInterface")
240 #endif
241 };
242
243
244
245 /*****************************************************************************/
246 /*! class defining abstract function interface */
247 /*  has to provide iterating functionality */
248 class LbmSolverInterface 
249 {
250         public:
251                 //! Constructor 
252                 LbmSolverInterface();
253                 //! Destructor 
254                 virtual ~LbmSolverInterface();
255                 //! id string of solver
256                 virtual string getIdString() = 0;
257
258                 // multi step solver init
259                 /*! finish the init with config file values (allocate arrays...) */
260                 virtual bool initializeSolverMemory() =0;
261                 /*! init solver arrays */
262                 virtual bool initializeSolverGrids() =0;
263                 /*! prepare actual simulation start, setup viz etc */
264                 virtual bool initializeSolverPostinit() =0;
265                 
266                 /*! notify object that dump is in progress (e.g. for field dump) */
267                 virtual void notifySolverOfDump(int dumptype, int frameNr,char *frameNrStr,string outfilename) = 0;
268
269                 /*! parse a boundary flag string */
270                 CellFlagType readBoundaryFlagInt(string name, int defaultValue, string source,string target, bool needed);
271                 /*! parse standard attributes */
272                 void parseStdAttrList();
273                 /*! initilize variables fom attribute list (should at least call std parse) */
274                 virtual void parseAttrList() = 0;
275
276                 virtual void step() = 0;
277                 virtual void prepareVisualization() { /* by default off */ };
278
279                 /*! particle handling */
280                 virtual int initParticles() = 0;
281                 virtual void advanceParticles() = 0;
282                 /*! get surface object (NULL if no surface) */
283                 IsoSurface* getSurfaceGeoObj() { return mpIso; }
284
285                 /*! debug object display */
286                 virtual vector<ntlGeometryObject*> getDebugObjects() { vector<ntlGeometryObject*> empty(0); return empty; }
287
288                 /* surface generation settings */
289                 virtual void setSurfGenSettings(short value) = 0;
290
291 #if LBM_USE_GUI==1
292                 /*! show simulation info */
293                 virtual void debugDisplay(int) = 0;
294 #endif
295
296                 /*! init tree for certain geometry init */
297                 void initGeoTree();
298                 /*! destroy tree etc. when geometry init done */
299                 void freeGeoTree();
300                 /*! check for a certain flag type at position org (needed for e.g. quadtree refinement) */
301                 bool geoInitCheckPointInside(ntlVec3Gfx org, int flags, int &OId, gfxReal &distance,int shootDir=0);
302                 bool geoInitCheckPointInside(ntlVec3Gfx org, ntlVec3Gfx dir, int flags, int &OId, gfxReal &distance, 
303                                 const gfxReal halfCellsize, bool &thinHit, bool recurse);
304                 /*! set render globals, for scene/tree access */
305                 void setRenderGlobals(ntlRenderGlobals *glob) { mpGlob = glob; };
306                 /*! get max. velocity of all objects to initialize as fluid regions, and of all moving objects */
307                 ntlVec3Gfx getGeoMaxMovementVelocity(LbmFloat simtime, LbmFloat stepsize);
308
309                 /* rt interface functions */
310                 unsigned int getIsoVertexCount()  { return mpIso->getIsoVertexCount(); }
311                 unsigned int getIsoIndexCount()   { return mpIso->getIsoIndexCount(); }
312                 char* getIsoVertexArray()         { return mpIso->getIsoVertexArray(); }
313                 unsigned int *getIsoIndexArray()  { return mpIso->getIsoIndexArray(); }
314                 void triangulateSurface()         { mpIso->triangulate(); }
315
316                 /* access functions */
317
318                 /*! return grid sizes */
319                 int getSizeX( void ) { return mSizex; }
320                 int getSizeY( void ) { return mSizey; }
321                 int getSizeZ( void ) { return mSizez; }
322                 /*! return grid sizes */
323                 void setSizeX( int ns ) { mSizex = ns; }
324                 void setSizeY( int ns ) { mSizey = ns; }
325                 void setSizeZ( int ns ) { mSizez = ns; }
326                 /*! access fluid only simulation flag */
327                 void setAllfluid(bool set) { mAllfluid=set; }
328                 bool getAllfluid()         { return mAllfluid; }
329
330                 /*! set attr list pointer */
331                 void setAttrList(AttributeList *set) { mpSifAttrs = set; }
332                 /*! Returns the attribute list pointer */
333                 inline AttributeList *getAttributeList() { return mpSifAttrs; }
334                 /*! set sws attr list pointer */
335                 void setSwsAttrList(AttributeList *set) { mpSifSwsAttrs = set; }
336                 inline AttributeList *getSwsAttributeList() { return mpSifSwsAttrs; }
337
338                 /*! set parametrizer pointer */
339                 inline void setParametrizer(Parametrizer *set) { mpParam = set; }
340                 /*! get parametrizer pointer */
341                 inline Parametrizer *getParametrizer() { return mpParam; }
342                 /*! get/set particle pointer */
343                 inline void setParticleTracer(ParticleTracer *set) { mpParticles = set; }
344                 inline ParticleTracer *getParticleTracer() { return mpParticles; }
345
346                 /*! set density gradient init from e.g. init test cases */
347                 inline void setInitDensityGradient(bool set) { mInitDensityGradient = set; }
348
349                 /*! access geometry start vector */
350                 inline void setGeoStart(ntlVec3Gfx set) { mvGeoStart = set; }
351                 inline ntlVec3Gfx getGeoStart() const   { return mvGeoStart; }
352
353                 /*! access geometry end vector */
354                 inline void setGeoEnd(ntlVec3Gfx set)   { mvGeoEnd = set; }
355                 inline ntlVec3Gfx getGeoEnd() const     { return mvGeoEnd; }
356
357                 /*! access geo init vars */
358                 inline void setLbmInitId(int set)       { mLbmInitId = set; }
359                 inline int getLbmInitId() const { return mLbmInitId; }
360
361                 /*! init domain transformation matrix from float array */
362                 void initDomainTrafo(float *mat);
363                 /*! get domain transformation matrix to have object centered fluid vertices */
364                 inline ntlMatrix4x4<gfxReal> *getDomainTrafo() { return mpSimTrafo; }
365
366                 /*! access name string */
367                 inline void setName(string set) { mName = set; }
368                 inline string getName() const   { return mName; }
369
370                 /*! access string for node info debugging output */
371                 inline string getNodeInfoString() const { return mNodeInfoString; }
372
373                 /*! get panic flag */
374                 inline bool getPanic() { return mPanic; }
375
376                 //! set silent mode?
377                 inline void setSilent(bool set){ mSilent = set; }
378
379                 //! set amount of surface/normal smoothing
380                 inline void setSmoothing(float setss,float setns){ mSmoothSurface=setss; mSmoothNormals=setns; }
381                 //! set amount of iso subdivisions
382                 inline void setIsoSubdivs(int s){ mIsoSubdivs=s; }
383                 //! set desired refinement
384                 inline void setPreviewSize(int set){ mOutputSurfacePreview = set; }
385                 //! set desired refinement
386                 inline void setRefinementDesired(int set){ mRefinementDesired = set; }
387
388                 //! set/get dump velocities flag
389                 inline void setDumpVelocities(bool set) { mDumpVelocities = set; }
390                 inline bool getDumpVelocities() const   { return mDumpVelocities; }
391
392                 //! set/get particle generation prob.
393                 inline void setGenerateParticles(LbmFloat set)  { mPartGenProb = set; }
394                 inline LbmFloat getGenerateParticles() const    { return mPartGenProb; }
395
396                 //! set/get dump velocities flag
397                 inline void setDomainBound(string set)  { mDomainBound = set; }
398                 inline string getDomainBound() const    { return mDomainBound; }
399                 //! set/get dump velocities flag
400                 inline void setDomainPartSlip(LbmFloat set)     { mDomainPartSlipValue = set; }
401                 inline LbmFloat getDomainPartSlip() const       { return mDomainPartSlipValue; }
402                 //! set/get far field size
403                 inline void setFarFieldSize(LbmFloat set)       { mFarFieldSize = set; }
404                 inline LbmFloat getFarFieldSize() const { return mFarFieldSize; }
405                 //! set/get cp stage
406                 inline void setCpStage(int set) { mCppfStage = set; }
407                 inline int getCpStage() const   { return mCppfStage; }
408                 //! set/get dump modes
409                 inline void setDumpRawText(bool set)    { mDumpRawText = set; }
410                 inline bool getDumpRawText() const      { return mDumpRawText; }
411                 inline void setDumpRawBinary(bool set)  { mDumpRawBinary = set; }
412                 inline bool getDumpRawBinary() const    { return mDumpRawBinary; }
413                 inline void setDumpRawBinaryZip(bool set)       { mDumpRawBinaryZip = set; }
414                 inline bool getDumpRawBinaryZip() const { return mDumpRawBinaryZip; }
415                 //! set/get debug vel scale
416                 inline void setDebugVelScale(LbmFloat set)      { mDebugVelScale = set; }
417                 inline LbmFloat getDebugVelScale() const        { return mDebugVelScale; }
418
419                 // cell iterator interface
420                 
421                 // cell id type
422                 typedef CellIdentifierInterface* CellIdentifier;
423
424                 //! cell iteration methods
425                 virtual CellIdentifierInterface* getFirstCell( ) = 0;
426                 virtual void advanceCell( CellIdentifierInterface* ) = 0;
427                 virtual bool noEndCell( CellIdentifierInterface* ) = 0;
428                 //! clean up iteration, this should be called, when the iteration is not completely finished
429                 virtual void deleteCellIterator( CellIdentifierInterface** ) = 0;
430
431                 //! find cell at a given position (returns NULL if not in domain)
432                 virtual CellIdentifierInterface* getCellAt( ntlVec3Gfx pos ) = 0;
433
434                 //! return node information
435                 virtual int        getCellSet      ( CellIdentifierInterface* ) = 0;
436                 virtual ntlVec3Gfx getCellOrigin   ( CellIdentifierInterface* ) = 0;
437                 virtual ntlVec3Gfx getCellSize     ( CellIdentifierInterface* ) = 0;
438                 virtual int        getCellLevel    ( CellIdentifierInterface* ) = 0;
439                 virtual LbmFloat   getCellDensity  ( CellIdentifierInterface*,int ) = 0;
440                 virtual LbmVec     getCellVelocity ( CellIdentifierInterface*,int ) = 0;
441                 /*! get equilibrium distribution functions */
442                 virtual LbmFloat   getEquilDf      ( int ) = 0;
443                 /*! redundant cell functions */
444                 virtual LbmFloat   getCellDf       ( CellIdentifierInterface* ,int set, int dir) = 0;
445                 virtual LbmFloat   getCellMass     ( CellIdentifierInterface* ,int set) = 0;
446                 virtual LbmFloat   getCellFill     ( CellIdentifierInterface* ,int set) = 0;
447                 virtual CellFlagType getCellFlag   ( CellIdentifierInterface* ,int set) = 0;
448
449                 /*! get velocity directly from position */
450                 virtual ntlVec3Gfx getVelocityAt(float x, float y, float z) = 0;
451
452                 // gui/output debugging functions
453 #if LBM_USE_GUI==1
454                 virtual void debugDisplayNode(int dispset, CellIdentifier cell ) = 0;
455                 virtual void lbmDebugDisplay(int dispset) = 0;
456                 virtual void lbmMarkedCellDisplay() = 0;
457 #endif // LBM_USE_GUI==1
458                 virtual void debugPrintNodeInfo(CellIdentifier cell, int forceSet=-1) = 0;
459
460                 // debugging cell marker functions
461
462                 //! add cell to mMarkedCells list
463                 void addCellToMarkedList( CellIdentifierInterface *cid );
464                 //! marked cell iteration methods
465                 CellIdentifierInterface* markedGetFirstCell( );
466                 CellIdentifierInterface* markedAdvanceCell();
467                 void markedClearList();
468
469 #if PARALLEL==1
470                 void setNumOMPThreads(int num_threads);
471 #endif  // PARALLEL==1
472         protected:
473
474                 /*! abort simulation on error... */
475                 bool mPanic;
476
477
478                 /*! Size of the array in x,y,z direction */
479                 int mSizex, mSizey, mSizez;
480                 /*! only fluid in sim? */
481                 bool mAllfluid;
482
483
484                 /*! step counter */
485                 int mStepCnt;
486
487                 /*! mass change from one step to the next, for extreme cases fix globally */
488                 LbmFloat mFixMass;
489
490                 // deprecated param vars
491                 /*! omega for lbm */
492                 LbmFloat mOmega;
493                 /*! gravity strength in neg. z direction */
494                 LbmVec mGravity;
495                 /*! Surface tension of the fluid */
496                 LbmFloat mSurfaceTension;
497
498
499                 /* boundary inits */
500                 CellFlagType mBoundaryEast, mBoundaryWest, 
501                   mBoundaryNorth, mBoundarySouth, 
502                   mBoundaryTop, mBoundaryBottom;
503
504                 /*! initialization from config file done? */
505                 int mInitDone;
506
507                 /*! init density gradient? */
508                 bool mInitDensityGradient;
509
510                 /*! pointer to the attribute list, only pointer to obj attrs */
511                 AttributeList *mpSifAttrs;
512                 AttributeList *mpSifSwsAttrs;
513
514                 /*! get parameters from this parametrize in finishInit */
515                 Parametrizer *mpParam;
516                 //! store particle tracer
517                 ParticleTracer *mpParticles;
518
519                 /*! number of particles lost so far */
520                 int mNumParticlesLost;
521                 /*! number of particles lost so far */
522                 int mNumInvalidDfs;
523                 /*! no of filled/emptied cells per time step */
524                 int mNumFilledCells, mNumEmptiedCells;
525                 /*! counter number of used cells for performance */
526                 int mNumUsedCells;
527                 /*! MLSUPS counter */
528                 LbmFloat mMLSUPS;
529                 /*! debug - velocity output scaling factor */
530                 LbmFloat mDebugVelScale;
531                 /*! string for node info debugging output */
532                 string mNodeInfoString;
533
534                 // geo init vars
535                 // TODO deprecate SimulationObject vars
536
537                 /*! for display - start and end vectors for geometry */
538                 ntlVec3Gfx mvGeoStart, mvGeoEnd;
539                 //! domain vertex trafos
540                 ntlMatrix4x4<gfxReal> *mpSimTrafo;
541
542                 /*! perform accurate geometry init? */
543                 bool mAccurateGeoinit;
544
545                 /*! name of this lbm object (for debug output) */
546                 string mName;
547
548                 //! Mcubes object for surface reconstruction 
549                 IsoSurface *mpIso;
550                 /*! isolevel value for marching cubes surface reconstruction */
551                 LbmFloat mIsoValue;
552
553                 //! debug output?
554                 bool mSilent;
555
556                 /*! geometry init id, passed from ntl_geomclass */
557                 int mLbmInitId;
558                 /*! tree object for geomerty initialization */
559                 ntlTree *mpGiTree;
560                 /*! object vector for geo init */
561                 vector<ntlGeometryObject*> *mpGiObjects;
562                 /*! inside which objects? */
563                 vector<int> mGiObjInside;
564                 /*! inside which objects? */
565                 vector<gfxReal> mGiObjDistance;
566                 vector<gfxReal> mGiObjSecondDist;
567                 /*! remember globals */
568                 ntlRenderGlobals *mpGlob;
569                 
570                 //! use refinement/coarsening?
571                 int mRefinementDesired;
572
573                 //! output surface preview? if >0 yes, and use as reduzed size 
574                 int mOutputSurfacePreview;
575                 LbmFloat mPreviewFactor;
576
577                 /*! enable surface and normals smoothing? */
578                 float mSmoothSurface;
579                 float mSmoothNormals;
580                 /*! isosurface subdivisions */
581                 int mIsoSubdivs;
582
583                 //! particle generation probability
584                 LbmFloat mPartGenProb;
585
586                 //! dump velocities?
587                 bool mDumpVelocities;
588
589                 // list for marked cells
590                 vector<CellIdentifierInterface *> mMarkedCells;
591                 int mMarkedCellIndex;
592
593                 //! domain boundary free/no slip type
594                 string mDomainBound;
595                 //! part slip value for domain
596                 LbmFloat mDomainPartSlipValue;
597
598                 // size of far field area
599                 LbmFloat mFarFieldSize;
600                 // amount of drop mass to subtract
601                 LbmFloat mPartDropMassSub;
602                 // use physical drop model for particles?
603                 bool mPartUsePhysModel;
604
605                 //! test vars
606                 // strength of applied force
607                 LbmFloat mTForceStrength;
608                 int mCppfStage;
609
610                 //! dumping modes
611                 bool mDumpRawText;
612                 bool mDumpRawBinary;
613                 bool mDumpRawBinaryZip;
614
615 #if PARALLEL==1
616                 int mNumOMPThreads;
617 #endif  // PARALLEL==1
618
619 private:
620 #ifdef WITH_CXX_GUARDEDALLOC
621         MEM_CXX_CLASS_ALLOC_FUNCS("ELBEEM:LbmSolverInterface")
622 #endif
623 };
624
625
626 // helper function to create consistent grid resolutions
627 void initGridSizes(int &mSizex, int &mSizey, int &mSizez,
628                 ntlVec3Gfx &mvGeoStart, ntlVec3Gfx &mvGeoEnd, 
629                 int mMaxRefine, bool parallel);
630 // return the amount of memory required in total (reqret)
631 // and for the finest grid only (reqretFine, can be NULL)
632 void calculateMemreqEstimate(int resx,int resy,int resz, int refine,
633                 float farfieldsize, double *reqret, double *reqretFine, string *reqstr);
634
635 //! helper function to convert flag to string (for debuggin)
636 string convertCellFlagType2String( CellFlagType flag );
637 string convertSingleFlag2String(CellFlagType cflag);
638
639 #endif // LBMINTERFACE_H