Merge pull request #1119 from PowerGridModel/feature/clean-main-core-ybus-templates

mgovers · web-flow · commit d30ae63a19a8 · 2025-09-23T10:32:33.000Z
Cleanup main model: Clean up templates and variadics from y bus
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp
@@ -112,11 +112,6 @@ class MainModelType<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     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
-    static constexpr auto branch_param_in_seq_map =
-        std::array{index_of_component<Line>, index_of_component<Link>, index_of_component<Transformer>};
-    static constexpr auto shunt_param_in_seq_map = std::array{index_of_component<Shunt>};
-
     template <class Functor> static constexpr void run_functor_with_all_component_types_return_void(Functor&& functor) {
         (std::forward<Functor>(functor).template operator()<ComponentType>(), ...);
     }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/y_bus.hpp
@@ -8,8 +8,56 @@
 
 namespace power_grid_model::main_core {
 
-template <symmetry_tag sym, typename ComponentContainer, typename... ComponentType>
-void prepare_y_bus(MainModelState<ComponentContainer> const& state_, Idx n_math_solvers_, MathState& math_state_) {
+namespace detail {
+template <std::derived_from<Branch> ComponentType, typename ComponentContainer>
+constexpr void add_to_increment(std::vector<MathModelParamIncrement>& increments,
+                                MainModelState<ComponentContainer> const& state, Idx2D const& changed_component_idx) {
+    Idx2D const math_idx =
+        state.topo_comp_coup->branch[main_core::get_component_sequence_idx<Branch>(state, changed_component_idx)];
+    if (math_idx.group == isolated_component) {
+        return;
+    }
+    // assign parameters
+    increments[math_idx.group].branch_param_to_change.push_back(math_idx.pos);
+}
+
+template <std::derived_from<Branch3> ComponentType, typename ComponentContainer>
+constexpr void add_to_increment(std::vector<MathModelParamIncrement>& increments,
+                                MainModelState<ComponentContainer> const& state, Idx2D const& changed_component_idx) {
+    Idx2DBranch3 const math_idx =
+        state.topo_comp_coup->branch3[main_core::get_component_sequence_idx<Branch3>(state, changed_component_idx)];
+    if (math_idx.group == isolated_component) {
+        return;
+    }
+    // assign parameters, branch3 param consists of three branch parameters
+    for (size_t branch2 = 0; branch2 < 3; ++branch2) {
+        increments[math_idx.group].branch_param_to_change.push_back(math_idx.pos[branch2]);
+    }
+}
+
+template <std::same_as<Shunt> ComponentType, typename ComponentContainer>
+constexpr void add_to_increment(std::vector<MathModelParamIncrement>& increments,
+                                MainModelState<ComponentContainer> const& state, Idx2D const& changed_component_idx) {
+    Idx2D const math_idx =
+        state.topo_comp_coup->shunt[main_core::get_component_sequence_idx<Shunt>(state, changed_component_idx)];
+    if (math_idx.group == isolated_component) {
+        return;
+    }
+    // assign parameters
+    increments[math_idx.group].shunt_param_to_change.push_back(math_idx.pos);
+}
+
+// default implementation for other components, does nothing
+template <typename ComponentType, typename ComponentContainer>
+constexpr void add_to_increment(std::vector<MathModelParamIncrement> const& /* increments */,
+                                MainModelState<ComponentContainer> const& /* state */,
+                                Idx2D const& /* changed_component_idx */) {
+    // default implementation is no-op
+}
+} // namespace detail
+
+template <symmetry_tag sym, typename MainModelType>
+void prepare_y_bus(typename MainModelType::MainModelState const& state_, Idx n_math_solvers_, MathState& math_state_) {
     std::vector<YBus<sym>>& y_bus_vec = main_core::get_y_bus<sym>(math_state_);
     // also get the vector of other Y_bus (sym -> asym, or asym -> sym)
     std::vector<YBus<other_symmetry_t<sym>>>& other_y_bus_vec =
@@ -20,14 +68,6 @@ void prepare_y_bus(MainModelState<ComponentContainer> const& state_, Idx n_math_
         y_bus_vec.reserve(n_math_solvers_);
         auto math_params = get_math_param<sym>(state_, n_math_solvers_);
 
-        // Check the branch and shunt indices
-        constexpr auto branch_param_in_seq_map =
-            std::array{main_core::utils::index_of_component<Line, ComponentType...>,
-                       main_core::utils::index_of_component<Link, ComponentType...>,
-                       main_core::utils::index_of_component<Transformer, ComponentType...>};
-        constexpr auto shunt_param_in_seq_map =
-            std::array{main_core::utils::index_of_component<Shunt, ComponentType...>};
-
         for (Idx i = 0; i != n_math_solvers_; ++i) {
             // construct from existing Y_bus structure if possible
             if (other_y_bus_exist) {
@@ -38,66 +78,25 @@ void prepare_y_bus(MainModelState<ComponentContainer> const& state_, Idx n_math_
                 y_bus_vec.emplace_back(state_.math_topology[i],
                                        std::make_shared<MathModelParam<sym> const>(std::move(math_params[i])));
             }
-
-            y_bus_vec.back().set_branch_param_idx(
-                IdxVector{branch_param_in_seq_map.begin(), branch_param_in_seq_map.end()});
-            y_bus_vec.back().set_shunt_param_idx(
-                IdxVector{shunt_param_in_seq_map.begin(), shunt_param_in_seq_map.end()});
         }
     }
 }
 
-template <symmetry_tag sym, typename ComponentContainer, typename... ComponentType>
-static std::vector<MathModelParamIncrement> get_math_param_increment(
-    MainModelState<ComponentContainer>& received_state, Idx n_math_solvers_,
-    std::array<std::vector<Idx2D>, main_core::utils::n_types<ComponentType...>> const& parameter_changed_components_) {
-    using AddToIncrement =
-        void (*)(std::vector<MathModelParamIncrement>&, MainModelState<ComponentContainer> const&, Idx2D const&);
-
-    static constexpr std::array<AddToIncrement, main_core::utils::n_types<ComponentType...>> add_to_increments{
-        [](std::vector<MathModelParamIncrement>& increments, MainModelState<ComponentContainer> const& state,
-           Idx2D const& changed_component_idx) {
-            if constexpr (std::derived_from<ComponentType, Branch>) {
-                Idx2D const math_idx =
-                    state.topo_comp_coup
-                        ->branch[main_core::get_component_sequence_idx<Branch>(state, changed_component_idx)];
-                if (math_idx.group == isolated_component) {
-                    return;
-                }
-                // assign parameters
-                increments[math_idx.group].branch_param_to_change.push_back(math_idx.pos);
-            } else if constexpr (std::derived_from<ComponentType, Branch3>) {
-                Idx2DBranch3 const math_idx =
-                    state.topo_comp_coup
-                        ->branch3[main_core::get_component_sequence_idx<Branch3>(state, changed_component_idx)];
-                if (math_idx.group == isolated_component) {
-                    return;
-                }
-                // assign parameters, branch3 param consists of three branch parameters
-                for (size_t branch2 = 0; branch2 < 3; ++branch2) {
-                    increments[math_idx.group].branch_param_to_change.push_back(math_idx.pos[branch2]);
-                }
-            } else if constexpr (std::same_as<ComponentType, Shunt>) {
-                Idx2D const math_idx =
-                    state.topo_comp_coup
-                        ->shunt[main_core::get_component_sequence_idx<Shunt>(state, changed_component_idx)];
-                if (math_idx.group == isolated_component) {
-                    return;
-                }
-                // assign parameters
-                increments[math_idx.group].shunt_param_to_change.push_back(math_idx.pos);
-            }
-        }...};
+template <typename MainModelType>
+static std::vector<MathModelParamIncrement>
+get_math_param_increment(typename MainModelType::MainModelState const& state, Idx n_math_solvers_,
+                         typename MainModelType::SequenceIdx const& parameter_changed_components_) {
 
     std::vector<MathModelParamIncrement> math_param_increment(n_math_solvers_);
 
-    for (size_t i = 0; i < main_core::utils::n_types<ComponentType...>; ++i) {
-        auto const& changed_type_components = parameter_changed_components_[i];
-        auto const& add_type_to_increment = add_to_increments[i];
-        for (auto const& changed_component : changed_type_components) {
-            add_type_to_increment(math_param_increment, received_state, changed_component);
-        }
-    }
+    MainModelType::run_functor_with_all_component_types_return_void(
+        [&math_param_increment, &state, &parameter_changed_components_]<typename CompType>() {
+            static constexpr auto comp_index = MainModelType::template index_of_component<CompType>;
+            for (auto const& changed_component : std::get<comp_index>(parameter_changed_components_)) {
+                detail::add_to_increment<CompType, typename MainModelType::ComponentContainer>(
+                    math_param_increment, state, changed_component);
+            }
+        });
 
     return math_param_increment;
 }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp
@@ -594,7 +594,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         if (!is_topology_up_to_date_) {
             rebuild_topology();
         }
-        main_core::prepare_y_bus<sym, ComponentContainer, ComponentType...>(state_, n_math_solvers_, math_state_);
+        main_core::prepare_y_bus<sym, ModelType>(state_, n_math_solvers_, math_state_);
 
         if (n_math_solvers_ != static_cast<Idx>(solvers.size())) {
             assert(solvers.empty());
@@ -616,8 +616,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
             std::vector<MathModelParam<sym>> const math_params =
                 main_core::get_math_param<sym>(state_, n_math_solvers_);
             std::vector<MathModelParamIncrement> const math_param_increments =
-                main_core::get_math_param_increment<sym, ComponentContainer, ComponentType...>(
-                    state_, n_math_solvers_, parameter_changed_components_);
+                main_core::get_math_param_increment<ModelType>(state_, n_math_solvers_, parameter_changed_components_);
             if (last_updated_calculation_symmetry_mode_ == is_symmetric_v<sym>) {
                 main_core::update_y_bus(math_state_, math_params, math_param_increments);
             } else {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
@@ -324,11 +324,6 @@ template <symmetry_tag sym> class YBus {
 
     constexpr auto& get_y_bus_structure() const { return y_bus_struct_; }
 
-    void set_branch_param_idx(IdxVector branch_param_idx) { branch_param_idx_ = std::move(branch_param_idx); }
-    void set_shunt_param_idx(IdxVector shunt_param_idx) { shunt_param_idx_ = std::move(shunt_param_idx); }
-    IdxVector const& get_branch_param_idx() const { return branch_param_idx_; }
-    IdxVector const& get_shunt_param_idx() const { return shunt_param_idx_; }
-
     void update_admittance(std::shared_ptr<MathModelParam<sym> const> const& math_model_param) {
         // overwrite the old cached parameters
         math_model_param_ = math_model_param;
@@ -524,10 +519,6 @@ template <symmetry_tag sym> class YBus {
     // cache the math parameters
     std::shared_ptr<MathModelParam<sym> const> math_model_param_;
 
-    // cache the branch and shunt parameters in sequence_idx_map
-    IdxVector branch_param_idx_;
-    IdxVector shunt_param_idx_;
-
     // map index between admittance entries and parameter entries
     std::vector<IdxVector> map_admittance_param_branch_;
     std::vector<IdxVector> map_admittance_param_shunt_;
