grid_fluid_solver2.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_GRID_FLUID_SOLVER2_H_
#define INCLUDE_JET_GRID_FLUID_SOLVER2_H_
 
#include <jet/advection_solver2.h>
#include <jet/cell_centered_scalar_grid2.h>
#include <jet/collider2.h>
#include <jet/face_centered_grid2.h>
#include <jet/grid_boundary_condition_solver2.h>
#include <jet/grid_diffusion_solver2.h>
#include <jet/grid_emitter2.h>
#include <jet/grid_pressure_solver2.h>
#include <jet/grid_system_data2.h>
#include <jet/physics_animation.h>
 
namespace jet {
 
class GridFluidSolver2 : public PhysicsAnimation {
 public:
    class Builder;
 
    GridFluidSolver2();
 
    GridFluidSolver2(const Size2& resolution, const Vector2D& gridSpacing,
                     const Vector2D& gridOrigin);
 
    virtual ~GridFluidSolver2();
 
    const Vector2D& gravity() const;
 
    void setGravity(const Vector2D& newGravity);
 
    double viscosityCoefficient() const;
 
    void setViscosityCoefficient(double newValue);
 
    double cfl(double timeIntervalInSeconds) const;
 
    double maxCfl() const;
 
    void setMaxCfl(double newCfl);
 
    bool useCompressedLinearSystem() const;
 
    void setUseCompressedLinearSystem(bool onoff);
 
    const AdvectionSolver2Ptr& advectionSolver() const;
 
    void setAdvectionSolver(const AdvectionSolver2Ptr& newSolver);
 
    const GridDiffusionSolver2Ptr& diffusionSolver() const;
 
    void setDiffusionSolver(const GridDiffusionSolver2Ptr& newSolver);
 
    const GridPressureSolver2Ptr& pressureSolver() const;
 
    void setPressureSolver(const GridPressureSolver2Ptr& newSolver);
 
    int closedDomainBoundaryFlag() const;
 
    void setClosedDomainBoundaryFlag(int flag);
 
    const GridSystemData2Ptr& gridSystemData() const;
 
    void resizeGrid(const Size2& newSize, const Vector2D& newGridSpacing,
                    const Vector2D& newGridOrigin);
 
    Size2 resolution() const;
 
    Vector2D gridSpacing() const;
 
    Vector2D gridOrigin() const;
 
    const FaceCenteredGrid2Ptr& velocity() const;
 
    const Collider2Ptr& collider() const;
 
    void setCollider(const Collider2Ptr& newCollider);
 
    const GridEmitter2Ptr& emitter() const;
 
    void setEmitter(const GridEmitter2Ptr& newEmitter);
 
    static Builder builder();
 
 protected:
    void onInitialize() override;
 
    void onAdvanceTimeStep(double timeIntervalInSeconds) override;
 
    unsigned int numberOfSubTimeSteps(
        double timeIntervalInSeconds) const override;
 
    virtual void onBeginAdvanceTimeStep(double timeIntervalInSeconds);
 
    virtual void onEndAdvanceTimeStep(double timeIntervalInSeconds);
 
    virtual void computeExternalForces(double timeIntervalInSeconds);
 
    virtual void computeViscosity(double timeIntervalInSeconds);
 
    virtual void computePressure(double timeIntervalInSeconds);
 
    virtual void computeAdvection(double timeIntervalInSeconds);
 
    virtual ScalarField2Ptr fluidSdf() const;
 
    void computeGravity(double timeIntervalInSeconds);
 
    void applyBoundaryCondition();
 
    void extrapolateIntoCollider(ScalarGrid2* grid);
 
    void extrapolateIntoCollider(CollocatedVectorGrid2* grid);
 
    void extrapolateIntoCollider(FaceCenteredGrid2* grid);
 
    ScalarField2Ptr colliderSdf() const;
 
    VectorField2Ptr colliderVelocityField() const;
 
 private:
    Vector2D _gravity = Vector2D(0.0, -9.8);
    double _viscosityCoefficient = 0.0;
    double _maxCfl = 5.0;
    bool _useCompressedLinearSys = false;
    int _closedDomainBoundaryFlag = kDirectionAll;
 
    GridSystemData2Ptr _grids;
    Collider2Ptr _collider;
    GridEmitter2Ptr _emitter;
 
    AdvectionSolver2Ptr _advectionSolver;
    GridDiffusionSolver2Ptr _diffusionSolver;
    GridPressureSolver2Ptr _pressureSolver;
    GridBoundaryConditionSolver2Ptr _boundaryConditionSolver;
 
    void beginAdvanceTimeStep(double timeIntervalInSeconds);
 
    void endAdvanceTimeStep(double timeIntervalInSeconds);
 
    void updateCollider(double timeIntervalInSeconds);
 
    void updateEmitter(double timeIntervalInSeconds);
};
 
typedef std::shared_ptr<GridFluidSolver2> GridFluidSolver2Ptr;
 
template <typename DerivedBuilder>
class GridFluidSolverBuilderBase2 {
 public:
    DerivedBuilder& withResolution(const Size2& resolution);
 
    DerivedBuilder& withGridSpacing(const Vector2D& gridSpacing);
 
    DerivedBuilder& withGridSpacing(double gridSpacing);
 
    DerivedBuilder& withDomainSizeX(double domainSizeX);
 
    DerivedBuilder& withOrigin(const Vector2D& gridOrigin);
 
 protected:
    Size2 _resolution{1, 1};
    Vector2D _gridSpacing{1, 1};
    Vector2D _gridOrigin{0, 0};
    double _domainSizeX = 1.0;
    bool _useDomainSize = false;
 
    Vector2D getGridSpacing() const;
};
 
template <typename T>
T& GridFluidSolverBuilderBase2<T>::withResolution(const Size2& resolution) {
    _resolution = resolution;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase2<T>::withGridSpacing(
    const Vector2D& gridSpacing) {
    _gridSpacing = gridSpacing;
    _useDomainSize = false;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase2<T>::withGridSpacing(double gridSpacing) {
    _gridSpacing.x = gridSpacing;
    _gridSpacing.y = gridSpacing;
    _useDomainSize = false;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase2<T>::withDomainSizeX(double domainSizeX) {
    _domainSizeX = domainSizeX;
    _useDomainSize = true;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase2<T>::withOrigin(const Vector2D& gridOrigin) {
    _gridOrigin = gridOrigin;
    return static_cast<T&>(*this);
}
 
template <typename T>
Vector2D GridFluidSolverBuilderBase2<T>::getGridSpacing() const {
    Vector2D gridSpacing = _gridSpacing;
    if (_useDomainSize) {
        gridSpacing.set(_domainSizeX / static_cast<double>(_resolution.x));
    }
    return gridSpacing;
}
 
class GridFluidSolver2::Builder final
    : public GridFluidSolverBuilderBase2<GridFluidSolver2::Builder> {
 public:
    GridFluidSolver2 build() const;
 
    GridFluidSolver2Ptr makeShared() const {
        return std::make_shared<GridFluidSolver2>(_resolution, getGridSpacing(),
                                                  _gridOrigin);
    }
};
 
}  // namespace jet
 
#endif  // INCLUDE_JET_GRID_FLUID_SOLVER2_H_