rocky_boundary_api.hpp | Ansys Developer Portal

#pragma once
 
// Includes =======================================================================================
#include <rocky20/core/utils/rocky_math.hpp>
#include <rocky20/device/device_model.hpp>
 
#include "rocky_boundary.hpp"
 
// ================================================================================================
// IRockyGeometryTriangleImpl
// ================================================================================================
 
template <typename Model>
struct IRockyGeometryTriangleImpl
{
    ROCKY_FUNCTIONS IRockyMaterial get_material() const
    {
        return IRockyMaterial(this->_impl.get_material());
    }
 
    ROCKY_FUNCTIONS double3 get_normal_unit_vector() const
    {
        return this->_impl.get_normal();
    }
 
    ROCKY_FUNCTIONS double get_area() const
    {
        return this->_impl.get_area();
    }
 
    ROCKY_FUNCTIONS double3 get_centroid() const
    {
        return this->_impl.get_centroid();
    }
 
    ROCKY_FUNCTIONS int get_geometry_index() const
    {
        return this->_impl.get_boundary_index();
    }
 
    ROCKY_FUNCTIONS int get_material_index() const
    {
        return this->_impl.get_material_index();
    }
 
    ROCKY_FUNCTIONS double3 get_translational_velocity(double current_time) const
    {
        return this->_impl.get_translational_velocity(current_time);
    }
 
    ROCKY_FUNCTIONS double3 get_geometry_rotational_velocity() const
    {
        return this->_impl.get_geometry_rotational_velocity();
    }
 
    ROCKY_FUNCTIONS double3 get_geometry_rotation_center() const
    {
        return this->_impl.get_geometry_rotation_center();
    }
 
    ROCKY_FUNCTIONS double get_temperature() const
    {
        return this->_impl.get_temperature();
    }
 
    ROCKY_FUNCTIONS void set_temperature(double value)
    {
        this->_impl.set_temperature(value);
    }
 
    ROCKY_FUNCTIONS bool is_adiabatic() const
    {
        return this->_impl.is_adiabatic();
    }
 
    ROCKY_FUNCTIONS double get_thermal_conductivity() const
    {
        return this->_impl.get_thermal_conductivity();
    }
 
    ROCKY_FUNCTIONS void set_thermal_conductivity(double value)
    {
        this->_impl.set_thermal_conductivity(value);
    }
 
    ROCKY_FUNCTIONS double get_poisson_ratio() const
    {
        return this->_impl.get_poisson_ratio();
    }
 
    ROCKY_FUNCTIONS void set_poisson_ratio(double value)
    {
        this->_impl.set_poisson_ratio(value);
    }
 
    ROCKY_FUNCTIONS IRockyTriangleScalars get_scalars()
    {
        return this->_impl.get_scalars();
    }
 
    ROCKY_FUNCTIONS IRockyGeometryTriangleImpl(int _index, Model* _model, bool _current = true)
        : _impl(_model, _index, _current)
    {
    }
 
    RockyBoundaryTriangle<Model> _impl;
};
 
// ================================================================================================
// IRockyGeometryTriangle
// ================================================================================================
 
struct IRockyGeometryTriangle : public IRockyGeometryTriangleImpl<SDeviceModel>
{
    ROCKY_FUNCTIONS IRockyGeometryTriangle(int _index, SDeviceModel* _model)
        : IRockyGeometryTriangleImpl(_index, _model, true)
    {}
 
#ifdef ONLY_FOR_DOXYGEN
 
    ROCKY_FUNCTIONS IRockyMaterial get_material() const;
 
    ROCKY_FUNCTIONS double3 get_normal_unit_vector() const;
 
    ROCKY_FUNCTIONS double get_area() const;
 
    ROCKY_FUNCTIONS double3 get_centroid() const;
 
    ROCKY_FUNCTIONS int get_geometry_index() const;
 
    ROCKY_FUNCTIONS int get_material_index() const;
 
    ROCKY_FUNCTIONS double3 get_translational_velocity(double current_time) const;
 
