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;
    }
 
    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)
    {
        auto& particle = this->model->get_particle(particle_index);
        const cuda_particle_group& particle_group = this->model->get_particle_group(particle.get_group_index());
        
        this->cfd_particle_group = &this->model->cfd_particle_groups[particle.get_group_index()];
 
        const double mass = ParticleProperties::get_mass(this->model, particle, particle_index);
        const double bulk_volume = ParticleProperties::get_bulk_volume(this->model, particle, particle_index);
        const double solid_volume = ParticleProperties::get_solid_volume(this->model, particle, particle_index);
        props.diameter = cbrt(6.0 * bulk_volume / M_PI);
        props.density = mass / solid_volume;
        props.cgm_factor = particle_group.cgm_scale_factor;
 
        auto &particle_vel = this->model->get_particle_velocity(particle_index);
        double3 fluid_velocity = this->model->fluid_scalars->get_velocity(this->cfd_index);
 
        /* converting velocity according to Fluent's porous 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 velocity */
                return min(velocity, abs(superficial_velocity/porosity))*direction;
            };
 
            props.relative_velocity = {
            true_velocity(fluid_velocity.x, particle_vel.ux) - particle_vel.ux,
            true_velocity(fluid_velocity.y, particle_vel.uy) - particle_vel.uy,
            true_velocity(fluid_velocity.z, particle_vel.uz) - particle_vel.uz,
            };
        }
        else
        {
            props.relative_velocity = {
            fluid_velocity.x - particle_vel.ux,
            fluid_velocity.y - particle_vel.uy,
            fluid_velocity.z - particle_vel.uz };
        }
 
        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 2024 R2

rocky_cfd

Connect with Ansys
