rocky_api_functions.h | Ansys Developer Portal

#pragma once
 
// Includes =======================================================================================
#include "dll_export.h"
 
#include "rocky_boundary_api.hpp"
 
// Forward declarations ===========================================================================
class IRockyPluginData;
struct IRockyModel;
struct IRockyDeviceModel;
struct IRockyContact;
struct IRockyParticle;
struct IRockyParticleHost;
struct IRockyBreakableParticle;
struct IRockyJoint;
 
class IRockyTimestepData;
class IRockyAdhesiveDistanceData;
struct IRockyTimeCurveData;
struct IRockyAdhesionOutputData;
struct IRockyJointOutputData;
struct IRockyGeometriesMotionData;
struct IRockyOutputPropertyCollection;
 
// Functions Prototypes ===========================================================================
#ifdef __linux__
#define __stdcall
#endif
 
typedef void(__stdcall *configure_f_type)(IRockyPluginData &_input, void *&data);
 
// Setup/Tear Down
typedef void(__stdcall *initialize_f_type)(IRockyModel &model, void *data);
 
typedef void(__stdcall *tear_down_f_type)(const IRockyModel &model, void *data);
 
typedef void(__stdcall *setup_f_type)(IRockyModel &model, void *data);
 
typedef double(__stdcall *compute_timestep_f_type)(const IRockyTimestepData &timestep_data, void *data);
 
typedef double(__stdcall *compute_adhesive_distances_f_type)(IRockyAdhesiveDistanceData &adhesive_distance_data, void *data);
 
typedef void(__stdcall *non_dimensionalize_f_type)(IRockyModel &model, void *data);
 
typedef void(__stdcall *initialize_cuda_f_type)(const IRockyModel &model, void *host_data, int device_id, void *&device_data);
 
typedef void(__stdcall *tear_down_cuda_f_type)(const IRockyModel &model, int device_id, void *device_data);
 
typedef void(__stdcall *sync_cuda_data_f_type)(const IRockyModel &model, void *host_data, int device_id, void *device_data);
 
typedef void(__stdcall* initialize_particle_f_type)(const IRockyModel& model, IRockyParticleHost& particle, void* data);
 
typedef void(__stdcall* initialize_triangle_f_type)(const IRockyModel& model, IRockyGeometryTriangleHost& triangle, void* data);
 
typedef void(__stdcall *initialize_breakage_f_type)(const IRockyBreakableParticle& breakable_particle, void* data);
 
typedef void(__stdcall* setup_output_properties_f_type)(const IRockyModel& model, IRockyOutputPropertyCollection& output_property_collection, void* data);
 
typedef bool(__stdcall *is_valid_f_type)(const IRockyModel &model, void *data);
 
 
// Output
typedef void(__stdcall *output_f_type)(const IRockyModel &model, void *data);
 
typedef double(__stdcall* output_particles_f_type)(const IRockyModel& model, const IRockyParticleHost& particle, int property_id, void* data);
 
typedef double(__stdcall* output_triangles_f_type)(const IRockyModel& model, const IRockyGeometryTriangleHost& triangle, int property_id, void* data);
 
// Contacts
typedef void(__stdcall *contacts_f_type)(IRockyDeviceModel &model, IRockyContact &contact, void *data);
 
typedef void(__stdcall* cuda_contacts_kernel_f_type)(IRockyModel& model, void** plugin_devices_data);
 
typedef void(__stdcall *triangle_wear_f_type)(IRockyContact& contact, double& wear_volume, void* data);
 
typedef void(__stdcall* cuda_triangle_wear_kernel_f_type)(IRockyModel& model, void* data);
 
// Adhesion
 
typedef void(__stdcall* adhesion_forces_f_type)(IRockyContact& contact, IRockyAdhesionOutputData& output_data, void* data);
 
typedef void(__stdcall* cuda_adhesion_forces_kernel_f_type)(IRockyModel& model, void** plugin_devices_data);
 
// Particles
typedef void(__stdcall *particles_f_type)(IRockyDeviceModel &model, IRockyParticle &particle, void *data);
 
typedef void(__stdcall *cuda_particles_kernel_f_type)(IRockyModel &model, void **plugin_devices_data);
 
// Triangles
typedef void(__stdcall* triangles_f_type)(IRockyDeviceModel& model, IRockyBoundaryTriangle& triangle, void* data);
 
typedef void(__stdcall* cuda_triangles_kernel_f_type)(IRockyModel& model, void** plugin_devices_data);
 
// Instantaneous breakage
typedef void(__stdcall* instantaneous_breakage_f_type)(IRockyParticle& particle, bool& broken, void* data);
 
typedef void(__stdcall* cuda_instantaneous_breakage_kernel_f_type)(IRockyModel& model, void** plugin_devices_data);
 
