Keep only important integration tests: step 5

docs/advanced_documentation/c-api.md

@@ -116,7 +116,7 @@ and may vary between power grid model versions, compilers, operating systems and
 <line_0><line_1><line_2>   <-- 3 lines.
 |   |   |   |   |   |   |  <-- alignment: a line may start every 4 bytes.
 iiiift  iiiift  iiiift     <-- data: 6 bytes per line: 4 bytes for the ID, 1 for the from_status and 1 for the to_status.
-|     ..|     ..|     ..|  <-- padding: (6 mod 4 = 2) bytes after every line.
+|     ..|     ..|     ..|  <-- padding: (4 - (6 mod 4) = 2) bytes after every line.
 |       |       |       |  <-- aligned size: (6 + 2 = 8) bytes every line.
 ```
 

power_grid_model_c/power_grid_model/include/power_grid_model/common/enum.hpp

@@ -24,7 +24,7 @@ enum class ControlSide : IntS { from = 0, to = 1, side_1 = 0, side_2 = 1, side_3
 
 enum class CalculationType : IntS { power_flow = 0, state_estimation = 1, short_circuit = 2 };
 
-enum class CalculationSymmetry : IntS { symmetric = 0, asymmetric = 1 };
+enum class CalculationSymmetry : IntS { symmetric = 1, asymmetric = 2 };
 
 enum class CalculationMethod : IntS {
     default_method = -128,

power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp

@@ -55,9 +55,6 @@ class MainModel {
     }
 
     void set_construction_complete() { impl().set_construction_complete(); }
-    void restore_components(ConstDataset const& update_data) {
-        impl().restore_components(impl().get_all_sequence_idx_map(update_data));
-    }
 
     template <class CompType> void add_component(std::vector<typename CompType::InputType> const& components) {
         add_component<CompType>(std::span<typename CompType::InputType const>{components});

power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp

@@ -306,35 +306,6 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         update_components<CacheType>(update_data, 0, sequence_idx_map);
     }
 
-    template <typename CompType> void restore_component(SequenceIdxView const& sequence_idx) {
-        constexpr auto component_index = main_core::utils::index_of_component<CompType, ComponentType...>;
-
-        auto& cached_inverse_update = std::get<component_index>(cached_inverse_update_);
-        auto const& component_sequence = std::get<component_index>(sequence_idx);
-
-        if (!cached_inverse_update.empty()) {
-            update_component<CompType, permanent_update_t>(cached_inverse_update, component_sequence);
-            cached_inverse_update.clear();
-        }
-    }
-
-    // restore the initial values of all components
-    void restore_components(SequenceIdxView const& sequence_idx) {
-        (restore_component<ComponentType>(sequence_idx), ...);
-
-        update_state(cached_state_changes_);
-        cached_state_changes_ = {};
-    }
-    void restore_components(std::array<std::reference_wrapper<std::vector<Idx2D> const>,
-                                       main_core::utils::n_types<ComponentType...>> const& sequence_idx) {
-        restore_components(std::array{std::span<Idx2D const>{
-            std::get<main_core::utils::index_of_component<ComponentType, ComponentType...>>(sequence_idx).get()}...});
-    }
-    void restore_components(main_core::utils::SequenceIdx<ComponentType...> const& sequence_idx) {
-        restore_components(std::array{std::span<Idx2D const>{
-            std::get<main_core::utils::index_of_component<ComponentType, ComponentType...>>(sequence_idx)}...});
-    }
-
     // set complete construction
     // initialize internal arrays
     void set_construction_complete() {
@@ -402,6 +373,35 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         is_asym_parameter_up_to_date_ = is_asym_parameter_up_to_date_ && !changes.topo && !changes.param;
     }
 
+    template <typename CompType> void restore_component(SequenceIdxView const& sequence_idx) {
+        constexpr auto component_index = main_core::utils::index_of_component<CompType, ComponentType...>;
+
+        auto& cached_inverse_update = std::get<component_index>(cached_inverse_update_);
+        auto const& component_sequence = std::get<component_index>(sequence_idx);
+
+        if (!cached_inverse_update.empty()) {
+            update_component<CompType, permanent_update_t>(cached_inverse_update, component_sequence);
+            cached_inverse_update.clear();
+        }
+    }
+
+    // restore the initial values of all components
+    void restore_components(SequenceIdxView const& sequence_idx) {
+        (restore_component<ComponentType>(sequence_idx), ...);
+
+        update_state(cached_state_changes_);
+        cached_state_changes_ = {};
+    }
+    void restore_components(std::array<std::reference_wrapper<std::vector<Idx2D> const>,
+                                       main_core::utils::n_types<ComponentType...>> const& sequence_idx) {
+        restore_components(std::array{std::span<Idx2D const>{
+            std::get<main_core::utils::index_of_component<ComponentType, ComponentType...>>(sequence_idx).get()}...});
+    }
+    void restore_components(main_core::utils::SequenceIdx<ComponentType...> const& sequence_idx) {
+        restore_components(std::array{std::span<Idx2D const>{
+            std::get<main_core::utils::index_of_component<ComponentType, ComponentType...>>(sequence_idx)}...});
+    }
+
     template <solver_output_type SolverOutputType, typename MathSolverType, typename YBus, typename InputType,
               typename PrepareInputFn, typename SolveFn>
         requires std::invocable<std::remove_cvref_t<PrepareInputFn>, Idx /*n_math_solvers*/> &&

power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h

@@ -166,6 +166,14 @@ enum PGM_CalculationMethod {
     PGM_iec60909 = 5           /**< fault analysis for short circuits using the iec60909 standard */
 };
 
+/**
+ * @brief Enumeration for calculation and/or component symmetry
+ */
+enum PGM_SymmetryType {
+    PGM_asymmetric = 0, /** < asymmetric calculation and/or component */
+    PGM_symmetric = 1   /** < symmetric calculation and/or component */
+};
+
 /**
  * @brief Enumeration of error codes.
  *

power_grid_model_c/power_grid_model_c/include/power_grid_model_c/options.h

@@ -66,7 +66,7 @@ PGM_API void PGM_set_calculation_method(PGM_Handle* handle, PGM_Options* opt, PG
  *
  * @param handle
  * @param opt The pointer to the option instance.
- * @param sym 1 for symmetric calculation; 0 for asymmetric calculation.
+ * @param sym See #PGM_CalculationSymmetry . 1 for symmetric calculation; 0 for asymmetric calculation.
  */
 PGM_API void PGM_set_symmetric(PGM_Handle* handle, PGM_Options* opt, PGM_Idx sym);
 

power_grid_model_c/power_grid_model_c/src/model.cpp

@@ -75,10 +75,14 @@ constexpr auto get_calculation_type(PGM_Options const& opt) {
 }
 
 constexpr auto get_calculation_symmetry(PGM_Options const& opt) {
-    if (opt.symmetric == 0) {
+    switch (opt.symmetric) {
+    case PGM_asymmetric:
         return CalculationSymmetry::asymmetric;
+    case PGM_symmetric:
+        return CalculationSymmetry::symmetric;
+    default:
+        throw MissingCaseForEnumError{"get_calculation_symmetry", opt.tap_changing_strategy};
     }
-    return CalculationSymmetry::symmetric;
 }
 
 constexpr auto get_calculation_method(PGM_Options const& opt) {

power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/buffer.hpp

@@ -20,6 +20,7 @@ class Buffer {
     RawDataConstPtr get() const { return buffer_.get(); }
     RawDataPtr get() { return buffer_.get(); }
 
+    MetaComponent const* component() const { return component_; }
     Idx size() const { return size_; }
 
     void set_nan() { set_nan(0, size_); }

power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/dataset.hpp

@@ -88,9 +88,13 @@ class DatasetWritable {
 
 class DatasetMutable {
   public:
-    DatasetMutable(std::string const& dataset, Idx is_batch, Idx batch_size)
-        : dataset_{handle_.call_with(PGM_create_dataset_mutable, dataset.c_str(), is_batch, batch_size)},
+    DatasetMutable(std::string const& dataset, std::convertible_to<Idx> auto is_batch, Idx batch_size)
+        requires(!std::same_as<decltype(is_batch), bool>)
+        : handle_{},
+          dataset_{handle_.call_with(PGM_create_dataset_mutable, dataset.c_str(), is_batch, batch_size)},
           info_{handle_.call_with(PGM_dataset_mutable_get_info, get())} {}
+    explicit DatasetMutable(std::string const& dataset, std::same_as<bool> auto is_batch, Idx batch_size)
+        : DatasetMutable{dataset, is_batch ? Idx{1} : Idx{0}, batch_size} {}
 
     RawMutableDataset const* get() const { return dataset_.get(); }
     RawMutableDataset* get() { return dataset_.get(); }
@@ -126,9 +130,13 @@ class DatasetMutable {
 
 class DatasetConst {
   public:
-    DatasetConst(std::string const& dataset, Idx is_batch, Idx batch_size)
-        : dataset_{handle_.call_with(PGM_create_dataset_const, dataset.c_str(), is_batch, batch_size)},
+    DatasetConst(std::string const& dataset, std::convertible_to<Idx> auto is_batch, Idx batch_size)
+        requires(!std::same_as<decltype(is_batch), bool>)
+        : handle_{},
+          dataset_{handle_.call_with(PGM_create_dataset_const, dataset.c_str(), is_batch, batch_size)},
           info_{handle_.call_with(PGM_dataset_const_get_info, get())} {}
+    explicit DatasetConst(std::string const& dataset, std::same_as<bool> auto is_batch, Idx batch_size)
+        : DatasetConst{dataset, is_batch ? Idx{1} : Idx{0}, batch_size} {}
     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())} {}

tests/CMakeLists.txt

@@ -8,6 +8,5 @@ include("${doctest_DIR}/doctest.cmake")
 
 add_subdirectory("native_api_tests")
 add_subdirectory("cpp_unit_tests")
-add_subdirectory("cpp_integration_tests")
 add_subdirectory("cpp_validation_tests")
 add_subdirectory("benchmark_cpp")