rocky_contact_api.hpp | Ansys Developer Portal

// (C) 2024 ANSYS, Inc. Unauthorized use, distribution, or duplication is prohibited.
#pragma once
 
// Includes =======================================================================================
#include <rocky20/api/rocky_contact.hpp>
#include <rocky20/api/rocky_material_api.hpp>
#include <rocky20/device/device_contact.hpp>
 
 
// ================================================================================================
// IRockyContact
// ================================================================================================
 
struct IRockyContact
{
    ROCKY_FUNCTIONS IRockyMaterial get_home_material() const;
 
    ROCKY_FUNCTIONS IRockyMaterial get_near_material() const;
 
    ROCKY_FUNCTIONS IRockyMaterialInteraction get_material_interaction() const;
 
    ROCKY_FUNCTIONS int get_material_interaction_index() const;
 
    ROCKY_FUNCTIONS IRockyParticle get_home_particle() const;
 
    ROCKY_FUNCTIONS int get_home_particle_group_index() const;
 
    ROCKY_FUNCTIONS IRockyParticle get_near_particle() const;
 
    ROCKY_FUNCTIONS int get_near_particle_group_index() const;
 
    ROCKY_FUNCTIONS IRockyGeometryTriangle get_near_triangle() const;
 
    ROCKY_FUNCTIONS int get_near_geometry_index() const;
 
    ROCKY_FUNCTIONS bool is_particle_particle_contact() const;
 
    ROCKY_FUNCTIONS bool is_particle_triangle_contact() const;
 
    ROCKY_FUNCTIONS bool is_frictional() const;
 
    ROCKY_FUNCTIONS bool is_adhesive() const;
 
    ROCKY_FUNCTIONS double get_previous_overlap() const;
 
    ROCKY_FUNCTIONS double get_overlap() const;
 
    ROCKY_FUNCTIONS double3 get_normal_unit_vector() const;
 
    ROCKY_FUNCTIONS double3 get_contact_position() const;
 
    ROCKY_FUNCTIONS double get_scale_factor() const;
 
    ROCKY_FUNCTIONS bool just_started_frictional() const;
 
    ROCKY_FUNCTIONS bool just_started_adhesive() const;
 
    ROCKY_FUNCTIONS bool just_finished_frictional() const;
 
    ROCKY_FUNCTIONS bool just_finished_adhesive() const;
 
    ROCKY_FUNCTIONS bool is_loading() const;
 
    ROCKY_FUNCTIONS bool is_unloading() const;
 
    ROCKY_FUNCTIONS bool is_positive_oriented() const;
 
    ROCKY_FUNCTIONS double get_current_time() const;
 
    ROCKY_FUNCTIONS double get_timestep() const;
 
    ROCKY_FUNCTIONS IRockyContactScalars get_particle_contact_scalars() const;
 
    ROCKY_FUNCTIONS IRockyContactScalars get_triangle_contact_scalars() const;
 
    ROCKY_FUNCTIONS double get_home_stiffness() const;
 
    ROCKY_FUNCTIONS double get_near_stiffness() const;
 
    ROCKY_FUNCTIONS double get_equivalent_stiffness() const;
 
    ROCKY_FUNCTIONS double get_home_stiffness_fraction() const;
 
    ROCKY_FUNCTIONS double get_reduced_young_modulus() const;
 
    ROCKY_FUNCTIONS double get_equivalent_mass() const;
 
    ROCKY_FUNCTIONS double get_equivalent_radius() const;
 
    ROCKY_FUNCTIONS double get_normal_contact_force() const;
 
    ROCKY_FUNCTIONS double3 get_tangential_contact_force() const;
 
    ROCKY_FUNCTIONS double3 calculate_relative_velocity() const;
 
    ROCKY_FUNCTIONS double get_restitution_coefficient() const;
 
    ROCKY_FUNCTIONS void set_restitution_coefficient(double value);
 
    ROCKY_FUNCTIONS double get_dynamic_friction_coefficient() const;
 
    ROCKY_FUNCTIONS void set_dynamic_friction_coefficient(double value);
 
    ROCKY_FUNCTIONS double get_static_friction_coefficient() const;
 
    ROCKY_FUNCTIONS void set_static_friction_coefficient(double value);
 
    ROCKY_FUNCTIONS double get_sliding_distance() const;
 
    ROCKY_FUNCTIONS bool get_is_sliding_marker() const;
 
