api_device_contacts.hpp | Ansys Developer Portal

#pragma once
 
#include <rocky20/api/rocky_model_api.hpp>
#include <rocky20/device/device_forces.hpp>
#include <rocky20/device/device_contact.hpp>
 
namespace
{
 
template <typename ForcePipelineFunctions>
__host__ __device__ void api_process_frictional_contact_data(
    IRockyContact& contact_api,
    IRockyContactOutputData& contact_output,
    const ForcePipelineFunctions& functions,
    void* udf_data)
{
    auto rocky_contact = contact_api._impl;
 
    // Intermediate Data
    IRockyContactIntermediateData contact_idata {};
    cuda_contact_intermediate_data& idata = contact_idata._idata;
 
    // Output Data
    contact_output_data& output = contact_output._output;
 
    device::get_frictional_contact_general_parameters(
        *rocky_contact, output, idata, contact_api.get_current_time());
 
    // Custom (or standard) function calculating contact normal force
    functions.template run<EForcePipelineFunctions::fpfComputeNormalForce>(
        contact_api, contact_idata, contact_output, udf_data);
 
    // Custom (or standard) function calculating contact tangential force
    functions.template run<EForcePipelineFunctions::fpfComputeTangentialForce>(
        contact_api, contact_idata, contact_output, udf_data);
 
    if (rocky_contact->get_tangential_force_model() == tfmCustom)
        device::calculate_mu_and_slip(*rocky_contact, contact_output, contact_idata);
 
    // Custom (or standard) function calculating contact rolling resistance
    functions.template run<EForcePipelineFunctions::fpfComputeRollingResistance>(
        contact_api, contact_idata, contact_output, udf_data);
    if (!contact_output._is_rr_power_set)
        device::calculate_standard_rr_power(*rocky_contact, contact_idata, contact_output);
 
    // Custom (or standard) function calculating contact impact energies
 
    if (rocky_contact->model->gen->flags.needs_impact_energy())
    {
        functions.template run<EForcePipelineFunctions::fpfComputeImpactEnergy>(
            contact_api, contact_idata, contact_output, udf_data);
    }
 
    device::calculate_standard_shear_energy(contact_output, contact_api);
 
    device::get_total_frictional_forces_and_moments(*rocky_contact, output, idata);
 
    /* updating stored values */
    const int contact_index = rocky_contact->contact_index;
    rocky20::ContactScalars& scalars = rocky_contact->get_scalars();
 
    if (rocky_contact->get_normal_force_model() != nfmLinearHysteresis)
        scalars.get_normal_force(contact_index) = output.normal_force;
 
    if (scalars.has_tangential_force_enabled()
        && (rocky_contact->get_tangential_force_model() == tfmCustom
            || rocky_contact->get_tangential_force_model() == tfmCoulombLimitTangential))
        scalars.get_tangential_forces()[contact_index] = output.tangential_force;
 
    if (scalars.has_tangential_sliding_enabled()
        && rocky_contact->get_tangential_force_model() == tfmCustom)
        scalars.get_is_sliding_scalars()[contact_index] = contact_output._sliding;
 
    if (scalars.has_sliding_distance())
        scalars.get_sliding_distance(contact_index) = output.sliding_distance;
    if (scalars.has_normal_relative_velocity())
        scalars.get_normal_relative_velocity(contact_index) = output.normal_velocity;
    if (scalars.has_tangential_relative_velocity())
        scalars.get_tangential_relative_velocity(contact_index) = output.tangential_velocity;
 
    if (rocky_contact->model->gen->flags.needs_energy_dissipation())
        device::compute_frictional_dissipation_energy(
            *rocky_contact, output, idata, output.rr_power);
}
 
 
template <typename Callable>
__host__ __device__ void api_process_adhesive_contact_data(
    IRockyContact& contact_api, IRockyAdhesionOutputData& output_data,
    Callable process_contact_ptr, void *udf_data,
    cu_real* normal_adhesion_forces, cu_real3* tangential_adhesion_forces
)
{
    cuda_contact_intermediate_data idata{};
    auto rocky_contact = contact_api._impl;
 
    device::get_adhesive_contact_general_parameters(
        *rocky_contact, output_data._output, idata, contact_api.get_current_time());
 
    // Custom function calculating adhesive force
    process_contact_ptr(contact_api, output_data, udf_data);
    auto& output = output_data._output;
 
    const auto scale = rocky_contact->get_scale();
    output.adhesive_normal_force *= scale;
    output.adhesive_tangential_force *= scale;
 
    output.force = output.adhesive_normal_force * rocky_contact->get_normal_unit_vector()
        + output.adhesive_tangential_force;
 
    if (rocky_contact->model->gen->flags.needs_energy_dissipation())
        device::compute_adhesive_dissipation_energy(*rocky_contact, output, idata);
 
    if (normal_adhesion_forces)
        normal_adhesion_forces[rocky_contact->contact_index] = output.adhesive_normal_force;
    if (tangential_adhesion_forces)
        tangential_adhesion_forces[rocky_contact->contact_index] = output.adhesive_tangential_force;
 
    output.home_moment = cross(idata.home_arm, output.force);
    if (rocky_contact->is_particle_contact)
        output.near_moment = -cross(idata.near_arm, output.force);
}
 
} // namespace
 
 
namespace device
{
 
template <class backend, typename Callable>
__host__ __device__ void execute_contacts_function(
    SDeviceModel *device_data, cu_real current_time,
    unsigned int *contact_indexes, int total_number_contacts,
    bool is_particle_contacts,
    Callable process_contact_ptr, void *udf_data
)
{
    IRockyDeviceModel device_model_api;
    RockyContact rocky_contact(device_data, is_particle_contacts);
    IRockyContact contact_api { &rocky_contact, current_time };
    device_model_api._impl.model = device_data;
    device_model_api._impl.current_time = current_time;
    
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, total_number_contacts);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        unsigned int contact_index = contact_indexes[index];
        rocky_contact.reset(contact_index);
        const SContactState state = rocky_contact.get_state();
        if (!state.disabled())
        {
            process_contact_ptr(device_model_api, contact_api, udf_data);
        }
    }
}
 
