GridFluidSolver3.h

Go to the documentation of this file.

/*************************************************************************
> File Name: GridFluidSolver3.h
> Project Name: CubbyFlow
> Author: Dongmin Kim
> Purpose: Abstract base class for grid-based 3-D fluid solver.
> Created Time: 2017/08/16
> Copyright (c) 2018, Dongmin Kim
*************************************************************************/
#ifndef CUBBYFLOW_GRID_FLUID_SOLVER3_H
#define CUBBYFLOW_GRID_FLUID_SOLVER3_H

#include <Core/Animation/PhysicsAnimation.h>
#include <Core/Collider/Collider3.h>
#include <Core/Emitter/GridEmitter3.h>
#include <Core/Grid/GridSystemData3.h>
#include <Core/Solver/Advection/AdvectionSolver3.h>
#include <Core/Solver/Grid/GridDiffusionSolver3.h>
#include <Core/Solver/Grid/GridPressureSolver3.h>

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

        GridFluidSolver3();

        GridFluidSolver3(
            const Size3& resolution,
            const Vector3D& gridSpacing,
            const Vector3D& gridOrigin);

        virtual ~GridFluidSolver3();

        const Vector3D& GetGravity() const;

        void SetGravity(const Vector3D& newGravity);

        double GetViscosityCoefficient() const;

        void SetViscosityCoefficient(double newValue);

        double GetCFL(double timeIntervalInSeconds) const;

        double GetMaxCFL() const;

        void SetMaxCFL(double newCFL);

        bool GetUseCompressedLinearSystem() const;

        void SetUseCompressedLinearSystem(bool onoff);

        const AdvectionSolver3Ptr& GetAdvectionSolver() const;

        void SetAdvectionSolver(const AdvectionSolver3Ptr& newSolver);

        const GridDiffusionSolver3Ptr& GetDiffusionSolver() const;

        void SetDiffusionSolver(const GridDiffusionSolver3Ptr& newSolver);

        const GridPressureSolver3Ptr& GetPressureSolver() const;

        void SetPressureSolver(const GridPressureSolver3Ptr& newSolver);

        int GetClosedDomainBoundaryFlag() const;

        void SetClosedDomainBoundaryFlag(int flag);

        const GridSystemData3Ptr& GetGridSystemData() const;

        void ResizeGrid(
            const Size3& newSize,
            const Vector3D& newGridSpacing,
            const Vector3D& newGridOrigin) const;

        Size3 GetResolution() const;

        Vector3D GetGridSpacing() const;

        Vector3D GetGridOrigin() const;

        const FaceCenteredGrid3Ptr& GetVelocity() const;

        const Collider3Ptr& GetCollider() const;

        void SetCollider(const Collider3Ptr& newCollider);

        const GridEmitter3Ptr& GetEmitter() const;

        void SetEmitter(const GridEmitter3Ptr& newEmitter);

        static Builder GetBuilder();

    protected:
        void OnInitialize() override;

        void OnAdvanceTimeStep(double timeIntervalInSeconds) override;

        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);

        virtual ScalarField3Ptr GetFluidSDF() const;

        void ComputeGravity(double timeIntervalInSeconds);

        void ApplyBoundaryCondition() const;

        void ExtrapolateIntoCollider(ScalarGrid3* grid);

        void ExtrapolateIntoCollider(CollocatedVectorGrid3* grid);

        void ExtrapolateIntoCollider(FaceCenteredGrid3* grid);

        ScalarField3Ptr GetColliderSDF() const;

        VectorField3Ptr GetColliderVelocityField() const;

    private:
        Vector3D m_gravity = Vector3D(0.0, -9.8, 0.0);
        double m_viscosityCoefficient = 0.0;
        double m_maxCFL = 5.0;
        bool m_useCompressedLinearSys = false;
        int m_closedDomainBoundaryFlag = DIRECTION_ALL;

        GridSystemData3Ptr m_grids;
        Collider3Ptr m_collider;
        GridEmitter3Ptr m_emitter;

        AdvectionSolver3Ptr m_advectionSolver;
        GridDiffusionSolver3Ptr m_diffusionSolver;
        GridPressureSolver3Ptr m_pressureSolver;
        GridBoundaryConditionSolver3Ptr m_boundaryConditionSolver;

        void BeginAdvanceTimeStep(double timeIntervalInSeconds);

        void EndAdvanceTimeStep(double timeIntervalInSeconds);

        void UpdateCollider(double timeIntervalInSeconds) const;

        void UpdateEmitter(double timeIntervalInSeconds) const;
    };

    using GridFluidSolver3Ptr = std::shared_ptr<GridFluidSolver3>;

    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 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;

        Vector3D GetGridSpacing() const;
    };

    template <typename T>
    T& GridFluidSolverBuilderBase3<T>::WithResolution(const Size3& 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.Set(m_domainSizeX / static_cast<double>(m_resolution.x));
        }

        return gridSpacing;
    }

    class GridFluidSolver3::Builder final : public GridFluidSolverBuilderBase3<GridFluidSolver3::Builder>
    {
    public:
        GridFluidSolver3 Build() const;

        GridFluidSolver3Ptr MakeShared() const
        {
            return std::make_shared<GridFluidSolver3>(m_resolution, GetGridSpacing(), m_gridOrigin);
        }
    };
}

#endif