rocky_sph_element_scalars.hpp | Ansys Developer Portal

#pragma once
 
// Includes =======================================================================================
#include "../rocky_scalars.h"
#include <rocky20/sph/sph_particle_scalars.h>
 
using rocky20::KnownSPHParticleScalars;
 
// Forward declarations ===========================================================================
class cuda_host;
struct SPHDeviceModel;
typedef cuda_host RockyModel;
 
enum ESPHOperationType
{
    sphotReset,
    sphotSum,
    sphotUpdate
};
 
struct IRockySPHElementScalarsModel : ScalarsModel<rocky20::SPHParticleScalarsController>
{
    // Scalars Operations ------------------------------------------------------------------------
 
    void set_operation(int scalar_index, ESPHOperationType operation, ESPHOperationPlace place);
 
    void enable_velocity_gradient() const;
 
#ifdef ONLY_FOR_DOXYGEN
 
    int find(const char* name);
 
    void reset(int scalar_index);
 
    void set_dimension(int scalar_index, double dimension_factor);
 
#endif
 
    template <class _data_type = float>
    int add(const char* name, const char* unit, bool output = true)
    {
        // By definition, SPH Scalars are default-typed accumulation for mGPU combine operations.
        // Although, this is a convention that must be enforced by a set_operation call indicating
        // where the accumulation/sum must occur.
        return this->_impl.template add_scalars<_data_type>(
            name, unit, rocky20::ScalarsInfo::cotAccumulateOnDemand, output);
    }
 
    IRockySPHElementScalarsModel(SPHModel* sph_model, const std::vector<int>& device_ids);
 
};
 
struct IRockySPHElementScalars : EntityScalars<rocky20::SPHParticleScalars>
{
    using base_type = EntityScalars<rocky20::SPHParticleScalars>;
    // get ----------------------------------------------------------------------------------------
 
    template <class _data_type = float>
    ROCKY_FUNCTIONS _data_type get_scalar(int scalar_index) const
    {
        return base_type::get_scalar<_data_type>(scalar_index);
    }
 
    ROCKY_FUNCTIONS inline float get_turbulent_viscosity() const
    {
        return this->get_known_scalar<float>(KnownSPHParticleScalars::TurbulentViscosity);
    }
 
    ROCKY_FUNCTIONS inline float get_temperature() const
    {
        return this->get_known_scalar<float>(KnownSPHParticleScalars::Temperature);
    }
 
    ROCKY_FUNCTIONS inline float get_heat_transfer() const
    {
        return this->get_known_scalar<float>(KnownSPHParticleScalars::HeatTransferRate);
    }
 
    ROCKY_FUNCTIONS inline float3 get_velocity_gradient_x() const
    {
        return this->get_known_scalar<float3>(KnownSPHParticleScalars::GradientVelocityX);
    }
 
    ROCKY_FUNCTIONS inline float3 get_velocity_gradient_y() const
    {
        return this->get_known_scalar<float3>(KnownSPHParticleScalars::GradientVelocityY);
    }
 
    ROCKY_FUNCTIONS inline float3 get_velocity_gradient_z() const
    {
        return this->get_known_scalar<float3>(KnownSPHParticleScalars::GradientVelocityZ);
    }
 
    // set ----------------------------------------------------------------------------------------
 
    template <class _data_type = float>
    ROCKY_FUNCTIONS void set_scalar(int scalar_index, _data_type value) const
    {
        base_type::set_scalar<_data_type>(scalar_index, value);
    }
 
    ROCKY_FUNCTIONS inline void set_turbulent_viscosity(const float value)
    {
        this->get_known_scalar<float>(KnownSPHParticleScalars::TurbulentViscosity) = value;
    }
 
    ROCKY_FUNCTIONS inline void set_temperature(const float value)
    {
        this->get_known_scalar<float>(KnownSPHParticleScalars::Temperature) = value;
    }
 
    ROCKY_FUNCTIONS inline void set_heat_transfer(const float value)
    {
        this->get_known_scalar<float>(KnownSPHParticleScalars::HeatTransferRate) = value;
    }
 
    // add ----------------------------------------------------------------------------------------
 
    template <class _data_type = float>
    ROCKY_FUNCTIONS void add_scalar(int scalar_index, _data_type value) const
    {
        base_type::add_scalar<_data_type>(scalar_index, value);
    }
 
    ROCKY_FUNCTIONS inline void add_turbulent_viscosity(const float value)
    {
        this->add_known_scalar(KnownSPHParticleScalars::TurbulentViscosity, value);
    }
 
    ROCKY_FUNCTIONS inline void add_temperature(const float value)
    {
        this->add_known_scalar(KnownSPHParticleScalars::Temperature, value);
    }
 
    ROCKY_FUNCTIONS inline void add_heat_transfer(const float value)
    {
        this->add_known_scalar(KnownSPHParticleScalars::HeatTransferRate, value);
    }
 
    // max ----------------------------------------------------------------------------------------
 
    template <class _data_type = float>
    ROCKY_FUNCTIONS void max_scalar(int scalar_index, _data_type value) const
    {
        base_type::max_scalar<_data_type>(scalar_index, value);
    }
 
    ROCKY_FUNCTIONS IRockySPHElementScalars(
        rocky20::SPHParticleScalars& _scalars, int _element_index)
        : EntityScalars<rocky20::SPHParticleScalars>(_scalars, _element_index)
    {
    }
 
};
Rocky Solver SDK 2025 R1

rocky_sph_element_scalars

Connect with Ansys
