GridFluidSolver2.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_SOLVER2_HPP
#define CUBBYFLOW_GRID_FLUID_SOLVER2_HPP

#include <Core/Animation/PhysicsAnimation.hpp>
#include <Core/Emitter/GridEmitter2.hpp>
#include <Core/Geometry/Collider.hpp>
#include <Core/Grid/GridSystemData.hpp>
#include <Core/Solver/Advection/AdvectionSolver2.hpp>
#include <Core/Solver/Grid/GridDiffusionSolver2.hpp>
#include <Core/Solver/Grid/GridPressureSolver2.hpp>

namespace CubbyFlow
{
class GridFluidSolver2 : public PhysicsAnimation
{
 public:
    class Builder;

    GridFluidSolver2();

    GridFluidSolver2(const Vector2UZ& resolution, const Vector2D& gridSpacing,
                     const Vector2D& gridOrigin);

    GridFluidSolver2(const GridFluidSolver2&) = delete;

    GridFluidSolver2(GridFluidSolver2&&) noexcept = delete;

    ~GridFluidSolver2() override = default;

    GridFluidSolver2& operator=(const GridFluidSolver2&) = delete;

    GridFluidSolver2& operator=(GridFluidSolver2&&) noexcept = delete;

    [[nodiscard]] const Vector2D& GetGravity() const;

    void SetGravity(const Vector2D& 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 AdvectionSolver2Ptr& GetAdvectionSolver() const;

    void SetAdvectionSolver(const AdvectionSolver2Ptr& newSolver);

    [[nodiscard]] const GridDiffusionSolver2Ptr& GetDiffusionSolver() const;

    void SetDiffusionSolver(const GridDiffusionSolver2Ptr& newSolver);

    [[nodiscard]] const GridPressureSolver2Ptr& GetPressureSolver() const;

    void SetPressureSolver(const GridPressureSolver2Ptr& newSolver);

    [[nodiscard]] int GetClosedDomainBoundaryFlag() const;

    void SetClosedDomainBoundaryFlag(int flag);

    [[nodiscard]] const GridSystemData2Ptr& GetGridSystemData() const;

    void ResizeGrid(const Vector2UZ& newSize, const Vector2D& newGridSpacing,
                    const Vector2D& newGridOrigin) const;

    [[nodiscard]] Vector2UZ GetResolution() const;

    [[nodiscard]] Vector2D GetGridSpacing() const;

    [[nodiscard]] Vector2D GetGridOrigin() const;

    [[nodiscard]] const FaceCenteredGrid2Ptr& GetVelocity() const;

    [[nodiscard]] const Collider2Ptr& GetCollider() const;

    void SetCollider(const Collider2Ptr& newCollider);

    [[nodiscard]] const GridEmitter2Ptr& GetEmitter() const;

    void SetEmitter(const GridEmitter2Ptr& 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 ScalarField2Ptr GetFluidSDF() const;

    void ComputeGravity(double timeIntervalInSeconds);

    void ApplyBoundaryCondition() const;

    void ExtrapolateIntoCollider(ScalarGrid2* grid);

    void ExtrapolateIntoCollider(CollocatedVectorGrid2* grid);

    void ExtrapolateIntoCollider(FaceCenteredGrid2* grid);

    [[nodiscard]] ScalarField2Ptr GetColliderSDF() const;

    [[nodiscard]] VectorField2Ptr GetColliderVelocityField() const;

 private:
    void BeginAdvanceTimeStep(double timeIntervalInSeconds);

    void EndAdvanceTimeStep(double timeIntervalInSeconds);

    void UpdateCollider(double timeIntervalInSeconds) const;

    void UpdateEmitter(double timeIntervalInSeconds) const;

    GridSystemData2Ptr m_grids;
    Collider2Ptr m_collider;
    GridEmitter2Ptr m_emitter;

    AdvectionSolver2Ptr m_advectionSolver;
    GridDiffusionSolver2Ptr m_diffusionSolver;
    GridPressureSolver2Ptr m_pressureSolver;
    GridBoundaryConditionSolver2Ptr m_boundaryConditionSolver;

    Vector2D m_gravity = Vector2D{ 0.0, -9.8 };
    double m_viscosityCoefficient = 0.0;
    double m_maxCFL = 5.0;
    int m_closedDomainBoundaryFlag = DIRECTION_ALL;
    bool m_useCompressedLinearSys = false;
};

using GridFluidSolver2Ptr = std::shared_ptr<GridFluidSolver2>;

template <typename DerivedBuilder>
class GridFluidSolverBuilderBase2
{
 public:
    [[nodiscard]] DerivedBuilder& WithResolution(const Vector2UZ& resolution);

    [[nodiscard]] DerivedBuilder& WithGridSpacing(const Vector2D& gridSpacing);

    [[nodiscard]] DerivedBuilder& WithGridSpacing(double gridSpacing);

    [[nodiscard]] DerivedBuilder& WithDomainSizeX(double domainSizeX);

    [[nodiscard]] DerivedBuilder& WithOrigin(const Vector2D& gridOrigin);

 protected:
    [[nodiscard]] Vector2D GetGridSpacing() const;

    Vector2UZ m_resolution{ 1, 1 };
    Vector2D m_gridSpacing{ 1, 1 };
    Vector2D m_gridOrigin{ 0, 0 };
    double m_domainSizeX = 1.0;
    bool m_useDomainSize = false;
};

template <typename T>
T& GridFluidSolverBuilderBase2<T>::WithResolution(const Vector2UZ& resolution)
{
    m_resolution = resolution;
    return static_cast<T&>(*this);
}

template <typename T>
T& GridFluidSolverBuilderBase2<T>::WithGridSpacing(const Vector2D& gridSpacing)
{
    m_gridSpacing = gridSpacing;
    m_useDomainSize = false;
    return static_cast<T&>(*this);
}

template <typename T>
T& GridFluidSolverBuilderBase2<T>::WithGridSpacing(double gridSpacing)
{
    m_gridSpacing.x = gridSpacing;
    m_gridSpacing.y = gridSpacing;
    m_useDomainSize = false;
    return static_cast<T&>(*this);
}

template <typename T>
T& GridFluidSolverBuilderBase2<T>::WithDomainSizeX(double domainSizeX)
{
    m_domainSizeX = domainSizeX;
    m_useDomainSize = true;
    return static_cast<T&>(*this);
}

template <typename T>
T& GridFluidSolverBuilderBase2<T>::WithOrigin(const Vector2D& gridOrigin)
{
    m_gridOrigin = gridOrigin;
    return static_cast<T&>(*this);
}

template <typename T>
Vector2D GridFluidSolverBuilderBase2<T>::GetGridSpacing() const
{
    Vector2D gridSpacing = m_gridSpacing;

    if (m_useDomainSize)
    {
        gridSpacing.Fill(m_domainSizeX / static_cast<double>(m_resolution.x));
    }

    return gridSpacing;
}

class GridFluidSolver2::Builder final
    : public GridFluidSolverBuilderBase2<Builder>
{
 public:
    [[nodiscard]] GridFluidSolver2 Build() const;

    [[nodiscard]] GridFluidSolver2Ptr MakeShared() const
    {
        return std::make_shared<GridFluidSolver2>(
            m_resolution, GetGridSpacing(), m_gridOrigin);
    }
};
}  // namespace CubbyFlow

#endif