template <class backend, typename Callable>
__host__ __device__ void execute_finished_contacts_function(
    SDeviceModel* device_data, cu_real current_time,
    int total_number_contacts,
    bool is_particle_contacts,
    Callable process_contact_ptr, void* udf_data
)
{
    IRockyDeviceModel device_model_api;
    RockyContact rocky_contact(device_data, is_particle_contacts);
    IRockyContact contact_api { &rocky_contact, current_time };
    device_model_api._impl.model = device_data;
    device_model_api._impl.current_time = current_time;
 
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, total_number_contacts);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        rocky_contact.reset(index);
        if (rocky_contact.just_finished_adhesive() || rocky_contact.just_finished_frictional())
        {
            process_contact_ptr(device_model_api, contact_api, udf_data);
        }
    }
}
 
template <class backend, typename Callable>
__host__ __device__ void execute_active_contacts_function(
    SDeviceModel* device_data, cu_real current_time,
    int total_number_contacts,
    bool is_particle_contacts,
    Callable process_contact_ptr, void* udf_data
)
{
    IRockyDeviceModel device_model_api;
    RockyContact rocky_contact(device_data, is_particle_contacts);
    IRockyContact contact_api { &rocky_contact, current_time };
    device_model_api._impl.model = device_data;
    device_model_api._impl.current_time = current_time;
 
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, total_number_contacts);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        rocky_contact.reset(index);
        const SContactState state = rocky_contact.get_state();
        if (state.is_frictional() || state.is_adhesive())
        {
            process_contact_ptr(device_model_api, contact_api, udf_data);
        }
    }
}
 
template <class backend, typename Callable>
__host__ __device__ void execute_all_contacts_function(
    SDeviceModel *device_data, cu_real current_time,
    int total_number_contacts,
    bool is_particle_contacts,
    Callable process_contact_ptr, void *udf_data
)
{
    IRockyDeviceModel device_model_api;
    RockyContact rocky_contact(device_data, is_particle_contacts);
    IRockyContact contact_api { &rocky_contact, current_time };
    device_model_api._impl.model = device_data;
    device_model_api._impl.current_time = current_time;
    contact_api._impl = &rocky_contact;
 
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, total_number_contacts);
    for (int contact_index = thread_start; contact_index < thread_stop; contact_index += thread_step)
    {
        //Process frictional contacts
        rocky_contact.reset(contact_index);
        const SContactState state = rocky_contact.get_state();
        if (!state.disabled())
        {
            process_contact_ptr(device_model_api, contact_api, udf_data);
        }
    }
}
 
template <class backend, typename ForcePipelineFunctions>
__host__ __device__ void api_compute_particle_contact_frictional_forces(
    SDeviceModel* device_data,
    cu_real current_time,
    const ForcePipelineFunctions& functions,
    void* udf_data)
{
    RockyContact rocky_contact(device_data, true);
    IRockyContact contact_api { &rocky_contact, current_time };
 
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, device_data->n_contacts->particle_fr);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        unsigned int contact_index = device_data->ind_cnt_p_fr[index];
        rocky_contact.reset(contact_index);
 
        if (!rocky_contact.get_state().disabled())
        {
            IRockyContactOutputData contact_output{};
 
            api_process_frictional_contact_data(contact_api, contact_output, functions, udf_data);
 
            update_frictional_particle_contact_forces_and_statistics<backend>(
                rocky_contact, contact_output._output, current_time);
        }
    }
}
 
