controlparticles.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// El'Beem - the visual lattice boltzmann freesurface simulator
// All code distributed as part of El'Beem is covered by the version 2 of the 
// GNU General Public License. See the file COPYING for details.  
//
// Copyright 2008 Nils Thuerey , Richard Keiser, Mark Pauly, Ulrich Ruede
//
// control particle classes
//
// --------------------------------------------------------------------------

#ifndef CONTROLPARTICLES_H
#define CONTROLPARTICLES_H

#include "ntl_geometrymodel.h"

// indicator for LBM inclusion
//#ifndef LBMDIM

//#include <NxFoundation.h>
//#include <vector>
//class MultisphGUI;
//#define NORMALIZE(a) a.normalize()
//#define MAGNITUDE(a) a.magnitude()
//#define CROSS(a,b,c) a.cross(b,c)
//#define ABS(a) (a>0. ? (a) : -(a))
//#include "cpdefines.h"

//#else // LBMDIM

// use compatibility defines
//#define NORMALIZE(a) normalize(a)
//#define MAGNITUDE(a) norm(a)
//#define CROSS(a,b,c) a=cross(b,c)

//#endif // LBMDIM

#define MAGNITUDE(a) norm(a)

// math.h compatibility
#define CP_PI ((LbmFloat)3.14159265358979323846)

// project 2d test cases onto plane?
// if not, 3d distance is used for 2d sim as well
#define CP_PROJECT2D 1


// default init for mincpdist, ControlForces::maxDistance
#define CPF_MAXDINIT 10000.

// storage of influence for a fluid cell/particle in lbm/sph
class ControlForces
{
public:
    ControlForces() { };
    ~ControlForces() {};

    // attraction force
    LbmFloat weightAtt;
    LbmVec forceAtt;
    // velocity influence
    LbmFloat weightVel;
    LbmVec forceVel;
    // maximal distance influence, 
    // first is max. distance to first control particle
    // second attraction strength
    LbmFloat maxDistance;
    LbmVec forceMaxd;

    LbmFloat compAvWeight;
    LbmVec compAv;

    void resetForces() {
        weightAtt = weightVel = 0.;
        maxDistance = CPF_MAXDINIT;
        forceAtt = forceVel = forceMaxd = LbmVec(0.,0.,0.);
        compAvWeight=0.; compAv=LbmVec(0.);
    };
};


// single control particle
class ControlParticle
{
public:
    ControlParticle() { reset(); };
    ~ControlParticle() {};

    // control parameters
    
    // position
    LbmVec pos;
    // size (influences influence radius)
    LbmFloat size;
    // overall strength of influence
    LbmFloat influence;
    // rotation axis
    LbmVec rotaxis;

    // computed values

    // velocity
    LbmVec vel;
    // computed density
    LbmFloat density;
    LbmFloat densityWeight;

    LbmVec avgVel;
    LbmVec avgVelAcc;
    LbmFloat avgVelWeight;

    // init all zero / defaults
    void reset();
};


// container for a particle configuration at time t
class ControlParticleSet
{
public:

    // time of particle set
    LbmFloat time;
    // particle positions
    std::vector<ControlParticle> particles;

};


// container & management of control particles
class ControlParticles
{
public:
    ControlParticles();
    ~ControlParticles();

    // reset datastructures for next influence step
    // if motion object is given, particle 1 of second system is used for overall 
    // position and speed offset
    void prepareControl(LbmFloat simtime, LbmFloat dt, ControlParticles *motion);
    // post control operations
    void finishControl(std::vector<ControlForces> &forces, LbmFloat iatt, LbmFloat ivel, LbmFloat imaxd);
    // recalculate 
    void calculateKernelWeight();

    // calculate forces at given position, and modify velocity
    // according to timestep (from initControl)
    void calculateCpInfluenceOpt (ControlParticle *cp, LbmVec fluidpos, LbmVec fluidvel, ControlForces *force, LbmFloat fillFactor);
    void calculateMaxdForce      (ControlParticle *cp, LbmVec fluidpos, ControlForces *force);

    // no. of particles
    inline int getSize() { return (int)_particles.size(); }
    int getTotalSize();
    // get particle [i]
    inline ControlParticle* getParticle(int i){ return &_particles[i]; }

    // set influence parameters
    void setInfluenceTangential(LbmFloat set) { _influenceTangential=set; }
    void setInfluenceAttraction(LbmFloat set) { _influenceAttraction=set; }
    void setInfluenceMaxdist(LbmFloat set)    { _influenceMaxdist=set; }
    // calculate for delta t
    void setInfluenceVelocity(LbmFloat set, LbmFloat dt);
    // get influence parameters
    inline LbmFloat getInfluenceAttraction()    { return _influenceAttraction; }
    inline LbmFloat getInfluenceTangential()    { return _influenceTangential; }
    inline LbmFloat getInfluenceVelocity()      { return _influenceVelocity; }
    inline LbmFloat getInfluenceMaxdist()       { return _influenceMaxdist; }
    inline LbmFloat getCurrTimestep()           { return _currTimestep; }

