parametrizer.h

Go to the documentation of this file.

/******************************************************************************
 *
 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
 * Copyright 2003-2006 Nils Thuerey
 *
 * Parameter calculator for the LBM Solver class
 *
 *****************************************************************************/
#ifndef MFFSLBM_PARAMETRIZER
#define MFFSLBM_PARAMETRIZER  


/* LBM Files */
#include "utilities.h"
#include "attributes.h"

/* parametrizer accuracy */
typedef double ParamFloat;
typedef ntlVec3d ParamVec;

#define PARAM_RELAXTIME  (1<< 0)
#define PARAM_REYNOLDS   (1<< 1)
#define PARAM_VISCOSITY  (1<< 2)
#define PARAM_SOUNDSPEED (1<< 3)
#define PARAM_DOMAINSIZE (1<< 4)
#define PARAM_GRAVITY            (1<< 5)
#define PARAM_STEPTIME   (1<< 7)
#define PARAM_SIZE       (1<< 8)
#define PARAM_TIMEFACTOR (1<< 9)
#define PARAM_ANIFRAMETIME              (1<<11)
#define PARAM_ANISTART                          (1<<12)
#define PARAM_SURFACETENSION    (1<<13)
#define PARAM_DENSITY                                   (1<<14)
#define PARAM_GSTAR                                             (1<<16)
#define PARAM_SIMMAXSPEED                       (1<<18)
#define PARAM_FLUIDVOLHEIGHT  (1<<19)
#define PARAM_NORMALIZEDGSTAR (1<<20)
#define PARAM_NUMIDS                                    21

//#define PARAM_DEBUG      1



class Parametrizer {

        public:
                Parametrizer();

                ~Parametrizer();

                void parseAttrList( void );

                bool calculateAllMissingValues( double time, bool silent );
                bool isUsed() { return true; }

                void seenThis(int seen) { mSeenValues = (mSeenValues | seen); 
#ifdef PARAM_DEBUG              
                        errorOut(" seen "<<seen<<endl); 
#endif
                }

                void setSeenValues(int set) { mSeenValues = set; }
                bool checkSeenValues(int check) { /*errorOut( " b"<<((mSeenValues&check)==check) );*/ return ((mSeenValues&check)==check); }

                void calculatedThis(int cac) { mCalculatedValues = (mCalculatedValues | cac); /*errorOut(" a "<<seen);*/ }
                void setCalculatedValues(int set) { mCalculatedValues = set; }
                bool checkCalculatedValues(int check) { /*errorOut( " b"<<((mSeenValues&check)==check) );*/ return ((mCalculatedValues&check)==check); }
                void setFrameNum(int frame);
                ParamFloat getAniFrameTime(int frame);
                ParamFloat getCurrentAniFrameTime(){ return getAniFrameTime(mFrameNum); };

                ParamVec calculateAddForce(ParamVec vec, string usage);

                /* simple calulation functions */
                ParamFloat calculateOmega( double time );
                int calculateNoOfSteps( ParamFloat timelen );
                ParamVec calculateGravity( double time );
                int calculateStepsForSecs( ParamFloat s );
                int calculateAniStepsPerFrame(int frame);
                int calculateAniStart( void );
                //ParamVec calculateExtent( void );
                ParamFloat calculateSurfaceTension( void );
                // unused ParamFloat calculateTimestep( void );
                ParamFloat calculateCellSize(void);
                ParamFloat calculateLatticeViscosity( double time );

                ParamVec calculateLattVelocityFromRw( ParamVec ivel );
                ParamVec calculateRwVelocityFromLatt( ParamVec ivel );

                void setSoundSpeed(ParamFloat set) { mSoundSpeed = set; seenThis( PARAM_SOUNDSPEED ); }
                ParamFloat getSoundSpeed( void )   { return mSoundSpeed; }

                void setViscosity(ParamFloat set);
                void initViscosityChannel(vector<ParamFloat> val, vector<double> time);

                void setGravity(ParamFloat setx, ParamFloat sety, ParamFloat setz);
                void setGravity(ParamVec set);
                void initGravityChannel(vector<ParamVec> val, vector<double> time);
                ParamVec getGravity(double time) { return mcGravity.get( time ); }

                void setAniFrameTimeChannel(ParamFloat set);
                void initAniFrameTimeChannel(vector<ParamFloat> val, vector<double> time);