    ROCKY_FUNCTIONS double3 get_geometry_rotational_velocity() const;
 
    ROCKY_FUNCTIONS double3 get_geometry_rotation_center() const;
 
    ROCKY_FUNCTIONS double get_temperature() const;
 
    ROCKY_FUNCTIONS void set_temperature(double value);
 
    ROCKY_FUNCTIONS bool is_adiabatic() const;
 
    ROCKY_FUNCTIONS double get_thermal_conductivity() const;
 
    ROCKY_FUNCTIONS void set_thermal_conductivity(double value);
 
    ROCKY_FUNCTIONS double get_poisson_ratio() const;
 
    ROCKY_FUNCTIONS void set_poisson_ratio(double value);
 
    ROCKY_FUNCTIONS IRockyTriangleScalars get_scalars();
 
#endif
 
};
 
 
// ================================================================================================
// IRockyGeometryTriangleHost
// ================================================================================================
 
struct IRockyGeometryTriangleHost : public IRockyGeometryTriangleImpl<RockyModel>
{
    IRockyGeometryTriangleHost(int _index, RockyModel* _model)
        : IRockyGeometryTriangleImpl(_index, _model, true)
    {}
 
#ifdef ONLY_FOR_DOXYGEN
 
    ROCKY_FUNCTIONS IRockyMaterial get_material() const;
 
    ROCKY_FUNCTIONS double3 get_normal_unit_vector() const;
 
    ROCKY_FUNCTIONS double get_area() const;
 
    ROCKY_FUNCTIONS double3 get_centroid() const;
 
    ROCKY_FUNCTIONS int get_geometry_index() const;
 
    ROCKY_FUNCTIONS int get_material_index() const;
 
    ROCKY_FUNCTIONS double3 get_translational_velocity(double current_time) const;
 
    ROCKY_FUNCTIONS double3 get_geometry_rotational_velocity() const;
 
    ROCKY_FUNCTIONS double3 get_geometry_rotation_center() const;
 
    ROCKY_FUNCTIONS double get_temperature() const;
 
    ROCKY_FUNCTIONS void set_temperature(double value);
 
    ROCKY_FUNCTIONS bool is_adiabatic() const;
 
    ROCKY_FUNCTIONS double get_thermal_conductivity() const;
 
    ROCKY_FUNCTIONS void set_thermal_conductivity(double value);
 
    ROCKY_FUNCTIONS double get_poisson_ratio() const;
 
    ROCKY_FUNCTIONS void set_poisson_ratio(double value);
 
    ROCKY_FUNCTIONS IRockyTriangleScalars get_scalars();
 
#endif
 
};
 
// Legacy structs
 
using IRockyBoundaryTriangle = IRockyGeometryTriangle;
 
using IRockyBoundaryTriangleHost = IRockyGeometryTriangleHost;
 
 
// ================================================================================================
// IRockyGeometryMotionData
// ================================================================================================
 
struct IRockyGeometryMotionData
{
    int get_id() const;
 
    std::string get_name() const;
 
    double3 get_force() const;
 
    double3 get_moment() const;
 
    double3 get_position() const;
 
    double3 get_translational_velocity() const;
 
    double4 get_orientation_quaternion() const;
 
    double3 get_orientation_euler_angles() const;
 
    double3 get_rotational_velocity() const;
 
    void set_position(double3 position);
 
    void set_translational_velocity(double3 v);
 
    void set_orientation(double4 quat);
 
    void set_orientation_angles(double3 angles);
 
    void set_rotational_velocity(double3 w);
 
    bool has_linked_motion_frame() const;
 
 
    IRockyGeometryMotionData(unsigned int _index, RockyModel& _model);
 
    unsigned int geometry_index;
    RockyModel& model;
 
};
 
inline int IRockyGeometryMotionData::get_id() const
{
    return this->geometry_index;
}
 
inline std::string IRockyGeometryMotionData::get_name() const
{
    return this->model.bnd_h[this->geometry_index].name;
}
 
