grid_fluid_solver3.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_SOLVER3_H_
#define INCLUDE_JET_GRID_FLUID_SOLVER3_H_
 
#include <jet/advection_solver3.h>
#include <jet/cell_centered_scalar_grid3.h>
#include <jet/collider3.h>
#include <jet/face_centered_grid3.h>
#include <jet/grid_boundary_condition_solver3.h>
#include <jet/grid_diffusion_solver3.h>
#include <jet/grid_emitter3.h>
#include <jet/grid_pressure_solver3.h>
#include <jet/grid_system_data3.h>
#include <jet/physics_animation.h>
 
namespace jet {
 
class GridFluidSolver3 : public PhysicsAnimation {
 public:
    class Builder;
 
    GridFluidSolver3();
 
    GridFluidSolver3(const Size3& resolution, const Vector3D& gridSpacing,
                     const Vector3D& gridOrigin);
 
    virtual ~GridFluidSolver3();
 
    const Vector3D& gravity() const;
 
    void setGravity(const Vector3D& 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 AdvectionSolver3Ptr& advectionSolver() const;
 
    void setAdvectionSolver(const AdvectionSolver3Ptr& newSolver);
 
    const GridDiffusionSolver3Ptr& diffusionSolver() const;
 
    void setDiffusionSolver(const GridDiffusionSolver3Ptr& newSolver);
 
    const GridPressureSolver3Ptr& pressureSolver() const;
 
    void setPressureSolver(const GridPressureSolver3Ptr& newSolver);
 
    int closedDomainBoundaryFlag() const;
 
    void setClosedDomainBoundaryFlag(int flag);
 
    const GridSystemData3Ptr& gridSystemData() const;
 
    void resizeGrid(const Size3& newSize, const Vector3D& newGridSpacing,
                    const Vector3D& newGridOrigin);
 
    Size3 resolution() const;
 
    Vector3D gridSpacing() const;
 
    Vector3D gridOrigin() const;
 
    const FaceCenteredGrid3Ptr& velocity() const;
 
    const Collider3Ptr& collider() const;
 
    void setCollider(const Collider3Ptr& newCollider);
 
    const GridEmitter3Ptr& emitter() const;
 
    void setEmitter(const GridEmitter3Ptr& 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 ScalarField3Ptr fluidSdf() const;
 
    void computeGravity(double timeIntervalInSeconds);
 
    void applyBoundaryCondition();
 
    void extrapolateIntoCollider(ScalarGrid3* grid);
 
    void extrapolateIntoCollider(CollocatedVectorGrid3* grid);
 
    void extrapolateIntoCollider(FaceCenteredGrid3* grid);
 
    ScalarField3Ptr colliderSdf() const;
 
    VectorField3Ptr colliderVelocityField() const;
 
 private:
    Vector3D _gravity = Vector3D(0.0, -9.8, 0.0);
    double _viscosityCoefficient = 0.0;
    double _maxCfl = 5.0;
    bool _useCompressedLinearSys = false;
    int _closedDomainBoundaryFlag = kDirectionAll;
 
    GridSystemData3Ptr _grids;
    Collider3Ptr _collider;
    GridEmitter3Ptr _emitter;
 
    AdvectionSolver3Ptr _advectionSolver;
    GridDiffusionSolver3Ptr _diffusionSolver;
    GridPressureSolver3Ptr _pressureSolver;
    GridBoundaryConditionSolver3Ptr _boundaryConditionSolver;
 
    void beginAdvanceTimeStep(double timeIntervalInSeconds);
 
    void endAdvanceTimeStep(double timeIntervalInSeconds);
 
    void updateCollider(double timeIntervalInSeconds);
 
    void updateEmitter(double timeIntervalInSeconds);
};
 
typedef std::shared_ptr<GridFluidSolver3> GridFluidSolver3Ptr;
 
template <typename DerivedBuilder>
class GridFluidSolverBuilderBase3 {
 public:
    DerivedBuilder& withResolution(const Size3& resolution);
 
    DerivedBuilder& withGridSpacing(const Vector3D& gridSpacing);
 
    DerivedBuilder& withGridSpacing(double gridSpacing);
 
    DerivedBuilder& withDomainSizeX(double domainSizeX);
 
    DerivedBuilder& withOrigin(const Vector3D& gridOrigin);
 
 protected:
    Size3 _resolution{1, 1, 1};
    Vector3D _gridSpacing{1, 1, 1};
    Vector3D _gridOrigin{0, 0, 0};
    double _domainSizeX = 1.0;
    bool _useDomainSize = false;
 
    Vector3D getGridSpacing() const;
};
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::withResolution(const Size3& resolution) {
    _resolution = resolution;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::withGridSpacing(
    const Vector3D& gridSpacing) {
    _gridSpacing = gridSpacing;
    _useDomainSize = false;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::withGridSpacing(double gridSpacing) {
    _gridSpacing.x = gridSpacing;
    _gridSpacing.y = gridSpacing;
    _gridSpacing.z = gridSpacing;
    _useDomainSize = false;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::withDomainSizeX(double domainSizeX) {
    _domainSizeX = domainSizeX;
    _useDomainSize = true;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::withOrigin(const Vector3D& gridOrigin) {
    _gridOrigin = gridOrigin;
    return static_cast<T&>(*this);
}
 
template <typename T>
Vector3D GridFluidSolverBuilderBase3<T>::getGridSpacing() const {
    Vector3D gridSpacing = _gridSpacing;
    if (_useDomainSize) {
        gridSpacing.set(_domainSizeX / static_cast<double>(_resolution.x));
    }
    return gridSpacing;
}
 
class GridFluidSolver3::Builder final
    : public GridFluidSolverBuilderBase3<GridFluidSolver3::Builder> {
 public:
    GridFluidSolver3 build() const;
 
    GridFluidSolver3Ptr makeShared() const {
        return std::make_shared<GridFluidSolver3>(_resolution, getGridSpacing(),
                                                  _gridOrigin);
    }
};
 
}  // namespace jet
 
#endif  // INCLUDE_JET_GRID_FLUID_SOLVER3_H_