This version now includes the fluid control sources, however the Blender
[blender.git] / intern / elbeem / intern / controlparticles.h
1 // --------------------------------------------------------------------------
2 //
3 // El'Beem - the visual lattice boltzmann freesurface simulator
4 // All code distributed as part of El'Beem is covered by the version 2 of the 
5 // GNU General Public License. See the file COPYING for details.  
6 //
7 // Copyright 2008 Nils Thuerey , Richard Keiser, Mark Pauly, Ulrich Ruede
8 //
9 // control particle classes
10 //
11 // --------------------------------------------------------------------------
12
13 #ifndef CONTROLPARTICLES_H
14 #define CONTROLPARTICLES_H
15
16 // indicator for LBM inclusion
17 //#ifndef LBMDIM
18
19 //#include <NxFoundation.h>
20 //#include <vector>
21 //class MultisphGUI;
22 //#define NORMALIZE(a) a.normalize()
23 //#define MAGNITUDE(a) a.magnitude()
24 //#define CROSS(a,b,c) a.cross(b,c)
25 //#define ABS(a) (a>0. ? (a) : -(a))
26 //#include "cpdefines.h"
27
28 //#else // LBMDIM
29
30 // use compatibility defines
31 //#define NORMALIZE(a) normalize(a)
32 //#define MAGNITUDE(a) norm(a)
33 //#define CROSS(a,b,c) a=cross(b,c)
34
35 //#endif // LBMDIM
36
37 #define MAGNITUDE(a) norm(a)
38
39 // math.h compatibility
40 #define CP_PI ((LbmFloat)3.14159265358979323846)
41
42 // project 2d test cases onto plane?
43 // if not, 3d distance is used for 2d sim as well
44 #define CP_PROJECT2D 1
45
46
47 // default init for mincpdist, ControlForces::maxDistance
48 #define CPF_MAXDINIT 10000.
49
50 // storage of influence for a fluid cell/particle in lbm/sph
51 class ControlForces
52 {
53 public:
54         ControlForces() { };
55         ~ControlForces() {};
56
57         // attraction force
58         LbmFloat weightAtt;
59         LbmVec forceAtt;
60         // velocity influence
61         LbmFloat weightVel;
62         LbmVec forceVel;
63         // maximal distance influence, 
64         // first is max. distance to first control particle
65         // second attraction strength
66         LbmFloat maxDistance;
67         LbmVec forceMaxd;
68
69         LbmFloat compAvWeight;
70         LbmVec compAv;
71
72         void resetForces() {
73                 weightAtt = weightVel = 0.;
74                 maxDistance = CPF_MAXDINIT;
75                 forceAtt = forceVel = forceMaxd = LbmVec(0.,0.,0.);
76                 compAvWeight=0.; compAv=LbmVec(0.);
77         };
78 };
79
80
81 // single control particle
82 class ControlParticle
83 {
84 public:
85         ControlParticle() { reset(); };
86         ~ControlParticle() {};
87
88         // control parameters
89         
90         // position
91         LbmVec pos;
92         // size (influences influence radius)
93         LbmFloat size;
94         // overall strength of influence
95         LbmFloat influence;
96         // rotation axis
97         LbmVec rotaxis;
98
99         // computed values
100
101         // velocity
102         LbmVec vel;
103         // computed density
104         LbmFloat density;
105         LbmFloat densityWeight;
106
107         LbmVec avgVel;
108         LbmVec avgVelAcc;
109         LbmFloat avgVelWeight;
110
111         // init all zero / defaults
112         void reset();
113 };
114
115
116 // container for a particle configuration at time t
117 class ControlParticleSet
118 {
119 public:
120
121         // time of particle set
122         LbmFloat time;
123         // particle positions
124         std::vector<ControlParticle> particles;
125
126 };
127
128
129 // container & management of control particles
130 class ControlParticles
131 {
132 public:
133         ControlParticles();
134         ~ControlParticles();
135
136         // reset datastructures for next influence step
137         // if motion object is given, particle 1 of second system is used for overall 
138         // position and speed offset
139         void prepareControl(LbmFloat simtime, LbmFloat dt, ControlParticles *motion);
140         // post control operations
141         void finishControl(std::vector<ControlForces> &forces, LbmFloat iatt, LbmFloat ivel, LbmFloat imaxd);
142         // recalculate 
143         void calculateKernelWeight();
144
145         // calculate forces at given position, and modify velocity
146         // according to timestep (from initControl)
147         void calculateCpInfluenceOpt (ControlParticle *cp, LbmVec fluidpos, LbmVec fluidvel, ControlForces *force, LbmFloat fillFactor);
148         void calculateMaxdForce      (ControlParticle *cp, LbmVec fluidpos, ControlForces *force);
149
150         // no. of particles
151         inline int getSize() { return (int)_particles.size(); }
152         int getTotalSize();
153         // get particle [i]
154         inline ControlParticle* getParticle(int i){ return &_particles[i]; }
155
156         // set influence parameters
157         void setInfluenceTangential(LbmFloat set) { _influenceTangential=set; }
158         void setInfluenceAttraction(LbmFloat set) { _influenceAttraction=set; }
159         void setInfluenceMaxdist(LbmFloat set)    { _influenceMaxdist=set; }
160         // calculate for delta t
161         void setInfluenceVelocity(LbmFloat set, LbmFloat dt);
162         // get influence parameters
163         inline LbmFloat getInfluenceAttraction()    { return _influenceAttraction; }
164         inline LbmFloat getInfluenceTangential()    { return _influenceTangential; }
165         inline LbmFloat getInfluenceVelocity()      { return _influenceVelocity; }
166         inline LbmFloat getInfluenceMaxdist()       { return _influenceMaxdist; }
167         inline LbmFloat getCurrTimestep()           { return _currTimestep; }
168
169         void setRadiusAtt(LbmFloat set)       { _radiusAtt=set; }
170         inline LbmFloat getRadiusAtt()        { return _radiusAtt; }
171         void setRadiusVel(LbmFloat set)       { _radiusVel=set; }
172         inline LbmFloat getRadiusVel()        { return _radiusVel; }
173         void setRadiusMaxd(LbmFloat set)      { _radiusMaxd=set; }
174         inline LbmFloat getRadiusMaxd()       { return _radiusMaxd; }
175         void setRadiusMinMaxd(LbmFloat set)   { _radiusMinMaxd=set; }
176         inline LbmFloat getRadiusMinMaxd()    { return _radiusMinMaxd; }
177
178         LbmFloat getControlTimStart();
179         LbmFloat getControlTimEnd();
180
181         // set/get characteristic length (and inverse)
182         void setCharLength(LbmFloat set)      { _charLength=set; _charLengthInv=1./_charLength; }
183         inline LbmFloat getCharLength()       { return _charLength;}
184         inline LbmFloat getCharLengthInv()    { return _charLengthInv;}
185
186         // set init parameters
187         void setInitTimeScale(LbmFloat set)  { _initTimeScale = set; };
188         void setInitMirror(string set)  { _initMirror = set; };
189         string getInitMirror()          { return _initMirror; };
190
191         void setLastOffset(LbmVec set) { _initLastPartOffset = set; };
192         void setLastScale(LbmVec set)  { _initLastPartScale = set; };
193         void setOffset(LbmVec set) { _initPartOffset = set; };
194         void setScale(LbmVec set)  { _initPartScale = set; };
195
196         // set/get cps params
197         void setCPSWith(LbmFloat set)       { mCPSWidth = set; };
198         void setCPSTimestep(LbmFloat set)   { mCPSTimestep = set; };
199         void setCPSTimeStart(LbmFloat set)  { mCPSTimeStart = set; };
200         void setCPSTimeEnd(LbmFloat set)    { mCPSTimeEnd = set; };
201         void setCPSMvmWeightFac(LbmFloat set) { mCPSWeightFac = set; };
202
203         LbmFloat getCPSWith()       { return mCPSWidth; };
204         LbmFloat getCPSTimestep()   { return mCPSTimestep; };
205         LbmFloat getCPSTimeStart()  { return mCPSTimeStart; };
206         LbmFloat getCPSTimeEnd()    { return mCPSTimeEnd; };
207         LbmFloat getCPSMvmWeightFac() { return mCPSWeightFac; };
208
209         void setDebugInit(int set)       { mDebugInit = set; };
210
211         // set init parameters
212         void setFluidSpacing(LbmFloat set)  { _fluidSpacing = set; };
213
214         // load positions & timing from text file
215         int initFromTextFile(string filename);
216         int initFromTextFileOld(string filename);
217         // load positions & timing from gzipped binary file
218         int initFromBinaryFile(string filename);
219         int initFromMVCMesh(string filename);
220         // init an example test case
221         int initExampleSet();
222
223         // init for a given time
224         void initTime(LbmFloat t, LbmFloat dt);
225
226         // blender test init
227         void initBlenderTest();
228
229 protected:
230         // sets influence params
231         friend class MultisphGUI;
232
233         // tangential and attraction influence
234         LbmFloat _influenceTangential, _influenceAttraction;
235         // direct velocity influence
236         LbmFloat _influenceVelocity;
237         // maximal distance influence
238         LbmFloat _influenceMaxdist;
239
240         // influence radii
241         LbmFloat _radiusAtt, _radiusVel, _radiusMinMaxd, _radiusMaxd;
242
243         // currently valid time & timestep
244         LbmFloat _currTime, _currTimestep;
245         // all particles
246         std::vector<ControlParticle> _particles;
247
248         // particle sets
249         std::vector<ControlParticleSet> mPartSets;
250
251         // additional parameters for initing particles
252         LbmFloat _initTimeScale;
253         LbmVec _initPartOffset;
254         LbmVec _initPartScale;
255         LbmVec _initLastPartOffset;
256         LbmVec _initLastPartScale;
257         // mirror particles for loading?
258         string _initMirror;
259
260         // row spacing paramter, e.g. use for approximation of kernel area/volume
261         LbmFloat _fluidSpacing;
262         // save current kernel weight
263         LbmFloat _kernelWeight;
264         // charateristic length in world coordinates for normalizatioon of forces
265         LbmFloat _charLength, _charLengthInv;
266
267
268         /*! do ani mesh CPS */
269         void calculateCPS(string filename);
270         //! ani mesh cps params 
271         ntlVec3Gfx mvCPSStart, mvCPSEnd;
272         gfxReal mCPSWidth, mCPSTimestep;
273         gfxReal mCPSTimeStart, mCPSTimeEnd;
274         gfxReal mCPSWeightFac;
275
276         int mDebugInit;
277
278         
279 protected:
280         // apply init transformations
281         void applyTrafos();
282
283         // helper function for init -> swap components everywhere
284         void swapCoords(int a,int b);
285         // helper function for init -> mirror time
286         void mirrorTime();
287
288         // helper, init given array
289         void initTimeArray(LbmFloat t, std::vector<ControlParticle> &parts);
290
291         bool checkPointInside(ntlTree *tree, ntlVec3Gfx org, gfxReal &distance);
292 };
293
294
295
296 #endif
297