Elbeem: fix memory leak and add guarded allocator directives
[blender.git] / intern / elbeem / intern / parametrizer.h
1 /** \file elbeem/intern/parametrizer.h
2  *  \ingroup elbeem
3  */
4 /******************************************************************************
5  *
6  * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
7  * Copyright 2003-2006 Nils Thuerey
8  *
9  * Parameter calculator for the LBM Solver class
10  *
11  *****************************************************************************/
12 #ifndef MFFSLBM_PARAMETRIZER
13 #define MFFSLBM_PARAMETRIZER  
14
15
16 /* LBM Files */
17 #include "utilities.h"
18 #include "attributes.h"
19
20 #ifdef WITH_CXX_GUARDEDALLOC
21 #  include "MEM_guardedalloc.h"
22 #endif
23
24 /* parametrizer accuracy */
25 typedef double ParamFloat;
26 typedef ntlVec3d ParamVec;
27
28 /*! flags to check which values are known */
29 #define PARAM_RELAXTIME  (1<< 0)
30 #define PARAM_REYNOLDS   (1<< 1)
31 #define PARAM_VISCOSITY  (1<< 2)
32 #define PARAM_SOUNDSPEED (1<< 3)
33 #define PARAM_DOMAINSIZE (1<< 4)
34 #define PARAM_GRAVITY            (1<< 5)
35 #define PARAM_STEPTIME   (1<< 7)
36 #define PARAM_SIZE       (1<< 8)
37 #define PARAM_TIMEFACTOR (1<< 9)
38 #define PARAM_ANIFRAMETIME              (1<<11)
39 #define PARAM_ANISTART                          (1<<12)
40 #define PARAM_SURFACETENSION    (1<<13)
41 #define PARAM_DENSITY                                   (1<<14)
42 #define PARAM_GSTAR                                             (1<<16)
43 #define PARAM_SIMMAXSPEED                       (1<<18)
44 #define PARAM_FLUIDVOLHEIGHT  (1<<19)
45 #define PARAM_NORMALIZEDGSTAR (1<<20)
46 #define PARAM_NUMIDS                                    21
47
48 //! output parameter debug message?
49 //#define PARAM_DEBUG      1
50
51
52
53 /*! Parameter calculator for the LBM Solver class */
54 class Parametrizer {
55
56         public:
57                 /*! default contructor */
58                 Parametrizer();
59
60                 /*! destructor */
61                 ~Parametrizer();
62
63                 /*! Initilize variables fom attribute list */
64                 void parseAttrList( void );
65
66                 /*! function that tries to calculate all the missing values from the given ones
67                  *  prints errors and returns false if thats not possible 
68                  *  currently needs time value as well */
69                 bool calculateAllMissingValues( double time, bool silent );
70                 /*! is the parametrizer used at all? */
71                 bool isUsed() { return true; }
72
73                 /*! add this flag to the seen values */
74                 void seenThis(int seen) { mSeenValues = (mSeenValues | seen); 
75 #ifdef PARAM_DEBUG              
76                         errorOut(" seen "<<seen<<endl); 
77 #endif
78                 }
79
80                 /*! set the flags integer */
81                 void setSeenValues(int set) { mSeenValues = set; }
82                 /*! check if the flags are set in the values int */
83                 bool checkSeenValues(int check) { /*errorOut( " b"<<((mSeenValues&check)==check) );*/ return ((mSeenValues&check)==check); }
84
85                 /*! add this flag to the calculated values */
86                 void calculatedThis(int cac) { mCalculatedValues = (mCalculatedValues | cac); /*errorOut(" a "<<seen);*/ }
87                 /*! set the calculated flags integer */
88                 void setCalculatedValues(int set) { mCalculatedValues = set; }
89                 /*! check if the calculated flags are set in the values int */
90                 bool checkCalculatedValues(int check) { /*errorOut( " b"<<((mSeenValues&check)==check) );*/ return ((mCalculatedValues&check)==check); }
91                 /*! advance to next render/output frame */
92                 void setFrameNum(int frame);
93                 ParamFloat getAniFrameTime(int frame);
94                 ParamFloat getCurrentAniFrameTime(){ return getAniFrameTime(mFrameNum); };
95
96                 /*! scale a given speed vector in m/s to lattice values 
97                  *  usage string is only needed for debugging */
98                 ParamVec calculateAddForce(ParamVec vec, string usage);
99
100                 /* simple calulation functions */
101                 /*! get omega for LBM */
102                 ParamFloat calculateOmega( double time );
103                 /*! get no. of timesteps for LBM */
104                 int calculateNoOfSteps( ParamFloat timelen );
105                 /*! get external force x component */
106                 ParamVec calculateGravity( double time );
107                 /*! get no of steps for the given length in seconds */
108                 int calculateStepsForSecs( ParamFloat s );
109                 /*! get no of steps for a singel animation frame */
110                 int calculateAniStepsPerFrame(int frame);
111                 /*! get start time of animation */
112                 int calculateAniStart( void );
113                 /*! get extent of the domain = (1,1,1) if parametrizer not used, (x,y,z) [m] otherwise */
114                 //ParamVec calculateExtent( void );
115                 /*! get (scaled) surface tension */
116                 ParamFloat calculateSurfaceTension( void );
117                 /*! get time step size for lbm (equals mTimeFactor) */
118                 // unused ParamFloat calculateTimestep( void );
119                 /*! calculate size of a single cell */
120                 ParamFloat calculateCellSize(void);
121                 /*! calculate the lattice viscosity */
122                 ParamFloat calculateLatticeViscosity( double time );
123
124                 /*! calculate lattice velocity from real world value [m/s] */
125                 ParamVec calculateLattVelocityFromRw( ParamVec ivel );
126                 /*! calculate real world [m/s] velocity from lattice value */
127                 ParamVec calculateRwVelocityFromLatt( ParamVec ivel );
128
129                 /*! set speed of sound */
130                 void setSoundSpeed(ParamFloat set) { mSoundSpeed = set; seenThis( PARAM_SOUNDSPEED ); }
131                 /*! get speed of sound */
132                 ParamFloat getSoundSpeed( void )   { return mSoundSpeed; }
133
134                 /*! set kinematic viscosity */
135                 void setViscosity(ParamFloat set);
136                 void initViscosityChannel(vector<ParamFloat> val, vector<double> time);
137
138                 /*! set the external force */
139                 void setGravity(ParamFloat setx, ParamFloat sety, ParamFloat setz);
140                 void setGravity(ParamVec set);
141                 void initGravityChannel(vector<ParamVec> val, vector<double> time);
142                 ParamVec getGravity(double time) { return mcGravity.get( time ); }
143
144                 /*! set time of an animation frame (renderer)  */
145                 void setAniFrameTimeChannel(ParamFloat set);
146                 void initAniFrameTimeChannel(vector<ParamFloat> val, vector<double> time);
147
148                 /*! set the length of a single time step */
149                 void setTimestep(ParamFloat set) { mTimestep = set; seenThis( PARAM_STEPTIME ); }
150                 /*! get the length of a single time step */
151                 ParamFloat getTimestep( void);
152                 /*! set a desired step time for rescaling/adaptive timestepping */
153                 void setDesiredTimestep(ParamFloat set) { mDesiredTimestep = set; }
154                 /*! get the length of a single time step */
155                 ParamFloat getMaxTimestep( void )   { return mMaxTimestep; }
156                 /*! get the length of a single time step */
157                 ParamFloat getMinTimestep( void )   { return mMinTimestep; }
158
159                 /*! set the time scaling factor */
160                 void setTimeFactor(ParamFloat set) { mTimeFactor = set; seenThis( PARAM_TIMEFACTOR ); }
161                 /*! get the time scaling factor */
162                 ParamFloat getTimeFactor( void )   { return mTimeFactor; }
163
164                 /*! init domain resoultion */
165                 void setSize(int ijk)            { mSizex = ijk; mSizey = ijk; mSizez = ijk; seenThis( PARAM_SIZE ); }
166                 void setSize(int i,int j, int k) { mSizex = i; mSizey = j; mSizez = k; seenThis( PARAM_SIZE ); }
167
168                 /*! set starting time of the animation (renderer) */
169                 void setAniStart(ParamFloat set) { mAniStart = set; seenThis( PARAM_ANISTART ); }
170                 /*! get starting time of the animation (renderer) */
171                 ParamFloat getAniStart( void )   { return mAniStart; }
172
173                 /*! set fluid density */
174                 void setDensity(ParamFloat set) { mDensity = set; seenThis( PARAM_DENSITY ); }
175                 /*! get fluid density */
176                 ParamFloat getDensity( void )   { return mDensity; }
177
178                 /*! set g star value */
179                 void setGStar(ParamFloat set) { mGStar = set; seenThis( PARAM_GSTAR ); }
180                 /*! get g star value */
181                 ParamFloat getGStar( void )   { return mGStar; }
182                 /*! get g star value with fhvol calculations */
183                 ParamFloat getCurrentGStar( void );
184                 /*! set normalized g star value */
185                 void setNormalizedGStar(ParamFloat set) { mNormalizedGStar = set; seenThis( PARAM_NORMALIZEDGSTAR ); }
186                 /*! get normalized g star value */
187                 ParamFloat getNormalizedGStar( void ) { return mNormalizedGStar; }
188
189                 /*! set g star value */
190                 void setFluidVolumeHeight(ParamFloat set) { mFluidVolumeHeight = set; seenThis( PARAM_FLUIDVOLHEIGHT ); }
191                 /*! get g star value */
192                 ParamFloat getFluidVolumeHeight( void )   { return mFluidVolumeHeight; }
193
194                 /*! set the size of a single lbm cell */
195                 void setDomainSize(ParamFloat set) { mDomainSize = set; seenThis( PARAM_DOMAINSIZE ); }
196                 /*! get the size of a single lbm cell */
197                 ParamFloat getDomainSize( void )   { return mDomainSize; }
198
199                 /*! set the size of a single lbm cell (dont use, normally set by domainsize and resolution) */
200                 void setCellSize(ParamFloat set) { mCellSize = set; }
201                 /*! get the size of a single lbm cell */
202                 ParamFloat getCellSize( void )   { return mCellSize; }
203
204                 /*! set active flag for parametrizer */
205                 //void setActive(bool set) { mActive = set; }
206
207                 /*! set attr list pointer */
208                 void setAttrList(AttributeList *set) { mpAttrs = set; }
209                 /*! Returns the attribute list pointer */
210                 inline AttributeList *getAttributeList() { return mpAttrs; }
211
212                 /*! set maximum allowed speed for maxspeed setup */
213                 void setSimulationMaxSpeed(ParamFloat set) { mSimulationMaxSpeed = set; seenThis( PARAM_SIMMAXSPEED ); }
214                 /*! get maximum allowed speed for maxspeed setup */
215                 ParamFloat getSimulationMaxSpeed( void )   { return mSimulationMaxSpeed; }
216
217                 /*! set maximum allowed omega for time adaptivity */
218                 void setTadapMaxOmega(ParamFloat set) { mTadapMaxOmega = set; }
219                 /*! get maximum allowed omega for time adaptivity */
220                 ParamFloat getTadapMaxOmega( void )   { return mTadapMaxOmega; }
221
222                 /*! set maximum allowed speed for time adaptivity */
223                 void setTadapMaxSpeed(ParamFloat set) { mTadapMaxSpeed = set; }
224                 /*! get maximum allowed speed for time adaptivity */
225                 ParamFloat getTadapMaxSpeed( void )   { return mTadapMaxSpeed; }
226
227                 /*! set maximum allowed omega for time adaptivity */
228                 void setTadapLevels(int set) { mTadapLevels = set; }
229                 /*! get maximum allowed omega for time adaptivity */
230                 int getTadapLevels( void )   { return mTadapLevels; }
231
232                 /*! set */
233                 //      void set(ParamFloat set) { m = set; seenThis( PARAM_ ); }
234                 /*! get */
235                 //      ParamFloat get( void )   { return m; }
236
237
238
239         private:
240
241                 /*! kinematic viscosity of the fluid [m^2/s] */
242                 AnimChannel<ParamFloat> mcViscosity;
243
244                 /*! speed of sound of the fluid [m/s] */
245                 ParamFloat mSoundSpeed;
246
247                 /*! size of the domain [m] */
248                 ParamFloat mDomainSize;
249
250                 /*! size of a single cell in the grid [m] */
251                 ParamFloat mCellSize;
252
253                 /*! time step length [s] */
254                 ParamFloat mTimeStep;
255
256                 /*! external force as acceleration [m/s^2] */
257                 AnimChannel<ParamVec> mcGravity;
258
259                 /*! length of one time step in the simulation */
260                 ParamFloat mTimestep;
261                 /*! desired step time for rescaling/adaptive timestepping, only regarded if >0.0, reset after usage */
262                 ParamFloat mDesiredTimestep;
263                 /*! minimal and maximal step times for current setup */
264                 ParamFloat mMaxTimestep, mMinTimestep;
265
266                 /*! domain resoultion, the same values as in lbmsolver */
267                 int mSizex, mSizey, mSizez;
268
269                 /*! time scaling factor (auto calc from accel, or set), equals the delta t in LBM */
270                 ParamFloat mTimeFactor;
271
272                 /*! for renderer - length of an animation step [s] */
273                 AnimChannel<ParamFloat> mcAniFrameTime;
274                 /*! time step scaling factor for testing/debugging */
275                 ParamFloat mTimeStepScale;
276
277                 /*! for renderer - start time of the animation [s] */
278                 ParamFloat mAniStart;
279
280                 /*! extent of the domain in meters */
281                 //ParamVec mExtent;
282
283                 /*! fluid density [kg/m^3], default 1.0 g/cm^3 */
284                 ParamFloat mDensity;
285
286                 /*! max difference due to gravity (for caro setup) */
287                 ParamFloat mGStar;
288                 /*! set gstar normalized! */
289                 ParamFloat mNormalizedGStar;
290                 /*! fluid volume/height multiplier for GStar */
291                 ParamFloat mFluidVolumeHeight;
292
293                 /*! current max speed of the simulation (for adaptive time steps) */
294                 ParamFloat mSimulationMaxSpeed;
295                 /*! maximum omega (for adaptive time steps) */
296                 ParamFloat mTadapMaxOmega;
297                 /*! maximum allowed speed in lattice units e.g. 0.1 (for adaptive time steps, not directly used in parametrizer) */
298                 ParamFloat mTadapMaxSpeed;
299                 /*! no. of levels for max omega (set by fsgr, not in cfg file) */
300                 int mTadapLevels;
301
302                 /*! remember current frame number */
303                 int mFrameNum;
304
305                 /*! values that are seen for this simulation */
306                 int mSeenValues;
307
308                 /*! values that are calculated from the seen ones for this simulation */
309                 int mCalculatedValues;
310
311                 /*! pointer to the attribute list */
312                 AttributeList *mpAttrs;
313
314 private:
315 #ifdef WITH_CXX_GUARDEDALLOC
316         MEM_CXX_CLASS_ALLOC_FUNCS("ELBEEM:Parametrizer")
317 #endif
318 };
319
320
321 #endif
322