inline double3 IRockyGeometryMotionData::get_force() const
{
    const cuda_boundary& boundary = this->model.bnd[this->geometry_index];
    return double3{ boundary.fx_inst, boundary.fy_inst, boundary.fz_inst };
}
 
inline double3 IRockyGeometryMotionData::get_moment() const
{
    const cuda_boundary& boundary = this->model.bnd[this->geometry_index];
    return double3{ boundary.mx_inst, boundary.my_inst, boundary.mz_inst };
}
 
inline double3 IRockyGeometryMotionData::get_position() const
{
    const cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    return double3{ boundary.dx, boundary.dy, boundary.dz };
}
 
inline double3 IRockyGeometryMotionData::get_translational_velocity() const
{
    const cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    return double3{ boundary.ux, boundary.uy, boundary.uz };
}
 
inline double4 IRockyGeometryMotionData::get_orientation_quaternion() const
{
    const cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    return double4{ boundary.quat[0], boundary.quat[1], boundary.quat[2], boundary.quat[3] };
}
 
inline double3 IRockyGeometryMotionData::get_orientation_euler_angles() const
{
    cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    const auto& quat = boundary.quat;
    double3 euler_angles;
    // roll (x-axis rotation)
    double sinr_cosp = 2.0 * (quat[0] * quat[1] + quat[2] * quat[3]);
    double cosr_cosp = 1.0 - 2.0 * (quat[1] * quat[1] + quat[2] * quat[2]);
    euler_angles.x = std::atan2(sinr_cosp, cosr_cosp);
 
    // pitch (y-axis rotation)
    double sinp = 2 * (quat[0] * quat[2] - quat[3] * quat[1]);
    if (std::abs(sinp) >= 1.0)
        euler_angles.y = std::copysign(M_PI / 2, sinp);  // use 90 degrees if out of range
    else
        euler_angles.y = std::asin(sinp);
 
    // yaw (z-axis rotation)
    double siny_cosp = 2.0 * (quat[0] * quat[3] + quat[1] * quat[2]);
    double cosy_cosp = 1.0 - 2.0 * (quat[2] * quat[2] + quat[3] * quat[3]);
    euler_angles.z = std::atan2(siny_cosp, cosy_cosp);
 
    return euler_angles;
}
 
inline double3 IRockyGeometryMotionData::get_rotational_velocity() const
{
    const cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    return double3{ boundary.wx, boundary.wy, boundary.wz };
}
 
inline void check_write(const IRockyGeometryMotionData* motionData)
{
    if (motionData->has_linked_motion_frame())
    {
 
        ROCKY_RUNTIME_ERROR(
            "Cannot overwrite motion data in geometry " << motionData->get_name()
            << " because it is already linked to a motion frame.\nPlease review your setup.")
    }
}
 
inline void IRockyGeometryMotionData::set_position(double3 p)
{
    check_write(this);
    cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    boundary.previous_frame_center = boundary.get_current_frame_center();
    boundary.dx = p.x;
    boundary.dy = p.y;
    boundary.dz = p.z;
}
 
inline void IRockyGeometryMotionData::set_translational_velocity(double3 v)
{
    check_write(this);
    cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    boundary.previous_linear_velocity = boundary.get_linear_velocity();
    boundary.ux = v.x;
    boundary.uy = v.y;
    boundary.uz = v.z;
}
 
inline void IRockyGeometryMotionData::set_orientation(double4 quat)
{
    check_write(this);
    cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    rocky::transform::quaternion_conjugation(boundary.quat);
    boundary.rotation_delta = rocky::transform::quaternion_product<double4, true>(
        quat, rocky::transform::cast_quaternion(boundary.quat));
    boundary.quat[0] = quat.w;
    boundary.quat[1] = quat.x;
    boundary.quat[2] = quat.y;
    boundary.quat[3] = quat.z;
    SRotationMatrixD::wrap(boundary.a).set_quaternion(boundary.quat);
}
 
