power-grid-model 1.10.17__py3-none-win_amd64.whl → 1.12.119__py3-none-win_amd64.whl

power_grid_model/_core/power_grid_model_c/include/power_grid_model_c.h

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * @mainpage Power Grid Model C API Documentation
+ * This gives an overview of C API.
+ * All the exported functions are included in power_grid_model_c.h, except the dataset definitions
+ *
+ * Users can also include individual headers for a subset of the functionality
+ *     - power_grid_model_c/basics.h: type and enum definition
+ *     - power_grid_model_c/buffer.h: functions with buffer creation, release, set and get value
+ *     - power_grid_model_c/handle.h: functions with error handling
+ *     - power_grid_model_c/meta_data.h: functions with meta data
+ *     - power_grid_model_c/model.h: functions with create, release, run calculation of model
+ *     - power_grid_model_c/options.h: functions with setting the calculation options
+ *     - power_grid_model_c/serialization.h: functions with serialization functions
+ *     - power_grid_model_c/dataset.h: functions with dataset handling functions
+ *     - power_grid_model_c/dataset_definitions.h: external pointer variables to all datasets, components, and
+ *       attributes. You have to include this header separately. It is not included by power_grid_model_c.h.
+ */
+
+#pragma once
+#ifndef POWER_GRID_MODEL_C_H
+#define POWER_GRID_MODEL_C_H
+
+#include "power_grid_model_c/basics.h"
+#include "power_grid_model_c/buffer.h"
+#include "power_grid_model_c/dataset.h"
+#include "power_grid_model_c/handle.h"
+#include "power_grid_model_c/meta_data.h"
+#include "power_grid_model_c/model.h"
+#include "power_grid_model_c/options.h"
+#include "power_grid_model_c/serialization.h"
+
+#endif // POWER_GRID_MODEL_C_H

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/basics.hpp

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_BASICS_HPP
+#define POWER_GRID_MODEL_CPP_BASICS_HPP
+
+#ifdef PGM_DLL_EXPORTS
+#error                                                                                                                 \
+    "Cannot export out-of-line PGM C API symbols from the inline header-only PGM C++ API. Please disable PGM_DLL_EXPORT."
+#endif
+
+#ifndef PGM_ENABLE_EXPERIMENTAL
+#error "This is an experimental feature. Please #define PGM_ENABLE_EXPERIMENTAL to use this."
+#endif
+
+#include "power_grid_model_c/basics.h"
+
+#include <cassert>
+#include <exception>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace power_grid_model_cpp {
+
+using Idx = PGM_Idx;
+using ID = PGM_ID;
+using IntS = int8_t;
+
+using PowerGridModel = PGM_PowerGridModel;
+using MetaDataset = PGM_MetaDataset;
+using MetaComponent = PGM_MetaComponent;
+using MetaAttribute = PGM_MetaAttribute;
+using RawHandle = PGM_Handle;
+using RawDataPtr = void*;            // raw mutable data ptr
+using RawDataConstPtr = void const*; // raw read-only data ptr
+using RawConstDataset = PGM_ConstDataset;
+using RawMutableDataset = PGM_MutableDataset;
+using RawWritableDataset = PGM_WritableDataset;
+using RawDatasetInfo = PGM_DatasetInfo;
+using RawOptions = PGM_Options;
+using RawDeserializer = PGM_Deserializer;
+using RawSerializer = PGM_Serializer;
+
+namespace detail {
+// custom deleter
+template <auto func> struct DeleterFunctor {
+    template <typename T> void operator()(T* arg) const { func(arg); }
+};
+
+// unique pointer definition
+template <typename T, auto func> class UniquePtr : public std::unique_ptr<T, DeleterFunctor<func>> {
+  public:
+    using std::unique_ptr<T, DeleterFunctor<func>>::unique_ptr;
+    using std::unique_ptr<T, DeleterFunctor<func>>::operator=;
+    T* get() { return static_cast<std::unique_ptr<T, DeleterFunctor<func>>&>(*this).get(); }
+    T const* get() const { return static_cast<std::unique_ptr<T, DeleterFunctor<func>> const&>(*this).get(); }
+};
+} // namespace detail
+
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_BASICS_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/buffer.hpp