typedef void(__stdcall* fragments_distribution_f_type)(IRockyBreakableParticle& particle, std::vector<double>& distribution, void* data);
 
// Joints
typedef void(__stdcall *joints_f_type)(IRockyDeviceModel &model, IRockyJoint &joint, void *data);
 
typedef void(__stdcall *cuda_joints_kernel_f_type)(IRockyModel &model, void **plugin_devices_data);
 
typedef void(__stdcall *joint_forces_f_type)(IRockyJoint &joint, IRockyJointOutputData& output_data, void *data);
 
typedef void(__stdcall *cuda_joint_forces_kernel_f_type)(IRockyModel &model, void **plugin_devices_data);
 
// Joint breakage
typedef void(__stdcall* joint_breakage_f_type)(IRockyJoint &joint, bool &broken, void *data);
 
typedef void(__stdcall* cuda_joint_breakage_kernel_f_type)(IRockyModel &model, void **plugin_devices_data);
 
// Geometry motion
typedef void(__stdcall *geometries_motion_f_type)(IRockyModel &model, IRockyGeometriesMotionData &motion, void *data);
 
// Extra macros for Frictional Contact Forces ------------------------------------------------------
#include "rocky_api_contact_functions.h"
 
// Special Functor that wraps a function pointer
template <typename Function>
struct Function2Functor
{
    template <typename... Args>
    void operator()(Args&... args)
    {
        (*this->function)(args...);
    }
    Function function;
};
 
// UDF =============================================================================================
#define ROCKY_PLUGIN(plugin_name, plugin_version)      \
    ROCKY_PLUGIN_INFO(plugin_name, plugin_version) extern "C" {
 
#define ROCKY_PLUGIN_END                                \
    ROCKY_PLUGIN_FINISH_CONTACT_MODEL_FUNCTIONS_SETUP() }
 
// Initialization ---------------------------------------------------------------------------------
#define ROCKY_PLUGIN_CONFIGURE(input_data, data) \
    ROCKYAPI_EXPORT void configure(const IRockyPluginData &input_data, void *&data)
 
#define ROCKY_PLUGIN_NON_DIMENSIONALIZE(model, data) \
    extern "C" ROCKYAPI_EXPORT void non_dimensionalize(IRockyModel &model, void *data)
 
#define ROCKY_PLUGIN_INITIALIZE(model, data) \
    extern "C" ROCKYAPI_EXPORT void initialize(IRockyModel &model, void *data)
 
#define ROCKY_PLUGIN_TEAR_DOWN(model, data) \
    extern "C" ROCKYAPI_EXPORT void finish(const IRockyModel &model, void *data)
 
#define ROCKY_PLUGIN_SETUP(model, data) \
    extern "C" ROCKYAPI_EXPORT void setup(IRockyModel &model, void *data)
 
#define ROCKY_PLUGIN_COMPUTE_TIMESTEP(timestep_data, data) \
    extern "C" ROCKYAPI_EXPORT double compute_timestep(const IRockyTimestepData &timestep_data, void *data)
 
#define ROCKY_PLUGIN_IS_VALID(model, data) \
    extern "C" ROCKYAPI_EXPORT bool is_valid(const IRockyModel &model, void *data)
 
#ifdef _MSC_VER
    #define _STR(x) #x
    #define STR(x) _STR(x)
    #define DO_PRAGMA_(x) __pragma (message(__FILE__ "(" STR(__LINE__) ") warning: " x))
    #define DEPRECATED_WARNING(message) DO_PRAGMA_(message)
#else
    #define DO_PRAGMA_(x) _Pragma (#x)
    #define DEPRECATED_WARNING(message) DO_PRAGMA_(GCC warning #message)
#endif
 
#define ROCKY_PLUGIN_COMPUTE_ADHESIVE_DISTANCES(adhesive_distance_data, data) \
    extern "C" ROCKYAPI_EXPORT                                                \
    DEPRECATED_WARNING("'ROCKY_PLUGIN_COMPUTE_ADHESIVE_DISTANCES' hook is deprecated. Now you can set adhesive distances in ROCKY_PLUGIN_INITIALIZE or ROCKY_PLUGIN_BEGIN_ITERATION") \
    void compute_adhesive_distances(IRockyAdhesiveDistanceData &adhesive_distance_data, void *data)
 
#define ROCKY_PLUGIN_INITIALIZE_CUDA(model, host_data, device_id, device_data)                      \
    extern "C" ROCKYAPI_EXPORT void initialize_cuda(                                                \
        const IRockyModel &model, void *host_data, int device_id, void *&device_data)
 