    ROCKY_FUNCTIONS double get_normal_relative_velocity() const;
 
    ROCKY_FUNCTIONS double3 get_tangential_relative_velocity() const;
 
    ROCKY_FUNCTIONS double get_normal_adhesion_force() const;
 
    ROCKY_FUNCTIONS double3 get_tangential_adhesion_force() const;
 
    ROCKY_FUNCTIONS double3 get_previous_normal_vector() const;
 
    ROCKY_FUNCTIONS double3 get_previous_moment_vector() const;
 
    ROCKY_FUNCTIONS void set_previous_moment_vector(double3 value);
 
    RockyContact *_impl;
    double current_time;
};
 
inline ROCKY_FUNCTIONS IRockyMaterial IRockyContact::get_home_material() const
{
    return IRockyMaterial(this->_impl->get_home_material());
}
 
inline ROCKY_FUNCTIONS IRockyMaterial IRockyContact::get_near_material() const
{
    return IRockyMaterial(this->_impl->get_near_material());
}
 
inline ROCKY_FUNCTIONS IRockyMaterialInteraction IRockyContact::get_material_interaction() const
{
    return IRockyMaterialInteraction(this->_impl->get_material_interaction());
}
 
inline ROCKY_FUNCTIONS int IRockyContact::get_material_interaction_index() const
{
    return this->_impl->get_material_interaction_index();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::is_particle_particle_contact() const
{
    return this->_impl->is_particle_particle();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::is_particle_triangle_contact() const
{
    return this->_impl->is_particle_triangle();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::is_frictional() const
{
    return this->_impl->is_frictional();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::is_adhesive() const
{
    return this->_impl->is_adhesive();
}
 
inline ROCKY_FUNCTIONS IRockyParticle IRockyContact::get_home_particle() const
{
    return IRockyParticle(this->_impl->get_home_particle_index(), this->_impl->model);
}
 
inline ROCKY_FUNCTIONS int IRockyContact::get_home_particle_group_index() const
{
    return this->_impl->get_home_particle_base_group_index();
}
 
inline ROCKY_FUNCTIONS IRockyParticle IRockyContact::get_near_particle() const
{
    return IRockyParticle(this->_impl->get_near_particle_index(), this->_impl->model);
}
 
inline ROCKY_FUNCTIONS int IRockyContact::get_near_particle_group_index() const
{
    return this->_impl->get_near_particle_base_group_index();
}
 
inline ROCKY_FUNCTIONS IRockyGeometryTriangle IRockyContact::get_near_triangle() const
{
    return IRockyGeometryTriangle(this->_impl->get_near_triangle_index(), this->_impl->model);
}
 
inline ROCKY_FUNCTIONS int IRockyContact::get_near_geometry_index() const
{
    return this->_impl->get_near_boundary_index();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_overlap() const
{
    return this->_impl->get_overlap();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_previous_overlap() const
{
    return this->_impl->get_previous_overlap();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::get_normal_unit_vector() const
{
    return this->_impl->get_normal_unit_vector();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::get_contact_position() const
{
    return this->_impl->get_contact_position();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_scale_factor() const
{
    return this->_impl->get_scale_factor();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_current_time() const
{
    return this->current_time;
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_timestep() const
{
    return this->_impl->get_timestep();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::just_started_frictional() const
{
    return this->_impl->just_started_frictional();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::just_started_adhesive() const
{
    return this->_impl->just_started_adhesive();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::just_finished_frictional() const
{
    return this->_impl->just_finished_frictional();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::just_finished_adhesive() const
{
    return this->_impl->just_finished_adhesive();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::is_loading() const
{
    return this->_impl->is_loading();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::is_unloading() const
{
    return this->_impl->is_unloading();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_normal_contact_force() const
{
    return this->_impl->get_scaled_normal_force();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::get_tangential_contact_force() const
{
    if (this->_impl->get_scalars().has_tangential_force_enabled())
        return this->_impl->get_scaled_tangential_force();
    else
        return double3{};
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::is_positive_oriented() const 
{
    return this->_impl->is_positive_oriented();
}
 
// Composite properties
 
inline ROCKY_FUNCTIONS double IRockyContact::get_home_stiffness() const
{
    return this->_impl->get_home_stiffness();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_near_stiffness() const
{
    return this->_impl->get_near_stiffness();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_equivalent_stiffness() const
{
    return this->_impl->get_equivalent_stiffness();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_home_stiffness_fraction() const
{
    return this->_impl->get_home_stiffness_fraction();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_reduced_young_modulus() const
{
    return this->_impl->get_reduced_young_modulus();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_equivalent_mass() const
{
    return this->_impl->get_equivalent_mass();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_equivalent_radius() const
{
    return this->_impl->get_equivalent_radius();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::calculate_relative_velocity() const
{
    double3 home_trans_velocity, near_trans_velocity;
    double3 home_rotat_velocity, near_rotat_velocity;
    double3 home_arm, near_arm;
    deformable_fractions deformable_output;
 
    // For deformables, calculate the vertices weights for nodal forces
    if (this->_impl->get_home_particle_group().is_deformable())
        device::get_deformable_forces_nodal_fractions(
            *this->_impl,
            deformable_output.n_nde_h,
            deformable_output.nde_h,
            deformable_output.nde_fr_h,
            true,
            this->is_frictional());
    if (this->_impl->is_particle_particle()
        && this->_impl->get_near_particle_group().is_deformable())
        device::get_deformable_forces_nodal_fractions(
            *this->_impl,
            deformable_output.n_nde_n,
            deformable_output.nde_n,
            deformable_output.nde_fr_n,
            false,
            this->is_frictional());
 
    device::calculate_contact_velocities(
        *this->_impl,
        home_trans_velocity,
        near_trans_velocity,
        home_rotat_velocity,
        near_rotat_velocity,
        home_arm,
        near_arm,
        this->current_time,
        deformable_output);
 
    if (this->is_particle_particle_contact())
    {
        return device::get_relative_velocity_particle_particle(
            home_trans_velocity, near_trans_velocity,
            home_rotat_velocity, near_rotat_velocity,
            home_arm, near_arm
        );
    }
    else
    {
        return device::get_relative_velocity_particle_triangle(
            home_trans_velocity, near_trans_velocity,
            home_rotat_velocity, home_arm
        );
    }
}
 
// Scalars
 
inline ROCKY_FUNCTIONS IRockyContactScalars IRockyContact::get_particle_contact_scalars() const
{
    return this->_impl->get_particle_contact_scalars();
}
 
inline ROCKY_FUNCTIONS IRockyContactScalars IRockyContact::get_triangle_contact_scalars() const
{
    return this->_impl->get_triangle_contact_scalars();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::get_previous_normal_vector() const
{
    return this->_impl->get_previous_normal_vector();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::get_previous_moment_vector() const
{
    return this->_impl->get_previous_moment_vector();
}
 
inline ROCKY_FUNCTIONS void IRockyContact::set_previous_moment_vector(double3 value)
{
    this->_impl->set_previous_moment_vector(value);
}
 
// Variable Properties
inline ROCKY_FUNCTIONS double IRockyContact::get_dynamic_friction_coefficient() const
{
    return this->_impl->get_dynamic_friction_coefficient();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_static_friction_coefficient() const
{
    return this->_impl->get_static_friction_coefficient();
}
 
inline ROCKY_FUNCTIONS void IRockyContact::set_dynamic_friction_coefficient(double value)
{
    this->_impl->set_dynamic_friction_coefficient(value);
}
 
inline ROCKY_FUNCTIONS void IRockyContact::set_static_friction_coefficient(double value)
{
    this->_impl->set_static_friction_coefficient(value);
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_restitution_coefficient() const
{
    return this->_impl->get_restitution_coefficient();
}
 
inline ROCKY_FUNCTIONS void IRockyContact::set_restitution_coefficient(double value)
{
    this->_impl->set_restitution_coefficient(value);
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_sliding_distance() const
{
    return this->_impl->get_sliding_distance();
}
 
inline ROCKY_FUNCTIONS bool IRockyContact::get_is_sliding_marker() const
{
    return this->_impl->get_is_sliding_marker();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_normal_relative_velocity() const
{
    return this->_impl->get_normal_relative_velocity();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::get_tangential_relative_velocity() const
{
    return this->_impl->get_tangential_relative_velocity();
}
 
inline ROCKY_FUNCTIONS double IRockyContact::get_normal_adhesion_force() const
{
    return this->_impl->get_normal_adhesion_force();
}
 
inline ROCKY_FUNCTIONS double3 IRockyContact::get_tangential_adhesion_force() const
{
    return this->_impl->get_tangential_adhesion_force();
}
Rocky Solver SDK 2025 R2

rocky_contact_api

Connect with Ansys