@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_BUFFER_HPP
+#define POWER_GRID_MODEL_CPP_BUFFER_HPP
+
+#include "basics.hpp"
+#include "handle.hpp"
+
+#include "power_grid_model_c/buffer.h"
+
+namespace power_grid_model_cpp {
+class Buffer {
+  public:
+    Buffer(MetaComponent const* component, Idx size)
+        : component_{component}, size_{size}, buffer_{handle_.call_with(PGM_create_buffer, component, size)} {};
+
+    RawDataConstPtr get() const { return buffer_.get(); }
+    RawDataPtr get() { return buffer_.get(); }
+
+    Idx size() const { return size_; }
+
+    void set_nan() { set_nan(0, size_); }
+    void set_nan(Idx buffer_offset) { set_nan(buffer_offset, 1); }
+    void set_nan(Idx buffer_offset, Idx size) {
+        handle_.call_with(PGM_buffer_set_nan, component_, get(), buffer_offset, size);
+    }
+
+    void set_value(MetaAttribute const* attribute, RawDataConstPtr src_ptr, Idx src_stride) {
+        set_value(attribute, src_ptr, 0, size_, src_stride);
+    }
+    void set_value(MetaAttribute const* attribute, RawDataConstPtr src_ptr, Idx buffer_offset, Idx src_stride) {
+        set_value(attribute, src_ptr, buffer_offset, 1, src_stride);
+    }
+    void set_value(MetaAttribute const* attribute, RawDataConstPtr src_ptr, Idx buffer_offset, Idx size,
+                   Idx src_stride) {
+        handle_.call_with(PGM_buffer_set_value, attribute, get(), src_ptr, buffer_offset, size, src_stride);
+    }
+
+    void get_value(MetaAttribute const* attribute, RawDataPtr dest_ptr, Idx dest_stride) const {
+        get_value(attribute, dest_ptr, 0, size_, dest_stride);
+    }
+    void get_value(MetaAttribute const* attribute, RawDataPtr dest_ptr, Idx buffer_offset, Idx dest_stride) const {
+        get_value(attribute, dest_ptr, buffer_offset, 1, dest_stride);
+    }
+    void get_value(MetaAttribute const* attribute, RawDataPtr dest_ptr, Idx buffer_offset, Idx size,
+                   Idx dest_stride) const {
+        handle_.call_with(PGM_buffer_get_value, attribute, get(), dest_ptr, buffer_offset, size, dest_stride);
+    }
+
+  private:
+    Handle handle_{};
+    MetaComponent const* component_;
+    Idx size_;
+    detail::UniquePtr<void, &PGM_destroy_buffer> buffer_;
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_BUFFER_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/dataset.hpp

@@ -0,0 +1,224 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_DATASET_HPP
+#define POWER_GRID_MODEL_CPP_DATASET_HPP
+
+#include "basics.hpp"
+#include "buffer.hpp"
+#include "handle.hpp"
+
+#include "power_grid_model_c/dataset.h"
+
+namespace power_grid_model_cpp {
+class ComponentTypeNotFound : public PowerGridError {
+  public:
+    ComponentTypeNotFound(std::string const& component)
+        : PowerGridError{[&]() {
+              using namespace std::string_literals;
+              return "ComponentType"s + component + " not found"s;
+          }()} {}
+    ComponentTypeNotFound(std::string_view component) : ComponentTypeNotFound{std::string{component}} {}
+};
+
+class DatasetInfo {
+
+  public:
+    DatasetInfo(RawDatasetInfo const* info) noexcept : info_{info} {}
+    DatasetInfo(DatasetInfo&&) = default;
+    DatasetInfo& operator=(DatasetInfo&&) = default;
+    DatasetInfo(DatasetInfo const&) = delete;            // No copy constructor
+    DatasetInfo& operator=(DatasetInfo const&) = delete; // No copy assignment
+    ~DatasetInfo() = default;
+
+    std::string name() const { return std::string{handle_.call_with(PGM_dataset_info_name, info_)}; }
+
+    bool is_batch() const { return handle_.call_with(PGM_dataset_info_is_batch, info_) != 0; }
+
+    Idx batch_size() const { return handle_.call_with(PGM_dataset_info_batch_size, info_); }
+
+    Idx n_components() const { return handle_.call_with(PGM_dataset_info_n_components, info_); }
+
+    std::string component_name(Idx component_idx) const {
+        return std::string{handle_.call_with(PGM_dataset_info_component_name, info_, component_idx)};
+    }
+
+    Idx component_elements_per_scenario(Idx component_idx) const {
+        return handle_.call_with(PGM_dataset_info_elements_per_scenario, info_, component_idx);
+    }
+
+    Idx component_total_elements(Idx component_idx) const {
+        return handle_.call_with(PGM_dataset_info_total_elements, info_, component_idx);
+    }
+
+    Idx component_idx(std::string_view component) const {
+        Idx const n_comp = n_components();
+        for (Idx idx = 0; idx < n_comp; ++idx) {
+            if (component_name(idx) == component) {
+                return idx;
+            }
+        }
+        throw ComponentTypeNotFound{component};
+    }
+
+    bool has_attribute_indications(Idx component_idx) const {
+        return handle_.call_with(PGM_dataset_info_has_attribute_indications, info_, component_idx) != 0;
+    }
+
+    std::vector<std::string> attribute_indications(Idx component_idx) const {
+        Idx const n_attributes = handle_.call_with(PGM_dataset_info_n_attribute_indications, info_, component_idx);
+        std::vector<std::string> attributes;
+        attributes.reserve(n_attributes);
+        for (Idx idx = 0; idx < n_attributes; ++idx) {
+            attributes.emplace_back(handle_.call_with(PGM_dataset_info_attribute_name, info_, component_idx, idx));
+        }
+        return attributes;
+    }
+
+  private:
+    Handle handle_{};
+    RawDatasetInfo const* info_;
+};
+
+class DatasetWritable {
+  public:
+    DatasetWritable(RawWritableDataset* dataset)
+        : dataset_{dataset}, info_{handle_.call_with(PGM_dataset_writable_get_info, dataset_)} {}
+    DatasetWritable(DatasetWritable&&) = default;
+    DatasetWritable& operator=(DatasetWritable&&) = default;
+    DatasetWritable(DatasetWritable const&) = delete;            // No copy constructor
+    DatasetWritable& operator=(DatasetWritable const&) = delete; // No copy assignment
+    ~DatasetWritable() = default;
+
+    RawWritableDataset const* get() const { return dataset_; }
+    RawWritableDataset* get() { return dataset_; }
+
+    DatasetInfo const& get_info() const { return info_; }
+
+    void set_buffer(std::string const& component, Idx* indptr, RawDataPtr data) {
+        handle_.call_with(PGM_dataset_writable_set_buffer, get(), component.c_str(), indptr, data);
+    }
+
+    void set_buffer(std::string const& component, Idx* indptr, Buffer& data) {
+        handle_.call_with(PGM_dataset_writable_set_buffer, get(), component.c_str(), indptr, data.get());
+    }
+
+    void set_attribute_buffer(std::string const& component, std::string const& attribute, RawDataPtr data) {
+        handle_.call_with(PGM_dataset_writable_set_attribute_buffer, get(), component.c_str(), attribute.c_str(), data);
+    }
+
+    void set_attribute_buffer(std::string const& component, std::string const& attribute, Buffer& data) {
+        handle_.call_with(PGM_dataset_writable_set_attribute_buffer, get(), component.c_str(), attribute.c_str(),
+                          data.get());
+    }
+
+  private:
+    Handle handle_{};
+    RawWritableDataset* dataset_;
+    DatasetInfo info_;
+};
+
+class DatasetMutable {
+  public:
+    explicit DatasetMutable(std::string const& dataset, bool is_batch, Idx batch_size)
+        : dataset_{handle_.call_with(PGM_create_dataset_mutable, dataset.c_str(), (is_batch ? Idx{1} : Idx{0}),
+                                     batch_size)},
+          info_{handle_.call_with(PGM_dataset_mutable_get_info, get())} {}
+
+    RawMutableDataset const* get() const { return dataset_.get(); }
+    RawMutableDataset* get() { return dataset_.get(); }
+
+    void add_buffer(std::string const& component, Idx elements_per_scenario, Idx total_elements, Idx const* indptr,
+                    RawDataPtr data) {
+        handle_.call_with(PGM_dataset_mutable_add_buffer, get(), component.c_str(), elements_per_scenario,
+                          total_elements, indptr, data);
+    }
+
+    void add_buffer(std::string const& component, Idx elements_per_scenario, Idx total_elements, Idx const* indptr,
+                    Buffer& data) {
+        handle_.call_with(PGM_dataset_mutable_add_buffer, get(), component.c_str(), elements_per_scenario,
+                          total_elements, indptr, data.get());
+    }
+
+    void add_attribute_buffer(std::string const& component, std::string const& attribute, RawDataPtr data) {
+        handle_.call_with(PGM_dataset_mutable_add_attribute_buffer, get(), component.c_str(), attribute.c_str(), data);
+    }
+
+    void add_attribute_buffer(std::string const& component, std::string const& attribute, Buffer& data) {
+        handle_.call_with(PGM_dataset_mutable_add_attribute_buffer, get(), component.c_str(), attribute.c_str(),
+                          data.get());
+    }
+
+    DatasetInfo const& get_info() const { return info_; }
+
+  private:
+    Handle handle_{};
+    detail::UniquePtr<RawMutableDataset, &PGM_destroy_dataset_mutable> dataset_;
+    DatasetInfo info_;
+};
+
+class DatasetConst {
+  public:
+    explicit DatasetConst(std::string const& dataset, bool is_batch, Idx batch_size)
+        : dataset_{handle_.call_with(PGM_create_dataset_const, dataset.c_str(), (is_batch ? Idx{1} : Idx{0}),
+                                     batch_size)},
+          info_{handle_.call_with(PGM_dataset_const_get_info, get())} {}
+
+    DatasetConst(DatasetWritable const& writable_dataset)
+        : dataset_{handle_.call_with(PGM_create_dataset_const_from_writable, writable_dataset.get())},
+          info_{handle_.call_with(PGM_dataset_const_get_info, get())} {}
+
+    DatasetConst(DatasetMutable const& mutable_dataset)
+        : dataset_{handle_.call_with(PGM_create_dataset_const_from_mutable, mutable_dataset.get())},
+          info_{handle_.call_with(PGM_dataset_const_get_info, get())} {}
+
+    RawConstDataset const* get() const { return dataset_.get(); }
+    RawConstDataset* get() { return dataset_.get(); }
+
+    void add_buffer(std::string const& component, Idx elements_per_scenario, Idx total_elements, Idx const* indptr,
+                    RawDataConstPtr data) {
+        handle_.call_with(PGM_dataset_const_add_buffer, get(), component.c_str(), elements_per_scenario, total_elements,
+                          indptr, data);
+    }
+
+    void add_buffer(std::string const& component, Idx elements_per_scenario, Idx total_elements, Idx const* indptr,
+                    Buffer const& data) {
+        handle_.call_with(PGM_dataset_const_add_buffer, get(), component.c_str(), elements_per_scenario, total_elements,
+                          indptr, data.get());
+    }
+
+    void add_attribute_buffer(std::string const& component, std::string const& attribute, RawDataConstPtr data) {
+        handle_.call_with(PGM_dataset_const_add_attribute_buffer, get(), component.c_str(), attribute.c_str(), data);
+    }
+
+    void add_attribute_buffer(std::string const& component, std::string const& attribute, Buffer const& data) {
+        handle_.call_with(PGM_dataset_const_add_attribute_buffer, get(), component.c_str(), attribute.c_str(),
+                          data.get());
+    }
+
+    void set_next_cartesian_product_dimension(DatasetConst const& next_dataset) {
+        handle_.call_with(PGM_dataset_const_set_next_cartesian_product_dimension, get(), next_dataset.get());
+    }
+
+    DatasetInfo const& get_info() const { return info_; }
+
+  private:
+    Handle handle_{};
+    detail::UniquePtr<RawConstDataset, &PGM_destroy_dataset_const> dataset_;
+    DatasetInfo info_;
+};
+
+struct OwningMemory {
+    std::vector<Buffer> buffers;
+    std::vector<std::vector<Idx>> indptrs;
+};
+
+struct OwningDataset {
+    DatasetMutable dataset;
+    OwningMemory storage{};
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_DATASET_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/handle.hpp

@@ -0,0 +1,108 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_HANDLE_HPP
+#define POWER_GRID_MODEL_CPP_HANDLE_HPP
+
+#include "basics.hpp"
+
+#include "power_grid_model_c/handle.h"
+
+namespace power_grid_model_cpp {
+class PowerGridError : public std::exception {
+  public:
+    PowerGridError(std::string message) : message_(std::move(message)) {}
+    const char* what() const noexcept override { return message_.c_str(); }
+    virtual Idx error_code() const noexcept { return PGM_regular_error; };
+
+  private:
+    std::string message_;
+};
+
+class PowerGridRegularError : public PowerGridError {
+  public:
+    using PowerGridError::PowerGridError;
+    Idx error_code() const noexcept override { return PGM_regular_error; }
+};
+
+class PowerGridSerializationError : public PowerGridError {
+  public:
+    using PowerGridError::PowerGridError;
+    Idx error_code() const noexcept override { return PGM_serialization_error; }
+};
+
+class PowerGridBatchError : public PowerGridError {
+  public:
+    struct FailedScenario {
+        Idx scenario{};
+        std::string error_message;
+    };
+
+    PowerGridBatchError(std::string message, std::vector<FailedScenario> failed_scenarios_c)
+        : PowerGridError{std::move(message)}, failed_scenarios_{std::move(failed_scenarios_c)} {}
+    Idx error_code() const noexcept override { return PGM_batch_error; }
+    std::vector<FailedScenario> const& failed_scenarios() const { return failed_scenarios_; }
+
+  private:
+    std::vector<FailedScenario> failed_scenarios_;
+};
+
+class Handle {
+  public:
+    RawHandle* get() const { return handle_.get(); }
+
+    void clear_error() const { PGM_clear_error(get()); }
+
+    void check_error() const {
+        RawHandle const* handle_ptr = get();
+        Idx const error_code = PGM_error_code(handle_ptr);
+        std::string const error_message = error_code == PGM_no_error ? "" : PGM_error_message(handle_ptr);
+        switch (error_code) {
+        case PGM_no_error:
+            return;
+        case PGM_regular_error:
+            clear_error();
+            throw PowerGridRegularError{error_message};
+        case PGM_batch_error: {
+            Idx const n_failed_scenarios = PGM_n_failed_scenarios(handle_ptr);
+            std::vector<PowerGridBatchError::FailedScenario> failed_scenarios(n_failed_scenarios);
+            auto const* const failed_scenario_seqs = PGM_failed_scenarios(handle_ptr);
+            auto const* const failed_scenario_messages = PGM_batch_errors(handle_ptr);
+            for (Idx i = 0; i < n_failed_scenarios; ++i) {
+                failed_scenarios[i] =
+                    PowerGridBatchError::FailedScenario{// NOLINT(modernize-use-designated-initializers)
+                                                        failed_scenario_seqs[i], failed_scenario_messages[i]};
+            }
+            clear_error();
+            throw PowerGridBatchError{error_message, std::move(failed_scenarios)};
+        }
+        case PGM_serialization_error:
+            clear_error();
+            throw PowerGridSerializationError{error_message};
+        default:
+            clear_error();
+            throw PowerGridError{error_message};
+        }
+    }
+
+    template <typename Func, typename... Args> auto call_with(Func&& func, Args&&... args) const {
+        if constexpr (std::is_void_v<decltype(std::forward<Func>(func)(get(), std::forward<Args>(args)...))>) {
+            std::forward<Func>(func)(get(), std::forward<Args>(args)...);
+            check_error();
+        } else {
+            auto result = std::forward<Func>(func)(get(), std::forward<Args>(args)...);
+            check_error();
+            return result;
+        }
+    }
+
+  private:
+    // For handle the const semantics are not needed.
+    // It is meant to be mutated even in const situations.
+    std::unique_ptr<RawHandle, detail::DeleterFunctor<&PGM_destroy_handle>> handle_{PGM_create_handle()};
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_HANDLE_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/meta_data.hpp

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_META_DATA_HPP
+#define POWER_GRID_MODEL_CPP_META_DATA_HPP
+
+#include "basics.hpp"
+#include "handle.hpp"
+
+#include "power_grid_model_c/meta_data.h"
+
+namespace power_grid_model_cpp {
+class MetaData {
+  public:
+    static Idx n_datasets() { return PGM_meta_n_datasets(nullptr); }
+
+    static MetaDataset const* get_dataset_by_idx(Idx idx) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_dataset_by_idx, idx);
+    }
+
+    static MetaDataset const* get_dataset_by_name(std::string const& dataset) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_dataset_by_name, dataset.c_str());
+    }
+
+    static std::string dataset_name(MetaDataset const* dataset) {
+        return std::string{PGM_meta_dataset_name(nullptr, dataset)};
+    }
+
+    static Idx n_components(MetaDataset const* dataset) { return PGM_meta_n_components(nullptr, dataset); }
+
+    static MetaComponent const* get_component_by_idx(MetaDataset const* dataset, Idx idx) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_component_by_idx, dataset, idx);
+    }
+
+    static MetaComponent const* get_component_by_name(std::string const& dataset, std::string const& component) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_component_by_name, dataset.c_str(), component.c_str());
+    }
+
+    static std::string component_name(MetaComponent const* component) {
+        return std::string{PGM_meta_component_name(nullptr, component)};
+    }
+
+    static size_t component_size(MetaComponent const* component) { return PGM_meta_component_size(nullptr, component); }
+
+    static size_t component_alignment(MetaComponent const* component) {
+        return PGM_meta_component_alignment(nullptr, component);
+    }
+
+    static Idx n_attributes(MetaComponent const* component) { return PGM_meta_n_attributes(nullptr, component); }
+
+    static MetaAttribute const* get_attribute_by_idx(MetaComponent const* component, Idx idx) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_attribute_by_idx, component, idx);
+    }
+
+    static MetaAttribute const* get_attribute_by_name(std::string const& dataset, std::string const& component,
+                                                      std::string const& attribute) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_attribute_by_name, dataset.c_str(), component.c_str(), attribute.c_str());
+    }
+
+    static std::string attribute_name(MetaAttribute const* attribute) {
+        return std::string{PGM_meta_attribute_name(nullptr, attribute)};
+    }
+
+    static PGM_CType attribute_ctype(MetaAttribute const* attribute) {
+        return static_cast<PGM_CType>(PGM_meta_attribute_ctype(nullptr, attribute));
+    }
+
+    static size_t attribute_offset(MetaAttribute const* attribute) {
+        return PGM_meta_attribute_offset(nullptr, attribute);
+    }
+
+    static int is_little_endian() { return PGM_is_little_endian(nullptr); }
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_META_DATA_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/model.hpp

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_MODEL_HPP
+#define POWER_GRID_MODEL_CPP_MODEL_HPP
+
+#include "basics.hpp"
+#include "dataset.hpp"
+#include "handle.hpp"
+#include "options.hpp"
+
+#include "power_grid_model_c/model.h"
+
+namespace power_grid_model_cpp {
+class Model {
+  public:
+    Model(double system_frequency, DatasetConst const& input_dataset)
+        : model_{handle_.call_with(PGM_create_model, system_frequency, input_dataset.get())} {}
+    Model(Model const& other) : model_{handle_.call_with(PGM_copy_model, other.get())} {}
+    Model& operator=(Model const& other) {
+        if (this != &other) {
+            model_.reset(handle_.call_with(PGM_copy_model, other.get()));
+        }
+        return *this;
+    }
+    Model(Model&& other) noexcept : handle_{std::move(other.handle_)}, model_{std::move(other.model_)} {}
+    Model& operator=(Model&& other) noexcept {
+        if (this != &other) {
+            handle_ = std::move(other.handle_);
+            model_ = std::move(other.model_);
+        }
+        return *this;
+    }
+    ~Model() = default;
+
+    PowerGridModel const* get() const { return model_.get(); }
+    PowerGridModel* get() { return model_.get(); }
+
+    void update(DatasetConst const& update_dataset) {
+        handle_.call_with(PGM_update_model, get(), update_dataset.get());
+    }
+
+    void get_indexer(std::string const& component, Idx size, ID const* ids, Idx* indexer) const {
+        handle_.call_with(PGM_get_indexer, get(), component.c_str(), size, ids, indexer);
+    }
+
+    void calculate(Options const& opt, DatasetMutable const& output_dataset, DatasetConst const& batch_dataset) {
+        handle_.call_with(PGM_calculate, get(), opt.get(), output_dataset.get(), batch_dataset.get());
+    }
+
+    void calculate(Options const& opt, DatasetMutable const& output_dataset) {
+        handle_.call_with(PGM_calculate, get(), opt.get(), output_dataset.get(), nullptr);
+    }
+
+  private:
+    Handle handle_{};
+    detail::UniquePtr<PowerGridModel, &PGM_destroy_model> model_;
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_MODEL_HPP