initial commit of the fluid simulator.
[blender.git] / intern / elbeem / intern / parametrizer.h
1 /******************************************************************************
2  *
3  * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
4  * Copyright 2003,2004 Nils Thuerey
5  *
6  * Parameter calculator for the LBM Solver class
7  *
8  *****************************************************************************/
9 #ifndef MFFSLBM_PARAMETRIZER
10 #define MFFSLBM_PARAMETRIZER  
11
12
13 /* LBM Files */
14 #include "utilities.h"
15 #include "attributes.h"
16
17 /* parametrizer accuracy */
18 typedef double ParamFloat;
19 typedef ntlVec3d ParamVec;
20
21 /*! flags to check which values are known */
22 #define PARAM_RELAXTIME  (1<< 0)
23 #define PARAM_REYNOLDS   (1<< 1)
24 #define PARAM_VISCOSITY  (1<< 2)
25 #define PARAM_SOUNDSPEED (1<< 3)
26 #define PARAM_DOMAINSIZE (1<< 4)
27 #define PARAM_GRAVITY            (1<< 5)
28 #define PARAM_TIMELENGTH (1<< 6)
29 #define PARAM_STEPTIME   (1<< 7)
30 #define PARAM_SIZE       (1<< 8)
31 #define PARAM_TIMEFACTOR (1<< 9)
32 #define PARAM_ANIFRAMES  (1<<10)
33 #define PARAM_ANIFRAMETIME              (1<<11)
34 #define PARAM_ANISTART                          (1<<12)
35 #define PARAM_SURFACETENSION    (1<<13)
36 #define PARAM_DENSITY                                   (1<<14)
37 #define PARAM_CELLSIZE                          (1<<15)
38 #define PARAM_GSTAR                                             (1<<16)
39 #define PARAM_MAXSPEED                          (1<<17)
40 #define PARAM_SIMMAXSPEED                       (1<<18)
41 #define PARAM_FLUIDVOLHEIGHT  (1<<19)
42 #define PARAM_NORMALIZEDGSTAR (1<<20)
43 #define PARAM_NUMIDS                                    21
44
45 //! parameters to ignore for parametrizer activation
46 #define PARAM_IGNORE     (~(PARAM_ANIFRAMES|PARAM_SIZE))
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                 bool calculateAllMissingValues( bool silent = false );
69                 bool oldCalculateAllMissingValues( void );
70                 /*! is the parametrizer used at all? */
71                 //bool isUsed() { if(!mActive){ return false; } return(mSeenValues!=(~PARAM_IGNORE)); }
72                 bool isUsed() { return true; }
73
74                 /*! add this flag to the seen values */
75                 void seenThis(int seen) { mSeenValues = (mSeenValues | seen); 
76 #ifdef PARAM_DEBUG              
77                         errorOut(" seen "<<seen<<endl); 
78 #endif
79                 }
80
81                 /*! set the flags integer */
82                 void setSeenValues(int set) { mSeenValues = set; }
83                 /*! check if the flags are set in the values int */
84                 bool checkSeenValues(int check) { /*errorOut( " b"<<((mSeenValues&check)==check) );*/ return ((mSeenValues&check)==check); }
85
86                 /*! add this flag to the calculated values */
87                 void calculatedThis(int cac) { mCalculatedValues = (mCalculatedValues | cac); /*errorOut(" a "<<seen);*/ }
88                 /*! set the calculated flags integer */
89                 void setCalculatedValues(int set) { mCalculatedValues = set; }
90                 /*! check if the calculated flags are set in the values int */
91                 bool checkCalculatedValues(int check) { /*errorOut( " b"<<((mSeenValues&check)==check) );*/ return ((mCalculatedValues&check)==check); }
92
93                 /*! scale a given speed vector in m/s to lattice values 
94                  *  usage string is only needed for debugging */
95                 ParamVec calculateAddForce(ParamVec vec, string usage);
96
97                 /* simple calulation functions */
98                 /*! get omega for LBM */
99                 ParamFloat calculateOmega( void );
100                 /*! get no. of timesteps for LBM */
101                 //int calculateNoOfSteps( void ) { return (int)(mTimeLength/mStepTime); }
102                 int calculateNoOfSteps( ParamFloat timelen );
103                 /*! get external force x component */
104                 ParamVec calculateGravity( void );
105                 /*! get no of steps for the given length in seconds */
106                 int calculateStepsForSecs( ParamFloat s );
107                 /*! get start time of animation */
108                 int calculateAniStart( void );
109                 /*! get no of steps for a singel animation frame */
110                 int calculateAniStepsPerFrame( void );
111                 /*! get extent of the domain = (1,1,1) if parametrizer not used, (x,y,z) [m] otherwise */
112                 ParamVec calculateExtent( void );
113                 /*! get (scaled) surface tension */
114                 ParamFloat calculateSurfaceTension( void );
115                 /*! get time step size for lbm (equals mTimeFactor) */
116                 // unused ParamFloat calculateTimestep( void );
117                 /*! calculate size of a single cell */
118                 ParamFloat calculateCellSize(void);
119                 /*! calculate the lattice viscosity */
120                 ParamFloat calculateLatticeViscosity(void);
121
122                 /*! calculate lattice velocity from real world value [m/s] */
123                 ParamVec calculateLattVelocityFromRw( ParamVec ivel );
124                 /*! calculate real world [m/s] velocity from lattice value */
125                 ParamVec calculateRwVelocityFromLatt( ParamVec ivel );
126
127
128                 /*! set relaxation time */
129                 void setRelaxTime(ParamFloat set) { mRelaxTime = set; seenThis( PARAM_RELAXTIME ); }
130                 /*! get relaxation time */
131                 ParamFloat getRelaxTime( void )   { return mRelaxTime; }
132
133                 /*! set reynolds number */
134                 void setReynolds(ParamFloat set) { mReynolds = set; seenThis( PARAM_REYNOLDS ); }
135                 /*! get reynolds number */
136                 ParamFloat getReynolds( void )   { return mReynolds; }
137
138                 /*! set kinematic viscosity */
139                 void setViscosity(ParamFloat set) { mViscosity = set; seenThis( PARAM_VISCOSITY ); }
140                 /*! get kinematic viscosity */
141                 ParamFloat getViscosity( void )   { return mViscosity; }
142
143                 /*! set speed of sound */
144                 void setSoundSpeed(ParamFloat set) { mSoundSpeed = set; seenThis( PARAM_SOUNDSPEED ); }
145                 /*! get speed of sound */
146                 ParamFloat getSoundSpeed( void )   { return mSoundSpeed; }
147
148                 /*! set the external force */
149                 void setGravity(ParamFloat setx, ParamFloat sety, ParamFloat setz) { mGravity = ParamVec(setx,sety,setz); seenThis( PARAM_GRAVITY ); }
150                 void setGravity(ParamVec set) { mGravity = set; seenThis( PARAM_GRAVITY ); }
151
152                 /*! set the length of the simulation */
153                 //void setTimeLength(ParamFloat set) { mTimeLength = set; seenThis( PARAM_TIMELENGTH ); }
154                 /*! get the length of the simulation */
155                 //ParamFloat getTimeLength( void )   { return mTimeLength; }
156
157                 /*! set the length of a single time step */
158                 void setStepTime(ParamFloat set) { mStepTime = set; seenThis( PARAM_STEPTIME ); }
159                 /*! get the length of a single time step */
160                 ParamFloat getStepTime( void);
161                 /*! set a desired step time for rescaling/adaptive timestepping */
162                 void setDesiredStepTime(ParamFloat set) { mDesiredStepTime = set; }
163                 /*! get the length of a single time step */
164                 ParamFloat getMaxStepTime( void )   { return mMaxStepTime; }
165                 /*! get the length of a single time step */
166                 ParamFloat getMinStepTime( void )   { return mMinStepTime; }
167
168                 /*! set the time scaling factor */
169                 void setTimeFactor(ParamFloat set) { mTimeFactor = set; seenThis( PARAM_TIMEFACTOR ); }
170                 /*! get the time scaling factor */
171                 ParamFloat getTimeFactor( void )   { return mTimeFactor; }
172
173                 /*! init domain resoultion */
174                 void setSize(int ijk)            { mSizex = ijk; mSizey = ijk; mSizez = ijk; seenThis( PARAM_SIZE ); }
175                 void setSize(int i,int j, int k) { mSizex = i; mSizey = j; mSizez = k; seenThis( PARAM_SIZE ); }
176
177                 /*! set no of animation steps (renderer)  */
178                 void setAniFrames(int set) { mAniFrames = set; seenThis( PARAM_ANIFRAMES ); }
179                 /*! get no of animation steps (renderer)  */
180                 int getAniFrames( void )   { return mAniFrames; }
181
182                 /*! set time of an animation frame (renderer)  */
183                 void setAniFrameTime(ParamFloat set) { mAniFrameTime = set; seenThis( PARAM_ANIFRAMETIME ); }
184                 /*! get time of an animation frame (renderer)  */
185                 ParamFloat getAniFrameTime( void )   { return mAniFrameTime; }
186
187                 /*! set starting time of the animation (renderer) */
188                 void setAniStart(ParamFloat set) { mAniStart = set; seenThis( PARAM_ANISTART ); }
189                 /*! get starting time of the animation (renderer) */
190                 ParamFloat getAniStart( void )   { return mAniStart; }
191
192                 /*! set starting time of the animation (renderer) */
193                 void setSurfaceTension(ParamFloat set) { mSurfaceTension = set; seenThis( PARAM_SURFACETENSION ); }
194                 /*! get starting time of the animation (renderer) */
195                 ParamFloat getSurfaceTension( void )   { return mSurfaceTension; }
196
197                 /*! set fluid density */
198                 void setDensity(ParamFloat set) { mDensity = set; seenThis( PARAM_DENSITY ); }
199                 /*! get fluid density */
200                 ParamFloat getDensity( void )   { return mDensity; }
201
202                 /*! set g star value */
203                 void setGStar(ParamFloat set) { mGStar = set; seenThis( PARAM_GSTAR ); }
204                 /*! get g star value */
205                 ParamFloat getGStar( void )   { return mGStar; }
206                 /*! get g star value with fhvol calculations */
207                 ParamFloat getCurrentGStar( void );
208                 /*! set normalized g star value */
209                 void setNormalizedGStar(ParamFloat set) { mNormalizedGStar = set; seenThis( PARAM_NORMALIZEDGSTAR ); }
210                 /*! get normalized g star value */
211                 ParamFloat getNormalizedGStar( void ) { return mNormalizedGStar; }
212
213                 /*! set g star value */
214                 void setFluidVolumeHeight(ParamFloat set) { mFluidVolumeHeight = set; seenThis( PARAM_FLUIDVOLHEIGHT ); }
215                 /*! get g star value */
216                 ParamFloat getFluidVolumeHeight( void )   { return mFluidVolumeHeight; }
217
218                 /*! set the size of a single lbm cell */
219                 void setDomainSize(ParamFloat set) { mDomainSize = set; seenThis( PARAM_DOMAINSIZE ); }
220                 /*! get the size of a single lbm cell */
221                 ParamFloat getDomainSize( void )   { return mDomainSize; }
222
223                 /*! set the size of a single lbm cell */
224                 void setCellSize(ParamFloat set) { mCellSize = set; seenThis( PARAM_CELLSIZE ); }
225                 /*! get the size of a single lbm cell */
226                 ParamFloat getCellSize( void )   { return mCellSize; }
227
228                 /*! set active flag for parametrizer */
229                 //void setActive(bool set) { mActive = set; }
230
231                 /*! set attr list pointer */
232                 void setAttrList(AttributeList *set) { mpAttrs = set; }
233                 /*! Returns the attribute list pointer */
234                 inline AttributeList *getAttributeList() { return mpAttrs; }
235
236                 /*! set maximum allowed speed for maxspeed setup */
237                 void setMaxSpeed(ParamFloat set) { mMaxSpeed = set; seenThis( PARAM_MAXSPEED ); }
238                 /*! get maximum allowed speed for maxspeed setup */
239                 ParamFloat getMaxSpeed( void )   { return mMaxSpeed; }
240
241                 /*! set maximum allowed speed for maxspeed setup */
242                 void setSimulationMaxSpeed(ParamFloat set) { mSimulationMaxSpeed = set; seenThis( PARAM_SIMMAXSPEED ); }
243                 /*! get maximum allowed speed for maxspeed setup */
244                 ParamFloat getSimulationMaxSpeed( void )   { return mSimulationMaxSpeed; }
245
246                 /*! set maximum allowed omega for time adaptivity */
247                 void setTadapMaxOmega(ParamFloat set) { mTadapMaxOmega = set; }
248                 /*! get maximum allowed omega for time adaptivity */
249                 ParamFloat getTadapMaxOmega( void )   { return mTadapMaxOmega; }
250
251                 /*! set maximum allowed speed for time adaptivity */
252                 void setTadapMaxSpeed(ParamFloat set) { mTadapMaxSpeed = set; }
253                 /*! get maximum allowed speed for time adaptivity */
254                 ParamFloat getTadapMaxSpeed( void )   { return mTadapMaxSpeed; }
255
256                 /*! set maximum allowed omega for time adaptivity */
257                 void setTadapLevels(int set) { mTadapLevels = set; }
258                 /*! get maximum allowed omega for time adaptivity */
259                 int getTadapLevels( void )   { return mTadapLevels; }
260
261
262                 /*! set */
263                 //      void set(ParamFloat set) { m = set; seenThis( PARAM_ ); }
264                 /*! get */
265                 //      ParamFloat get( void )   { return m; }
266
267
268
269         private:
270
271                 /*! type of parameter setup to use */
272                 string mSetupType;
273
274                 /*! relaxation time [s] */
275                 ParamFloat mRelaxTime;
276
277                 /*! reynolds number (calculated from domain length and max. speed [dimensionless] */
278                 ParamFloat mReynolds;
279
280                 /*! kinematic viscosity of the fluid [m^2/s] */
281                 ParamFloat mViscosity;
282
283                 /*! speed of sound of the fluid [m/s] */
284                 ParamFloat mSoundSpeed;
285
286                 /*! size of the domain [m] */
287                 ParamFloat mDomainSize;
288
289                 /*! size of a single cell in the grid [m] */
290                 ParamFloat mCellSize;
291
292                 /*! time step length [s] */
293                 ParamFloat mTimeStep;
294
295                 /*! external force as acceleration [m/s^2] */
296                 ParamVec mGravity;
297                 /*! force converted to lattice units (returned by calc gravity) */
298                 ParamVec mLatticeGravity;
299
300                 /*! lenth of the simulation [s] */
301                 //ParamFloat mTimeLength;
302
303                 /*! length of one time step in the simulation */
304                 ParamFloat mStepTime;
305                 /*! desired step time for rescaling/adaptive timestepping, only regarded if >0.0, reset after usage */
306                 ParamFloat mDesiredStepTime;
307                 /*! minimal and maximal step times for current setup */
308                 ParamFloat mMaxStepTime, mMinStepTime;
309
310                 /*! domain resoultion, the same values as in lbmsolver */
311                 int mSizex, mSizey, mSizez;
312
313                 /*! time scaling factor (auto calc from accel, or set), equals the delta t in LBM */
314                 ParamFloat mTimeFactor;
315
316                 /*! from renderer - no of animation frames for the animation (same as mpglob mAniFrames) */
317                 int mAniFrames;
318
319                 /*! for renderer - length of an animation step [s] */
320                 ParamFloat mAniFrameTime;
321
322                 /*! for renderer - start time of the animation [s] */
323                 ParamFloat mAniStart;
324
325                 /*! extent of the domain in meters */
326                 ParamVec mExtent;
327
328                 /*! surface tension, [kg/s^2] */
329                 ParamFloat mSurfaceTension;
330
331                 /*! fluid density [kg/m^3], default 1.0 g/cm^3 */
332                 ParamFloat mDensity;
333
334                 /*! max difference due to gravity (for caro setup) */
335                 ParamFloat mGStar;
336                 /*! set gstar normalized! */
337                 ParamFloat mNormalizedGStar;
338                 /*! fluid volume/height multiplier for GStar */
339                 ParamFloat mFluidVolumeHeight;
340
341                 /*! max speed (for maxspeed setup) */
342                 ParamFloat mMaxSpeed;
343
344                 /*! current max speed of the simulation (for adaptive time steps) */
345                 ParamFloat mSimulationMaxSpeed;
346                 /*! maximum omega (for adaptive time steps) */
347                 ParamFloat mTadapMaxOmega;
348                 /*! maximum allowed speed in lattice units e.g. 0.1 (for adaptive time steps, not directly used in parametrizer) */
349                 ParamFloat mTadapMaxSpeed;
350                 /*! no. of levels for max omega (set by fsgr, not in cfg file) */
351                 int mTadapLevels;
352
353
354                 /*! values that are seen for this simulation */
355                 int mSeenValues;
356
357                 /*! values that are calculated from the seen ones for this simulation */
358                 int mCalculatedValues;
359
360                 /*! is the parametrizer active? */
361                 //bool mActive;
362
363                 /*! pointer to the attribute list */
364                 AttributeList *mpAttrs;
365 };
366
367
368 #endif
369