GridFluidSolver3.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_GRID_FLUID_SOLVER3_HPP
#define CUBBYFLOW_GRID_FLUID_SOLVER3_HPP
 
#include <Core/Animation/PhysicsAnimation.hpp>
#include <Core/Emitter/GridEmitter3.hpp>
#include <Core/Geometry/Collider.hpp>
#include <Core/Grid/GridSystemData.hpp>
#include <Core/Solver/Advection/AdvectionSolver3.hpp>
#include <Core/Solver/Grid/GridDiffusionSolver3.hpp>
#include <Core/Solver/Grid/GridPressureSolver3.hpp>
 
namespace CubbyFlow
{
class GridFluidSolver3 : public PhysicsAnimation
{
 public:
    class Builder;
 
    GridFluidSolver3();
 
    GridFluidSolver3(const Vector3UZ& resolution, const Vector3D& gridSpacing,
                     const Vector3D& gridOrigin);
 
    GridFluidSolver3(const GridFluidSolver3&) = delete;
 
    GridFluidSolver3(GridFluidSolver3&&) noexcept = delete;
 
    ~GridFluidSolver3() override = default;
 
    GridFluidSolver3& operator=(const GridFluidSolver3&) = delete;
 
    GridFluidSolver3& operator=(GridFluidSolver3&&) noexcept = delete;
 
    [[nodiscard]] const Vector3D& GetGravity() const;
 
    void SetGravity(const Vector3D& newGravity);
 
    [[nodiscard]] double GetViscosityCoefficient() const;
 
    void SetViscosityCoefficient(double newValue);
 
    [[nodiscard]] double GetCFL(double timeIntervalInSeconds) const;
 
    [[nodiscard]] double GetMaxCFL() const;
 
    void SetMaxCFL(double newCFL);
 
    [[nodiscard]] bool GetUseCompressedLinearSystem() const;
 
    void SetUseCompressedLinearSystem(bool isOn);
 
    [[nodiscard]] const AdvectionSolver3Ptr& GetAdvectionSolver() const;
 
    void SetAdvectionSolver(const AdvectionSolver3Ptr& newSolver);
 
    [[nodiscard]] const GridDiffusionSolver3Ptr& GetDiffusionSolver() const;
 
    void SetDiffusionSolver(const GridDiffusionSolver3Ptr& newSolver);
 
    [[nodiscard]] const GridPressureSolver3Ptr& GetPressureSolver() const;
 
    void SetPressureSolver(const GridPressureSolver3Ptr& newSolver);
 
    [[nodiscard]] int GetClosedDomainBoundaryFlag() const;
 
    void SetClosedDomainBoundaryFlag(int flag);
 
    [[nodiscard]] const GridSystemData3Ptr& GetGridSystemData() const;
 
    void ResizeGrid(const Vector3UZ& newSize, const Vector3D& newGridSpacing,
                    const Vector3D& newGridOrigin) const;
 
    [[nodiscard]] Vector3UZ GetResolution() const;
 
    [[nodiscard]] Vector3D GetGridSpacing() const;
 
    [[nodiscard]] Vector3D GetGridOrigin() const;
 
    [[nodiscard]] const FaceCenteredGrid3Ptr& GetVelocity() const;
 
    [[nodiscard]] const Collider3Ptr& GetCollider() const;
 
    void SetCollider(const Collider3Ptr& newCollider);
 
    [[nodiscard]] const GridEmitter3Ptr& GetEmitter() const;
 
    void SetEmitter(const GridEmitter3Ptr& newEmitter);
 
    [[nodiscard]] static Builder GetBuilder();
 
 protected:
    void OnInitialize() override;
 
    void OnAdvanceTimeStep(double timeIntervalInSeconds) override;
 
    [[nodiscard]] unsigned int GetNumberOfSubTimeSteps(
        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);
 
    [[nodiscard]] virtual ScalarField3Ptr GetFluidSDF() const;
 
    void ComputeGravity(double timeIntervalInSeconds);
 
    void ApplyBoundaryCondition() const;
 
    void ExtrapolateIntoCollider(ScalarGrid3* grid);
 