template <class backend, typename ForcePipelineFunctions>
__host__ __device__ void api_compute_triangle_contact_frictional_forces(
    SDeviceModel *device_data, cu_real current_time,
    const ForcePipelineFunctions& functions, void *udf_data
)
{
    RockyContact rocky_contact(device_data, false);
    IRockyContact contact_api { &rocky_contact, current_time };
 
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, device_data->n_contacts->triangle_fr);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        unsigned int contact_index = device_data->ind_cnt_t_fr[index];
        rocky_contact.reset(contact_index);
 
        if (!rocky_contact.get_state().disabled())
        {
            IRockyContactOutputData contact_output{};
 
            api_process_frictional_contact_data(contact_api, contact_output, functions, udf_data);
 
            update_frictional_triangle_contact_forces_and_statistics<backend>(
                rocky_contact, contact_output._output, current_time);
        }
    }
}
 
template <class backend, typename Callable>
__host__ __device__ void api_compute_particle_contact_adhesive_forces(
    SDeviceModel* device_data, cu_real current_time, Callable process_contact_ptr, void* udf_data)
{
    RockyContact rocky_contact(device_data, true);
    IRockyContact contact_api { &rocky_contact, current_time };
 
    rocky20::ContactScalars* contact_scalars = device_data->current_particle_contact_scalars;
    cu_real* normal_adhesion_forces = contact_scalars->has_normal_adhesion_force() ?
        contact_scalars->get_normal_adhesion_forces() : nullptr;
    cu_real3* tangential_adhesion_forces = contact_scalars->has_tangential_adhesion_force() ?
        contact_scalars->get_tangential_adhesion_forces() : nullptr;
 
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, device_data->n_contacts->particle_ad);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        unsigned int contact_index = device_data->ind_cnt_p_ad[index];
        const SContactState state = contact_scalars->get_state(contact_index);
 
        if (!state.disabled())
        {
            rocky_contact.reset(contact_index);
            IRockyAdhesionOutputData adhesion_output{};
 
            api_process_adhesive_contact_data(
                contact_api, adhesion_output,
                process_contact_ptr, udf_data,
                normal_adhesion_forces, tangential_adhesion_forces
            );
 
            update_adhesive_particle_contact_forces_and_statistics<backend>(
                rocky_contact, adhesion_output._output);
        }
    }
}
 
template <class backend, typename Callable>
__host__ __device__ void api_compute_triangle_contact_adhesive_forces(
    SDeviceModel* device_data, cu_real current_time, Callable process_contact_ptr, void* udf_data)
{
    RockyContact rocky_contact(device_data, false);
    IRockyContact contact_api { &rocky_contact, current_time };
 
    rocky20::ContactScalars* contact_scalars = device_data->current_triangle_contact_scalars;
    cu_real* normal_adhesion_forces = contact_scalars->has_normal_adhesion_force() ?
        contact_scalars->get_normal_adhesion_forces() : nullptr;
    cu_real3* tangential_adhesion_forces = contact_scalars->has_tangential_adhesion_force() ?
        contact_scalars->get_tangential_adhesion_forces() : nullptr;
 
    // Thread
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, device_data->n_contacts->triangle_ad);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        unsigned int contact_index = device_data->ind_cnt_t_ad[index];
        const SContactState state = contact_scalars->get_state(contact_index);
 
        if (!state.disabled())
        {
            rocky_contact.reset(contact_index);
            IRockyAdhesionOutputData adhesion_output{};
 
            api_process_adhesive_contact_data(
                contact_api, adhesion_output,
                process_contact_ptr, udf_data,
                normal_adhesion_forces, tangential_adhesion_forces
            );
 
            update_adhesive_triangle_contact_forces_and_statistics<backend>(
                rocky_contact, adhesion_output._output);
        }
    }
}
 
template <class backend, typename Callable>
__host__ __device__ void api_compute_boundaries_wear(
    SDeviceModel* device_data,
    const cu_real current_time,
    Callable process_triangle_wear_f_ptr,
    void* udf_data)
{
    RockyContact rocky_contact(device_data, false);
 
    IRockyContact contact_api;
    contact_api._impl = &rocky_contact;
 
    int thread_start, thread_step, thread_stop;
    backend::ThreadIteration(thread_start, thread_step, thread_stop, device_data->n_contacts->triangle_fr);
    for (int index = thread_start; index < thread_stop; index += thread_step)
    {
        unsigned int contact_index = device_data->ind_cnt_t_fr[index];
        rocky_contact.reset(contact_index);
        const SContactState state = rocky_contact.get_state();
 
        if (!state.disabled())
        {
            auto& boundary = rocky_contact.get_near_boundary();
            if (boundary.wear_model == wmCustom)
            {
                double wear_volume;
                process_triangle_wear_f_ptr(contact_api, wear_volume, udf_data);
                accumulate_wear_volume<backend>(rocky_contact, wear_volume, current_time);
            }
        }
    }
}
 
} // namespace device
Rocky Solver SDK 2024 R2

api_device_contacts

Connect with Ansys