#define ROCKY_PLUGIN_TEAR_DOWN_CUDA(model, device_id, device_data) \
    extern "C" ROCKYAPI_EXPORT void finish_cuda(const IRockyModel &model, int device_id, void *device_data)
 
#define ROCKY_PLUGIN_INITIALIZE_PARTICLE(model, particle, data) \
    extern "C" ROCKYAPI_EXPORT void initialize_particle(        \
        IRockyModel& model, IRockyParticleHost& particle, void* data)
 
#define ROCKY_PLUGIN_INITIALIZE_TRIANGLE(model, triangle, data) \
    extern "C" ROCKYAPI_EXPORT void initialize_triangle(        \
        IRockyModel& model, IRockyGeometryTriangleHost& triangle, void* data)
 
#define ROCKY_PLUGIN_INITIALIZE_INSTANTANEOUS_BREAKAGE(breakable_particle, data)\
    extern "C" ROCKYAPI_EXPORT void initialize_breakage(                        \
        IRockyBreakableParticle& breakable_particle, void* data)
 
#define ROCKY_PLUGIN_INITIALIZE_FRAGMENTS_SIZE_DISTRIBUTION(breakable_particle, data) \
    extern "C" ROCKYAPI_EXPORT void initialize_size_distribution(                     \
        IRockyBreakableParticle& breakable_particle, void* data)
 
#define ROCKY_PLUGIN_SETUP_OUTPUT_PROPERTIES(model, output_property_collection, data)              \
    extern "C" ROCKYAPI_EXPORT void setup_output_properties(                                       \
        const IRockyModel& model, IRockyOutputPropertyCollection& output_property_collection, void* data)
 
// Iteration ---------------------------------------------------------------------------------------
#define ROCKY_PLUGIN_BEGIN_ITERATION_CUDA(model, host_data, device_id, device_data)                \
    extern "C" ROCKYAPI_EXPORT void begin_iteration_cuda(                                          \
        const IRockyModel &model, void *host_data, int device_id, void *&device_data)
 
#define ROCKY_PLUGIN_BEGIN_ITERATION(model, data)                                                  \
    extern "C" ROCKYAPI_EXPORT void begin_iteration(IRockyModel &model, void *data)
 
#define ROCKY_PLUGIN_END_ITERATION_CUDA(model, host_data, device_id, device_data)                  \
    extern "C" ROCKYAPI_EXPORT void end_iteration_cuda(                                            \
        const IRockyModel &model, void *host_data, int device_id, void *&device_data)
 
#define ROCKY_PLUGIN_END_ITERATION(model, data)                                                    \
    extern "C" ROCKYAPI_EXPORT void end_iteration(IRockyModel &model, void *data)
 
// Output ------------------------------------------------------------------------------------------
#define ROCKY_PLUGIN_PRE_OUTPUT_CUDA_SYNC_DATA(model, host_data, device_id, device_data)           \
    extern "C" ROCKYAPI_EXPORT void pre_output_cuda_sync_data(                                     \
        const IRockyModel& model, void* host_data, int device_id, void* device_data)
 
#define ROCKY_PLUGIN_PRE_OUTPUT(model, data)                                                       \
    extern "C" ROCKYAPI_EXPORT void pre_output(const IRockyModel& model, void* data)
 
#define ROCKY_PLUGIN_PRE_OUTPUT_ON_CONTACTS(device_model, contact, data)                           \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_output_on_active_contacts(                 \
        IRockyDeviceModel &device_model, IRockyContact &contact, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_OUTPUT_ON_CONTACTS_END() }
#endif
 
#define ROCKY_PLUGIN_OUTPUT_PARTICLE_PROPERTY(model, particle, property_id, data)                  \
    extern "C" ROCKYAPI_EXPORT double output_particle_property(                                    \
        const IRockyModel& model, IRockyParticleHost& particle, int property_id, void* data) 
 
#define ROCKY_PLUGIN_OUTPUT_TRIANGLE_PROPERTY(model, triangle, property_id, data)                  \
    extern "C" ROCKYAPI_EXPORT double output_triangle_property(                                    \
        const IRockyModel& model, IRockyGeometryTriangleHost& triangle, int property_id, void* data) 
 
#define ROCKY_PLUGIN_POST_OUTPUT(model, data)                                                      \
    extern "C" ROCKYAPI_EXPORT void post_output(const IRockyModel& model, void* data)
 
// Search ------------------------------------------------------------------------------------------
#define ROCKY_PLUGIN_PRE_SEARCH_ON_PARTICLES(device_model, particle, data)                           \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_search_on_particles(                         \
        IRockyDeviceModel &device_model, IRockyParticle &particle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_SEARCH_ON_PARTICLES_END() }
#endif
 
