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