rocky_cfd.hpp | Ansys Developer Portal

#pragma once
 
// Includes =======================================================================================
#include "rocky_particle_scalars.hpp"
#include "rocky_fluid_scalars.hpp"
 
#include <rocky20/api/rocky_particle.hpp>
#include <rocky20/api/device/api_backend.hpp>
#include <rocky20/device/device_model.hpp>
#include <rocky20/cuda/interaction_forces.hpp>
 
// ================================================================================================
// IRockyCFDProperties
// ================================================================================================
 
struct IRockyCFDProperties
{       
    inline ROCKY_FUNCTIONS double get_fluid_density() const
    {
        return this->model->fluid_scalars->get_density(this->cfd_index);
    }
 
 
    inline ROCKY_FUNCTIONS double get_fluid_viscosity() const
    {
        return this->model->fluid_scalars->get_viscosity(this->cfd_index);
    }
 
 
    inline ROCKY_FUNCTIONS double get_fluid_temperature() const
    {
        return this->model->fluid_scalars->get_temperature(this->cfd_index);
    }
 
 
    inline ROCKY_FUNCTIONS double get_fluid_specific_heat() const
    {
        return this->model->fluid_scalars->get_specific_heat(this->cfd_index);
    }
 
 
    inline ROCKY_FUNCTIONS double get_fluid_thermal_conductivity() const
    {
        return this->model->fluid_scalars->get_thermal_conductivity(this->cfd_index);
    }
 
 
    inline ROCKY_FUNCTIONS double3 get_fluid_pressure_gradient() const
    {
        return this->model->fluid_scalars->get_pressure_gradient(this->cfd_index);
    }
 
 
    inline ROCKY_FUNCTIONS double3 compute_fluid_vorticity() const
    {
        const cu_real3 grad_u = this->model->fluid_scalars->get_velocity_u_gradient(this->cfd_index);
        const cu_real3 grad_v = this->model->fluid_scalars->get_velocity_v_gradient(this->cfd_index);
        const cu_real3 grad_w = this->model->fluid_scalars->get_velocity_w_gradient(this->cfd_index);
        return double3{ grad_w.y - grad_v.z, grad_u.z - grad_w.x, grad_v.x - grad_u.y };
    }
 
 
    inline ROCKY_FUNCTIONS double3 get_relative_velocity() const
    {
        return this->props.relative_velocity;
    }
 
 
    inline ROCKY_FUNCTIONS double get_reynolds_number() const
    {
        return Reynolds(
            props.relative_velocity_norm,
            this->get_fluid_density(), props.diameter,
            this->get_fluid_viscosity() * props.cgm_factor
        ) + DBL_EPSILON;
    }
 
 
    inline ROCKY_FUNCTIONS double compute_vorticity_reynolds_number() const
    {
        double omega_f = rocky::vector::get_norm(this->compute_fluid_vorticity());
        return Reynolds_omega(omega_f, this->get_fluid_density(), this->props.diameter,
            this->get_fluid_viscosity() * props.cgm_factor) + DBL_EPSILON;
    }
 
 
    inline ROCKY_FUNCTIONS double compute_relative_angular_reynolds_number(
        const double3& particle_angular_velocity) const
    {
        double omega_r = rocky::vector::get_norm(0.5 * this->compute_fluid_vorticity() - particle_angular_velocity);
        return Reynolds_omega(omega_r, this->get_fluid_density(), this->props.diameter,
            this->get_fluid_viscosity() * props.cgm_factor) + DBL_EPSILON;
    }
 
 
    inline ROCKY_FUNCTIONS double get_prandtl_number() const
    {
        if (this->get_fluid_thermal_conductivity() > SMALL_VALUE)
        {
            return this->get_fluid_specific_heat() * this->get_fluid_viscosity() 
                / this->get_fluid_thermal_conductivity();
        }
        else
        {
            return DBL_MAX;
        }
    }
 
 
    inline ROCKY_FUNCTIONS double get_solid_fraction() const
    {
        return this->model->fluid_scalars->get_solid_volume_fraction(this->cfd_index);
    }
 