// Force -------------------------------------------------------------------------------------------
#define ROCKY_PLUGIN_PRE_FORCE_ON_CONTACTS(device_model, contact, data)                             \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_force_on_contacts(                          \
        IRockyDeviceModel &device_model, IRockyContact &contact, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_FORCE_ON_CONTACTS_END() }
#endif
 
#define ROCKY_PLUGIN_PRE_FORCE_ON_PARTICLES(device_model, particle, data)                           \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_force_on_particles(                         \
        IRockyDeviceModel &device_model, IRockyParticle &particle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_FORCE_ON_PARTICLES_END() }
#endif
 
#define ROCKY_PLUGIN_PRE_FORCE_ON_TRIANGLES(device_model, triangle, data)                           \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_force_on_triangles(                         \
        IRockyDeviceModel &device_model, IRockyBoundaryTriangle &triangle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_FORCE_ON_TRIANGLES_END() }
#endif
 
#define ROCKY_PLUGIN_PRE_FORCE_ON_JOINTS(device_model, joint, data)                                 \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_force_on_joints(                            \
        IRockyDeviceModel &device_model, IRockyJoint &joint, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_FORCE_ON_JOINTS_END() }
#endif
 
#define ROCKY_PLUGIN_POST_FORCE_ON_CONTACTS(device_model, contact, data)                            \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void post_force_on_contacts(                         \
        IRockyDeviceModel &device_model, IRockyContact &contact, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_POST_FORCE_ON_CONTACTS_END() }
#endif
 
#define ROCKY_PLUGIN_POST_FORCE_ON_FINISHED_CONTACTS(device_model, contact, data)                   \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void post_force_on_finished_contacts(                \
        IRockyDeviceModel &device_model, IRockyContact &contact, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_POST_FORCE_ON_FINISHED_CONTACTS_END() }
#endif
 
#define ROCKY_PLUGIN_POST_FORCE_ON_PARTICLES(device_model, particle, data)                          \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void post_force_on_particles(                        \
        IRockyDeviceModel &device_model, IRockyParticle &particle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_POST_FORCE_ON_PARTICLES_END() }
#endif
 
#define ROCKY_PLUGIN_POST_FORCE_ON_TRIANGLES(device_model, triangle, data)                           \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void post_force_on_triangles(                         \
        IRockyDeviceModel &device_model, IRockyBoundaryTriangle &triangle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_POST_FORCE_ON_TRIANGLES_END() }
#endif
 
#define ROCKY_PLUGIN_POST_FORCE_ON_JOINTS(device_model, joint, data)                                \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void post_force_on_joints(                           \
        IRockyDeviceModel &device_model, IRockyJoint &joint, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_POST_FORCE_ON_JOINTS_END() }
#endif
 
// Move --------------------------------------------------------------------------------------------
#define ROCKY_PLUGIN_PRE_MOVE_PARTICLES(device_model, particle, data)                               \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_move_particles(                             \
        IRockyDeviceModel &device_model, IRockyParticle &particle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_MOVE_PARTICLES_END() }
#endif
 
#define ROCKY_PLUGIN_POST_MOVE_PARTICLES(device_model, particle, data)                              \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void post_move_particles(                            \
        IRockyDeviceModel &device_model, IRockyParticle &particle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_POST_MOVE_PARTICLES_END() }
#endif
 
#define ROCKY_PLUGIN_PRE_MOVE_ON_TRIANGLES(device_model, triangle, data)                            \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void pre_move_triangles(                             \
        IRockyDeviceModel &device_model, IRockyBoundaryTriangle &triangle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_PRE_MOVE_ON_TRIANGLES_END() }
#endif
 
#define ROCKY_PLUGIN_POST_MOVE_ON_TRIANGLES(device_model, triangle, data)                           \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void post_move_triangles(                            \
        IRockyDeviceModel &device_model, IRockyBoundaryTriangle &triangle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_POST_MOVE_ON_TRIANGLES_END() }
#endif
 
// Adhesive forces  ---------------------------------------------------------------------------------------
 
#define COMPUTE_CONTACT_ADHESIVE_FORCES_NAME compute_contact_adhesive_forces
 
#define ROCKY_PLUGIN_COMPUTE_CONTACT_ADHESIVE_FORCES(contact, output, data)                         \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS void COMPUTE_CONTACT_ADHESIVE_FORCES_NAME(           \
        IRockyContact& contact, IRockyAdhesionOutputData& output_data, void* data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_COMPUTE_CONTACT_ADHESIVE_FORCES_END() }
#endif
 
// Joint forces ------------------------------------------------------------------------------------------
 
#define COMPUTE_JOINT_FORCES_NAME compute_joint_forces
 
#define ROCKY_PLUGIN_COMPUTE_JOINT_FORCES(joint, output_data, data)                                 \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS                                                      \
        void COMPUTE_JOINT_FORCES_NAME(IRockyJoint &joint, IRockyJointOutputData& output_data, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_COMPUTE_JOINT_FORCES_END() }
