power-grid-model 1.12.41__tar.gz → 1.12.43__tar.gz

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/.github/workflows/build-test-release.yml

@@ -213,7 +213,7 @@ jobs:
           xcode-version: latest-stable
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v3.1
+        uses: pypa/cibuildwheel@v3.2
         # GitHub Actions specific build parameters
         env:
           # pass GitHub runner info into Linux container

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-grid-model
-Version: 1.12.41
+Version: 1.12.43
 Summary: Python/C++ library for distribution power system analysis
 Author-Email: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
 License-Expression: MPL-2.0

power_grid_model-1.12.43/VERSION

@@ -0,0 +1 @@
+1.12.43

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/all_components.hpp

@@ -32,4 +32,9 @@ using AllComponents =
     ComponentList<Node, Line, AsymLine, Link, GenericBranch, Transformer, ThreeWindingTransformer, Shunt, Source,
                   SymGenerator, AsymGenerator, SymLoad, AsymLoad, SymPowerSensor, AsymPowerSensor, SymVoltageSensor,
                   AsymVoltageSensor, SymCurrentSensor, AsymCurrentSensor, Fault, TransformerTapRegulator>;
+
+using AllExtraRetrievableTypes =
+    ExtraRetrievableTypes<Base, Node, Branch, Branch3, Appliance, GenericLoadGen, GenericLoad, GenericGenerator,
+                          GenericPowerSensor, GenericVoltageSensor, GenericCurrentSensor, Regulator>;
+
 } // namespace power_grid_model

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/common/component_list.hpp

@@ -16,4 +16,7 @@ template <typename T, typename... Ts>
     requires is_in_list_c<T, Ts...>
 struct IsInList<T, ComponentList<Ts...>> : std::true_type {};
 
+// type traits associated with the container
+template <class... T> struct ExtraRetrievableTypes {};
+
 } // namespace power_grid_model

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp

@@ -7,6 +7,7 @@
 // container for multiple components
 
 #include "common/common.hpp"
+#include "common/component_list.hpp"
 #include "common/exception.hpp"
 #include "common/iterator_facade.hpp"
 #include "container_fwd.hpp"
@@ -336,8 +337,6 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
     template <supported_type_c<GettableTypes...> Gettable> auto citer() const { return iter<Gettable>(); }
 };
 
-// type traits to instantiate container
-template <class... T> struct ExtraRetrievableTypes;
 // with no extra types, default all vector value types
 template <class... T> struct container_trait {
     using type = Container<RetrievableTypes<T...>, T...>;
@@ -349,8 +348,6 @@ template <class... TR, class... T> struct container_trait<ExtraRetrievableTypes<
 
 } // namespace container_impl
 
