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