CUDASPHSolverBase2.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_CUDA_PARTICLE_SPH_SOLVER_BASE2_HPP
#define CUBBYFLOW_CUDA_PARTICLE_SPH_SOLVER_BASE2_HPP

#ifdef CUBBYFLOW_USE_CUDA

#include <Core/CUDA/CUDAParticleSystemSolverBase2.hpp>
#include <Core/CUDA/CUDASPHSystemData2.hpp>
#include <Core/Geometry/BoundingBox.hpp>

namespace CubbyFlow
{
class CUDASPHSolverBase2 : public CUDAParticleSystemSolverBase2
{
 public:
    CUDASPHSolverBase2();

    CUDASPHSolverBase2(const CUDASPHSolverBase2&) = delete;

    CUDASPHSolverBase2(CUDASPHSolverBase2&&) noexcept = delete;

    ~CUDASPHSolverBase2() override = default;

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

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

    float NegativePressureScale() const;

    void SetNegativePressureScale(float newNegativePressureScale);

    float ViscosityCoefficient() const;

    void SetViscosityCoefficient(float newViscosityCoefficient);

    float PseudoViscosityCoefficient() const;

    void SetPseudoViscosityCoefficient(float newPseudoViscosityCoefficient);

    float SpeedOfSound() const;

    void SetSpeedOfSound(float newSpeedOfSound);

    float TimeStepLimitScale() const;

    void SetTimeStepLimitScale(float newScale);

    const BoundingBox2F& Container() const;

    void SetContainer(const BoundingBox2F& cont);

    CUDAParticleSystemData2* ParticleSystemData() override;

    const CUDAParticleSystemData2* ParticleSystemData() const override;

    CUDASPHSystemData2* SPHSystemData();

    const CUDASPHSystemData2* SPHSystemData() const;

 protected:
    unsigned int GetNumberOfSubTimeSteps(
        double timeIntervalInSeconds) const override;

    CUDAArrayView1<float2> Forces() const;

    CUDAArrayView1<float2> SmoothedVelocities() const;

 private:
    // Basic SPH solver properties
    size_t m_forcesIdx;
    size_t m_smoothedVelIdx;
    float m_negativePressureScale = 0.0f;
    float m_viscosityCoefficient = 0.01f;
    float m_pseudoViscosityCoefficient = 10.0f;
    float m_speedOfSound = 100.0f;
    float m_timeStepLimitScale = 1.0f;
    BoundingBox2F m_container{ Vector2F{ -1000.0f, -1000.0f },
                               Vector2F{ 1000.0f, 1000.0f } };

    // Data model
    CUDASPHSystemData2Ptr m_sphSystemData;
};

using CUDASPHSolverBase2Ptr = std::shared_ptr<CUDASPHSolverBase2>;

template <typename DerivedBuilder>
class CUDASPHSolverBuilderBase2
    : public CUDAParticleSystemSolverBuilderBase2<DerivedBuilder>
{
 public:
    DerivedBuilder& WithTargetDensity(float targetDensity);

    DerivedBuilder& WithTargetSpacing(float targetSpacing);

    DerivedBuilder& WithRelativeKernelRadius(float relativeKernelRadius);

    DerivedBuilder& WithNegativePressureScale(float negativePressureScale);

    DerivedBuilder& WithViscosityCoefficient(float viscosityCoefficient);

    DerivedBuilder& WithPseudoViscosityCoefficient(
        float pseudoViscosityCoefficient);

 protected:
    float m_targetDensity = WATER_DENSITY_FLOAT;
    float m_targetSpacing = 0.1f;
    float m_relativeKernelRadius = 1.8f;
    float m_negativePressureScale = 0.0f;
    float m_viscosityCoefficient = 0.01f;
    float m_pseudoViscosityCoefficient = 10.0f;
};

template <typename T>
T& CUDASPHSolverBuilderBase2<T>::WithTargetDensity(float targetDensity)
{
    m_targetDensity = targetDensity;
    return static_cast<T&>(*this);
}

template <typename T>
T& CUDASPHSolverBuilderBase2<T>::WithTargetSpacing(float targetSpacing)
{
    m_targetSpacing = targetSpacing;
    return static_cast<T&>(*this);
}

template <typename T>
T& CUDASPHSolverBuilderBase2<T>::WithRelativeKernelRadius(
    float relativeKernelRadius)
{
    m_relativeKernelRadius = relativeKernelRadius;
    return static_cast<T&>(*this);
}

template <typename T>
T& CUDASPHSolverBuilderBase2<T>::WithNegativePressureScale(
    float negativePressureScale)
{
    m_negativePressureScale = negativePressureScale;
    return static_cast<T&>(*this);
}

template <typename T>
T& CUDASPHSolverBuilderBase2<T>::WithViscosityCoefficient(
    float viscosityCoefficient)
{
    m_viscosityCoefficient = viscosityCoefficient;
    return static_cast<T&>(*this);
}

template <typename T>
T& CUDASPHSolverBuilderBase2<T>::WithPseudoViscosityCoefficient(
    float pseudoViscosityCoefficient)
{
    m_pseudoViscosityCoefficient = pseudoViscosityCoefficient;
    return static_cast<T&>(*this);
}
}  // namespace CubbyFlow

#endif

#endif