    void setRadiusAtt(LbmFloat set)       { _radiusAtt=set; }
    inline LbmFloat getRadiusAtt()        { return _radiusAtt; }
    void setRadiusVel(LbmFloat set)       { _radiusVel=set; }
    inline LbmFloat getRadiusVel()        { return _radiusVel; }
    void setRadiusMaxd(LbmFloat set)      { _radiusMaxd=set; }
    inline LbmFloat getRadiusMaxd()       { return _radiusMaxd; }
    void setRadiusMinMaxd(LbmFloat set)   { _radiusMinMaxd=set; }
    inline LbmFloat getRadiusMinMaxd()    { return _radiusMinMaxd; }

    LbmFloat getControlTimStart();
    LbmFloat getControlTimEnd();

    // set/get characteristic length (and inverse)
    void setCharLength(LbmFloat set)      { _charLength=set; _charLengthInv=1./_charLength; }
    inline LbmFloat getCharLength()       { return _charLength;}
    inline LbmFloat getCharLengthInv()    { return _charLengthInv;}

    // set init parameters
    void setInitTimeScale(LbmFloat set)  { _initTimeScale = set; };
    void setInitMirror(string set)  { _initMirror = set; };
    string getInitMirror()          { return _initMirror; };

    void setLastOffset(LbmVec set) { _initLastPartOffset = set; };
    void setLastScale(LbmVec set)  { _initLastPartScale = set; };
    void setOffset(LbmVec set) { _initPartOffset = set; };
    void setScale(LbmVec set)  { _initPartScale = set; };

    // set/get cps params
    void setCPSWith(LbmFloat set)       { mCPSWidth = set; };
    void setCPSTimestep(LbmFloat set)   { mCPSTimestep = set; };
    void setCPSTimeStart(LbmFloat set)  { mCPSTimeStart = set; };
    void setCPSTimeEnd(LbmFloat set)    { mCPSTimeEnd = set; };
    void setCPSMvmWeightFac(LbmFloat set) { mCPSWeightFac = set; };

    LbmFloat getCPSWith()       { return mCPSWidth; };
    LbmFloat getCPSTimestep()   { return mCPSTimestep; };
    LbmFloat getCPSTimeStart()  { return mCPSTimeStart; };
    LbmFloat getCPSTimeEnd()    { return mCPSTimeEnd; };
    LbmFloat getCPSMvmWeightFac() { return mCPSWeightFac; };

    void setDebugInit(int set)       { mDebugInit = set; };

    // set init parameters
    void setFluidSpacing(LbmFloat set)  { _fluidSpacing = set; };

    // load positions & timing from text file
    int initFromTextFile(string filename);
    int initFromTextFileOld(string filename);
    // load positions & timing from gzipped binary file
    int initFromBinaryFile(string filename);
    int initFromMVCMesh(string filename);
    // init an example test case
    int initExampleSet();

    // init for a given time
    void initTime(LbmFloat t, LbmFloat dt);

    // blender test init
    void initBlenderTest();
    
    int initFromObject(ntlGeometryObjModel *model);

protected:
    // sets influence params
    friend class MultisphGUI;

    // tangential and attraction influence
    LbmFloat _influenceTangential, _influenceAttraction;
    // direct velocity influence
    LbmFloat _influenceVelocity;
    // maximal distance influence
    LbmFloat _influenceMaxdist;

    // influence radii
    LbmFloat _radiusAtt, _radiusVel, _radiusMinMaxd, _radiusMaxd;

    // currently valid time & timestep
    LbmFloat _currTime, _currTimestep;
    // all particles
    std::vector<ControlParticle> _particles;

    // particle sets
    std::vector<ControlParticleSet> mPartSets;

    // additional parameters for initing particles
    LbmFloat _initTimeScale;
    LbmVec _initPartOffset;
    LbmVec _initPartScale;
    LbmVec _initLastPartOffset;
    LbmVec _initLastPartScale;
    // mirror particles for loading?
    string _initMirror;

    // row spacing paramter, e.g. use for approximation of kernel area/volume
    LbmFloat _fluidSpacing;
    // save current kernel weight
    LbmFloat _kernelWeight;
    // charateristic length in world coordinates for normalizatioon of forces
    LbmFloat _charLength, _charLengthInv;


    void calculateCPS(string filename);
    ntlVec3Gfx mvCPSStart, mvCPSEnd;
    gfxReal mCPSWidth, mCPSTimestep;
    gfxReal mCPSTimeStart, mCPSTimeEnd;
    gfxReal mCPSWeightFac;

    int mDebugInit;

    
protected:
    // apply init transformations
    void applyTrafos();

    // helper function for init -> swap components everywhere
    void swapCoords(int a,int b);
    // helper function for init -> mirror time
    void mirrorTime();

    // helper, init given array
    void initTimeArray(LbmFloat t, std::vector<ControlParticle> &parts);

    bool checkPointInside(ntlTree *tree, ntlVec3Gfx org, gfxReal &distance);
};



#endif