rocky_output_collections_api.hpp | Ansys Developer Portal

// (C) 2024 ANSYS, Inc. Unauthorized use, distribution, or duplication is prohibited.
#pragma once
 
// Includes ========================================================================================
#include "rocky_time_curve_data.hpp"
#include "rocky_output_properties.h"
 
// =================================================================================================
// IRockyCurveCollectionData
// =================================================================================================
 
struct IRockyCurveCollectionData
{
    void create_particles_dataset(const std::string& name, const std::string& unit);
 
    void create_solver_dataset(const std::string& name, const std::string& unit);
 
    void create_geometry_dataset(int geometry_id, const std::string& name, const std::string& unit);
 
    void create_dataset(const std::string& owner_name, const std::string& name, const std::string& unit);
 
    void create_particles_curve(
        const std::string& domain_dataset, const std::string& image_dataset);
 
    void create_solver_curve(
        const std::string& domain_dataset, const std::string& image_dataset);
 
    void create_geometry_curve(
        int geometry_id, const std::string& domain_dataset, const std::string& image_dataset);
 
    void add_curve(
        const std::string& owner_name, const std::string& domain_dataset, const std::string& image_dataset);
 
    void setup_particles_dataset_dimension(const std::string& name, double dimension);
 
    void setup_solver_dataset_dimension(const std::string& name, double dimension);
 
    void setup_geometry_dataset_dimension(
        int geometry_id, const std::string& name, double dimension);
 
    void setup_dataset_dimension(
            const std::string& owner_name, const std::string& name, double dimension);
 
    void update_particles_dataset(const std::string& name, const double* dataset, size_t size);
 
    void update_solver_dataset(const std::string& name, const double* dataset, size_t size);
 
    void update_geometry_dataset(
        int geometry_id, const std::string& name, const double* dataset, size_t size);
 
    void update_dataset(
            const std::string& owner_name, const std::string& name, const double* dataset, size_t size);
 
    void create_particles_time_curve(const std::string& name, const std::string& unit);
 
    void create_solver_time_curve(const std::string& name, const std::string& unit);
 
    void create_geometry_time_curve(int geometry_id, const std::string& name, const std::string& unit);
 
    void create_time_curve(const std::string& owner_name, const std::string& name, const std::string& unit);
 
    void setup_particles_time_curve_dimension(const std::string& name, double dimension);
 
    void setup_solver_time_curve_dimension(const std::string& name, double dimension);
 
    void setup_geometry_time_curve_dimension(int geometry_id, const std::string& name, double dimension);
 
    void setup_time_curve_dimension(const std::string& owner_name, const std::string& name, double dimension);
 
    void update_particles_time_curve(const std::string& name, double value);
 
    void update_solver_time_curve(const std::string& name, double value);
 
    void update_geometry_time_curve(int geometry_id, const std::string& name, double value);
 
    void update_time_curve(const std::string& owner_name, const std::string& name, double value);
 
    IRockyCurveCollectionData(
        std::shared_ptr<rocky20::RockyAddinCurvesWriter> datasets_writer, bool is_setup_stage);
 
    RockyCurveCollectionData _impl;
    bool _is_setup_stage;
};
 
inline IRockyCurveCollectionData::IRockyCurveCollectionData(
    std::shared_ptr<rocky20::RockyAddinCurvesWriter> datasets_writer, bool is_setup_stage)
    : _impl(datasets_writer)
    , _is_setup_stage(is_setup_stage)
{
}
 
// create ------------------------------------------------------------------------------------------
 