#endif
 
// Joint breakage ----------------------------------------------------------------------------------
 
#define COMPUTE_JOINT_BREAKAGE_NAME compute_joint_breakage
 
#define ROCKY_PLUGIN_COMPUTE_JOINT_BREAKAGE(joint, broken, data)                                    \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS                                                      \
        void COMPUTE_JOINT_BREAKAGE_NAME(IRockyJoint &joint, bool &broken, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_COMPUTE_JOINT_BREAKAGE_END() }
#endif
 
// Instantaneous breakage --------------------------------------------------------------------------
 
#define COMPUTE_INSTANTANEOUS_BREAKAGE_NAME compute_instantaneous_breakage
 
#define ROCKY_PLUGIN_COMPUTE_INSTANTANEOUS_BREAKAGE(particle, broken, data)                         \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS                                                      \
        void COMPUTE_INSTANTANEOUS_BREAKAGE_NAME(IRockyParticle &particle, bool &broken, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_COMPUTE_INSTANTANEOUS_BREAKAGE_END() }
#endif
 
// Fragments size distribution ---------------------------------------------------------------------
 
#define COMPUTE_SIZE_DISTRIBUTION_NAME compute_fragments_size_distribution
 
#define ROCKY_PLUGIN_COMPUTE_FRAGMENTS_SIZE_DISTRIBUTION(breakable_particle, distribution, data)        \
    extern "C" ROCKYAPI_EXPORT                                                                          \
        void COMPUTE_SIZE_DISTRIBUTION_NAME(IRockyBreakableParticle &breakable_particle, std::vector<double>& distribution, void *data) {
 
#define ROCKY_PLUGIN_COMPUTE_FRAGMENTS_SIZE_DISTRIBUTION_END() }
 
// Boundaries wear ---------------------------------------------------------------------------------
 
#define COMPUTE_BOUNDARIES_WEAR_NAME compute_boundaries_wear
 
#define ROCKY_PLUGIN_COMPUTE_BOUNDARIES_WEAR(triangle_contact, wear_volume, data)                   \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS                                                      \
        void COMPUTE_BOUNDARIES_WEAR_NAME(IRockyContact &triangle_contact, double& wear_volume, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_COMPUTE_BOUNDARIES_WEAR_END() }
#endif
 
// Thermal -----------------------------------------------------------------------------------------
#define COMPUTE_FRICTIONAL_HEAT_CONDUCTION_NAME compute_contact_heat_conduction
 
#define ROCKY_PLUGIN_COMPUTE_CONTACT_HEAT_CONDUCTION(model, contact, data)                         \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS                                                     \
        void COMPUTE_FRICTIONAL_HEAT_CONDUCTION_NAME(                                              \
            IRockyDeviceModel &model, IRockyContact &contact, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_COMPUTE_CONTACT_HEAT_CONDUCTION_END() }
#endif
 
#define COMPUTE_THERMAL_INTEGRATION_NAME compute_thermal_integration
 
#define ROCKY_PLUGIN_COMPUTE_THERMAL_INTEGRATION(model, particle, data)                            \
    extern "C" ROCKYAPI_EXPORT ROCKY_FUNCTIONS                                                     \
        void COMPUTE_THERMAL_INTEGRATION_NAME(                                                     \
            IRockyDeviceModel &model, IRockyParticle &particle, void *data) {
 
#ifndef ROCKY_CUDA_API
#define ROCKY_PLUGIN_COMPUTE_THERMAL_INTEGRATION_END() }
#endif
 
// Geometry motion ---------------------------------------------------------------------------------
#define ROCKY_PLUGIN_COMPUTE_GEOMETRIES_MOTION(model, motion, data)   \
    extern "C" ROCKYAPI_EXPORT void compute_geometries_motion(IRockyModel &model, IRockyGeometriesMotionData &motion, void *data)
 
// CUDA ============================================================================================
 
#ifdef ROCKY_CUDA_API
 
    // on particles
    #define ROCKY_PLUGIN_PARTICLES_CUDA_KERNEL(func_name)                                          \
        struct f_##func_name##_type                                                                \
        {                                                                                          \
            ROCKY_FUNCTIONS void operator()(                                                       \
                IRockyDeviceModel& device_model_api, IRockyParticle& particle_api, void* udf_data) \
            {                                                                                      \
                func_name(device_model_api, particle_api, udf_data);                               \
            }                                                                                      \
        };                                                                                         \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(                                 \
            IRockyModel& model, void** plugin_device_data)                                         \
        {                                                                                          \
            f_##func_name##_type device_functor {};                                                \
            rocky::cuda::dispatch_particles_kernel(model, device_functor, plugin_device_data);     \
        }
 
    // on triangles
    #define ROCKY_PLUGIN_TRIANGLES_CUDA_KERNEL(func_name)                                      \
        struct f_##func_name##_type                                                            \
        {                                                                                      \
            ROCKY_FUNCTIONS void operator()(                                                   \
                IRockyDeviceModel& device_model_api,                                           \
                IRockyBoundaryTriangle& triangle_api,                                          \
                void* udf_data)                                                                \
            {                                                                                  \
                func_name(device_model_api, triangle_api, udf_data);                           \
            }                                                                                  \
        };                                                                                     \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(                             \
            IRockyModel& model, void** plugin_device_data)                                     \
        {                                                                                      \
            f_##func_name##_type device_functor {};                                            \
            rocky::cuda::dispatch_triangles_kernel(model, device_functor, plugin_device_data); \
        }
 
    // on contacts
    #define ROCKY_PLUGIN_CONTACTS_CUDA_KERNEL(func_name, c_type)                                 \
        struct f_##func_name##_type                                                              \
        {                                                                                        \
            ROCKY_FUNCTIONS void operator()(                                                     \
                IRockyDeviceModel& device_model_api, IRockyContact& contact_api, void* udf_data) \
            {                                                                                    \
                func_name(device_model_api, contact_api, udf_data);                              \
            }                                                                                    \
        };                                                                                       \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(                               \
            IRockyModel& model, void** plugin_device_data)                                       \
        {                                                                                        \
            f_##func_name##_type device_functor {};                                              \
            rocky::cuda::dispatch_##c_type##_contacts_kernel(                                    \
                model, device_functor, device_functor, plugin_device_data);                      \
        }
 
    // on joints
    #define ROCKY_PLUGIN_JOINTS_CUDA_KERNEL(func_name)                                       \
        struct f_##func_name##_type                                                          \
        {                                                                                    \
            ROCKY_FUNCTIONS void operator()(                                                 \
                IRockyDeviceModel& device_model_api, IRockyJoint& joint_api, void* udf_data) \
            {                                                                                \
                func_name(device_model_api, joint_api, udf_data);                            \
            }                                                                                \
        };                                                                                   \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(                           \
            IRockyModel& model, void** plugin_device_data)                                   \
        {                                                                                    \
            f_##func_name##_type device_functor {};                                          \
            rocky::cuda::dispatch_joints_kernel(model, device_functor, plugin_device_data);  \
        }
 
    // Search --------------------------------------------------------------------------------------
    #define ROCKY_PLUGIN_PRE_SEARCH_ON_PARTICLES_END() \
        }                                              \
        ROCKY_PLUGIN_PARTICLES_CUDA_KERNEL(pre_search_on_particles)
 
    // Force ---------------------------------------------------------------------------------------
    #define ROCKY_PLUGIN_PRE_FORCE_ON_CONTACTS_END() \
        }                                            \
        ROCKY_PLUGIN_CONTACTS_CUDA_KERNEL(pre_force_on_contacts, frictional)
 
    #define ROCKY_PLUGIN_PRE_FORCE_ON_PARTICLES_END() \
        }                                             \
        ROCKY_PLUGIN_PARTICLES_CUDA_KERNEL(pre_force_on_particles)
 
    #define ROCKY_PLUGIN_PRE_FORCE_ON_TRIANGLES_END() \
        }                                             \
        ROCKY_PLUGIN_TRIANGLES_CUDA_KERNEL(pre_force_on_triangles)
 
    #define ROCKY_PLUGIN_PRE_FORCE_ON_JOINTS_END() \
        }                                          \
        ROCKY_PLUGIN_JOINTS_CUDA_KERNEL(pre_force_on_joints)
 
    #define ROCKY_PLUGIN_POST_FORCE_ON_CONTACTS_END() \
        }                                             \
        ROCKY_PLUGIN_CONTACTS_CUDA_KERNEL(post_force_on_contacts, frictional)
 
    #define ROCKY_PLUGIN_POST_FORCE_ON_PARTICLES_END() \
        }                                              \
        ROCKY_PLUGIN_PARTICLES_CUDA_KERNEL(post_force_on_particles)
 
    #define ROCKY_PLUGIN_POST_FORCE_ON_TRIANGLES_END() \
        }                                              \
        ROCKY_PLUGIN_TRIANGLES_CUDA_KERNEL(post_force_on_triangles)
 
    #define ROCKY_PLUGIN_POST_FORCE_ON_JOINTS_END() \
        }                                           \
        ROCKY_PLUGIN_JOINTS_CUDA_KERNEL(post_force_on_joints)
 
    #define ROCKY_PLUGIN_POST_FORCE_ON_FINISHED_CONTACTS_END() \
        }                                                      \
        ROCKY_PLUGIN_CONTACTS_CUDA_KERNEL(post_force_on_finished_contacts, finished)
 
    #define ROCKY_PLUGIN_PRE_OUTPUT_ON_CONTACTS_END() \
        }                                             \
        ROCKY_PLUGIN_CONTACTS_CUDA_KERNEL(pre_output_on_active_contacts, active)
 
    // Move ----------------------------------------------------------------------------------------
    #define ROCKY_PLUGIN_PRE_MOVE_PARTICLES_CUDA() \
        ROCKY_PLUGIN_PARTICLES_CUDA_KERNEL(pre_move_particles)
 
    #define ROCKY_PLUGIN_PRE_MOVE_PARTICLES_END() \
        }                                         \
        ROCKY_PLUGIN_PRE_MOVE_PARTICLES_CUDA()
 
    #define ROCKY_PLUGIN_POST_MOVE_PARTICLES_CUDA() \
        ROCKY_PLUGIN_PARTICLES_CUDA_KERNEL(post_move_particles)
 
    #define ROCKY_PLUGIN_POST_MOVE_PARTICLES_END() \
        }                                          \
        ROCKY_PLUGIN_POST_MOVE_PARTICLES_CUDA()
 
    #define ROCKY_PLUGIN_PRE_MOVE_ON_TRIANGLES_CUDA() \
        ROCKY_PLUGIN_TRIANGLES_CUDA_KERNEL(pre_move_triangles)
 
    #define ROCKY_PLUGIN_PRE_MOVE_ON_TRIANGLES_END() \
        }                                            \
        ROCKY_PLUGIN_PRE_MOVE_ON_TRIANGLES_CUDA()
 
    #define ROCKY_PLUGIN_POST_MOVE_ON_TRIANGLES_CUDA() \
        ROCKY_PLUGIN_TRIANGLES_CUDA_KERNEL(post_move_triangles)
 
    #define ROCKY_PLUGIN_POST_MOVE_ON_TRIANGLES_END() \
        }                                             \
        ROCKY_PLUGIN_POST_MOVE_ON_TRIANGLES_CUDA()
 
