Merge pull request #1135 from PowerGridModel/feature/main-model-refactor-clean-templates-2

Cleanup main model: Finish migrating to main model type

Author: figueroa1395

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_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_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_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_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_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -14,57 +14,60 @@
 #include <utility>
 
 namespace power_grid_model {
-template <typename Adapter> class JobInterface {
+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>;
+    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>;
         }
     {
-        static_cast<Adapter*>(this)->calculate_impl(result_data, pos, logger);
+        return std::forward<Self>(self).calculate_impl(result_data, pos, logger);
     }
-    template <typename ResultDataset> void calculate(ResultDataset const& result_data, Logger& logger) {
-        calculate(result_data, Idx{}, 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);
     }
 
-    void cache_calculate(Logger& logger)
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.cache_calculate_impl(logger) } -> std::same_as<void>;
+    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>;
         }
     {
-        static_cast<Adapter*>(this)->cache_calculate_impl(logger);
+        return std::forward<Self>(self).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>;
+    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>;
         }
     {
-        static_cast<Adapter*>(this)->prepare_job_dispatch_impl(update_data);
+        return std::forward<Self>(self).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>;
+    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>;
         }
     {
-        static_cast<Adapter*>(this)->setup_impl(update_data, scenario_idx);
+        return std::forward<Self>(self).setup_impl(update_data, scenario_idx);
     }
 
-    void winddown()
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.winddown_impl() } -> std::same_as<void>;
+    template <typename Self>
+    void winddown(this Self&& self)
+        requires requires { // NOSONAR
+            { std::forward<Self>(self).winddown_impl() } -> std::same_as<void>;
         }
     {
-        static_cast<Adapter*>(this)->winddown_impl();
+        return std::forward<Self>(self).winddown_impl();
     }
 
-  private:
-    friend Adapter;
+  protected:
     JobInterface() = default;
     JobInterface(const JobInterface& /*other*/) = default;
     JobInterface& operator=(const JobInterface& /*other*/) = default;

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

@@ -4,9 +4,6 @@
 
 #pragma once
 
-#include "../container.hpp"
-#include "state.hpp"
-
 #include <array>
 #include <vector>
 namespace power_grid_model::main_core::utils {
@@ -20,26 +17,9 @@ constexpr void run_functor_with_tuple_index_return_void(Functor&& functor, std::
 
 } // namespace detail
 
+constexpr Idx sequential{-1};
 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>>{});

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_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_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,