                void setTimestep(ParamFloat set) { mTimestep = set; seenThis( PARAM_STEPTIME ); }
                ParamFloat getTimestep( void);
                void setDesiredTimestep(ParamFloat set) { mDesiredTimestep = set; }
                ParamFloat getMaxTimestep( void )   { return mMaxTimestep; }
                ParamFloat getMinTimestep( void )   { return mMinTimestep; }

                void setTimeFactor(ParamFloat set) { mTimeFactor = set; seenThis( PARAM_TIMEFACTOR ); }
                ParamFloat getTimeFactor( void )   { return mTimeFactor; }

                void setSize(int ijk)            { mSizex = ijk; mSizey = ijk; mSizez = ijk; seenThis( PARAM_SIZE ); }
                void setSize(int i,int j, int k) { mSizex = i; mSizey = j; mSizez = k; seenThis( PARAM_SIZE ); }

                void setAniStart(ParamFloat set) { mAniStart = set; seenThis( PARAM_ANISTART ); }
                ParamFloat getAniStart( void )   { return mAniStart; }

                void setDensity(ParamFloat set) { mDensity = set; seenThis( PARAM_DENSITY ); }
                ParamFloat getDensity( void )   { return mDensity; }

                void setGStar(ParamFloat set) { mGStar = set; seenThis( PARAM_GSTAR ); }
                ParamFloat getGStar( void )   { return mGStar; }
                ParamFloat getCurrentGStar( void );
                void setNormalizedGStar(ParamFloat set) { mNormalizedGStar = set; seenThis( PARAM_NORMALIZEDGSTAR ); }
                ParamFloat getNormalizedGStar( void ) { return mNormalizedGStar; }

                void setFluidVolumeHeight(ParamFloat set) { mFluidVolumeHeight = set; seenThis( PARAM_FLUIDVOLHEIGHT ); }
                ParamFloat getFluidVolumeHeight( void )   { return mFluidVolumeHeight; }

                void setDomainSize(ParamFloat set) { mDomainSize = set; seenThis( PARAM_DOMAINSIZE ); }
                ParamFloat getDomainSize( void )   { return mDomainSize; }

                void setCellSize(ParamFloat set) { mCellSize = set; }
                ParamFloat getCellSize( void )   { return mCellSize; }

                //void setActive(bool set) { mActive = set; }

                void setAttrList(AttributeList *set) { mpAttrs = set; }
                inline AttributeList *getAttributeList() { return mpAttrs; }

                void setSimulationMaxSpeed(ParamFloat set) { mSimulationMaxSpeed = set; seenThis( PARAM_SIMMAXSPEED ); }
                ParamFloat getSimulationMaxSpeed( void )   { return mSimulationMaxSpeed; }

                void setTadapMaxOmega(ParamFloat set) { mTadapMaxOmega = set; }
                ParamFloat getTadapMaxOmega( void )   { return mTadapMaxOmega; }

                void setTadapMaxSpeed(ParamFloat set) { mTadapMaxSpeed = set; }
                ParamFloat getTadapMaxSpeed( void )   { return mTadapMaxSpeed; }

                void setTadapLevels(int set) { mTadapLevels = set; }
                int getTadapLevels( void )   { return mTadapLevels; }

                //      void set(ParamFloat set) { m = set; seenThis( PARAM_ ); }
                //      ParamFloat get( void )   { return m; }



        private:

                AnimChannel<ParamFloat> mcViscosity;

                ParamFloat mSoundSpeed;

                ParamFloat mDomainSize;

                ParamFloat mCellSize;

                ParamFloat mTimeStep;

                AnimChannel<ParamVec> mcGravity;

                ParamFloat mTimestep;
                ParamFloat mDesiredTimestep;
                ParamFloat mMaxTimestep, mMinTimestep;

                int mSizex, mSizey, mSizez;

                ParamFloat mTimeFactor;

                AnimChannel<ParamFloat> mcAniFrameTime;
                ParamFloat mTimeStepScale;

                ParamFloat mAniStart;

                //ParamVec mExtent;

                ParamFloat mDensity;

                ParamFloat mGStar;
                ParamFloat mNormalizedGStar;
                ParamFloat mFluidVolumeHeight;

                ParamFloat mSimulationMaxSpeed;
                ParamFloat mTadapMaxOmega;
                ParamFloat mTadapMaxSpeed;
                int mTadapLevels;

                int mFrameNum;

                int mSeenValues;

                int mCalculatedValues;

                AttributeList *mpAttrs;
};


#endif