// Contact adhesive forces -------------------------------------------------------------------------
 
    #define ROCKY_PLUGIN_CONTACT_ADHESIVE_FORCES_CUDA_KERNEL(func_name)     \
        struct f_##func_name##_type                                         \
        {                                                                   \
            ROCKY_FUNCTIONS void operator()(                                \
                IRockyContact& contact_api,                                 \
                IRockyAdhesionOutputData& output_data_api,                  \
                void* udf_data)                                             \
            {                                                               \
                func_name(contact_api, output_data_api, udf_data);          \
            }                                                               \
        };                                                                  \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(          \
            IRockyModel& model, void** plugin_device_data)                  \
        {                                                                   \
            f_##func_name##_type device_functor {};                         \
            rocky::cuda::dispatch_adhesive_contact_forces_kernel(           \
                model, device_functor, device_functor, plugin_device_data); \
        }
 
    #define ROCKY_PLUGIN_COMPUTE_CONTACT_ADHESIVE_FORCES_END() \
        }                                                      \
        ROCKY_PLUGIN_CONTACT_ADHESIVE_FORCES_CUDA_KERNEL(compute_contact_adhesive_forces)
 
// Joint forces ------------------------------------------------------------------------------------
 
    #define ROCKY_PLUGIN_JOINT_FORCES_CUDA_KERNEL(func_name)                                      \
        struct f_##func_name##_type                                                               \
        {                                                                                         \
            ROCKY_FUNCTIONS void operator()(                                                      \
                IRockyJoint& joint_api, IRockyJointOutputData& output_data_api, void* udf_data)   \
            {                                                                                     \
                func_name(joint_api, output_data_api, udf_data);                                  \
            }                                                                                     \
        };                                                                                        \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(                                \
            IRockyModel& model, void** plugin_device_data)                                        \
        {                                                                                         \
            f_##func_name##_type device_functor {};                                               \
            rocky::cuda::dispatch_joint_forces_kernel(model, device_functor, plugin_device_data); \
        }
 
    #define ROCKY_PLUGIN_COMPUTE_JOINT_FORCES_END() \
        }                                           \
        ROCKY_PLUGIN_JOINT_FORCES_CUDA_KERNEL(compute_joint_forces)
 
