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