inline void IRockyCurveCollectionData::create_particles_dataset(
    const std::string& name, const std::string& unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_particles_dataset(name, unit);
    else
        ROCKY_RUNTIME_ERROR("Curve collection datasets must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_solver_dataset(
    const std::string& name, const std::string& unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_solver_dataset(name, unit);
    else
        ROCKY_RUNTIME_ERROR("Curve collection datasets must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_geometry_dataset(
    int geometry_id, const std::string& name, const std::string& unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_geometry_dataset(name, unit, geometry_id);
    else
        ROCKY_RUNTIME_ERROR("Curve collection datasets must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_dataset(
    const std::string& owner_name, const std::string& name, const std::string& unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_custom_dataset(name, unit, owner_name);
    else
        ROCKY_RUNTIME_ERROR("Curve collection datasets must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_particles_curve(
    const std::string& domain_dataset, const std::string& image_dataset)
{
    if (this->_is_setup_stage)
        this->_impl.create_particles_curve(domain_dataset, image_dataset);
    else
        ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_solver_curve(
    const std::string& domain_dataset, const std::string& image_dataset)
{
    if (this->_is_setup_stage)
        this->_impl.create_solver_curve(domain_dataset, image_dataset);
    else
        ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_geometry_curve(
    int geometry_id, const std::string& domain_dataset, const std::string& image_dataset)
{
    if (this->_is_setup_stage)
        this->_impl.create_geometry_curve(domain_dataset, image_dataset, geometry_id);
    else
        ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::add_curve(
    const std::string& owner_name, const std::string& domain_dataset, const std::string& image_dataset)
{
    if (this->_is_setup_stage)
        this->_impl.create_custom_curve(domain_dataset, image_dataset, owner_name);
    else
        ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_particles_time_curve(const std::string& name, const std::string& unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_particles_time_curve(name, unit);
    else
    ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_solver_time_curve(const std::string& name, const std::string& unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_solver_time_curve(name, unit);
    else
        ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
    }
 
inline void IRockyCurveCollectionData::create_geometry_time_curve(int geometry_id, const std::string& name, const std::string& unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_geometry_time_curve(name, unit, geometry_id);
    else
    ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::create_time_curve(
    const std::string &owner_name, const std::string &name, const std::string &unit)
{
    if (this->_is_setup_stage)
        this->_impl.create_custom_time_curve(name, unit, owner_name);
    else
        ROCKY_RUNTIME_ERROR("Curve collection curves must be created before a simulation starts.")
}
 
// dimensions --------------------------------------------------------------------------------------
inline void IRockyCurveCollectionData::setup_particles_dataset_dimension(
    const std::string& name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_particles_dataset_dimension(name, dimension);
    else
        ROCKY_RUNTIME_ERROR(
            "The dimension associated to a dataset must be set before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::setup_solver_dataset_dimension(
    const std::string& name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_solver_dataset_dimension(name, dimension);
    else
        ROCKY_RUNTIME_ERROR(
            "The dimension associated to a dataset must be set before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::setup_geometry_dataset_dimension(
    int geometry_id, const std::string& name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_geometry_dataset_dimension(name, dimension, geometry_id);
    else
        ROCKY_RUNTIME_ERROR(
            "The dimension associated to a dataset must be set before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::setup_dataset_dimension(
    const std::string &owner_name, const std::string &name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_custom_dataset_dimension(name, dimension, owner_name);
    else
        ROCKY_RUNTIME_ERROR("The dimension associated to a dataset must be set before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::setup_particles_time_curve_dimension(
    const std::string& name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_particles_dataset_dimension(name, dimension);
    else
    ROCKY_RUNTIME_ERROR(
        "The dimension associated to a time curve must be set before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::setup_solver_time_curve_dimension(
    const std::string& name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_solver_dataset_dimension(name, dimension);
    else
        ROCKY_RUNTIME_ERROR(
            "The dimension associated to a time curve must be set before a simulation starts.")
    }
 
inline void IRockyCurveCollectionData::setup_geometry_time_curve_dimension(
    int geometry_id, const std::string& name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_geometry_dataset_dimension(name, dimension, geometry_id);
    else
    ROCKY_RUNTIME_ERROR(
        "The dimension associated to a time curve must be set before a simulation starts.")
}
 
inline void IRockyCurveCollectionData::setup_time_curve_dimension(
        const std::string& owner_name, const std::string& name, double dimension)
{
    if (this->_is_setup_stage)
        this->_impl.setup_custom_dataset_dimension(name, dimension, owner_name);
    else
        ROCKY_RUNTIME_ERROR(
            "The dimension associated to a time curve must be set before a simulation starts.")
}
 
// update ------------------------------------------------------------------------------------------
 
inline void IRockyCurveCollectionData::update_particles_dataset(
    const std::string& name, const double* dataset, size_t size)
{
    if (!this->_is_setup_stage)
        this->_impl.update_particles_dataset(name, dataset, size);
    else
        ROCKY_RUNTIME_ERROR(
            "Curve collection datasets must be updated during the simulation iterative process.")
}
 
inline void IRockyCurveCollectionData::update_solver_dataset(
    const std::string& name, const double* dataset, size_t size)
{
    if (!this->_is_setup_stage)
        this->_impl.update_solver_dataset(name, dataset, size);
    else
        ROCKY_RUNTIME_ERROR(
            "Curve collection datasets must be updated during the simulation iterative process.")
}
 
inline void IRockyCurveCollectionData::update_geometry_dataset(
    int geometry_id, const std::string& name, const double* dataset, size_t size)
{
    if (!this->_is_setup_stage)
        this->_impl.update_geometry_dataset(name, dataset, size, geometry_id);
    else
        ROCKY_RUNTIME_ERROR(
            "Curve collection datasets must be updated during the simulation iterative process.")
}
 
inline void IRockyCurveCollectionData::update_dataset(
    const std::string& owner_name, const std::string& name, const double* dataset, size_t size)
{
    if (!this->_is_setup_stage)
        this->_impl.update_custom_dataset(name, dataset, size, owner_name);
    else
        ROCKY_RUNTIME_ERROR(
            "Curve collection datasets must be updated during the simulation iterative process.")
}
 
inline void IRockyCurveCollectionData::update_particles_time_curve(const std::string& name, double value)
{
    if (!this->_is_setup_stage)
        this->_impl.update_particles_dataset(name, &value, 1);
    else
        ROCKY_RUNTIME_ERROR(
        "Curve collection datasets must be updated during the simulation iterative process.")
}
 
inline void IRockyCurveCollectionData::update_solver_time_curve(const std::string& name, double value)
{
    if (!this->_is_setup_stage)
        this->_impl.update_solver_dataset(name, &value, 1);
    else
        ROCKY_RUNTIME_ERROR(
        "Curve collection datasets must be updated during the simulation iterative process.")
}
 
inline void IRockyCurveCollectionData::update_geometry_time_curve(int geometry_id, const std::string& name, double value)
{
    if (!this->_is_setup_stage)
        this->_impl.update_geometry_dataset(name, &value, 1, geometry_id);
    else
        ROCKY_RUNTIME_ERROR(
        "Curve collection datasets must be updated during the simulation iterative process.")
}
 
inline void IRockyCurveCollectionData::update_time_curve(
    const std::string &owner_name, const std::string &name, double value)
{
    if (!this->_is_setup_stage)
        this->_impl.update_custom_dataset(name, &value, 1, owner_name);
    else
        ROCKY_RUNTIME_ERROR("Curve collection datasets must be updated during the simulation iterative process.")
}
 
// =================================================================================================
// IRockyOutputPropertyCollection
// =================================================================================================
 
struct IRockyOutputPropertyCollection
{
    int create_particles_instantaneous_property(const std::string& name, const std::string& unit, double dimension = 1.0);
 
    int create_particles_statistical_property(const std::string& name, const std::string& unit, double dimension = 1.0);
 
    int create_triangles_instantaneous_property(const std::string& name, const std::string& unit, double dimension = 1.0);
 
    int create_triangles_statistical_property(const std::string& name, const std::string& unit, double dimension = 1.0);
 
    int create_vertex_triangles_instantaneous_property(const std::string& name, const std::string& unit, double dimension = 1.0);
 
    int create_vertex_triangles_statistical_property(const std::string& name, const std::string& unit, double dimension = 1.0);
 
    IRockyOutputPropertyCollection(std::shared_ptr<OutputPropertiesSetup> properties_setup);
 
    std::shared_ptr<OutputPropertiesSetup> _impl;
};
 
inline IRockyOutputPropertyCollection::IRockyOutputPropertyCollection(
    std::shared_ptr<OutputPropertiesSetup> properties_setup) 
    : _impl(properties_setup)
{}
 
inline int IRockyOutputPropertyCollection::create_particles_instantaneous_property(
    const std::string& name, const std::string& unit, double dimension)
{
    return this->_impl->create_particles_instantaneous_property(name, unit, dimension);
}
 
inline int IRockyOutputPropertyCollection::create_particles_statistical_property(
    const std::string& name, const std::string& unit, double dimension)
{
    return this->_impl->create_particles_statistical_property(name, unit, dimension);
}
 
inline int IRockyOutputPropertyCollection::create_triangles_instantaneous_property(
    const std::string& name, const std::string& unit, double dimension)
{
    return this->_impl->create_triangles_instantaneous_property(name, unit, dimension);
}
 
inline int IRockyOutputPropertyCollection::create_triangles_statistical_property(
    const std::string& name, const std::string& unit, double dimension)
{
    return this->_impl->create_triangles_statistical_property(name, unit, dimension);
}
 
inline int IRockyOutputPropertyCollection::create_vertex_triangles_instantaneous_property(
    const std::string& name, const std::string& unit, double dimension)
{
    return this->_impl->create_vertex_triangles_instantaneous_property(name, unit, dimension);
}
 
inline int IRockyOutputPropertyCollection::create_vertex_triangles_statistical_property(
    const std::string& name, const std::string& unit, double dimension)
{
    return this->_impl->create_vertex_triangles_statistical_property(name, unit, dimension);
}
Rocky Solver SDK 2025 R2

rocky_output_collections_api

Connect with Ansys