// Joint breakage ------------------------------------------------------------------------------
 
    #define ROCKY_PLUGIN_JOINT_BREAKAGE_CUDA_KERNEL(func_name)                                    \
        struct f_##func_name##_type                                                               \
        {                                                                                         \
            ROCKY_FUNCTIONS void operator()(IRockyJoint& joint_api, bool& broken, void* udf_data) \
            {                                                                                     \
                func_name(joint_api, broken, udf_data);                                           \
            }                                                                                     \
        };                                                                                        \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(                                \
            IRockyModel& model, void** plugin_device_data)                                        \
        {                                                                                         \
            f_##func_name##_type device_functor {};                                               \
            rocky::cuda::dispatch_joint_breakage_kernel(                                          \
                model, device_functor, plugin_device_data);                                       \
        }
 
    #define ROCKY_PLUGIN_COMPUTE_JOINT_BREAKAGE_END() \
        }                                             \
        ROCKY_PLUGIN_JOINT_BREAKAGE_CUDA_KERNEL(compute_joint_breakage)
 
// Instantaneous breakage --------------------------------------------------------------------------
 
    #define ROCKY_PLUGIN_INSTANTANEOUS_BREAKAGE_CUDA_KERNEL(func_name)      \
        struct f_##func_name##_type                                         \
        {                                                                   \
            ROCKY_FUNCTIONS void operator()(                                \
                IRockyParticle& particle_api, bool& broken, void* udf_data) \
            {                                                               \
                func_name(particle_api, broken, udf_data);                  \
            }                                                               \
        };                                                                  \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(          \
            IRockyModel& model, void** plugin_device_data)                  \
        {                                                                   \
            f_##func_name##_type device_functor {};                         \
            rocky::cuda::dispatch_instantaneous_breakage_kernel(            \
                model, device_functor, plugin_device_data);                 \
        }
 
    #define ROCKY_PLUGIN_COMPUTE_INSTANTANEOUS_BREAKAGE_END() \
        }                                                     \
        ROCKY_PLUGIN_INSTANTANEOUS_BREAKAGE_CUDA_KERNEL(compute_instantaneous_breakage)
 
