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