fluidsolver.h

Go to the documentation of this file.

/******************************************************************************
 *
 * MantaFlow fluid solver framework
 * Copyright 2011 Tobias Pfaff, Nils Thuerey 
 *
 * This program is free software, distributed under the terms of the
 * GNU General Public License (GPL) 
 * http://www.gnu.org/licenses
 *
 * Main class for the fluid solver
 *
 ******************************************************************************/

#ifndef _FLUIDSOLVER_H
#define _FLUIDSOLVER_H

#include "manta.h"
#include "vectorbase.h"
#include "vector4d.h"
#include <vector>
#include <map>

namespace Manta { 
    
PYTHON class FluidSolver : public PbClass {
public:
    PYTHON() FluidSolver(Vec3i gridSize, int dim=3, int fourthDim=-1);
    virtual ~FluidSolver();
    
    // accessors
    PYTHON() Vec3i getGridSize() { return mGridSize; }
    inline Real  getDt()       { return mDt; }
    inline Real  getDx()       { return 1.0 / mGridSize.max(); }
    inline Real  getTime()     { return mTimeTotal; }

    inline bool is2D() const { return mDim==2; }
    inline bool is3D() const { return mDim==3; }
    
    PYTHON() void printMemInfo();
    
    PYTHON() void step();
    
    PYTHON() void adaptTimestep(Real maxVel);
    
    PYTHON() PbClass* create(PbType type, PbTypeVec T=PbTypeVec(),const std::string& name = "");
    
    // temp grid and plugin functions: you shouldn't call this manually
    template<class T> T*   getGridPointer();
    template<class T> void freeGridPointer(T* ptr);    

    PYTHON(name=timestep)  Real mDt;  
    PYTHON(name=timeTotal) Real mTimeTotal;
    PYTHON(name=frame)     int  mFrame;
    PYTHON(name=cfl)          Real mCflCond;  
    PYTHON(name=timestepMin)  Real mDtMin;  
    PYTHON(name=timestepMax)  Real mDtMax;  
    PYTHON(name=frameLength)  Real mFrameLength;

protected:
    Vec3i     mGridSize;
    const int mDim;
    Real      mTimePerFrame;
    bool      mLockDt;
        
    template<class T> struct GridStorage {
        GridStorage() : used(0) {}
        T* get(Vec3i size);
        void free();
        void release(T* ptr);
        
        std::vector<T*> grids;
        int used;
    };
    
    GridStorage<int>  mGridsInt;
    GridStorage<Real> mGridsReal;
    GridStorage<Vec3> mGridsVec;



public:
    inline bool supports4D() const        { return mFourthDim>0; }
    inline int  getFourthDim() const { return mFourthDim; }
    template<class T> T*   getGrid4dPointer();
    template<class T> void freeGrid4dPointer(T* ptr);    

protected:

    int       mFourthDim;  

    GridStorage<Vec4> mGridsVec4; 
    GridStorage<int>  mGrids4dInt;
    GridStorage<Real> mGrids4dReal;
    GridStorage<Vec3> mGrids4dVec;
    GridStorage<Vec4> mGrids4dVec4;
};

}

#endif