// Boundaries wear ---------------------------------------------------------------------------------
 
    #define ROCKY_PLUGIN_COMPUTE_BOUNDARIES_WEAR_CUDA_KERNEL(func_name)          \
        struct f_##func_name##_type                                              \
        {                                                                        \
            ROCKY_FUNCTIONS void operator()(                                     \
                IRockyContact& contact_api, double& wear_volume, void* udf_data) \
            {                                                                    \
                func_name(contact_api, wear_volume, udf_data);                   \
            }                                                                    \
        };                                                                       \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(               \
            IRockyModel& model, void** plugin_device_data)                       \
        {                                                                        \
            f_##func_name##_type device_functor {};                              \
            rocky::cuda::dispatch_boundaries_wear_kernel(                        \
                model, device_functor, plugin_device_data);                      \
        }
 
    #define ROCKY_PLUGIN_COMPUTE_BOUNDARIES_WEAR_END() \
        }                                              \
        ROCKY_PLUGIN_COMPUTE_BOUNDARIES_WEAR_CUDA_KERNEL(compute_boundaries_wear)
 
// Contact Data Gathering --------------------------------------------------------------------------
 
    #define ROCKY_PLUGIN_ALL_CONTACTS_CUDA_KERNEL(func_name)                                     \
        struct f_##func_name##_type                                                              \
        {                                                                                        \
            ROCKY_FUNCTIONS void operator()(                                                     \
                IRockyDeviceModel& device_model_api, IRockyContact& contact_api, void* udf_data) \
            {                                                                                    \
                func_name(device_model_api, contact_api, udf_data);                              \
            }                                                                                    \
        };                                                                                       \
        extern "C" ROCKYAPI_EXPORT void cuda_##func_name##_kernel(                               \
            IRockyModel& model, void** plugin_device_data)                                       \
        {                                                                                        \
            f_##func_name##_type device_functor {};                                              \
            rocky::cuda::dispatch_all_contacts_kernel(                                           \
                model, device_model, device_model, plugin_device_data);                          \
        }
 
    #define ROCKY_PLUGIN_COLLECT_CONTACTS_DATA_END() \
        }                                            \
        ROCKY_PLUGIN_ALL_CONTACTS_CUDA_KERNEL(collect_contacts_data)
 
// Thermal -----------------------------------------------------------------------------------------
    #define ROCKY_PLUGIN_COMPUTE_CONTACT_HEAT_CONDUCTION_END() \
        }                                                      \
        ROCKY_PLUGIN_CONTACTS_CUDA_KERNEL(compute_contact_heat_conduction, frictional)
 
    #define ROCKY_PLUGIN_COMPUTE_THERMAL_INTEGRATION_END() \
        }                                                  \
        ROCKY_PLUGIN_PARTICLES_CUDA_KERNEL(compute_thermal_integration)
 
#endif // ROCKY_CUDA_API
Rocky Solver SDK 2024 R2

rocky_api_functions

Connect with Ansys
