CUDASPHSolverBase3.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_BASE3_HPP
#define CUBBYFLOW_CUDA_PARTICLE_SPH_SOLVER_BASE3_HPP
 
#ifdef CUBBYFLOW_USE_CUDA
 
#include <Core/CUDA/CUDAParticleSystemSolverBase3.hpp>
#include <Core/CUDA/CUDASPHSystemData3.hpp>
#include <Core/Geometry/BoundingBox.hpp>
 
namespace CubbyFlow
{
class CUDASPHSolverBase3 : public CUDAParticleSystemSolverBase3
{
 public:
    CUDASPHSolverBase3();
 
    CUDASPHSolverBase3(const CUDASPHSolverBase3&) = delete;
 
    CUDASPHSolverBase3(CUDASPHSolverBase3&&) noexcept = delete;
 
    ~CUDASPHSolverBase3() override = default;
 
    CUDASPHSolverBase3& operator=(const CUDASPHSolverBase3&) = delete;
 
    CUDASPHSolverBase3& operator=(CUDASPHSolverBase3&&) 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 BoundingBox3F& Container() const;
 
    void SetContainer(const BoundingBox3F& cont);
 
    CUDAParticleSystemData3* ParticleSystemData() override;
 
    const CUDAParticleSystemData3* ParticleSystemData() const override;
 
    CUDASPHSystemData3* SPHSystemData();
 
    const CUDASPHSystemData3* SPHSystemData() const;
 
 protected:
    unsigned int GetNumberOfSubTimeSteps(
        double timeIntervalInSeconds) const override;
 
    CUDAArrayView1<float4> Forces() const;
 
    CUDAArrayView1<float4> 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;
    BoundingBox3F m_container;
 
    // Data model
    CUDASPHSystemData3Ptr m_sphSystemData;
};
 
using CUDASPHSolverBase3Ptr = std::shared_ptr<CUDASPHSolverBase3>;
 
template <typename DerivedBuilder>
class CUDASPHSolverBuilderBase3
    : public CUDAParticleSystemSolverBuilderBase3<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& CUDASPHSolverBuilderBase3<T>::WithTargetDensity(float targetDensity)
{
    m_targetDensity = targetDensity;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& CUDASPHSolverBuilderBase3<T>::WithTargetSpacing(float targetSpacing)
{
    m_targetSpacing = targetSpacing;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& CUDASPHSolverBuilderBase3<T>::WithRelativeKernelRadius(
    float relativeKernelRadius)
{
    m_relativeKernelRadius = relativeKernelRadius;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& CUDASPHSolverBuilderBase3<T>::WithNegativePressureScale(
    float negativePressureScale)
{
    m_negativePressureScale = negativePressureScale;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& CUDASPHSolverBuilderBase3<T>::WithViscosityCoefficient(
    float viscosityCoefficient)
{
    m_viscosityCoefficient = viscosityCoefficient;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& CUDASPHSolverBuilderBase3<T>::WithPseudoViscosityCoefficient(
    float pseudoViscosityCoefficient)
{
    m_pseudoViscosityCoefficient = pseudoViscosityCoefficient;
    return static_cast<T&>(*this);
}
}  // namespace CubbyFlow
 
#endif
 
#endif