    inline ROCKY_FUNCTIONS double get_cell_volume() const
    {
        return this->model->fluid_scalars->get_cell_volume(this->cfd_index);
    }
 
    inline ROCKY_FUNCTIONS IRockyFluidScalars get_scalars() const
    {
        return IRockyFluidScalars(*this->model->fluid_scalars, this->cfd_index);
    }
 
    inline ROCKY_FUNCTIONS double get_cfd_time_step() const
    {
        return this->model->gen_cfd->dt_target_f;
    }
 
 
    inline ROCKY_FUNCTIONS double get_particle_equivalent_diameter() const
    {
        return this->props.diameter;
    }
 
    inline ROCKY_FUNCTIONS double get_particle_volume() const
    {
        return M_PI / 6.0 * this->props.diameter * this->props.diameter * this->props.diameter;
    }
 
    inline ROCKY_FUNCTIONS double get_particle_equivalent_cross_area() const
    {
        return 0.25 * M_PI * this->props.diameter * this->props.diameter;
    }
 
    // Equivalent to RockyParticle::get_sphericity but faster, as the equivalent diameter is already
    // computed (which requires a cubic root)
    inline ROCKY_FUNCTIONS double compute_particle_sphericity(const RockyParticle& particle) const
    {
        return (particle.get_group().tpe == ptSpherical)
            ? 1.0
            : (M_PI * this->props.diameter * this->props.diameter) / particle.get_area();
    }
 
    inline ROCKY_FUNCTIONS double get_relative_velocity_norm() const
    {
        return this->props.relative_velocity_norm;
    }
 
 
 
    SDeviceModel* model;
    CFDParticleProperties props;
    int cfd_index;
    const CFDParticleGroup* cfd_particle_group;
 
    inline ROCKY_FUNCTIONS void reset(int particle_index, int cfd_index)
    {
        this->cfd_index = cfd_index;
        this->update_properties(particle_index);
    }
 
    inline ROCKY_FUNCTIONS void update_properties(int particle_index)
    {
        const RockyParticle particle(this->model, particle_index);
 
        this->cfd_particle_group =
            &this->model->cfd_particle_groups[particle.get_particle_group_index()];
 
        props.diameter = particle.get_equivalent_diameter();
        props.density = particle.get_mass() / particle.get_solid_volume();
        props.cgm_factor = particle.get_cgm_scale_factor();
 
        const double3 particle_velocity = particle.get_translational_velocity();
        const double3 fluid_velocity = this->model->fluid_scalars->get_velocity(this->cfd_index);
 
        /* converting particle_velocity according to Fluent's porous particle_velocity formulation*/
        if (this->model->gen_cfd->superficial_velocity_formulation)
        {
            double porosity = 1.0 - this->model->fluid_scalars->get_solid_volume_fraction(this->cfd_index);
           
            auto true_velocity = [porosity] (double superficial_velocity, double particle_vel) 
            {
                double direction;
                direction = superficial_velocity >= 0.0 ? 1.0 : -1.0;
                    
                double velocity =  superficial_velocity + (1.0/porosity - 1.0)*(superficial_velocity - particle_vel);
                velocity = max(abs(velocity), abs(superficial_velocity));
                /* where superficial_velocity/porosity is the physical particle_velocity */
                return min(velocity, abs(superficial_velocity/porosity))*direction;
            };
 
            props.relative_velocity = {
                true_velocity(fluid_velocity.x, particle_velocity.x) - particle_velocity.x,
                true_velocity(fluid_velocity.y, particle_velocity.y) - particle_velocity.y,
                true_velocity(fluid_velocity.z, particle_velocity.z) - particle_velocity.z,
            };
        }
        else
        {
            props.relative_velocity = fluid_velocity - particle_velocity;
        }
 
        if (this->model->gen_cfd->use_turbulent_dispersion)
        {
            props.relative_velocity += this->model->particle_scalars->get_turbulence_velocity(particle_index);
        }
 
        props.relative_velocity_norm = rocky::vector::get_norm(props.relative_velocity);
    }
 
};
 
Rocky Solver SDK 2025 R1

rocky_cfd

Connect with Ansys