    void ExtrapolateIntoCollider(CollocatedVectorGrid3* grid);
 
    void ExtrapolateIntoCollider(FaceCenteredGrid3* grid);
 
    [[nodiscard]] ScalarField3Ptr GetColliderSDF() const;
 
    [[nodiscard]] VectorField3Ptr GetColliderVelocityField() const;
 
 private:
    void BeginAdvanceTimeStep(double timeIntervalInSeconds);
 
    void EndAdvanceTimeStep(double timeIntervalInSeconds);
 
    void UpdateCollider(double timeIntervalInSeconds) const;
 
    void UpdateEmitter(double timeIntervalInSeconds) const;
 
    GridSystemData3Ptr m_grids;
    Collider3Ptr m_collider;
    GridEmitter3Ptr m_emitter;
 
    AdvectionSolver3Ptr m_advectionSolver;
    GridDiffusionSolver3Ptr m_diffusionSolver;
    GridPressureSolver3Ptr m_pressureSolver;
    GridBoundaryConditionSolver3Ptr m_boundaryConditionSolver;
 
    Vector3D m_gravity = Vector3D{ 0.0, -9.8, 0.0 };
    double m_viscosityCoefficient = 0.0;
    double m_maxCFL = 5.0;
    int m_closedDomainBoundaryFlag = DIRECTION_ALL;
    bool m_useCompressedLinearSys = false;
};
 
using GridFluidSolver3Ptr = std::shared_ptr<GridFluidSolver3>;
 
template <typename DerivedBuilder>
class GridFluidSolverBuilderBase3
{
 public:
    [[nodiscard]] DerivedBuilder& WithResolution(const Vector3UZ& resolution);
 
    [[nodiscard]] DerivedBuilder& WithGridSpacing(const Vector3D& gridSpacing);
 
    [[nodiscard]] DerivedBuilder& WithGridSpacing(double gridSpacing);
 
    [[nodiscard]] DerivedBuilder& WithDomainSizeX(double domainSizeX);
 
    [[nodiscard]] DerivedBuilder& WithOrigin(const Vector3D& gridOrigin);
 
 protected:
    [[nodiscard]] Vector3D GetGridSpacing() const;
 
    Vector3UZ m_resolution{ 1, 1, 1 };
    Vector3D m_gridSpacing{ 1, 1, 1 };
    Vector3D m_gridOrigin{ 0, 0, 0 };
    double m_domainSizeX = 1.0;
    bool m_useDomainSize = false;
};
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::WithResolution(const Vector3UZ& resolution)
{
    m_resolution = resolution;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::WithGridSpacing(const Vector3D& gridSpacing)
{
    m_gridSpacing = gridSpacing;
    m_useDomainSize = false;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::WithGridSpacing(double gridSpacing)
{
    m_gridSpacing.x = gridSpacing;
    m_gridSpacing.y = gridSpacing;
    m_gridSpacing.z = gridSpacing;
    m_useDomainSize = false;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::WithDomainSizeX(double domainSizeX)
{
    m_domainSizeX = domainSizeX;
    m_useDomainSize = true;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& GridFluidSolverBuilderBase3<T>::WithOrigin(const Vector3D& gridOrigin)
{
    m_gridOrigin = gridOrigin;
    return static_cast<T&>(*this);
}
 
template <typename T>
Vector3D GridFluidSolverBuilderBase3<T>::GetGridSpacing() const
{
    Vector3D gridSpacing = m_gridSpacing;
 
    if (m_useDomainSize)
    {
        gridSpacing.Fill(m_domainSizeX / static_cast<double>(m_resolution.x));
    }
 
    return gridSpacing;
}
 
class GridFluidSolver3::Builder final
    : public GridFluidSolverBuilderBase3<Builder>
{
 public:
    [[nodiscard]] GridFluidSolver3 Build() const;
 
    [[nodiscard]] GridFluidSolver3Ptr MakeShared() const
    {
        return std::make_shared<GridFluidSolver3>(
            m_resolution, GetGridSpacing(), m_gridOrigin);
    }
};
}  // namespace CubbyFlow
 
#endif