inline void IRockyGeometryMotionData::set_orientation_angles(double3 angles)
{
    check_write(this);
    cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    double cos_roll = cos(angles.x / 2.0);
    double sin_roll = sin(angles.x / 2.0);
    double cos_pitch = cos(angles.y / 2.0);
    double sin_pitch = sin(angles.y / 2.0);
    double cos_yaw = cos(angles.z / 2.0);
    double sin_yaw = sin(angles.z / 2.0);
 
    double previous_quat[4] {
        boundary.quat[0], boundary.quat[1], boundary.quat[2], boundary.quat[3]
    };
    rocky::transform::quaternion_conjugation(previous_quat);
    boundary.quat[0] = cos_roll * cos_pitch * cos_yaw + sin_roll * sin_pitch * sin_yaw;
    boundary.quat[1] = sin_roll * cos_pitch * cos_yaw - cos_roll * sin_pitch * sin_yaw;
    boundary.quat[2] = cos_roll * sin_pitch * cos_yaw + sin_roll * cos_pitch * sin_yaw;
    boundary.quat[3] = cos_roll * cos_pitch * sin_yaw - sin_roll * sin_pitch * cos_yaw;
    SRotationMatrixD::wrap(boundary.a).set_quaternion(boundary.quat);
    boundary.rotation_delta = rocky::transform::quaternion_product<double4, true>(
        rocky::transform::cast_quaternion(boundary.quat),
        rocky::transform::cast_quaternion(previous_quat));
}
 
inline void IRockyGeometryMotionData::set_rotational_velocity(double3 w)
{
    check_write(this);
    cuda_boundary_host& boundary = this->model.bnd_h[this->geometry_index];
    boundary.previous_angular_velocity = boundary.get_angular_velocity();
    boundary.wx = w.x;
    boundary.wy = w.y;
    boundary.wz = w.z;
}
 
inline bool IRockyGeometryMotionData::has_linked_motion_frame() const
{
    return this->model.boundary_has_linked_frame(this->geometry_index);
}
 
inline IRockyGeometryMotionData::IRockyGeometryMotionData(unsigned int _index, RockyModel& _model)
    : model(_model)
    , geometry_index(_index)
{
}
 
// ================================================================================================
// IRockyGeometriesMotionData
// ================================================================================================
 
struct IRockyGeometriesMotionData
{
    unsigned int get_number_of_geometries() const;
 
    IRockyGeometryMotionData get_geometry(unsigned int id) const;
 
    IRockyGeometryMotionData get_geometry(const std::string& name) const;
 
    bool has_linked_motion_frame(unsigned int id) const;
 
    IRockyGeometriesMotionData(RockyModel& _model);
 
    RockyModel& model;
 
};
 
inline unsigned int IRockyGeometriesMotionData::get_number_of_geometries() const
{
    return this->model.gen.nbnd;
}
 
inline IRockyGeometryMotionData IRockyGeometriesMotionData::get_geometry(unsigned int id) const
{
    if (id >= (unsigned int)this->model.gen.nbnd)
    {
        ROCKY_RUNTIME_ERROR(
            "IRockyGeometriesMotionData: Not a valid geometry ID, must be less than "
            << this->model.gen.nbnd << ".")
    }
    return IRockyGeometryMotionData(id, this->model);
}
 
inline IRockyGeometryMotionData IRockyGeometriesMotionData::get_geometry(
    const std::string& name) const
{
    const auto &begin = this->model.bnd_h.begin();
    const auto &end = this->model.bnd_h.end();
    auto it = std::find_if(
        begin, end, [name](cuda_boundary_host& boundary) {
            return boundary.name == name;
        });
    if (it == end)
    {
        ROCKY_RUNTIME_ERROR("IRockyGeometriesMotionData: Not a valid geometry name.")
    }
    return IRockyGeometryMotionData((unsigned int)std::distance(begin, it), this->model);
}
 
inline bool IRockyGeometriesMotionData::has_linked_motion_frame(unsigned int id) const
{
    return this->model.boundary_has_linked_frame(id);
}
 
 
inline IRockyGeometriesMotionData::IRockyGeometriesMotionData(RockyModel& _model)
    : model(_model)
{
}
Rocky Solver SDK 2024 R2

rocky_boundary_api

Connect with Ansys