-template <class... T> using ExtraRetrievableTypes = container_impl::ExtraRetrievableTypes<T...>;
-
 template <class... T> using Container = typename container_impl::container_trait<T...>::type;
 
 } // namespace power_grid_model

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -16,7 +16,7 @@ namespace power_grid_model {
 
 template <class MainModel> class JobAdapter;
 
-template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<MainModel>> {
+template <class MainModel> class JobAdapter : public JobInterface {
   public:
     using ModelType = typename MainModel::ImplType;
 
@@ -66,10 +66,7 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
     ~JobAdapter() { model_copy_.reset(); }
 
   private:
-    // Grant the CRTP base (JobInterface<JobAdapter>) access to
-    // JobAdapter's private members. This allows the base class template
-    // to call derived-class implementation details as part of the CRTP pattern.
-    friend class JobInterface<JobAdapter>;
+    friend class JobInterface;
 
     std::unique_ptr<MainModel> model_copy_;
     std::reference_wrapper<MainModel> model_reference_;

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp

@@ -17,10 +17,8 @@ namespace power_grid_model {
 
 class JobDispatch {
   public:
-    static constexpr Idx sequential{-1};
-
     template <typename Adapter, typename ResultDataset, typename UpdateDataset>
-        requires std::is_base_of_v<JobInterface<Adapter>, Adapter>
+        requires std::is_base_of_v<JobInterface, Adapter>
     static BatchParameter batch_calculation(Adapter& adapter, ResultDataset const& result_data,
                                             UpdateDataset const& update_data, Idx threading,
                                             common::logging::MultiThreadedLogger& log) {

power_grid_model-1.12.43/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+// batch dispatch interface class
+
+#include "common/common.hpp"
+#include "common/logging.hpp"
+
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+namespace power_grid_model {
+class JobInterface {
+  public:
+    // the multiple  NOSONARs are used to avoid the complaints about the unnamed concepts
+    template <typename Self, typename ResultDataset>
+    void calculate(this Self&& self, ResultDataset const& result_data, Idx pos, Logger& logger)
+        requires requires { // NOSONAR
+            { std::forward<Self>(self).calculate_impl(result_data, pos, logger) } -> std::same_as<void>;
+        }
+    {
+        return std::forward<Self>(self).calculate_impl(result_data, pos, logger);
+    }
+
+    template <typename Self, typename ResultDataset>
+    void calculate(this Self&& self, ResultDataset const& result_data, Logger& logger) {
+        std::forward<Self>(self).calculate(result_data, Idx{}, logger);
+    }
+
+    template <typename Self>
+    void cache_calculate(this Self&& self, Logger& logger)
+        requires requires { // NOSONAR
+            { std::forward<Self>(self).cache_calculate_impl(logger) } -> std::same_as<void>;
+        }
+    {
+        return std::forward<Self>(self).cache_calculate_impl(logger);
+    }
+
+    template <typename Self, typename UpdateDataset>
+    void prepare_job_dispatch(this Self&& self, UpdateDataset const& update_data)
+        requires requires { // NOSONAR
+            { std::forward<Self>(self).prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
+        }
+    {
+        return std::forward<Self>(self).prepare_job_dispatch_impl(update_data);
+    }
+
+    template <typename Self, typename UpdateDataset>
+    void setup(this Self&& self, UpdateDataset const& update_data, Idx scenario_idx)
+        requires requires { // NOSONAR
+            { std::forward<Self>(self).setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
+        }
+    {
+        return std::forward<Self>(self).setup_impl(update_data, scenario_idx);
+    }
+
+    template <typename Self>
+    void winddown(this Self&& self)
+        requires requires { // NOSONAR
+            { std::forward<Self>(self).winddown_impl() } -> std::same_as<void>;
+        }
+    {
+        return std::forward<Self>(self).winddown_impl();
+    }
+
+  protected:
+    JobInterface() = default;
+    JobInterface(const JobInterface& /*other*/) = default;
+    JobInterface& operator=(const JobInterface& /*other*/) = default;
+    JobInterface(JobInterface&& /*other*/) noexcept = default;
+    JobInterface& operator=(JobInterface&& /*other*/) noexcept = default;
+    ~JobInterface() = default;
+};
+
+} // namespace power_grid_model

power_grid_model-1.12.43/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/core_utils.hpp

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include <array>
+#include <vector>
+namespace power_grid_model::main_core::utils {
+
+namespace detail {
+
+template <typename Tuple, class Functor, std::size_t... Indices>
+constexpr void run_functor_with_tuple_index_return_void(Functor&& functor, std::index_sequence<Indices...> /*unused*/) {
+    (std::forward<Functor>(functor).template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
+}
+
+} // namespace detail
+
+constexpr Idx sequential{-1};
+constexpr Idx invalid_index{-1};
+
+template <typename Tuple, class Functor> constexpr void run_functor_with_tuple_return_void(Functor&& functor) {
+    detail::run_functor_with_tuple_index_return_void<Tuple>(std::forward<Functor>(functor),
+                                                            std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+}
+
+} // namespace power_grid_model::main_core::utils

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp

@@ -78,15 +78,13 @@ class MainModelType<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     using ComponentTypesTuple = std::tuple<ComponentType...>;
 
     static constexpr size_t n_types = sizeof...(ComponentType);
-    // TODO Should not have to go via container_impl.
     template <class CompType>
     static constexpr size_t index_of_component = container_impl::get_cls_pos_v<CompType, ComponentType...>;
 
   private:
+    // This tuple may contain duplicate types. eg. Node.
     static constexpr auto all_types_tuple_v_ =
         std::tuple<std::type_identity<ComponentType>..., std::type_identity<ExtraRetrievableType>...>{};
-    // TODO: Would making a unique be necessary? We have Node mentioned as a ExtraRetrievableType and ComponentType so
-    // summing up is possible but maybe not appropriate. Would it be better to handle them both separately? using
 
     static constexpr auto topology_types_tuple_v_ =
         std::tuple<std::type_identity<Node>, std::type_identity<Branch>, std::type_identity<Branch3>,
@@ -121,4 +119,11 @@ class MainModelType<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 };
 
+template <typename T> struct is_main_model_type : std::false_type {};
+
+template <typename... ETs, typename... CTs>
+struct is_main_model_type<MainModelType<ExtraRetrievableTypes<ETs...>, ComponentList<CTs...>>> : std::true_type {};
+
+template <typename T> inline constexpr bool is_main_model_type_v = is_main_model_type<T>::value;
+
 } // namespace power_grid_model::main_core

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp

@@ -18,10 +18,7 @@ namespace power_grid_model {
 
 class MainModel {
   private:
-    using Impl = MainModelImpl<
-        ExtraRetrievableTypes<Base, Node, Branch, Branch3, Appliance, GenericLoadGen, GenericLoad, GenericGenerator,
-                              GenericPowerSensor, GenericVoltageSensor, GenericCurrentSensor, Regulator>,
-        AllComponents>;
+    using Impl = MainModelImpl<main_core::MainModelType<AllExtraRetrievableTypes, AllComponents>>;
 
   public:
     using Options = MainModelOptions;

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp

@@ -116,17 +116,12 @@ decltype(auto) calculation_type_symmetry_func_selector(CalculationType calculati
         calculation_symmetry, std::forward<Functor>(f), std::forward<Args>(args)...);
 }
 
-// main model implementation template
-template <class T, class U> class MainModelImpl;
-
-template <class... ExtraRetrievableType, class... ComponentType>
-class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentList<ComponentType...>> {
+template <class ModelType>
+    requires(main_core::is_main_model_type_v<ModelType>)
+class MainModelImpl {
 
   private:
-    using ModelType =
-        main_core::MainModelType<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentList<ComponentType...>>;
     // internal type traits
-    // container class
     using ComponentContainer = typename ModelType::ComponentContainer;
     using MainModelState = typename ModelType::MainModelState;
 
@@ -138,7 +133,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
 
     static constexpr Idx isolated_component{main_core::isolated_component};
     static constexpr Idx not_connected{main_core::not_connected};
-    static constexpr Idx sequential{JobDispatch::sequential};
+    static constexpr Idx sequential{main_core::utils::sequential};
 
   public:
     using ImplType = ModelType;
@@ -481,7 +476,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
                 faults, [](Fault const& fault) { return fault.get_fault_type() == FaultType::three_phase; });
             options.calculation_symmetry =
                 is_three_phase ? CalculationSymmetry::symmetric : CalculationSymmetry::asymmetric;
-        };
+        }
 
         calculation_type_symmetry_func_selector(
             options.calculation_type, options.calculation_symmetry,

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/tests/cpp_unit_tests/test_job_dispatch.cpp

@@ -9,6 +9,7 @@
 #include <power_grid_model/common/multi_threaded_logging.hpp>
 #include <power_grid_model/job_dispatch.hpp>
 #include <power_grid_model/job_interface.hpp>
+#include <power_grid_model/main_core/core_utils.hpp>
 
 #include <doctest/doctest.h>
 
@@ -48,7 +49,7 @@ struct CallCounter {
     }
 };
 
-class JobAdapterMock : public JobInterface<JobAdapterMock> {
+class JobAdapterMock : public JobInterface {
   public:
     JobAdapterMock(std::shared_ptr<CallCounter> counter) : counter_{std::move(counter)} {
         REQUIRE_MESSAGE(counter_ != nullptr, "Counter must not be null or all getters will fail later on");
@@ -76,7 +77,7 @@ class JobAdapterMock : public JobInterface<JobAdapterMock> {
     Idx get_winddown_counter() const { return counter_->winddown_calls; }
 
   private:
-    friend class JobInterface<JobAdapterMock>;
+    friend class JobInterface;
 
     std::shared_ptr<CallCounter> counter_;
 
@@ -166,8 +167,8 @@ TEST_CASE("Test job dispatch logic") {
             Idx const n_scenarios = 9; // arbitrary non-zero value
             auto const update_data = MockUpdateDataset(has_data, n_scenarios);
             adapter.reset_counters();
-            auto const actual_result =
-                JobDispatch::batch_calculation(adapter, result_data, update_data, JobDispatch::sequential, no_logger());
+            auto const actual_result = JobDispatch::batch_calculation(adapter, result_data, update_data,
+                                                                      main_core::utils::sequential, no_logger());
             CHECK(expected_result == actual_result);
             CHECK(adapter.get_calculate_counter() == 1);
             CHECK(adapter.get_cache_calculate_counter() == 0); // no cache calculation in this case
@@ -177,8 +178,8 @@ TEST_CASE("Test job dispatch logic") {
             Idx const n_scenarios = 0;
             auto const update_data = MockUpdateDataset(has_data, n_scenarios);
             adapter.reset_counters();
-            auto const actual_result =
-                JobDispatch::batch_calculation(adapter, result_data, update_data, JobDispatch::sequential, no_logger());
+            auto const actual_result = JobDispatch::batch_calculation(adapter, result_data, update_data,
+                                                                      main_core::utils::sequential, no_logger());
             CHECK(expected_result == actual_result);
             // no calculations should be done
             CHECK(adapter.get_calculate_counter() == 0);
@@ -189,8 +190,8 @@ TEST_CASE("Test job dispatch logic") {
             Idx const n_scenarios = 7; // arbitrary non-zero value
             auto const update_data = MockUpdateDataset(has_data, n_scenarios);
             adapter.reset_counters();
-            auto const actual_result =
-                JobDispatch::batch_calculation(adapter, result_data, update_data, JobDispatch::sequential, no_logger());
+            auto const actual_result = JobDispatch::batch_calculation(adapter, result_data, update_data,
+                                                                      main_core::utils::sequential, no_logger());
             CHECK(expected_result == actual_result);
             // n_scenarios calculations should be done as we run sequentially
             CHECK(adapter.get_calculate_counter() == n_scenarios);
@@ -265,7 +266,7 @@ TEST_CASE("Test job dispatch logic") {
 
         SUBCASE("Sequential") {
             Idx const n_scenarios = 10; // arbitrary non-zero value
-            Idx const threading = JobDispatch::sequential;
+            Idx const threading = main_core::utils::sequential;
             calls.clear();
             JobDispatch::job_dispatch(single_job, n_scenarios, threading);
             CHECK(calls.size() == 1);
@@ -323,7 +324,7 @@ TEST_CASE("Test job dispatch logic") {
         Idx const n_scenarios = 14; // arbitrary non-zero value
 
         SUBCASE("Sequential threading") {
-            CHECK(JobDispatch::n_threads(n_scenarios, JobDispatch::sequential) == 1);
+            CHECK(JobDispatch::n_threads(n_scenarios, main_core::utils::sequential) == 1);
             CHECK(JobDispatch::n_threads(n_scenarios, 1) == 1);
         }
         SUBCASE("Parallel threading") {

{power_grid_model-1.12.41 → power_grid_model-1.12.43}/tests/cpp_unit_tests/test_main_model_type.cpp

@@ -5,6 +5,7 @@
 #include <power_grid_model/container.hpp>
 #include <power_grid_model/main_core/core_utils.hpp>
 #include <power_grid_model/main_core/main_model_type.hpp>
+#include <power_grid_model/main_model_impl.hpp>
 #include <power_grid_model/math_solver/math_solver_dispatch.hpp>
 
 #include <doctest/doctest.h>
@@ -12,12 +13,25 @@
 namespace power_grid_model::main_core {
 
 namespace {
-struct AComponent {
-    using UpdateType = void;
+
+struct AType {};
+
+class AComponent {
+  public:
+    // This dependency exists because of main_core/update.hpp
+    using UpdateType = AType;
     static constexpr char const* name = "a_component";
 };
+
 } // namespace
 
+static_assert(is_main_model_type_v<MainModelType<AllExtraRetrievableTypes, AllComponents>>);
+static_assert(!is_main_model_type_v<MainModelType<AllComponents, AllComponents>>);
+static_assert(!is_main_model_type_v<MainModelType<AType, AllComponents>>);
+
+static_assert(std::constructible_from<MainModelImpl<MainModelType<AllExtraRetrievableTypes, AllComponents>>, double,
+                                      meta_data::MetaData const&, MathSolverDispatcher const&>);
+
 static_assert(detail::validate_component_types_c<AllComponents>);
 
 static_assert(detail::validate_component_types_c<ComponentList<Node, Source>>);
@@ -41,6 +55,9 @@ TEST_CASE("MainModelType") {
         static_assert(ModelType::index_of_component<Node> == 0);
         static_assert(ModelType::index_of_component<Source> == 1);
         static_assert(ModelType::n_types == 2);
+        static_assert(is_main_model_type_v<ModelType>);
+        static_assert(std::constructible_from<MainModelImpl<ModelType>, double, meta_data::MetaData const&,
+                                              MathSolverDispatcher const&>);
 
         CHECK(ModelType::run_functor_with_all_component_types_return_array([]<typename CompType>() {
                   return std::string_view(CompType::name);
@@ -70,6 +87,9 @@ TEST_CASE("MainModelType") {
         static_assert(ModelType::index_of_component<Line> == 1);
         static_assert(ModelType::index_of_component<Source> == 2);
         static_assert(ModelType::n_types == 3);
+        static_assert(is_main_model_type_v<ModelType>);
+        static_assert(std::constructible_from<MainModelImpl<ModelType>, double, meta_data::MetaData const&,
+                                              MathSolverDispatcher const&>);
 
         CHECK(ModelType::run_functor_with_all_component_types_return_array([]<typename CompType>() {
                   return std::string_view(CompType::name);
@@ -99,6 +119,10 @@ TEST_CASE("MainModelType") {
         static_assert(ModelType::index_of_component<Source> == 1);
         static_assert(ModelType::index_of_component<Node> == 2);
         static_assert(ModelType::n_types == 3);
+        static_assert(is_main_model_type_v<ModelType>);
+
+        static_assert(std::constructible_from<MainModelImpl<ModelType>, double, meta_data::MetaData const&,
+                                              MathSolverDispatcher const&>);
 
         CHECK(ModelType::run_functor_with_all_component_types_return_array([]<typename CompType>() {
                   return std::string_view(CompType::name);
@@ -129,6 +153,9 @@ TEST_CASE("MainModelType") {
         static_assert(ModelType::index_of_component<AComponent> == 1);
         static_assert(ModelType::index_of_component<Source> == 2);
         static_assert(ModelType::n_types == 3);
+        static_assert(is_main_model_type_v<ModelType>);
+        static_assert(std::constructible_from<MainModelImpl<ModelType>, double, meta_data::MetaData const&,
+                                              MathSolverDispatcher const&>);
 
         CHECK(ModelType::run_functor_with_all_component_types_return_array([]<typename CompType>() {
                   return std::string_view(CompType::name);
@@ -144,9 +171,6 @@ TEST_CASE("MainModelType") {
             [&calls]<typename CompType>() { calls.push_back(std::string_view(CompType::name)); });
         CHECK(calls == std::vector<std::string_view>{"node", "source"});
     }
-
-    // TODO add static_assert(std::constructible_from<ModelType, double, meta_data::MetaData const&,
-    // MathSolverDispatcher const&>);
 }
 
 } // namespace power_grid_model::main_core

power_grid_model-1.12.41/VERSION

@@ -1 +0,0 @@
-1.12.41

power_grid_model-1.12.41/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -1,76 +0,0 @@
-// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
-//
-// SPDX-License-Identifier: MPL-2.0
-
-#pragma once
-
-// batch dispatch interface class
-
-#include "common/common.hpp"
-#include "common/logging.hpp"
-
-#include <concepts>
-#include <type_traits>
-#include <utility>
-
-namespace power_grid_model {
-template <typename Adapter> class JobInterface {
-  public:
-    // the multiple  NOSONARs are used to avoid the complaints about the unnamed concepts
-    template <typename ResultDataset>
-    void calculate(ResultDataset const& result_data, Idx pos, Logger& logger)
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.calculate_impl(result_data, pos, logger) } -> std::same_as<void>;
-        }
-    {
-        static_cast<Adapter*>(this)->calculate_impl(result_data, pos, logger);
-    }
-    template <typename ResultDataset> void calculate(ResultDataset const& result_data, Logger& logger) {
-        calculate(result_data, Idx{}, logger);
-    }
-
-    void cache_calculate(Logger& logger)
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.cache_calculate_impl(logger) } -> std::same_as<void>;
-        }
-    {
-        static_cast<Adapter*>(this)->cache_calculate_impl(logger);
-    }
-
-    template <typename UpdateDataset>
-    void prepare_job_dispatch(UpdateDataset const& update_data)
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
-        }
-    {
-        static_cast<Adapter*>(this)->prepare_job_dispatch_impl(update_data);
-    }
-
-    template <typename UpdateDataset>
-    void setup(UpdateDataset const& update_data, Idx scenario_idx)
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
-        }
-    {
-        static_cast<Adapter*>(this)->setup_impl(update_data, scenario_idx);
-    }
-
-    void winddown()
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.winddown_impl() } -> std::same_as<void>;
-        }
-    {
-        static_cast<Adapter*>(this)->winddown_impl();
-    }
-
-  private:
-    friend Adapter;
-    JobInterface() = default;
-    JobInterface(const JobInterface& /*other*/) = default;
-    JobInterface& operator=(const JobInterface& /*other*/) = default;
-    JobInterface(JobInterface&& /*other*/) noexcept = default;
-    JobInterface& operator=(JobInterface&& /*other*/) noexcept = default;
-    ~JobInterface() = default;
-};
-
-} // namespace power_grid_model

power_grid_model-1.12.41/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/core_utils.hpp

@@ -1,48 +0,0 @@
-// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
-//
-// SPDX-License-Identifier: MPL-2.0
-
-#pragma once
-
-#include "../container.hpp"
-#include "state.hpp"
-
-#include <array>
-#include <vector>
-namespace power_grid_model::main_core::utils {
-
-namespace detail {
-
-template <typename Tuple, class Functor, std::size_t... Indices>
-constexpr void run_functor_with_tuple_index_return_void(Functor&& functor, std::index_sequence<Indices...> /*unused*/) {
-    (std::forward<Functor>(functor).template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
-}
-
-} // namespace detail
-
-constexpr Idx invalid_index{-1};
-
-/////////////////// To remove ///////////////////
-
-template <class... ComponentTypes> constexpr size_t n_types = sizeof...(ComponentTypes);
-template <class CompType, class... ComponentTypes>
-constexpr size_t index_of_component = container_impl::get_cls_pos_v<CompType, ComponentTypes...>;
-
-template <class... ComponentTypes> using SequenceIdx = std::array<std::vector<Idx2D>, n_types<ComponentTypes...>>;
-template <class... ComponentTypes> using ComponentFlags = std::array<bool, n_types<ComponentTypes...>>;
-
-// run functors with all component types
-template <class... Types, class Functor> constexpr void run_functor_with_all_types_return_void(Functor functor) {
-    (functor.template operator()<Types>(), ...);
-}
-template <class... Types, class Functor> constexpr auto run_functor_with_all_types_return_array(Functor functor) {
-    return std::array { functor.template operator()<Types>()... };
-}
-/////////////////// To remove ///////////////////
-
-template <typename Tuple, class Functor> constexpr void run_functor_with_tuple_return_void(Functor&& functor) {
-    detail::run_functor_with_tuple_index_return_void<Tuple>(std::forward<Functor>(functor),
-                                                            std::make_index_sequence<std::tuple_size_v<Tuple>>{});
-}
-
-} // namespace power_grid_model::main_core::utils