rename

Signed-off-by: Nitish Bharambe <[email protected]>

Author: nitbharambe

power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -18,7 +18,7 @@ template <class MainModel> class JobAdapter;
 
 template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<MainModel>> {
   public:
-    using MainModelType = typename MainModel::MainModelType;
+    using ModelType = typename MainModel::ImplType;
 
     JobAdapter(std::reference_wrapper<MainModel> model_reference,
                std::reference_wrapper<MainModelOptions const> options)
@@ -88,12 +88,12 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
     std::reference_wrapper<MainModel> model_reference_;
     std::reference_wrapper<MainModelOptions const> options_;
 
-    typename MainModelType::ComponentFlags components_to_update_{};
-    typename MainModelType::UpdateIndependence update_independence_{};
-    typename MainModelType::ComponentFlags independence_flags_{};
-    std::shared_ptr<typename MainModelType::SequenceIdx> all_scenarios_sequence_;
+    typename ModelType::ComponentFlags components_to_update_{};
+    typename ModelType::UpdateIndependence update_independence_{};
+    typename ModelType::ComponentFlags independence_flags_{};
+    std::shared_ptr<typename ModelType::SequenceIdx> all_scenarios_sequence_;
     // current_scenario_sequence_cache_ is calculated per scenario, so it is excluded from the constructors.
-    typename MainModelType::SequenceIdx current_scenario_sequence_cache_{};
+    typename ModelType::SequenceIdx current_scenario_sequence_cache_{};
 
     Logger* log_{nullptr};
 
@@ -124,17 +124,17 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
         // cache component update order where possible.
         // the order for a cacheable (independent) component by definition is the same across all scenarios
         components_to_update_ = model_reference_.get().get_components_to_update(update_data);
-        update_independence_ = main_core::update::independence::check_update_independence<MainModelType>(
+        update_independence_ = main_core::update::independence::check_update_independence<ModelType>(
             model_reference_.get().state(), update_data);
         std::ranges::transform(update_independence_, independence_flags_.begin(),
                                [](auto const& comp) { return comp.is_independent(); });
-        all_scenarios_sequence_ = std::make_shared<typename MainModelType::SequenceIdx>(
-            main_core::update::get_all_sequence_idx_map<MainModelType>(
+        all_scenarios_sequence_ =
+            std::make_shared<typename ModelType::SequenceIdx>(main_core::update::get_all_sequence_idx_map<ModelType>(
                 model_reference_.get().state(), update_data, 0, components_to_update_, update_independence_, false));
     }
 
     void setup_impl(ConstDataset const& update_data, Idx scenario_idx) {
-        current_scenario_sequence_cache_ = main_core::update::get_all_sequence_idx_map<MainModelType>(
+        current_scenario_sequence_cache_ = main_core::update::get_all_sequence_idx_map<ModelType>(
             model_reference_.get().state(), update_data, scenario_idx, components_to_update_, update_independence_,
             true);
         auto const current_scenario_sequence = get_current_scenario_sequence_view_();
@@ -148,8 +148,8 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
     }
 
     auto get_current_scenario_sequence_view_() const {
-        return MainModelType::run_functor_with_all_component_types_return_array([this]<typename CT>() {
-            constexpr auto comp_idx = MainModelType::template index_of_component<CT>;
+        return ModelType::run_functor_with_all_component_types_return_array([this]<typename CT>() {
+            constexpr auto comp_idx = ModelType::template index_of_component<CT>;
             if (std::get<comp_idx>(independence_flags_)) {
                 return std::span<Idx2D const>{std::get<comp_idx>(*all_scenarios_sequence_)};
             }

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

@@ -133,6 +133,7 @@ struct MainModelType<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLi
     using SequenceIdxView = std::array<std::span<Idx2D const>, n_types>;
     using UpdateIndependence = std::array<UpdateCompProperties, n_types>;
     using SequenceIdx = std::array<std::vector<Idx2D>, n_types>;
+    using SequenceIdxRefWrappers = std::array<std::reference_wrapper<std::vector<Idx2D> const>, n_types>;
     using ComponentFlags = std::array<bool, n_types>;
 
     // Clean these 2. They are unused

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp

@@ -207,25 +207,25 @@ constexpr void register_connections_components(ComponentContainer const& compone
 
 } // namespace detail
 
-template <typename MainModelType>
-    requires common::component_container_c<typename MainModelType::ComponentContainer, Branch, Branch3, Source, Shunt,
+template <typename ModelType>
+    requires common::component_container_c<typename ModelType::ComponentContainer, Branch, Branch3, Source, Shunt,
                                            GenericLoadGen, GenericVoltageSensor, GenericPowerSensor,
                                            GenericCurrentSensor, Regulator>
-ComponentTopology construct_topology(typename MainModelType::ComponentContainer const& components) {
+ComponentTopology construct_topology(typename ModelType::ComponentContainer const& components) {
     ComponentTopology comp_topo;
-    using TopologyTypesTuple = typename MainModelType::TopologyTypesTuple;
+    using TopologyTypesTuple = typename ModelType::TopologyTypesTuple;
     main_core::utils::run_functor_with_tuple_return_void<TopologyTypesTuple>(
         [&components, &comp_topo]<typename CompType>() {
             detail::register_topology_components<CompType>(components, comp_topo);
         });
     return comp_topo;
 }
 
-template <typename MainModelType>
-    requires common::component_container_c<typename MainModelType::ComponentContainer, Branch, Branch3, Source>
-ComponentConnections construct_components_connections(typename MainModelType::ComponentContainer const& components) {
+template <typename ModelType>
+    requires common::component_container_c<typename ModelType::ComponentContainer, Branch, Branch3, Source>
+ComponentConnections construct_components_connections(typename ModelType::ComponentContainer const& components) {
     ComponentConnections comp_conn;
-    using TopologyConnectionTypesTuple = typename MainModelType::TopologyConnectionTypesTuple;
+    using TopologyConnectionTypesTuple = typename ModelType::TopologyConnectionTypesTuple;
     main_core::utils::run_functor_with_tuple_return_void<TopologyConnectionTypesTuple>(
         [&components, &comp_conn]<typename CompType>() {
             detail::register_connections_components<CompType>(components, comp_conn);

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp

@@ -123,14 +123,13 @@ inline void validate_update_data_independence(UpdateCompProperties const& comp,
     }
 }
 
-template <typename MainModelType>
-typename MainModelType::UpdateIndependence
-check_update_independence(typename MainModelType::MainModelState const& state, ConstDataset const& update_data) {
-    return MainModelType::run_functor_with_all_component_types_return_array(
-        [&state, &update_data]<typename CompType>() {
-            auto const n_component = state.components.template size<CompType>();
-            return check_component_independence<CompType>(update_data, n_component);
-        });
+template <typename ModelType>
+typename ModelType::UpdateIndependence check_update_independence(typename ModelType::MainModelState const& state,
+                                                                 ConstDataset const& update_data) {
+    return ModelType::run_functor_with_all_component_types_return_array([&state, &update_data]<typename CompType>() {
+        auto const n_component = state.components.template size<CompType>();
+        return check_component_independence<CompType>(update_data, n_component);
+    });
 }
 
 } // namespace independence
@@ -187,22 +186,21 @@ std::vector<Idx2D> get_component_sequence(MainModelState<ComponentContainer> con
 }
 } // namespace detail
 
-template <class MainModelType>
-typename MainModelType::SequenceIdx
-get_all_sequence_idx_map(typename MainModelType::MainModelState const& state, ConstDataset const& update_data,
-                         Idx scenario_idx, typename MainModelType::ComponentFlags const& components_to_store,
-                         typename MainModelType::UpdateIndependence const& independence, bool cached) {
-    return MainModelType::run_functor_with_all_component_types_return_array(
+template <class ModelType>
+typename ModelType::SequenceIdx
+get_all_sequence_idx_map(typename ModelType::MainModelState const& state, ConstDataset const& update_data,
+                         Idx scenario_idx, typename ModelType::ComponentFlags const& components_to_store,
+                         typename ModelType::UpdateIndependence const& independence, bool cached) {
+    return ModelType::run_functor_with_all_component_types_return_array(
         [&state, &update_data, scenario_idx, &components_to_store, &independence, cached]<typename CompType>() {
-            auto const component_properties =
-                std::get<MainModelType::template index_of_component<CompType>>(independence);
+            auto const component_properties = std::get<ModelType::template index_of_component<CompType>>(independence);
             // The sequence for the independent components is cached (true). For the remaining components, the sequence
             // cannot be cached (false), so the independence flags are inverted to not return an empty sequence when
             // this is the case.
 
             if (bool const component_independence = cached != component_properties.is_independent();
                 !component_independence ||
-                !std::get<MainModelType::template index_of_component<CompType>>(components_to_store)) {
+                !std::get<ModelType::template index_of_component<CompType>>(components_to_store)) {
                 return std::vector<Idx2D>{};
             }
             independence::validate_update_data_independence(component_properties, CompType::name);