From e6728db46e02203b52fa2bf484e8ccde4cfc53a0 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Tue, 19 Aug 2025 14:13:16 +0200
Subject: [PATCH 01/17] move construct topology

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/main_core/topology.hpp   | 42 +++++++++++++++++
 .../power_grid_model/main_model_impl.hpp      | 45 +------------------
 2 files changed, 44 insertions(+), 43 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index 745e5f1dc3..ce098c7849 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -191,4 +191,46 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
     });
 }
 
+ComponentTopology construct_topology(main_model_state_c auto const& state) {
+    ComponentTopology comp_topo;
+    register_topology_components<Node>(state, comp_topo);
+    register_topology_components<Branch>(state, comp_topo);
+    register_topology_components<Branch3>(state, comp_topo);
+    register_topology_components<Source>(state, comp_topo);
+    register_topology_components<Shunt>(state, comp_topo);
+    register_topology_components<GenericLoadGen>(state, comp_topo);
+    register_topology_components<GenericVoltageSensor>(state, comp_topo);
+    register_topology_components<GenericPowerSensor>(state, comp_topo);
+    register_topology_components<GenericCurrentSensor>(state, comp_topo);
+    register_topology_components<Regulator>(state, comp_topo);
+    return comp_topo;
+}
+
+ComponentConnections construct_components_connections(main_model_state_c auto const& state) {
+    ComponentConnections comp_conn;
+    comp_conn.branch_connected.resize(state.comp_topo->branch_node_idx.size());
+    comp_conn.branch_phase_shift.resize(state.comp_topo->branch_node_idx.size());
+    comp_conn.branch3_connected.resize(state.comp_topo->branch3_node_idx.size());
+    comp_conn.branch3_phase_shift.resize(state.comp_topo->branch3_node_idx.size());
+    comp_conn.source_connected.resize(state.comp_topo->source_node_idx.size());
+    std::transform(state.components.template citer<Branch>().begin(), state.components.template citer<Branch>().end(),
+                   comp_conn.branch_connected.begin(), [](Branch const& branch) {
+                       return BranchConnected{static_cast<IntS>(branch.from_status()),
+                                              static_cast<IntS>(branch.to_status())};
+                   });
+    std::transform(state.components.template citer<Branch>().begin(), state.components.template citer<Branch>().end(),
+                   comp_conn.branch_phase_shift.begin(), [](Branch const& branch) { return branch.phase_shift(); });
+    std::transform(state.components.template citer<Branch3>().begin(), state.components.template citer<Branch3>().end(),
+                   comp_conn.branch3_connected.begin(), [](Branch3 const& branch3) {
+                       return Branch3Connected{static_cast<IntS>(branch3.status_1()),
+                                               static_cast<IntS>(branch3.status_2()),
+                                               static_cast<IntS>(branch3.status_3())};
+                   });
+    std::transform(state.components.template citer<Branch3>().begin(), state.components.template citer<Branch3>().end(),
+                   comp_conn.branch3_phase_shift.begin(), [](Branch3 const& branch3) { return branch3.phase_shift(); });
+    std::transform(state.components.template citer<Source>().begin(), state.components.template citer<Source>().end(),
+                   comp_conn.source_connected.begin(), [](Source const& source) { return source.status(); });
+    return comp_conn;
+}
+
 } // namespace power_grid_model::main_core
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
index f28e27892e..636e44bec8 100644
--- 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
@@ -314,22 +314,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         construction_complete_ = true;
 #endif // !NDEBUG
         state_.components.set_construction_complete();
-        construct_topology();
-    }
-
-    void construct_topology() {
-        ComponentTopology comp_topo;
-        main_core::register_topology_components<Node>(state_, comp_topo);
-        main_core::register_topology_components<Branch>(state_, comp_topo);
-        main_core::register_topology_components<Branch3>(state_, comp_topo);
-        main_core::register_topology_components<Source>(state_, comp_topo);
-        main_core::register_topology_components<Shunt>(state_, comp_topo);
-        main_core::register_topology_components<GenericLoadGen>(state_, comp_topo);
-        main_core::register_topology_components<GenericVoltageSensor>(state_, comp_topo);
-        main_core::register_topology_components<GenericPowerSensor>(state_, comp_topo);
-        main_core::register_topology_components<GenericCurrentSensor>(state_, comp_topo);
-        main_core::register_topology_components<Regulator>(state_, comp_topo);
-        state_.comp_topo = std::make_shared<ComponentTopology const>(std::move(comp_topo));
+        state_.comp_topo = std::make_shared<ComponentTopology const>(main_core::construct_topology(state_));
     }
 
     void reset_solvers() {
@@ -652,33 +637,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         assert(construction_complete_);
         // clear old solvers
         reset_solvers();
-        // get connection info
-        ComponentConnections comp_conn;
-        comp_conn.branch_connected.resize(state_.comp_topo->branch_node_idx.size());
-        comp_conn.branch_phase_shift.resize(state_.comp_topo->branch_node_idx.size());
-        comp_conn.branch3_connected.resize(state_.comp_topo->branch3_node_idx.size());
-        comp_conn.branch3_phase_shift.resize(state_.comp_topo->branch3_node_idx.size());
-        comp_conn.source_connected.resize(state_.comp_topo->source_node_idx.size());
-        std::transform(
-            state_.components.template citer<Branch>().begin(), state_.components.template citer<Branch>().end(),
-            comp_conn.branch_connected.begin(), [](Branch const& branch) {
-                return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
-            });
-        std::transform(state_.components.template citer<Branch>().begin(),
-                       state_.components.template citer<Branch>().end(), comp_conn.branch_phase_shift.begin(),
-                       [](Branch const& branch) { return branch.phase_shift(); });
-        std::transform(
-            state_.components.template citer<Branch3>().begin(), state_.components.template citer<Branch3>().end(),
-            comp_conn.branch3_connected.begin(), [](Branch3 const& branch3) {
-                return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
-                                        static_cast<IntS>(branch3.status_3())};
-            });
-        std::transform(state_.components.template citer<Branch3>().begin(),
-                       state_.components.template citer<Branch3>().end(), comp_conn.branch3_phase_shift.begin(),
-                       [](Branch3 const& branch3) { return branch3.phase_shift(); });
-        std::transform(state_.components.template citer<Source>().begin(),
-                       state_.components.template citer<Source>().end(), comp_conn.source_connected.begin(),
-                       [](Source const& source) { return source.status(); });
+        ComponentConnections comp_conn = main_core::construct_components_connections(state_);
         // re build
         Topology topology{*state_.comp_topo, comp_conn};
         std::tie(state_.math_topology, state_.topo_comp_coup) = topology.build_topology();

From 0c065eaaeedce9fb7dcce686bb5cf1bacb2200ff Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Tue, 19 Aug 2025 22:30:54 +0200
Subject: [PATCH 02/17] address sonar cloud

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/main_core/topology.hpp   | 36 ++++++++++---------
 .../power_grid_model/main_model_impl.hpp      |  2 +-
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index ce098c7849..1113a9f134 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -213,23 +213,25 @@ ComponentConnections construct_components_connections(main_model_state_c auto co
     comp_conn.branch3_connected.resize(state.comp_topo->branch3_node_idx.size());
     comp_conn.branch3_phase_shift.resize(state.comp_topo->branch3_node_idx.size());
     comp_conn.source_connected.resize(state.comp_topo->source_node_idx.size());
-    std::transform(state.components.template citer<Branch>().begin(), state.components.template citer<Branch>().end(),
-                   comp_conn.branch_connected.begin(), [](Branch const& branch) {
-                       return BranchConnected{static_cast<IntS>(branch.from_status()),
-                                              static_cast<IntS>(branch.to_status())};
-                   });
-    std::transform(state.components.template citer<Branch>().begin(), state.components.template citer<Branch>().end(),
-                   comp_conn.branch_phase_shift.begin(), [](Branch const& branch) { return branch.phase_shift(); });
-    std::transform(state.components.template citer<Branch3>().begin(), state.components.template citer<Branch3>().end(),
-                   comp_conn.branch3_connected.begin(), [](Branch3 const& branch3) {
-                       return Branch3Connected{static_cast<IntS>(branch3.status_1()),
-                                               static_cast<IntS>(branch3.status_2()),
-                                               static_cast<IntS>(branch3.status_3())};
-                   });
-    std::transform(state.components.template citer<Branch3>().begin(), state.components.template citer<Branch3>().end(),
-                   comp_conn.branch3_phase_shift.begin(), [](Branch3 const& branch3) { return branch3.phase_shift(); });
-    std::transform(state.components.template citer<Source>().begin(), state.components.template citer<Source>().end(),
-                   comp_conn.source_connected.begin(), [](Source const& source) { return source.status(); });
+    std::ranges::transform(
+        state.components.template citer<Branch>(), comp_conn.branch_connected.begin(), [](Branch const& branch) {
+            return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
+        });
+
+    std::ranges::transform(state.components.template citer<Branch>(), comp_conn.branch_phase_shift.begin(),
+                           [](Branch const& branch) { return branch.phase_shift(); });
+
+    std::ranges::transform(
+        state.components.template citer<Branch3>(), comp_conn.branch3_connected.begin(), [](Branch3 const& branch3) {
+            return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
+                                    static_cast<IntS>(branch3.status_3())};
+        });
+
+    std::ranges::transform(state.components.template citer<Branch3>(), comp_conn.branch3_phase_shift.begin(),
+                           [](Branch3 const& branch3) { return branch3.phase_shift(); });
+
+    std::ranges::transform(state.components.template citer<Source>(), comp_conn.source_connected.begin(),
+                           [](Source const& source) { return source.status(); });
     return comp_conn;
 }
 
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
index 636e44bec8..79f44edbd6 100644
--- 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
@@ -637,7 +637,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         assert(construction_complete_);
         // clear old solvers
         reset_solvers();
-        ComponentConnections comp_conn = main_core::construct_components_connections(state_);
+        ComponentConnections const comp_conn = main_core::construct_components_connections(state_);
         // re build
         Topology topology{*state_.comp_topo, comp_conn};
         std::tie(state_.math_topology, state_.topo_comp_coup) = topology.build_topology();

From df0dcbff77db9bbdda6fe6ee77e074a047b6f156 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Tue, 19 Aug 2025 22:40:00 +0200
Subject: [PATCH 03/17] decouple topology related state queries

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/main_core/state.hpp      |  7 +++
 .../main_core/state_queries.hpp               | 17 ++++++++
 .../power_grid_model/main_core/topology.hpp   | 43 ++++++++++---------
 3 files changed, 46 insertions(+), 21 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
index 94062f430d..c19c5003b1 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
@@ -37,6 +37,13 @@ concept component_container_c = requires(ContainerType const& c, ID id) {
     { c.template get_item<ComponentType>(id) } -> std::convertible_to<ComponentType const&>;
 };
 
+template <typename ContainerType, typename ComponentType>
+concept extended_component_container_c =
+    component_container_c<ContainerType, ComponentType> && requires(ContainerType const& c, Idx2D const& idx2d) {
+        { c.template size<ComponentType>() } -> std::same_as<Idx>;
+        { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
+    };
+
 template <template <typename T> class StateType, typename ContainerType, typename ComponentType>
 concept model_component_state_c =
     component_container_c<typename StateType<ContainerType>::ComponentContainer, ComponentType> &&
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp
index 4d92566c7d..5d26aefa22 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp
@@ -9,6 +9,23 @@
 #include "../all_components.hpp"
 
 namespace power_grid_model::main_core {
+
+// using only components and not state
+
+template <typename ComponentType, class ComponentContainer>
+    requires extended_component_container_c<ComponentContainer, ComponentType>
+constexpr auto get_component_size(ComponentContainer const& components) {
+    return components.template size<ComponentType>();
+}
+
+template <typename ComponentType, class ComponentContainer>
+    requires extended_component_container_c<ComponentContainer, ComponentType>
+inline Idx get_component_sequence_idx(ComponentContainer const& components, auto const& id_or_index) {
+    return components.template get_seq<ComponentType>(id_or_index);
+}
+
+// existing implementation
+
 template <typename ComponentType, class ComponentContainer>
     requires model_component_state_c<MainModelState, ComponentContainer, ComponentType>
 inline Idx get_component_type_index(MainModelState<ComponentContainer> const& state) {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index 1113a9f134..ac6183eb74 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -32,7 +32,7 @@ template <std::same_as<Node> Component, class ComponentContainer>
     requires model_component_state_c<MainModelState, ComponentContainer, Component>
 constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
                                             ComponentTopology& comp_topo) {
-    comp_topo.n_node = get_component_size<Node>(state);
+    comp_topo.n_node = get_component_size<Node>(state.components);
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
@@ -40,8 +40,8 @@ template <std::same_as<Branch> Component, class ComponentContainer>
 constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
                                             ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(state, comp_topo.branch_node_idx, [&state](Branch const& branch) {
-        return BranchIdx{get_component_sequence_idx<Node>(state, branch.from_node()),
-                         get_component_sequence_idx<Node>(state, branch.to_node())};
+        return BranchIdx{get_component_sequence_idx<Node>(state.components, branch.from_node()),
+                         get_component_sequence_idx<Node>(state.components, branch.to_node())};
     });
 }
 
@@ -50,9 +50,9 @@ template <std::same_as<Branch3> Component, class ComponentContainer>
 constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
                                             ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(state, comp_topo.branch3_node_idx, [&state](Branch3 const& branch3) {
-        return Branch3Idx{get_component_sequence_idx<Node>(state, branch3.node_1()),
-                          get_component_sequence_idx<Node>(state, branch3.node_2()),
-                          get_component_sequence_idx<Node>(state, branch3.node_3())};
+        return Branch3Idx{get_component_sequence_idx<Node>(state.components, branch3.node_1()),
+                          get_component_sequence_idx<Node>(state.components, branch3.node_2()),
+                          get_component_sequence_idx<Node>(state.components, branch3.node_3())};
     });
 }
 
@@ -61,7 +61,7 @@ template <std::same_as<Source> Component, class ComponentContainer>
 constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
                                             ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(state, comp_topo.source_node_idx, [&state](Source const& source) {
-        return get_component_sequence_idx<Node>(state, source.node());
+        return get_component_sequence_idx<Node>(state.components, source.node());
     });
 }
 
@@ -70,7 +70,7 @@ template <std::same_as<Shunt> Component, class ComponentContainer>
 constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
                                             ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(state, comp_topo.shunt_node_idx, [&state](Shunt const& shunt) {
-        return get_component_sequence_idx<Node>(state, shunt.node());
+        return get_component_sequence_idx<Node>(state.components, shunt.node());
     });
 }
 
@@ -79,8 +79,9 @@ template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
 constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
                                             ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.load_gen_node_idx,
-        [&state](GenericLoadGen const& load_gen) { return get_component_sequence_idx<Node>(state, load_gen.node()); });
+        state, comp_topo.load_gen_node_idx, [&state](GenericLoadGen const& load_gen) {
+            return get_component_sequence_idx<Node>(state.components, load_gen.node());
+        });
 
     detail::register_topo_components<Component>(state, comp_topo.load_gen_type,
                                                 [](GenericLoadGen const& load_gen) { return load_gen.type(); });
@@ -92,7 +93,7 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
                                             ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
         state, comp_topo.voltage_sensor_node_idx, [&state](GenericVoltageSensor const& voltage_sensor) {
-            return get_component_sequence_idx<Node>(state, voltage_sensor.measured_object());
+            return get_component_sequence_idx<Node>(state.components, voltage_sensor.measured_object());
         });
 }
 
@@ -110,23 +111,23 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state, measured_object);
+                return get_component_sequence_idx<Branch>(state.components, measured_object);
             case source:
-                return get_component_sequence_idx<Source>(state, measured_object);
+                return get_component_sequence_idx<Source>(state.components, measured_object);
             case shunt:
-                return get_component_sequence_idx<Shunt>(state, measured_object);
+                return get_component_sequence_idx<Shunt>(state.components, measured_object);
             case load:
                 [[fallthrough]];
             case generator:
-                return get_component_sequence_idx<GenericLoadGen>(state, measured_object);
+                return get_component_sequence_idx<GenericLoadGen>(state.components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state, measured_object);
+                return get_component_sequence_idx<Branch3>(state.components, measured_object);
             case node:
-                return get_component_sequence_idx<Node>(state, measured_object);
+                return get_component_sequence_idx<Node>(state.components, measured_object);
             default:
                 throw MissingCaseForEnumError("Power sensor idx to seq transformation",
                                               power_sensor.get_terminal_type());
@@ -152,13 +153,13 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state, measured_object);
+                return get_component_sequence_idx<Branch>(state.components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state, measured_object);
+                return get_component_sequence_idx<Branch3>(state.components, measured_object);
             default:
                 throw MissingCaseForEnumError("Current sensor idx to seq transformation",
                                               current_sensor.get_terminal_type());
@@ -178,9 +179,9 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
         state, comp_topo.regulated_object_idx, [&state](Regulator const& regulator) {
             switch (regulator.regulated_object_type()) {
             case ComponentType::branch:
-                return get_component_sequence_idx<Branch>(state, regulator.regulated_object());
+                return get_component_sequence_idx<Branch>(state.components, regulator.regulated_object());
             case ComponentType::branch3:
-                return get_component_sequence_idx<Branch3>(state, regulator.regulated_object());
+                return get_component_sequence_idx<Branch3>(state.components, regulator.regulated_object());
             default:
                 throw MissingCaseForEnumError("Regulator idx to seq transformation", regulator.regulated_object_type());
             }

From 3d29f46843f5eb86ee65cf41cf8b00912b49206e Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 08:38:04 +0200
Subject: [PATCH 04/17] shift to component container

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/main_core/state.hpp      |   3 +
 .../power_grid_model/main_core/topology.hpp   | 159 +++++++++---------
 2 files changed, 79 insertions(+), 83 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
index c19c5003b1..7bfdd3fe33 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
@@ -44,6 +44,9 @@ concept extended_component_container_c =
         { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
     };
 
+template <typename ContainerType, typename... ComponentType>
+concept multi_extended_component_container_c = (extended_component_container_c<ContainerType, ComponentType> && ...);
+
 template <template <typename T> class StateType, typename ContainerType, typename ComponentType>
 concept model_component_state_c =
     component_container_c<typename StateType<ContainerType>::ComponentContainer, ComponentType> &&
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index ac6183eb74..6f63bf293e 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -14,13 +14,13 @@ namespace power_grid_model::main_core {
 namespace detail {
 
 template <typename Component, class ComponentContainer, typename ResType, typename ResFunc>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component> &&
+    requires component_container_c<ComponentContainer, Component> &&
              std::invocable<std::remove_cvref_t<ResFunc>, Component const&> &&
              std::convertible_to<std::invoke_result_t<ResFunc, Component const&>, ResType>
-constexpr void register_topo_components(MainModelState<ComponentContainer> const& state, std::vector<ResType>& target,
+constexpr void register_topo_components(ComponentContainer const& components, std::vector<ResType>& target,
                                         ResFunc&& func) {
-    auto const begin = get_component_citer<Component>(state).begin();
-    auto const end = get_component_citer<Component>(state).end();
+    auto const begin = components.template citer<Component>().begin();
+    auto const end = components.template citer<Component>().end();
 
     target.resize(std::distance(begin, end));
     std::transform(begin, end, target.begin(), std::forward<ResFunc>(func));
@@ -29,80 +29,75 @@ constexpr void register_topo_components(MainModelState<ComponentContainer> const
 } // namespace detail
 
 template <std::same_as<Node> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    comp_topo.n_node = get_component_size<Node>(state.components);
+    requires component_container_c<ComponentContainer, Component>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    comp_topo.n_node = get_component_size<Node>(components);
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.branch_node_idx, [&state](Branch const& branch) {
-        return BranchIdx{get_component_sequence_idx<Node>(state.components, branch.from_node()),
-                         get_component_sequence_idx<Node>(state.components, branch.to_node())};
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
+            return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
+                             get_component_sequence_idx<Node>(components, branch.to_node())};
+        });
 }
 
 template <std::same_as<Branch3> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.branch3_node_idx, [&state](Branch3 const& branch3) {
-        return Branch3Idx{get_component_sequence_idx<Node>(state.components, branch3.node_1()),
-                          get_component_sequence_idx<Node>(state.components, branch3.node_2()),
-                          get_component_sequence_idx<Node>(state.components, branch3.node_3())};
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
+            return Branch3Idx{get_component_sequence_idx<Node>(components, branch3.node_1()),
+                              get_component_sequence_idx<Node>(components, branch3.node_2()),
+                              get_component_sequence_idx<Node>(components, branch3.node_3())};
+        });
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.source_node_idx, [&state](Source const& source) {
-        return get_component_sequence_idx<Node>(state.components, source.node());
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.source_node_idx,
+        [&components](Source const& source) { return get_component_sequence_idx<Node>(components, source.node()); });
 }
 
 template <std::same_as<Shunt> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.shunt_node_idx, [&state](Shunt const& shunt) {
-        return get_component_sequence_idx<Node>(state.components, shunt.node());
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.shunt_node_idx,
+        [&components](Shunt const& shunt) { return get_component_sequence_idx<Node>(components, shunt.node()); });
 }
 
 template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.load_gen_node_idx, [&state](GenericLoadGen const& load_gen) {
-            return get_component_sequence_idx<Node>(state.components, load_gen.node());
+        components, comp_topo.load_gen_node_idx, [&components](GenericLoadGen const& load_gen) {
+            return get_component_sequence_idx<Node>(components, load_gen.node());
         });
 
-    detail::register_topo_components<Component>(state, comp_topo.load_gen_type,
+    detail::register_topo_components<Component>(components, comp_topo.load_gen_type,
                                                 [](GenericLoadGen const& load_gen) { return load_gen.type(); });
 }
 
 template <std::same_as<GenericVoltageSensor> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.voltage_sensor_node_idx, [&state](GenericVoltageSensor const& voltage_sensor) {
-            return get_component_sequence_idx<Node>(state.components, voltage_sensor.measured_object());
+        components, comp_topo.voltage_sensor_node_idx, [&components](GenericVoltageSensor const& voltage_sensor) {
+            return get_component_sequence_idx<Node>(components, voltage_sensor.measured_object());
         });
 }
 
 template <std::same_as<GenericPowerSensor> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen,
+                                                  Branch3, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.power_sensor_object_idx, [&state](GenericPowerSensor const& power_sensor) {
+        components, comp_topo.power_sensor_object_idx, [&components](GenericPowerSensor const& power_sensor) {
             using enum MeasuredTerminalType;
 
             auto const measured_object = power_sensor.measured_object();
@@ -111,23 +106,23 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state.components, measured_object);
+                return get_component_sequence_idx<Branch>(components, measured_object);
             case source:
-                return get_component_sequence_idx<Source>(state.components, measured_object);
+                return get_component_sequence_idx<Source>(components, measured_object);
             case shunt:
-                return get_component_sequence_idx<Shunt>(state.components, measured_object);
+                return get_component_sequence_idx<Shunt>(components, measured_object);
             case load:
                 [[fallthrough]];
             case generator:
-                return get_component_sequence_idx<GenericLoadGen>(state.components, measured_object);
+                return get_component_sequence_idx<GenericLoadGen>(components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state.components, measured_object);
+                return get_component_sequence_idx<Branch3>(components, measured_object);
             case node:
-                return get_component_sequence_idx<Node>(state.components, measured_object);
+                return get_component_sequence_idx<Node>(components, measured_object);
             default:
                 throw MissingCaseForEnumError("Power sensor idx to seq transformation",
                                               power_sensor.get_terminal_type());
@@ -135,16 +130,15 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
         });
 
     detail::register_topo_components<Component>(
-        state, comp_topo.power_sensor_terminal_type,
+        components, comp_topo.power_sensor_terminal_type,
         [](GenericPowerSensor const& power_sensor) { return power_sensor.get_terminal_type(); });
 }
 
 template <std::same_as<GenericCurrentSensor> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.current_sensor_object_idx, [&state](GenericCurrentSensor const& current_sensor) {
+        components, comp_topo.current_sensor_object_idx, [&components](GenericCurrentSensor const& current_sensor) {
             using enum MeasuredTerminalType;
 
             auto const measured_object = current_sensor.measured_object();
@@ -153,13 +147,13 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state.components, measured_object);
+                return get_component_sequence_idx<Branch>(components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state.components, measured_object);
+                return get_component_sequence_idx<Branch3>(components, measured_object);
             default:
                 throw MissingCaseForEnumError("Current sensor idx to seq transformation",
                                               current_sensor.get_terminal_type());
@@ -167,43 +161,42 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
         });
 
     detail::register_topo_components<Component>(
-        state, comp_topo.current_sensor_terminal_type,
+        components, comp_topo.current_sensor_terminal_type,
         [](GenericCurrentSensor const& current_sensor) { return current_sensor.get_terminal_type(); });
 }
 
 template <std::derived_from<Regulator> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.regulated_object_idx, [&state](Regulator const& regulator) {
+        components, comp_topo.regulated_object_idx, [&components](Regulator const& regulator) {
             switch (regulator.regulated_object_type()) {
             case ComponentType::branch:
-                return get_component_sequence_idx<Branch>(state.components, regulator.regulated_object());
+                return get_component_sequence_idx<Branch>(components, regulator.regulated_object());
             case ComponentType::branch3:
-                return get_component_sequence_idx<Branch3>(state.components, regulator.regulated_object());
+                return get_component_sequence_idx<Branch3>(components, regulator.regulated_object());
             default:
                 throw MissingCaseForEnumError("Regulator idx to seq transformation", regulator.regulated_object_type());
             }
         });
 
-    detail::register_topo_components<Component>(state, comp_topo.regulated_object_type, [](Regulator const& regulator) {
-        return regulator.regulated_object_type();
-    });
+    detail::register_topo_components<Component>(
+        components, comp_topo.regulated_object_type,
+        [](Regulator const& regulator) { return regulator.regulated_object_type(); });
 }
 
 ComponentTopology construct_topology(main_model_state_c auto const& state) {
     ComponentTopology comp_topo;
-    register_topology_components<Node>(state, comp_topo);
-    register_topology_components<Branch>(state, comp_topo);
-    register_topology_components<Branch3>(state, comp_topo);
-    register_topology_components<Source>(state, comp_topo);
-    register_topology_components<Shunt>(state, comp_topo);
-    register_topology_components<GenericLoadGen>(state, comp_topo);
-    register_topology_components<GenericVoltageSensor>(state, comp_topo);
-    register_topology_components<GenericPowerSensor>(state, comp_topo);
-    register_topology_components<GenericCurrentSensor>(state, comp_topo);
-    register_topology_components<Regulator>(state, comp_topo);
+    register_topology_components<Node>(state.components, comp_topo);
+    register_topology_components<Branch>(state.components, comp_topo);
+    register_topology_components<Branch3>(state.components, comp_topo);
+    register_topology_components<Source>(state.components, comp_topo);
+    register_topology_components<Shunt>(state.components, comp_topo);
+    register_topology_components<GenericLoadGen>(state.components, comp_topo);
+    register_topology_components<GenericVoltageSensor>(state.components, comp_topo);
+    register_topology_components<GenericPowerSensor>(state.components, comp_topo);
+    register_topology_components<GenericCurrentSensor>(state.components, comp_topo);
+    register_topology_components<Regulator>(state.components, comp_topo);
     return comp_topo;
 }
 

From 68ebe009af9995af2b403abdfde949b0540fd163 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 11:10:31 +0200
Subject: [PATCH 05/17] move concepts to container_fwd

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../include/power_grid_model/container.hpp    |  1 +
 .../power_grid_model/container_fwd.hpp        | 32 +++++++++++++++++++
 .../power_grid_model/main_core/state.hpp      | 19 -----------
 .../power_grid_model/optimizer/optimizer.hpp  |  2 +-
 .../optimizer/tap_position_optimizer.hpp      | 18 +++++------
 tests/cpp_unit_tests/test_optimizer.hpp       |  6 ++--
 .../test_tap_position_optimizer.cpp           |  8 ++---
 7 files changed, 50 insertions(+), 36 deletions(-)
 create mode 100644 power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp
index 7b87d6dd66..26faf3f09a 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp
@@ -9,6 +9,7 @@
 #include "common/common.hpp"
 #include "common/exception.hpp"
 #include "common/iterator_facade.hpp"
+#include "container_fwd.hpp"
 
 #include <boost/range.hpp>
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
new file mode 100644
index 0000000000..8861591300
--- /dev/null
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "common/common.hpp"
+
+#include <concepts>
+
+namespace power_grid_model {
+
+template <typename ContainerType, typename ComponentType>
+concept component_container_c = requires(ContainerType const& c, ID id) {
+    { c.template citer<ComponentType>().begin() } -> std::forward_iterator;
+    { c.template citer<ComponentType>().end() } -> std::forward_iterator;
+    { *(c.template citer<ComponentType>().begin()) } -> std::same_as<ComponentType const&>;
+    { *(c.template citer<ComponentType>().end()) } -> std::same_as<ComponentType const&>;
+    { c.template get_item<ComponentType>(id) } -> std::convertible_to<ComponentType const&>;
+};
+
+template <typename ContainerType, typename ComponentType>
+concept extended_component_container_c =
+    component_container_c<ContainerType, ComponentType> && requires(ContainerType const& c, Idx2D const& idx2d) {
+        { c.template size<ComponentType>() } -> std::same_as<Idx>;
+        { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
+    };
+
+template <typename ContainerType, typename... ComponentType>
+concept multi_extended_component_container_c = (extended_component_container_c<ContainerType, ComponentType> && ...);
+
+} // namespace power_grid_model
\ No newline at end of file
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
index 7bfdd3fe33..0dc3d62dea 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
@@ -28,25 +28,6 @@ template <class CompContainer> struct MainModelState {
 template <class StateType>
 concept main_model_state_c = std::same_as<StateType, MainModelState<typename StateType::ComponentContainer>>;
 
-template <typename ContainerType, typename ComponentType>
-concept component_container_c = requires(ContainerType const& c, ID id) {
-    { c.template citer<ComponentType>().begin() } -> std::forward_iterator;
-    { c.template citer<ComponentType>().end() } -> std::forward_iterator;
-    { *(c.template citer<ComponentType>().begin()) } -> std::same_as<ComponentType const&>;
-    { *(c.template citer<ComponentType>().end()) } -> std::same_as<ComponentType const&>;
-    { c.template get_item<ComponentType>(id) } -> std::convertible_to<ComponentType const&>;
-};
-
-template <typename ContainerType, typename ComponentType>
-concept extended_component_container_c =
-    component_container_c<ContainerType, ComponentType> && requires(ContainerType const& c, Idx2D const& idx2d) {
-        { c.template size<ComponentType>() } -> std::same_as<Idx>;
-        { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
-    };
-
-template <typename ContainerType, typename... ComponentType>
-concept multi_extended_component_container_c = (extended_component_container_c<ContainerType, ComponentType> && ...);
-
 template <template <typename T> class StateType, typename ContainerType, typename ComponentType>
 concept model_component_state_c =
     component_container_c<typename StateType<ContainerType>::ComponentContainer, ComponentType> &&
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp
index de0232bde2..509d0ab0f2 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp
@@ -29,7 +29,7 @@ constexpr auto get_optimizer(OptimizerType optimizer_type, OptimizerStrategy str
     case automatic_tap_adjustment:
         if constexpr (detail::steady_state_calculator_c<StateCalculator, State> &&
                       std::invocable<std::remove_cvref_t<StateUpdater>, ConstDataset const&> &&
-                      main_core::component_container_c<typename State::ComponentContainer, TransformerTapRegulator>) {
+                      component_container_c<typename State::ComponentContainer, TransformerTapRegulator>) {
             return BaseOptimizer::template make_shared<TapPositionOptimizer<StateCalculator, StateUpdater, State>>(
                 std::move(calculator), std::move(updater), strategy, meta_data, search);
         }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
index 3475a7e048..65bf8f325e 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
@@ -471,7 +471,7 @@ template <transformer_c... TransformerTypes> struct TapRegulatorRef {
 };
 
 template <typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, TransformerTapRegulator>
+    requires component_container_c<typename State::ComponentContainer, TransformerTapRegulator>
 TransformerTapRegulator const& find_regulator(State const& state, ID regulated_object) {
     auto const regulators = get_component_citer<TransformerTapRegulator>(state);
 
@@ -503,7 +503,7 @@ template <typename... Ts> struct transformer_types_s<std::tuple<std::tuple<Ts...
 template <typename... Ts> using transformer_types_t = typename transformer_types_s<std::tuple<Ts...>>::type;
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(main_core::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline TapRegulatorRef<TransformerTypes...> regulator_mapping(State const& state, Idx2D const& transformer_index) {
     using ResultType = TapRegulatorRef<TransformerTypes...>;
     using IsType = bool (*)(Idx2D const&);
@@ -536,7 +536,7 @@ inline TapRegulatorRef<TransformerTypes...> regulator_mapping(State const& state
 }
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(main_core::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline auto regulator_mapping(State const& state, std::vector<Idx2D> const& order) {
     std::vector<TapRegulatorRef<TransformerTypes...>> result;
     result.reserve(order.size());
@@ -549,7 +549,7 @@ inline auto regulator_mapping(State const& state, std::vector<Idx2D> const& orde
 }
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(main_core::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline auto regulator_mapping(State const& state, RankedTransformerGroups const& order) {
     std::vector<std::vector<TapRegulatorRef<TransformerTypes...>>> result;
     result.reserve(order.size());
@@ -598,7 +598,7 @@ inline auto i_pu(std::vector<SolverOutputType> const& solver_output, Idx2DBranch
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto i_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regulator, State const& state,
                                  std::vector<SolverOutputType> const& solver_output) {
     auto const& branch_math_id = get_math_id<ComponentType>(state, regulator.transformer.topology_index());
@@ -606,7 +606,7 @@ inline auto i_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regul
 }
 
 template <transformer_c ComponentType, typename State, steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType> &&
+    requires component_container_c<typename State::ComponentContainer, ComponentType> &&
              requires(State const& state, Idx const i) {
                  { get_branch_nodes<ComponentType>(state, i)[i] } -> std::convertible_to<Idx>;
              }
@@ -619,7 +619,7 @@ inline auto u_pu(State const& state, std::vector<SolverOutputType> const& solver
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regulator, State const& state,
                                  std::vector<SolverOutputType> const& solver_output) {
     return u_pu<ComponentType>(state, solver_output, regulator.transformer.topology_index(),
@@ -627,7 +627,7 @@ inline auto u_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regul
 }
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline bool is_regulated_transformer_connected(TapRegulatorRef<RegulatedTypes...> const& regulator,
                                                State const& state) {
     auto const controlled_node_idx = get_topo_node<ComponentType>(state, regulator.transformer.topology_index(),
@@ -702,7 +702,7 @@ class RankIteration {
 template <typename... T> class TapPositionOptimizerImpl;
 template <transformer_c... TransformerTypes, typename StateCalculator, typename StateUpdater_, typename State_,
           typename TransformerRanker_>
-    requires(main_core::component_container_c<typename State_::ComponentContainer, TransformerTypes> && ...) &&
+    requires(component_container_c<typename State_::ComponentContainer, TransformerTypes> && ...) &&
             detail::steady_state_calculator_c<StateCalculator, State_> &&
             std::invocable<std::remove_cvref_t<StateUpdater_>, ConstDataset const&> &&
             requires(TransformerRanker_ const& ranker, State_ const& state) {
diff --git a/tests/cpp_unit_tests/test_optimizer.hpp b/tests/cpp_unit_tests/test_optimizer.hpp
index ae5def1a85..5f80a6b148 100644
--- a/tests/cpp_unit_tests/test_optimizer.hpp
+++ b/tests/cpp_unit_tests/test_optimizer.hpp
@@ -54,13 +54,13 @@ static_assert(transformer_c<StubTransformerA>);
 static_assert(transformer_c<StubTransformerB>);
 
 template <std::derived_from<StubTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_topology_index(State const& /* state */, auto const& /* id_or_index */) {
     return Idx{};
 }
 
 template <std::derived_from<StubTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_math_id(State const& /* state */, Idx /* topology_sequence_idx */) {
     return StubTransformerMathIdType{};
 }
@@ -73,7 +73,7 @@ inline auto i_pu(std::vector<SolverOutputType> const& /* solver_output */,
 
 template <std::derived_from<StubTransformer> ComponentType, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu(State const& /* state */, std::vector<SolverOutputType> const& /* solver_output */,
                  Idx /* topology_index */, ControlSide /* control_side */) {
     return ComplexValue<typename SolverOutputType::sym>{};
diff --git a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
index 245b105934..da6e055872 100644
--- a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
+++ b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
@@ -624,7 +624,7 @@ class MockSolverOutput : public SolverOutput<symmetric_t> {
     template <typename... T> struct AddTapPositions;
     template <typename T> struct AddTapPositions<T> {
         void operator()(main_core::MainModelState<ContainerType> const& state, std::map<ID, IntS>& target) {
-            if constexpr (transformer_c<T> && main_core::component_container_c<ContainerType, T>) {
+            if constexpr (transformer_c<T> && component_container_c<ContainerType, T>) {
                 for (auto const& component : state.components.template citer<T>()) {
                     target[component.id()] = component.tap_pos();
                 }
@@ -732,14 +732,14 @@ struct MockTransformer {
 static_assert(transformer_c<MockTransformer>);
 
 template <std::derived_from<MockTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_topology_index(State const& state, auto const& id_or_index) {
     auto const& transformer = main_core::get_component<ComponentType>(state, id_or_index);
     return transformer.state.math_id.pos;
 }
 
 template <std::derived_from<MockTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_math_id(State const& state, Idx topology_index) {
     return main_core::get_component_by_sequence<MockTransformer>(state, topology_index).state.math_id;
 }
@@ -763,7 +763,7 @@ inline DoubleComplex i_pu(std::vector<MockSolverOutput<ContainerType>> const& so
 
 template <std::derived_from<MockTransformer> ComponentType, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu(State const& state, std::vector<SolverOutputType> const& /* solver_output */, Idx topology_index,
                  ControlSide side) {
     return main_core::get_component_by_sequence<MockTransformer>(state, topology_index).state.u_pu(side);

From dd65f3bf7a06e2cd46779f776a80c00f03018509 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 11:31:26 +0200
Subject: [PATCH 06/17] move out container queries

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../main_core/container_queries.hpp           | 26 +++++++++++++++++++
 .../main_core/state_queries.hpp               | 16 ------------
 .../power_grid_model/main_core/topology.hpp   |  2 +-
 3 files changed, 27 insertions(+), 17 deletions(-)
 create mode 100644 power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
new file mode 100644
index 0000000000..1e827e3a70
--- /dev/null
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
@@ -0,0 +1,26 @@
+
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "../container.hpp"
+
+namespace power_grid_model::main_core {
+
+// TODO Reconfirm if there is duplication with state_queries and if we can remove either one of them
+
+template <typename ComponentType, class ComponentContainer>
+    requires extended_component_container_c<ComponentContainer, ComponentType>
+constexpr auto get_component_size(ComponentContainer const& components) {
+    return components.template size<ComponentType>();
+}
+
+template <typename ComponentType, class ComponentContainer>
+    requires extended_component_container_c<ComponentContainer, ComponentType>
+inline Idx get_component_sequence_idx(ComponentContainer const& components, auto const& id_or_index) {
+    return components.template get_seq<ComponentType>(id_or_index);
+}
+
+} // namespace power_grid_model::main_core
\ No newline at end of file
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp
index 5d26aefa22..d4f34b7d9b 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp
@@ -10,22 +10,6 @@
 
 namespace power_grid_model::main_core {
 
-// using only components and not state
-
-template <typename ComponentType, class ComponentContainer>
-    requires extended_component_container_c<ComponentContainer, ComponentType>
-constexpr auto get_component_size(ComponentContainer const& components) {
-    return components.template size<ComponentType>();
-}
-
-template <typename ComponentType, class ComponentContainer>
-    requires extended_component_container_c<ComponentContainer, ComponentType>
-inline Idx get_component_sequence_idx(ComponentContainer const& components, auto const& id_or_index) {
-    return components.template get_seq<ComponentType>(id_or_index);
-}
-
-// existing implementation
-
 template <typename ComponentType, class ComponentContainer>
     requires model_component_state_c<MainModelState, ComponentContainer, ComponentType>
 inline Idx get_component_type_index(MainModelState<ComponentContainer> const& state) {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index 6f63bf293e..db14295d95 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
+#include "container_queries.hpp"
 #include "state.hpp"
-#include "state_queries.hpp"
 
 #include "../all_components.hpp"
 

From 8597a46c5ca8bae84acc6bd2ff77c46f1bd3be8e Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 11:47:15 +0200
Subject: [PATCH 07/17] change size retrieval to component query

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../include/power_grid_model/main_core/topology.hpp    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index db14295d95..c619e1a72e 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -202,11 +202,11 @@ ComponentTopology construct_topology(main_model_state_c auto const& state) {
 
 ComponentConnections construct_components_connections(main_model_state_c auto const& state) {
     ComponentConnections comp_conn;
-    comp_conn.branch_connected.resize(state.comp_topo->branch_node_idx.size());
-    comp_conn.branch_phase_shift.resize(state.comp_topo->branch_node_idx.size());
-    comp_conn.branch3_connected.resize(state.comp_topo->branch3_node_idx.size());
-    comp_conn.branch3_phase_shift.resize(state.comp_topo->branch3_node_idx.size());
-    comp_conn.source_connected.resize(state.comp_topo->source_node_idx.size());
+    comp_conn.branch_connected.resize(get_component_size<Branch>(state.components));
+    comp_conn.branch_phase_shift.resize(get_component_size<Branch>(state.components));
+    comp_conn.branch3_connected.resize(get_component_size<Branch3>(state.components));
+    comp_conn.branch3_phase_shift.resize(get_component_size<Branch3>(state.components));
+    comp_conn.source_connected.resize(get_component_size<Source>(state.components));
     std::ranges::transform(
         state.components.template citer<Branch>(), comp_conn.branch_connected.begin(), [](Branch const& branch) {
             return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};

From fbbaa5e958ea4b9dd8f543cb009ba7542f42bc86 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 12:42:00 +0200
Subject: [PATCH 08/17] decouple topology from state

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/container_fwd.hpp        |  1 +
 .../power_grid_model/main_core/topology.hpp   | 51 ++++++++++---------
 .../power_grid_model/main_model_impl.hpp      |  4 +-
 3 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
index 8861591300..02f114d54b 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -19,6 +19,7 @@ concept component_container_c = requires(ContainerType const& c, ID id) {
     { c.template get_item<ComponentType>(id) } -> std::convertible_to<ComponentType const&>;
 };
 
+// TODO merge with component_container_c
 template <typename ContainerType, typename ComponentType>
 concept extended_component_container_c =
     component_container_c<ContainerType, ComponentType> && requires(ContainerType const& c, Idx2D const& idx2d) {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index c619e1a72e..1d9faa0cea 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "container_queries.hpp"
-#include "state.hpp"
 
 #include "../all_components.hpp"
 
@@ -185,46 +184,52 @@ constexpr void register_topology_components(ComponentContainer const& components
         [](Regulator const& regulator) { return regulator.regulated_object_type(); });
 }
 
-ComponentTopology construct_topology(main_model_state_c auto const& state) {
+template <typename ComponentContainer>
+    requires multi_extended_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
+                                                  GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor,
+                                                  Regulator>
+ComponentTopology construct_topology(ComponentContainer const& components) {
     ComponentTopology comp_topo;
-    register_topology_components<Node>(state.components, comp_topo);
-    register_topology_components<Branch>(state.components, comp_topo);
-    register_topology_components<Branch3>(state.components, comp_topo);
-    register_topology_components<Source>(state.components, comp_topo);
-    register_topology_components<Shunt>(state.components, comp_topo);
-    register_topology_components<GenericLoadGen>(state.components, comp_topo);
-    register_topology_components<GenericVoltageSensor>(state.components, comp_topo);
-    register_topology_components<GenericPowerSensor>(state.components, comp_topo);
-    register_topology_components<GenericCurrentSensor>(state.components, comp_topo);
-    register_topology_components<Regulator>(state.components, comp_topo);
+    register_topology_components<Node>(components, comp_topo);
+    register_topology_components<Branch>(components, comp_topo);
+    register_topology_components<Branch3>(components, comp_topo);
+    register_topology_components<Source>(components, comp_topo);
+    register_topology_components<Shunt>(components, comp_topo);
+    register_topology_components<GenericLoadGen>(components, comp_topo);
+    register_topology_components<GenericVoltageSensor>(components, comp_topo);
+    register_topology_components<GenericPowerSensor>(components, comp_topo);
+    register_topology_components<GenericCurrentSensor>(components, comp_topo);
+    register_topology_components<Regulator>(components, comp_topo);
     return comp_topo;
 }
 
-ComponentConnections construct_components_connections(main_model_state_c auto const& state) {
+template <typename ComponentContainer>
+    requires multi_extended_component_container_c<ComponentContainer, Branch, Branch3, Source>
+ComponentConnections construct_components_connections(ComponentContainer const& components) {
     ComponentConnections comp_conn;
-    comp_conn.branch_connected.resize(get_component_size<Branch>(state.components));
-    comp_conn.branch_phase_shift.resize(get_component_size<Branch>(state.components));
-    comp_conn.branch3_connected.resize(get_component_size<Branch3>(state.components));
-    comp_conn.branch3_phase_shift.resize(get_component_size<Branch3>(state.components));
-    comp_conn.source_connected.resize(get_component_size<Source>(state.components));
+    comp_conn.branch_connected.resize(get_component_size<Branch>(components));
+    comp_conn.branch_phase_shift.resize(get_component_size<Branch>(components));
+    comp_conn.branch3_connected.resize(get_component_size<Branch3>(components));
+    comp_conn.branch3_phase_shift.resize(get_component_size<Branch3>(components));
+    comp_conn.source_connected.resize(get_component_size<Source>(components));
     std::ranges::transform(
-        state.components.template citer<Branch>(), comp_conn.branch_connected.begin(), [](Branch const& branch) {
+        components.template citer<Branch>(), comp_conn.branch_connected.begin(), [](Branch const& branch) {
             return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
         });
 
-    std::ranges::transform(state.components.template citer<Branch>(), comp_conn.branch_phase_shift.begin(),
+    std::ranges::transform(components.template citer<Branch>(), comp_conn.branch_phase_shift.begin(),
                            [](Branch const& branch) { return branch.phase_shift(); });
 
     std::ranges::transform(
-        state.components.template citer<Branch3>(), comp_conn.branch3_connected.begin(), [](Branch3 const& branch3) {
+        components.template citer<Branch3>(), comp_conn.branch3_connected.begin(), [](Branch3 const& branch3) {
             return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
                                     static_cast<IntS>(branch3.status_3())};
         });
 
-    std::ranges::transform(state.components.template citer<Branch3>(), comp_conn.branch3_phase_shift.begin(),
+    std::ranges::transform(components.template citer<Branch3>(), comp_conn.branch3_phase_shift.begin(),
                            [](Branch3 const& branch3) { return branch3.phase_shift(); });
 
-    std::ranges::transform(state.components.template citer<Source>(), comp_conn.source_connected.begin(),
+    std::ranges::transform(components.template citer<Source>(), comp_conn.source_connected.begin(),
                            [](Source const& source) { return source.status(); });
     return comp_conn;
 }
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
index 79f44edbd6..b2961e9124 100644
--- 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
@@ -314,7 +314,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         construction_complete_ = true;
 #endif // !NDEBUG
         state_.components.set_construction_complete();
-        state_.comp_topo = std::make_shared<ComponentTopology const>(main_core::construct_topology(state_));
+        state_.comp_topo = std::make_shared<ComponentTopology const>(main_core::construct_topology(state_.components));
     }
 
     void reset_solvers() {
@@ -637,7 +637,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         assert(construction_complete_);
         // clear old solvers
         reset_solvers();
-        ComponentConnections const comp_conn = main_core::construct_components_connections(state_);
+        ComponentConnections const comp_conn = main_core::construct_components_connections(state_.components);
         // re build
         Topology topology{*state_.comp_topo, comp_conn};
         std::tie(state_.math_topology, state_.topo_comp_coup) = topology.build_topology();

From 1ab7ee82123506fcff37e8d725f987830a7a70c6 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 13:08:27 +0200
Subject: [PATCH 09/17] homogenize registration

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/main_core/topology.hpp   | 55 +++++++++++--------
 1 file changed, 31 insertions(+), 24 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index 1d9faa0cea..310174aca7 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -184,6 +184,34 @@ constexpr void register_topology_components(ComponentContainer const& components
         [](Regulator const& regulator) { return regulator.regulated_object_type(); });
 }
 
+// TODO Rename register_topo_components if this is combined
+template <std::same_as<Branch> Component, class ComponentContainer>
+    requires component_container_c<ComponentContainer, Component>
+constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+    detail::register_topo_components<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
+        return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
+    });
+    detail::register_topo_components<Component>(components, comp_conn.branch_phase_shift,
+                                                [](Branch const& branch) { return branch.phase_shift(); });
+}
+template <std::same_as<Branch3> Component, class ComponentContainer>
+    requires component_container_c<ComponentContainer, Component>
+constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+    detail::register_topo_components<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
+        return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
+                                static_cast<IntS>(branch3.status_3())};
+    });
+    detail::register_topo_components<Component>(components, comp_conn.branch3_phase_shift,
+                                                [](Branch3 const& branch3) { return branch3.phase_shift(); });
+}
+
+template <std::same_as<Source> Component, class ComponentContainer>
+    requires component_container_c<ComponentContainer, Component>
+constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+    detail::register_topo_components<Component>(components, comp_conn.source_connected,
+                                                [](Source const& source) { return source.status(); });
+}
+
 template <typename ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
                                                   GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor,
@@ -207,30 +235,9 @@ template <typename ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Branch, Branch3, Source>
 ComponentConnections construct_components_connections(ComponentContainer const& components) {
     ComponentConnections comp_conn;
-    comp_conn.branch_connected.resize(get_component_size<Branch>(components));
-    comp_conn.branch_phase_shift.resize(get_component_size<Branch>(components));
-    comp_conn.branch3_connected.resize(get_component_size<Branch3>(components));
-    comp_conn.branch3_phase_shift.resize(get_component_size<Branch3>(components));
-    comp_conn.source_connected.resize(get_component_size<Source>(components));
-    std::ranges::transform(
-        components.template citer<Branch>(), comp_conn.branch_connected.begin(), [](Branch const& branch) {
-            return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
-        });
-
-    std::ranges::transform(components.template citer<Branch>(), comp_conn.branch_phase_shift.begin(),
-                           [](Branch const& branch) { return branch.phase_shift(); });
-
-    std::ranges::transform(
-        components.template citer<Branch3>(), comp_conn.branch3_connected.begin(), [](Branch3 const& branch3) {
-            return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
-                                    static_cast<IntS>(branch3.status_3())};
-        });
-
-    std::ranges::transform(components.template citer<Branch3>(), comp_conn.branch3_phase_shift.begin(),
-                           [](Branch3 const& branch3) { return branch3.phase_shift(); });
-
-    std::ranges::transform(components.template citer<Source>(), comp_conn.source_connected.begin(),
-                           [](Source const& source) { return source.status(); });
+    register_connections_components<Branch>(components, comp_conn);
+    register_connections_components<Branch3>(components, comp_conn);
+    register_connections_components<Source>(components, comp_conn);
     return comp_conn;
 }
 

From 317c8ed4ad6169631843d3eda2947de12922e40e Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 13:22:03 +0200
Subject: [PATCH 10/17] rename common function to generic name

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/main_core/topology.hpp   | 71 +++++++++----------
 1 file changed, 34 insertions(+), 37 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index 310174aca7..c5008ebabe 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -16,8 +16,7 @@ template <typename Component, class ComponentContainer, typename ResType, typena
     requires component_container_c<ComponentContainer, Component> &&
              std::invocable<std::remove_cvref_t<ResFunc>, Component const&> &&
              std::convertible_to<std::invoke_result_t<ResFunc, Component const&>, ResType>
-constexpr void register_topo_components(ComponentContainer const& components, std::vector<ResType>& target,
-                                        ResFunc&& func) {
+constexpr void apply_registration(ComponentContainer const& components, std::vector<ResType>& target, ResFunc&& func) {
     auto const begin = components.template citer<Component>().begin();
     auto const end = components.template citer<Component>().end();
 
@@ -36,17 +35,16 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<Branch> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
-        components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
-            return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
-                             get_component_sequence_idx<Node>(components, branch.to_node())};
-        });
+    detail::apply_registration<Component>(components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
+        return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
+                         get_component_sequence_idx<Node>(components, branch.to_node())};
+    });
 }
 
 template <std::same_as<Branch3> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
+    detail::apply_registration<Component>(
         components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
             return Branch3Idx{get_component_sequence_idx<Node>(components, branch3.node_1()),
                               get_component_sequence_idx<Node>(components, branch3.node_2()),
@@ -57,35 +55,35 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<Source> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
-        components, comp_topo.source_node_idx,
-        [&components](Source const& source) { return get_component_sequence_idx<Node>(components, source.node()); });
+    detail::apply_registration<Component>(components, comp_topo.source_node_idx, [&components](Source const& source) {
+        return get_component_sequence_idx<Node>(components, source.node());
+    });
 }
 
 template <std::same_as<Shunt> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
-        components, comp_topo.shunt_node_idx,
-        [&components](Shunt const& shunt) { return get_component_sequence_idx<Node>(components, shunt.node()); });
+    detail::apply_registration<Component>(components, comp_topo.shunt_node_idx, [&components](Shunt const& shunt) {
+        return get_component_sequence_idx<Node>(components, shunt.node());
+    });
 }
 
 template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
-        components, comp_topo.load_gen_node_idx, [&components](GenericLoadGen const& load_gen) {
-            return get_component_sequence_idx<Node>(components, load_gen.node());
-        });
+    detail::apply_registration<Component>(components, comp_topo.load_gen_node_idx,
+                                          [&components](GenericLoadGen const& load_gen) {
+                                              return get_component_sequence_idx<Node>(components, load_gen.node());
+                                          });
 
-    detail::register_topo_components<Component>(components, comp_topo.load_gen_type,
-                                                [](GenericLoadGen const& load_gen) { return load_gen.type(); });
+    detail::apply_registration<Component>(components, comp_topo.load_gen_type,
+                                          [](GenericLoadGen const& load_gen) { return load_gen.type(); });
 }
 
 template <std::same_as<GenericVoltageSensor> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
+    detail::apply_registration<Component>(
         components, comp_topo.voltage_sensor_node_idx, [&components](GenericVoltageSensor const& voltage_sensor) {
             return get_component_sequence_idx<Node>(components, voltage_sensor.measured_object());
         });
@@ -95,7 +93,7 @@ template <std::same_as<GenericPowerSensor> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen,
                                                   Branch3, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
+    detail::apply_registration<Component>(
         components, comp_topo.power_sensor_object_idx, [&components](GenericPowerSensor const& power_sensor) {
             using enum MeasuredTerminalType;
 
@@ -128,7 +126,7 @@ constexpr void register_topology_components(ComponentContainer const& components
             }
         });
 
-    detail::register_topo_components<Component>(
+    detail::apply_registration<Component>(
         components, comp_topo.power_sensor_terminal_type,
         [](GenericPowerSensor const& power_sensor) { return power_sensor.get_terminal_type(); });
 }
@@ -136,7 +134,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<GenericCurrentSensor> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
+    detail::apply_registration<Component>(
         components, comp_topo.current_sensor_object_idx, [&components](GenericCurrentSensor const& current_sensor) {
             using enum MeasuredTerminalType;
 
@@ -159,7 +157,7 @@ constexpr void register_topology_components(ComponentContainer const& components
             }
         });
 
-    detail::register_topo_components<Component>(
+    detail::apply_registration<Component>(
         components, comp_topo.current_sensor_terminal_type,
         [](GenericCurrentSensor const& current_sensor) { return current_sensor.get_terminal_type(); });
 }
@@ -167,7 +165,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::derived_from<Regulator> Component, class ComponentContainer>
     requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(
+    detail::apply_registration<Component>(
         components, comp_topo.regulated_object_idx, [&components](Regulator const& regulator) {
             switch (regulator.regulated_object_type()) {
             case ComponentType::branch:
@@ -179,37 +177,36 @@ constexpr void register_topology_components(ComponentContainer const& components
             }
         });
 
-    detail::register_topo_components<Component>(
-        components, comp_topo.regulated_object_type,
-        [](Regulator const& regulator) { return regulator.regulated_object_type(); });
+    detail::apply_registration<Component>(components, comp_topo.regulated_object_type,
+                                          [](Regulator const& regulator) { return regulator.regulated_object_type(); });
 }
 
 // TODO Rename register_topo_components if this is combined
 template <std::same_as<Branch> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
-    detail::register_topo_components<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
+    detail::apply_registration<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
         return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
     });
-    detail::register_topo_components<Component>(components, comp_conn.branch_phase_shift,
-                                                [](Branch const& branch) { return branch.phase_shift(); });
+    detail::apply_registration<Component>(components, comp_conn.branch_phase_shift,
+                                          [](Branch const& branch) { return branch.phase_shift(); });
 }
 template <std::same_as<Branch3> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
-    detail::register_topo_components<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
+    detail::apply_registration<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
         return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
                                 static_cast<IntS>(branch3.status_3())};
     });
-    detail::register_topo_components<Component>(components, comp_conn.branch3_phase_shift,
-                                                [](Branch3 const& branch3) { return branch3.phase_shift(); });
+    detail::apply_registration<Component>(components, comp_conn.branch3_phase_shift,
+                                          [](Branch3 const& branch3) { return branch3.phase_shift(); });
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
-    detail::register_topo_components<Component>(components, comp_conn.source_connected,
-                                                [](Source const& source) { return source.status(); });
+    detail::apply_registration<Component>(components, comp_conn.source_connected,
+                                          [](Source const& source) { return source.status(); });
 }
 
 template <typename ComponentContainer>

From 423dcd22f96b90f32a848da24cbe46acca534dba Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 15:39:53 +0200
Subject: [PATCH 11/17] resolve todos

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/container_fwd.hpp        | 14 +++-------
 .../main_core/container_queries.hpp           |  4 +--
 .../power_grid_model/main_core/topology.hpp   | 28 +++++++++----------
 3 files changed, 19 insertions(+), 27 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
index 02f114d54b..18cde055fe 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -11,23 +11,17 @@
 namespace power_grid_model {
 
 template <typename ContainerType, typename ComponentType>
-concept component_container_c = requires(ContainerType const& c, ID id) {
+concept component_container_c = requires(ContainerType const& c, ID id, Idx2D idx2d) {
     { c.template citer<ComponentType>().begin() } -> std::forward_iterator;
     { c.template citer<ComponentType>().end() } -> std::forward_iterator;
     { *(c.template citer<ComponentType>().begin()) } -> std::same_as<ComponentType const&>;
     { *(c.template citer<ComponentType>().end()) } -> std::same_as<ComponentType const&>;
     { c.template get_item<ComponentType>(id) } -> std::convertible_to<ComponentType const&>;
+    { c.template size<ComponentType>() } -> std::same_as<Idx>;
+    { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
 };
 
-// TODO merge with component_container_c
-template <typename ContainerType, typename ComponentType>
-concept extended_component_container_c =
-    component_container_c<ContainerType, ComponentType> && requires(ContainerType const& c, Idx2D const& idx2d) {
-        { c.template size<ComponentType>() } -> std::same_as<Idx>;
-        { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
-    };
-
 template <typename ContainerType, typename... ComponentType>
-concept multi_extended_component_container_c = (extended_component_container_c<ContainerType, ComponentType> && ...);
+concept multi_component_container_c = (component_container_c<ContainerType, ComponentType> && ...);
 
 } // namespace power_grid_model
\ No newline at end of file
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
index 1e827e3a70..7f12403449 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
@@ -12,13 +12,13 @@ namespace power_grid_model::main_core {
 // TODO Reconfirm if there is duplication with state_queries and if we can remove either one of them
 
 template <typename ComponentType, class ComponentContainer>
-    requires extended_component_container_c<ComponentContainer, ComponentType>
+    requires component_container_c<ComponentContainer, ComponentType>
 constexpr auto get_component_size(ComponentContainer const& components) {
     return components.template size<ComponentType>();
 }
 
 template <typename ComponentType, class ComponentContainer>
-    requires extended_component_container_c<ComponentContainer, ComponentType>
+    requires component_container_c<ComponentContainer, ComponentType>
 inline Idx get_component_sequence_idx(ComponentContainer const& components, auto const& id_or_index) {
     return components.template get_seq<ComponentType>(id_or_index);
 }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index c5008ebabe..b5da43b436 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -33,7 +33,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+    requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
         return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
@@ -42,7 +42,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Branch3> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+    requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(
         components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
@@ -53,7 +53,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+    requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(components, comp_topo.source_node_idx, [&components](Source const& source) {
         return get_component_sequence_idx<Node>(components, source.node());
@@ -61,7 +61,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Shunt> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+    requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(components, comp_topo.shunt_node_idx, [&components](Shunt const& shunt) {
         return get_component_sequence_idx<Node>(components, shunt.node());
@@ -69,7 +69,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+    requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(components, comp_topo.load_gen_node_idx,
                                           [&components](GenericLoadGen const& load_gen) {
@@ -81,7 +81,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericVoltageSensor> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+    requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(
         components, comp_topo.voltage_sensor_node_idx, [&components](GenericVoltageSensor const& voltage_sensor) {
@@ -90,8 +90,8 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericPowerSensor> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen,
-                                                  Branch3, Node>
+    requires multi_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen, Branch3,
+                                         Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(
         components, comp_topo.power_sensor_object_idx, [&components](GenericPowerSensor const& power_sensor) {
@@ -132,7 +132,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericCurrentSensor> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
+    requires multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(
         components, comp_topo.current_sensor_object_idx, [&components](GenericCurrentSensor const& current_sensor) {
@@ -163,7 +163,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::derived_from<Regulator> Component, class ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
+    requires multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::apply_registration<Component>(
         components, comp_topo.regulated_object_idx, [&components](Regulator const& regulator) {
@@ -181,7 +181,6 @@ constexpr void register_topology_components(ComponentContainer const& components
                                           [](Regulator const& regulator) { return regulator.regulated_object_type(); });
 }
 
-// TODO Rename register_topo_components if this is combined
 template <std::same_as<Branch> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
@@ -210,9 +209,8 @@ constexpr void register_connections_components(ComponentContainer components, Co
 }
 
 template <typename ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
-                                                  GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor,
-                                                  Regulator>
+    requires multi_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
+                                         GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor, Regulator>
 ComponentTopology construct_topology(ComponentContainer const& components) {
     ComponentTopology comp_topo;
     register_topology_components<Node>(components, comp_topo);
@@ -229,7 +227,7 @@ ComponentTopology construct_topology(ComponentContainer const& components) {
 }
 
 template <typename ComponentContainer>
-    requires multi_extended_component_container_c<ComponentContainer, Branch, Branch3, Source>
+    requires multi_component_container_c<ComponentContainer, Branch, Branch3, Source>
 ComponentConnections construct_components_connections(ComponentContainer const& components) {
     ComponentConnections comp_conn;
     register_connections_components<Branch>(components, comp_conn);

From 5937456bd9baefb31836a575fd1185f843a4bc8c Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Wed, 20 Aug 2025 15:48:49 +0200
Subject: [PATCH 12/17] rename to retrievable type

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/container_fwd.hpp        | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
index 18cde055fe..0d73cc183f 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -10,18 +10,18 @@
 
 namespace power_grid_model {
 
-template <typename ContainerType, typename ComponentType>
+template <typename ContainerType, typename RetrievableType>
 concept component_container_c = requires(ContainerType const& c, ID id, Idx2D idx2d) {
-    { c.template citer<ComponentType>().begin() } -> std::forward_iterator;
-    { c.template citer<ComponentType>().end() } -> std::forward_iterator;
-    { *(c.template citer<ComponentType>().begin()) } -> std::same_as<ComponentType const&>;
-    { *(c.template citer<ComponentType>().end()) } -> std::same_as<ComponentType const&>;
-    { c.template get_item<ComponentType>(id) } -> std::convertible_to<ComponentType const&>;
-    { c.template size<ComponentType>() } -> std::same_as<Idx>;
-    { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
+    { c.template citer<RetrievableType>().begin() } -> std::forward_iterator;
+    { c.template citer<RetrievableType>().end() } -> std::forward_iterator;
+    { *(c.template citer<RetrievableType>().begin()) } -> std::same_as<RetrievableType const&>;
+    { *(c.template citer<RetrievableType>().end()) } -> std::same_as<RetrievableType const&>;
+    { c.template get_item<RetrievableType>(id) } -> std::convertible_to<RetrievableType const&>;
+    { c.template size<RetrievableType>() } -> std::same_as<Idx>;
+    { c.template get_seq<RetrievableType>(idx2d) } -> std::same_as<Idx>;
 };
 
-template <typename ContainerType, typename... ComponentType>
-concept multi_component_container_c = (component_container_c<ContainerType, ComponentType> && ...);
+template <typename ContainerType, typename... RetrievableType>
+concept multi_component_container_c = (component_container_c<ContainerType, RetrievableType> && ...);
 
 } // namespace power_grid_model
\ No newline at end of file

From ca5ae3f3baffeb51909e7ead1fae50c8c3189fba Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Fri, 22 Aug 2025 10:05:30 +0200
Subject: [PATCH 13/17] address comments 1

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../include/power_grid_model/container_fwd.hpp    |  2 +-
 .../main_core/container_queries.hpp               |  3 +--
 tests/cpp_unit_tests/test_container.cpp           | 15 +++++++++++++++
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
index 0d73cc183f..bc01a7a8a3 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -24,4 +24,4 @@ concept component_container_c = requires(ContainerType const& c, ID id, Idx2D id
 template <typename ContainerType, typename... RetrievableType>
 concept multi_component_container_c = (component_container_c<ContainerType, RetrievableType> && ...);
 
-} // namespace power_grid_model
\ No newline at end of file
+} // namespace power_grid_model
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
index 7f12403449..109c22902f 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
@@ -1,4 +1,3 @@
-
 // SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
 //
 // SPDX-License-Identifier: MPL-2.0
@@ -23,4 +22,4 @@ inline Idx get_component_sequence_idx(ComponentContainer const& components, auto
     return components.template get_seq<ComponentType>(id_or_index);
 }
 
-} // namespace power_grid_model::main_core
\ No newline at end of file
+} // namespace power_grid_model::main_core
diff --git a/tests/cpp_unit_tests/test_container.cpp b/tests/cpp_unit_tests/test_container.cpp
index a6bd14e8f9..88e1a94088 100644
--- a/tests/cpp_unit_tests/test_container.cpp
+++ b/tests/cpp_unit_tests/test_container.cpp
@@ -223,6 +223,21 @@ TEST_CASE("Test component container") {
         CHECK(const_container.get_id_by_idx(Idx2D{2, 0}) == 3);
     }
 #endif // NDEBUG
+
+    SUBCASE("Component Container concept") {
+        static_assert(component_container_c<CompContainer, C>);
+        static_assert(component_container_c<CompContainer, C1>);
+        static_assert(component_container_c<CompContainer, C2>);
+        static_assert(component_container_c<CompContainer2, C>);
+        static_assert(component_container_c<CompContainer2, C1>);
+        static_assert(component_container_c<CompContainer2, C2>);
+        static_assert(multi_component_container_c<CompContainer, C, C1>);
+        static_assert(multi_component_container_c<CompContainer, C1, C2>);
+        static_assert(multi_component_container_c<CompContainer, C, C1, C2>);
+        static_assert(multi_component_container_c<CompContainer2, C, C1>);
+        static_assert(multi_component_container_c<CompContainer2, C1, C2>);
+        static_assert(multi_component_container_c<CompContainer2, C, C1, C2>);
+    }
 }
 
 } // namespace power_grid_model

From f339e21ca978e07ef9a212986900a9ab35760a10 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Fri, 22 Aug 2025 10:24:19 +0200
Subject: [PATCH 14/17] move to detail namespace

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/main_core/topology.hpp   | 135 +++++++++---------
 1 file changed, 67 insertions(+), 68 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index b5da43b436..23972ce2e4 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -24,8 +24,6 @@ constexpr void apply_registration(ComponentContainer const& components, std::vec
     std::transform(begin, end, target.begin(), std::forward<ResFunc>(func));
 }
 
-} // namespace detail
-
 template <std::same_as<Node> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
@@ -35,7 +33,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<Branch> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
+    apply_registration<Component>(components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
         return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
                          get_component_sequence_idx<Node>(components, branch.to_node())};
     });
@@ -44,18 +42,17 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<Branch3> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(
-        components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
-            return Branch3Idx{get_component_sequence_idx<Node>(components, branch3.node_1()),
-                              get_component_sequence_idx<Node>(components, branch3.node_2()),
-                              get_component_sequence_idx<Node>(components, branch3.node_3())};
-        });
+    apply_registration<Component>(components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
+        return Branch3Idx{get_component_sequence_idx<Node>(components, branch3.node_1()),
+                          get_component_sequence_idx<Node>(components, branch3.node_2()),
+                          get_component_sequence_idx<Node>(components, branch3.node_3())};
+    });
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(components, comp_topo.source_node_idx, [&components](Source const& source) {
+    apply_registration<Component>(components, comp_topo.source_node_idx, [&components](Source const& source) {
         return get_component_sequence_idx<Node>(components, source.node());
     });
 }
@@ -63,7 +60,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<Shunt> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(components, comp_topo.shunt_node_idx, [&components](Shunt const& shunt) {
+    apply_registration<Component>(components, comp_topo.shunt_node_idx, [&components](Shunt const& shunt) {
         return get_component_sequence_idx<Node>(components, shunt.node());
     });
 }
@@ -71,19 +68,19 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(components, comp_topo.load_gen_node_idx,
-                                          [&components](GenericLoadGen const& load_gen) {
-                                              return get_component_sequence_idx<Node>(components, load_gen.node());
-                                          });
+    apply_registration<Component>(components, comp_topo.load_gen_node_idx,
+                                  [&components](GenericLoadGen const& load_gen) {
+                                      return get_component_sequence_idx<Node>(components, load_gen.node());
+                                  });
 
-    detail::apply_registration<Component>(components, comp_topo.load_gen_type,
-                                          [](GenericLoadGen const& load_gen) { return load_gen.type(); });
+    apply_registration<Component>(components, comp_topo.load_gen_type,
+                                  [](GenericLoadGen const& load_gen) { return load_gen.type(); });
 }
 
 template <std::same_as<GenericVoltageSensor> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(
+    apply_registration<Component>(
         components, comp_topo.voltage_sensor_node_idx, [&components](GenericVoltageSensor const& voltage_sensor) {
             return get_component_sequence_idx<Node>(components, voltage_sensor.measured_object());
         });
@@ -93,7 +90,7 @@ template <std::same_as<GenericPowerSensor> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen, Branch3,
                                          Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(
+    apply_registration<Component>(
         components, comp_topo.power_sensor_object_idx, [&components](GenericPowerSensor const& power_sensor) {
             using enum MeasuredTerminalType;
 
@@ -126,7 +123,7 @@ constexpr void register_topology_components(ComponentContainer const& components
             }
         });
 
-    detail::apply_registration<Component>(
+    apply_registration<Component>(
         components, comp_topo.power_sensor_terminal_type,
         [](GenericPowerSensor const& power_sensor) { return power_sensor.get_terminal_type(); });
 }
@@ -134,30 +131,30 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::same_as<GenericCurrentSensor> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(
-        components, comp_topo.current_sensor_object_idx, [&components](GenericCurrentSensor const& current_sensor) {
-            using enum MeasuredTerminalType;
-
-            auto const measured_object = current_sensor.measured_object();
-
-            switch (current_sensor.get_terminal_type()) {
-            case branch_from:
-                [[fallthrough]];
-            case branch_to:
-                return get_component_sequence_idx<Branch>(components, measured_object);
-            case branch3_1:
-                [[fallthrough]];
-            case branch3_2:
-                [[fallthrough]];
-            case branch3_3:
-                return get_component_sequence_idx<Branch3>(components, measured_object);
-            default:
-                throw MissingCaseForEnumError("Current sensor idx to seq transformation",
-                                              current_sensor.get_terminal_type());
-            }
-        });
-
-    detail::apply_registration<Component>(
+    apply_registration<Component>(components, comp_topo.current_sensor_object_idx,
+                                  [&components](GenericCurrentSensor const& current_sensor) {
+                                      using enum MeasuredTerminalType;
+
+                                      auto const measured_object = current_sensor.measured_object();
+
+                                      switch (current_sensor.get_terminal_type()) {
+                                      case branch_from:
+                                          [[fallthrough]];
+                                      case branch_to:
+                                          return get_component_sequence_idx<Branch>(components, measured_object);
+                                      case branch3_1:
+                                          [[fallthrough]];
+                                      case branch3_2:
+                                          [[fallthrough]];
+                                      case branch3_3:
+                                          return get_component_sequence_idx<Branch3>(components, measured_object);
+                                      default:
+                                          throw MissingCaseForEnumError("Current sensor idx to seq transformation",
+                                                                        current_sensor.get_terminal_type());
+                                      }
+                                  });
+
+    apply_registration<Component>(
         components, comp_topo.current_sensor_terminal_type,
         [](GenericCurrentSensor const& current_sensor) { return current_sensor.get_terminal_type(); });
 }
@@ -165,7 +162,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 template <std::derived_from<Regulator> Component, class ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
-    detail::apply_registration<Component>(
+    apply_registration<Component>(
         components, comp_topo.regulated_object_idx, [&components](Regulator const& regulator) {
             switch (regulator.regulated_object_type()) {
             case ComponentType::branch:
@@ -177,52 +174,54 @@ constexpr void register_topology_components(ComponentContainer const& components
             }
         });
 
-    detail::apply_registration<Component>(components, comp_topo.regulated_object_type,
-                                          [](Regulator const& regulator) { return regulator.regulated_object_type(); });
+    apply_registration<Component>(components, comp_topo.regulated_object_type,
+                                  [](Regulator const& regulator) { return regulator.regulated_object_type(); });
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
-    detail::apply_registration<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
+    apply_registration<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
         return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
     });
-    detail::apply_registration<Component>(components, comp_conn.branch_phase_shift,
-                                          [](Branch const& branch) { return branch.phase_shift(); });
+    apply_registration<Component>(components, comp_conn.branch_phase_shift,
+                                  [](Branch const& branch) { return branch.phase_shift(); });
 }
 template <std::same_as<Branch3> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
-    detail::apply_registration<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
+    apply_registration<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
         return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
                                 static_cast<IntS>(branch3.status_3())};
     });
-    detail::apply_registration<Component>(components, comp_conn.branch3_phase_shift,
-                                          [](Branch3 const& branch3) { return branch3.phase_shift(); });
+    apply_registration<Component>(components, comp_conn.branch3_phase_shift,
+                                  [](Branch3 const& branch3) { return branch3.phase_shift(); });
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
     requires component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
-    detail::apply_registration<Component>(components, comp_conn.source_connected,
-                                          [](Source const& source) { return source.status(); });
+    apply_registration<Component>(components, comp_conn.source_connected,
+                                  [](Source const& source) { return source.status(); });
 }
 
+} // namespace detail
+
 template <typename ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
                                          GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor, Regulator>
 ComponentTopology construct_topology(ComponentContainer const& components) {
     ComponentTopology comp_topo;
-    register_topology_components<Node>(components, comp_topo);
-    register_topology_components<Branch>(components, comp_topo);
-    register_topology_components<Branch3>(components, comp_topo);
-    register_topology_components<Source>(components, comp_topo);
-    register_topology_components<Shunt>(components, comp_topo);
-    register_topology_components<GenericLoadGen>(components, comp_topo);
-    register_topology_components<GenericVoltageSensor>(components, comp_topo);
-    register_topology_components<GenericPowerSensor>(components, comp_topo);
-    register_topology_components<GenericCurrentSensor>(components, comp_topo);
-    register_topology_components<Regulator>(components, comp_topo);
+    detail::register_topology_components<Node>(components, comp_topo);
+    detail::register_topology_components<Branch>(components, comp_topo);
+    detail::register_topology_components<Branch3>(components, comp_topo);
+    detail::register_topology_components<Source>(components, comp_topo);
+    detail::register_topology_components<Shunt>(components, comp_topo);
+    detail::register_topology_components<GenericLoadGen>(components, comp_topo);
+    detail::register_topology_components<GenericVoltageSensor>(components, comp_topo);
+    detail::register_topology_components<GenericPowerSensor>(components, comp_topo);
+    detail::register_topology_components<GenericCurrentSensor>(components, comp_topo);
+    detail::register_topology_components<Regulator>(components, comp_topo);
     return comp_topo;
 }
 
@@ -230,9 +229,9 @@ template <typename ComponentContainer>
     requires multi_component_container_c<ComponentContainer, Branch, Branch3, Source>
 ComponentConnections construct_components_connections(ComponentContainer const& components) {
     ComponentConnections comp_conn;
-    register_connections_components<Branch>(components, comp_conn);
-    register_connections_components<Branch3>(components, comp_conn);
-    register_connections_components<Source>(components, comp_conn);
+    detail::register_connections_components<Branch>(components, comp_conn);
+    detail::register_connections_components<Branch3>(components, comp_conn);
+    detail::register_connections_components<Source>(components, comp_conn);
     return comp_conn;
 }
 

From 0711e1000c49b65c25b9c7e7aa289e3251119050 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Fri, 22 Aug 2025 10:35:19 +0200
Subject: [PATCH 15/17] add to common namespace

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/container_fwd.hpp        |  4 +-
 .../main_core/container_queries.hpp           |  4 +-
 .../power_grid_model/main_core/state.hpp      |  2 +-
 .../power_grid_model/main_core/topology.hpp   | 37 ++++++++++---------
 .../power_grid_model/optimizer/optimizer.hpp  |  2 +-
 .../optimizer/tap_position_optimizer.hpp      | 18 ++++-----
 tests/cpp_unit_tests/test_container.cpp       | 24 ++++++------
 tests/cpp_unit_tests/test_optimizer.hpp       |  6 +--
 .../test_tap_position_optimizer.cpp           |  8 ++--
 9 files changed, 53 insertions(+), 52 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
index bc01a7a8a3..77178fc1d6 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -8,7 +8,7 @@
 
 #include <concepts>
 
-namespace power_grid_model {
+namespace power_grid_model::common {
 
 template <typename ContainerType, typename RetrievableType>
 concept component_container_c = requires(ContainerType const& c, ID id, Idx2D idx2d) {
@@ -24,4 +24,4 @@ concept component_container_c = requires(ContainerType const& c, ID id, Idx2D id
 template <typename ContainerType, typename... RetrievableType>
 concept multi_component_container_c = (component_container_c<ContainerType, RetrievableType> && ...);
 
-} // namespace power_grid_model
+} // namespace power_grid_model::common
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
index 109c22902f..50cd5fc65f 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
@@ -11,13 +11,13 @@ namespace power_grid_model::main_core {
 // TODO Reconfirm if there is duplication with state_queries and if we can remove either one of them
 
 template <typename ComponentType, class ComponentContainer>
-    requires component_container_c<ComponentContainer, ComponentType>
+    requires common::component_container_c<ComponentContainer, ComponentType>
 constexpr auto get_component_size(ComponentContainer const& components) {
     return components.template size<ComponentType>();
 }
 
 template <typename ComponentType, class ComponentContainer>
-    requires component_container_c<ComponentContainer, ComponentType>
+    requires common::component_container_c<ComponentContainer, ComponentType>
 inline Idx get_component_sequence_idx(ComponentContainer const& components, auto const& id_or_index) {
     return components.template get_seq<ComponentType>(id_or_index);
 }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
index 0dc3d62dea..ed8a6a0b8f 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp
@@ -30,7 +30,7 @@ concept main_model_state_c = std::same_as<StateType, MainModelState<typename Sta
 
 template <template <typename T> class StateType, typename ContainerType, typename ComponentType>
 concept model_component_state_c =
-    component_container_c<typename StateType<ContainerType>::ComponentContainer, ComponentType> &&
+    common::component_container_c<typename StateType<ContainerType>::ComponentContainer, ComponentType> &&
     std::same_as<StateType<ContainerType>, MainModelState<ContainerType>>;
 
 } // namespace power_grid_model::main_core
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index 23972ce2e4..c1b3ae9672 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -13,7 +13,7 @@ namespace power_grid_model::main_core {
 namespace detail {
 
 template <typename Component, class ComponentContainer, typename ResType, typename ResFunc>
-    requires component_container_c<ComponentContainer, Component> &&
+    requires common::component_container_c<ComponentContainer, Component> &&
              std::invocable<std::remove_cvref_t<ResFunc>, Component const&> &&
              std::convertible_to<std::invoke_result_t<ResFunc, Component const&>, ResType>
 constexpr void apply_registration(ComponentContainer const& components, std::vector<ResType>& target, ResFunc&& func) {
@@ -25,13 +25,13 @@ constexpr void apply_registration(ComponentContainer const& components, std::vec
 }
 
 template <std::same_as<Node> Component, class ComponentContainer>
-    requires component_container_c<ComponentContainer, Component>
+    requires common::component_container_c<ComponentContainer, Component>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     comp_topo.n_node = get_component_size<Node>(components);
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
         return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
@@ -40,7 +40,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Branch3> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
         return Branch3Idx{get_component_sequence_idx<Node>(components, branch3.node_1()),
@@ -50,7 +50,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.source_node_idx, [&components](Source const& source) {
         return get_component_sequence_idx<Node>(components, source.node());
@@ -58,7 +58,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Shunt> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.shunt_node_idx, [&components](Shunt const& shunt) {
         return get_component_sequence_idx<Node>(components, shunt.node());
@@ -66,7 +66,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.load_gen_node_idx,
                                   [&components](GenericLoadGen const& load_gen) {
@@ -78,7 +78,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericVoltageSensor> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::multi_component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(
         components, comp_topo.voltage_sensor_node_idx, [&components](GenericVoltageSensor const& voltage_sensor) {
@@ -87,8 +87,8 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericPowerSensor> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen, Branch3,
-                                         Node>
+    requires common::multi_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen,
+                                                 Branch3, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(
         components, comp_topo.power_sensor_object_idx, [&components](GenericPowerSensor const& power_sensor) {
@@ -129,7 +129,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericCurrentSensor> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
+    requires common::multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.current_sensor_object_idx,
                                   [&components](GenericCurrentSensor const& current_sensor) {
@@ -160,7 +160,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::derived_from<Regulator> Component, class ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
+    requires common::multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(
         components, comp_topo.regulated_object_idx, [&components](Regulator const& regulator) {
@@ -179,7 +179,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
-    requires component_container_c<ComponentContainer, Component>
+    requires common::component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
         return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
@@ -188,7 +188,7 @@ constexpr void register_connections_components(ComponentContainer components, Co
                                   [](Branch const& branch) { return branch.phase_shift(); });
 }
 template <std::same_as<Branch3> Component, class ComponentContainer>
-    requires component_container_c<ComponentContainer, Component>
+    requires common::component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
         return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
@@ -199,7 +199,7 @@ constexpr void register_connections_components(ComponentContainer components, Co
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
-    requires component_container_c<ComponentContainer, Component>
+    requires common::component_container_c<ComponentContainer, Component>
 constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.source_connected,
                                   [](Source const& source) { return source.status(); });
@@ -208,8 +208,9 @@ constexpr void register_connections_components(ComponentContainer components, Co
 } // namespace detail
 
 template <typename ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
-                                         GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor, Regulator>
+    requires common::multi_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
+                                                 GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor,
+                                                 Regulator>
 ComponentTopology construct_topology(ComponentContainer const& components) {
     ComponentTopology comp_topo;
     detail::register_topology_components<Node>(components, comp_topo);
@@ -226,7 +227,7 @@ ComponentTopology construct_topology(ComponentContainer const& components) {
 }
 
 template <typename ComponentContainer>
-    requires multi_component_container_c<ComponentContainer, Branch, Branch3, Source>
+    requires common::multi_component_container_c<ComponentContainer, Branch, Branch3, Source>
 ComponentConnections construct_components_connections(ComponentContainer const& components) {
     ComponentConnections comp_conn;
     detail::register_connections_components<Branch>(components, comp_conn);
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp
index 509d0ab0f2..a6fc278ce4 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp
@@ -29,7 +29,7 @@ constexpr auto get_optimizer(OptimizerType optimizer_type, OptimizerStrategy str
     case automatic_tap_adjustment:
         if constexpr (detail::steady_state_calculator_c<StateCalculator, State> &&
                       std::invocable<std::remove_cvref_t<StateUpdater>, ConstDataset const&> &&
-                      component_container_c<typename State::ComponentContainer, TransformerTapRegulator>) {
+                      common::component_container_c<typename State::ComponentContainer, TransformerTapRegulator>) {
             return BaseOptimizer::template make_shared<TapPositionOptimizer<StateCalculator, StateUpdater, State>>(
                 std::move(calculator), std::move(updater), strategy, meta_data, search);
         }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
index 65bf8f325e..2e39d6593c 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
@@ -471,7 +471,7 @@ template <transformer_c... TransformerTypes> struct TapRegulatorRef {
 };
 
 template <typename State>
-    requires component_container_c<typename State::ComponentContainer, TransformerTapRegulator>
+    requires common::component_container_c<typename State::ComponentContainer, TransformerTapRegulator>
 TransformerTapRegulator const& find_regulator(State const& state, ID regulated_object) {
     auto const regulators = get_component_citer<TransformerTapRegulator>(state);
 
@@ -503,7 +503,7 @@ template <typename... Ts> struct transformer_types_s<std::tuple<std::tuple<Ts...
 template <typename... Ts> using transformer_types_t = typename transformer_types_s<std::tuple<Ts...>>::type;
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(common::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline TapRegulatorRef<TransformerTypes...> regulator_mapping(State const& state, Idx2D const& transformer_index) {
     using ResultType = TapRegulatorRef<TransformerTypes...>;
     using IsType = bool (*)(Idx2D const&);
@@ -536,7 +536,7 @@ inline TapRegulatorRef<TransformerTypes...> regulator_mapping(State const& state
 }
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(common::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline auto regulator_mapping(State const& state, std::vector<Idx2D> const& order) {
     std::vector<TapRegulatorRef<TransformerTypes...>> result;
     result.reserve(order.size());
@@ -549,7 +549,7 @@ inline auto regulator_mapping(State const& state, std::vector<Idx2D> const& orde
 }
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(common::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline auto regulator_mapping(State const& state, RankedTransformerGroups const& order) {
     std::vector<std::vector<TapRegulatorRef<TransformerTypes...>>> result;
     result.reserve(order.size());
@@ -598,7 +598,7 @@ inline auto i_pu(std::vector<SolverOutputType> const& solver_output, Idx2DBranch
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto i_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regulator, State const& state,
                                  std::vector<SolverOutputType> const& solver_output) {
     auto const& branch_math_id = get_math_id<ComponentType>(state, regulator.transformer.topology_index());
@@ -606,7 +606,7 @@ inline auto i_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regul
 }
 
 template <transformer_c ComponentType, typename State, steady_state_solver_output_type SolverOutputType>
-    requires component_container_c<typename State::ComponentContainer, ComponentType> &&
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType> &&
              requires(State const& state, Idx const i) {
                  { get_branch_nodes<ComponentType>(state, i)[i] } -> std::convertible_to<Idx>;
              }
@@ -619,7 +619,7 @@ inline auto u_pu(State const& state, std::vector<SolverOutputType> const& solver
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regulator, State const& state,
                                  std::vector<SolverOutputType> const& solver_output) {
     return u_pu<ComponentType>(state, solver_output, regulator.transformer.topology_index(),
@@ -627,7 +627,7 @@ inline auto u_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regul
 }
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 inline bool is_regulated_transformer_connected(TapRegulatorRef<RegulatedTypes...> const& regulator,
                                                State const& state) {
     auto const controlled_node_idx = get_topo_node<ComponentType>(state, regulator.transformer.topology_index(),
@@ -702,7 +702,7 @@ class RankIteration {
 template <typename... T> class TapPositionOptimizerImpl;
 template <transformer_c... TransformerTypes, typename StateCalculator, typename StateUpdater_, typename State_,
           typename TransformerRanker_>
-    requires(component_container_c<typename State_::ComponentContainer, TransformerTypes> && ...) &&
+    requires(common::component_container_c<typename State_::ComponentContainer, TransformerTypes> && ...) &&
             detail::steady_state_calculator_c<StateCalculator, State_> &&
             std::invocable<std::remove_cvref_t<StateUpdater_>, ConstDataset const&> &&
             requires(TransformerRanker_ const& ranker, State_ const& state) {
diff --git a/tests/cpp_unit_tests/test_container.cpp b/tests/cpp_unit_tests/test_container.cpp
index 88e1a94088..24fe83d458 100644
--- a/tests/cpp_unit_tests/test_container.cpp
+++ b/tests/cpp_unit_tests/test_container.cpp
@@ -225,18 +225,18 @@ TEST_CASE("Test component container") {
 #endif // NDEBUG
 
     SUBCASE("Component Container concept") {
-        static_assert(component_container_c<CompContainer, C>);
-        static_assert(component_container_c<CompContainer, C1>);
-        static_assert(component_container_c<CompContainer, C2>);
-        static_assert(component_container_c<CompContainer2, C>);
-        static_assert(component_container_c<CompContainer2, C1>);
-        static_assert(component_container_c<CompContainer2, C2>);
-        static_assert(multi_component_container_c<CompContainer, C, C1>);
-        static_assert(multi_component_container_c<CompContainer, C1, C2>);
-        static_assert(multi_component_container_c<CompContainer, C, C1, C2>);
-        static_assert(multi_component_container_c<CompContainer2, C, C1>);
-        static_assert(multi_component_container_c<CompContainer2, C1, C2>);
-        static_assert(multi_component_container_c<CompContainer2, C, C1, C2>);
+        static_assert(common::component_container_c<CompContainer, C>);
+        static_assert(common::component_container_c<CompContainer, C1>);
+        static_assert(common::component_container_c<CompContainer, C2>);
+        static_assert(common::component_container_c<CompContainer2, C>);
+        static_assert(common::component_container_c<CompContainer2, C1>);
+        static_assert(common::component_container_c<CompContainer2, C2>);
+        static_assert(common::multi_component_container_c<CompContainer, C, C1>);
+        static_assert(common::multi_component_container_c<CompContainer, C1, C2>);
+        static_assert(common::multi_component_container_c<CompContainer, C, C1, C2>);
+        static_assert(common::multi_component_container_c<CompContainer2, C, C1>);
+        static_assert(common::multi_component_container_c<CompContainer2, C1, C2>);
+        static_assert(common::multi_component_container_c<CompContainer2, C, C1, C2>);
     }
 }
 
diff --git a/tests/cpp_unit_tests/test_optimizer.hpp b/tests/cpp_unit_tests/test_optimizer.hpp
index 5f80a6b148..d439a3c994 100644
--- a/tests/cpp_unit_tests/test_optimizer.hpp
+++ b/tests/cpp_unit_tests/test_optimizer.hpp
@@ -54,13 +54,13 @@ static_assert(transformer_c<StubTransformerA>);
 static_assert(transformer_c<StubTransformerB>);
 
 template <std::derived_from<StubTransformer> ComponentType, typename State>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_topology_index(State const& /* state */, auto const& /* id_or_index */) {
     return Idx{};
 }
 
 template <std::derived_from<StubTransformer> ComponentType, typename State>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_math_id(State const& /* state */, Idx /* topology_sequence_idx */) {
     return StubTransformerMathIdType{};
 }
@@ -73,7 +73,7 @@ inline auto i_pu(std::vector<SolverOutputType> const& /* solver_output */,
 
 template <std::derived_from<StubTransformer> ComponentType, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu(State const& /* state */, std::vector<SolverOutputType> const& /* solver_output */,
                  Idx /* topology_index */, ControlSide /* control_side */) {
     return ComplexValue<typename SolverOutputType::sym>{};
diff --git a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
index da6e055872..81a75ceee8 100644
--- a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
+++ b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
@@ -624,7 +624,7 @@ class MockSolverOutput : public SolverOutput<symmetric_t> {
     template <typename... T> struct AddTapPositions;
     template <typename T> struct AddTapPositions<T> {
         void operator()(main_core::MainModelState<ContainerType> const& state, std::map<ID, IntS>& target) {
-            if constexpr (transformer_c<T> && component_container_c<ContainerType, T>) {
+            if constexpr (transformer_c<T> && common::component_container_c<ContainerType, T>) {
                 for (auto const& component : state.components.template citer<T>()) {
                     target[component.id()] = component.tap_pos();
                 }
@@ -732,14 +732,14 @@ struct MockTransformer {
 static_assert(transformer_c<MockTransformer>);
 
 template <std::derived_from<MockTransformer> ComponentType, typename State>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_topology_index(State const& state, auto const& id_or_index) {
     auto const& transformer = main_core::get_component<ComponentType>(state, id_or_index);
     return transformer.state.math_id.pos;
 }
 
 template <std::derived_from<MockTransformer> ComponentType, typename State>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_math_id(State const& state, Idx topology_index) {
     return main_core::get_component_by_sequence<MockTransformer>(state, topology_index).state.math_id;
 }
@@ -763,7 +763,7 @@ inline DoubleComplex i_pu(std::vector<MockSolverOutput<ContainerType>> const& so
 
 template <std::derived_from<MockTransformer> ComponentType, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires component_container_c<typename State::ComponentContainer, ComponentType>
+    requires common::component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu(State const& state, std::vector<SolverOutputType> const& /* solver_output */, Idx topology_index,
                  ControlSide side) {
     return main_core::get_component_by_sequence<MockTransformer>(state, topology_index).state.u_pu(side);

From 077f892c8a7012531c888966f2f2e5c04aba923a Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Fri, 22 Aug 2025 11:58:35 +0200
Subject: [PATCH 16/17] merge both concepts to one

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../power_grid_model/container_fwd.hpp        |  9 +++----
 .../power_grid_model/main_core/topology.hpp   | 27 +++++++++----------
 tests/cpp_unit_tests/test_container.cpp       | 12 ++++-----
 3 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
index 77178fc1d6..5ae5a8cda8 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -10,8 +10,8 @@
 
 namespace power_grid_model::common {
 
-template <typename ContainerType, typename RetrievableType>
-concept component_container_c = requires(ContainerType const& c, ID id, Idx2D idx2d) {
+template <typename ContainerType, typename... RetrievableType>
+concept component_container_c = (requires(ContainerType const& c, ID id, Idx2D idx2d) {
     { c.template citer<RetrievableType>().begin() } -> std::forward_iterator;
     { c.template citer<RetrievableType>().end() } -> std::forward_iterator;
     { *(c.template citer<RetrievableType>().begin()) } -> std::same_as<RetrievableType const&>;
@@ -19,9 +19,6 @@ concept component_container_c = requires(ContainerType const& c, ID id, Idx2D id
     { c.template get_item<RetrievableType>(id) } -> std::convertible_to<RetrievableType const&>;
     { c.template size<RetrievableType>() } -> std::same_as<Idx>;
     { c.template get_seq<RetrievableType>(idx2d) } -> std::same_as<Idx>;
-};
-
-template <typename ContainerType, typename... RetrievableType>
-concept multi_component_container_c = (component_container_c<ContainerType, RetrievableType> && ...);
+} && ...);
 
 } // namespace power_grid_model::common
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index c1b3ae9672..343224039d 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -31,7 +31,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
         return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
@@ -40,7 +40,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Branch3> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
         return Branch3Idx{get_component_sequence_idx<Node>(components, branch3.node_1()),
@@ -50,7 +50,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.source_node_idx, [&components](Source const& source) {
         return get_component_sequence_idx<Node>(components, source.node());
@@ -58,7 +58,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<Shunt> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.shunt_node_idx, [&components](Shunt const& shunt) {
         return get_component_sequence_idx<Node>(components, shunt.node());
@@ -66,7 +66,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.load_gen_node_idx,
                                   [&components](GenericLoadGen const& load_gen) {
@@ -78,7 +78,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericVoltageSensor> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Node>
+    requires common::component_container_c<ComponentContainer, Component, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(
         components, comp_topo.voltage_sensor_node_idx, [&components](GenericVoltageSensor const& voltage_sensor) {
@@ -87,8 +87,8 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericPowerSensor> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen,
-                                                 Branch3, Node>
+    requires common::component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen,
+                                           Branch3, Node>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(
         components, comp_topo.power_sensor_object_idx, [&components](GenericPowerSensor const& power_sensor) {
@@ -129,7 +129,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::same_as<GenericCurrentSensor> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
+    requires common::component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(components, comp_topo.current_sensor_object_idx,
                                   [&components](GenericCurrentSensor const& current_sensor) {
@@ -160,7 +160,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 }
 
 template <std::derived_from<Regulator> Component, class ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Component, Branch, Branch3>
+    requires common::component_container_c<ComponentContainer, Component, Branch, Branch3>
 constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     apply_registration<Component>(
         components, comp_topo.regulated_object_idx, [&components](Regulator const& regulator) {
@@ -208,9 +208,8 @@ constexpr void register_connections_components(ComponentContainer components, Co
 } // namespace detail
 
 template <typename ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
-                                                 GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor,
-                                                 Regulator>
+    requires common::component_container_c<ComponentContainer, Branch, Branch3, Source, Shunt, GenericLoadGen,
+                                           GenericVoltageSensor, GenericPowerSensor, GenericCurrentSensor, Regulator>
 ComponentTopology construct_topology(ComponentContainer const& components) {
     ComponentTopology comp_topo;
     detail::register_topology_components<Node>(components, comp_topo);
@@ -227,7 +226,7 @@ ComponentTopology construct_topology(ComponentContainer const& components) {
 }
 
 template <typename ComponentContainer>
-    requires common::multi_component_container_c<ComponentContainer, Branch, Branch3, Source>
+    requires common::component_container_c<ComponentContainer, Branch, Branch3, Source>
 ComponentConnections construct_components_connections(ComponentContainer const& components) {
     ComponentConnections comp_conn;
     detail::register_connections_components<Branch>(components, comp_conn);
diff --git a/tests/cpp_unit_tests/test_container.cpp b/tests/cpp_unit_tests/test_container.cpp
index 24fe83d458..7663e768eb 100644
--- a/tests/cpp_unit_tests/test_container.cpp
+++ b/tests/cpp_unit_tests/test_container.cpp
@@ -228,15 +228,15 @@ TEST_CASE("Test component container") {
         static_assert(common::component_container_c<CompContainer, C>);
         static_assert(common::component_container_c<CompContainer, C1>);
         static_assert(common::component_container_c<CompContainer, C2>);
+        static_assert(common::component_container_c<CompContainer, C, C1>);
+        static_assert(common::component_container_c<CompContainer, C1, C2>);
+        static_assert(common::component_container_c<CompContainer, C, C1, C2>);
         static_assert(common::component_container_c<CompContainer2, C>);
         static_assert(common::component_container_c<CompContainer2, C1>);
         static_assert(common::component_container_c<CompContainer2, C2>);
-        static_assert(common::multi_component_container_c<CompContainer, C, C1>);
-        static_assert(common::multi_component_container_c<CompContainer, C1, C2>);
-        static_assert(common::multi_component_container_c<CompContainer, C, C1, C2>);
-        static_assert(common::multi_component_container_c<CompContainer2, C, C1>);
-        static_assert(common::multi_component_container_c<CompContainer2, C1, C2>);
-        static_assert(common::multi_component_container_c<CompContainer2, C, C1, C2>);
+        static_assert(common::component_container_c<CompContainer2, C, C1>);
+        static_assert(common::component_container_c<CompContainer2, C1, C2>);
+        static_assert(common::component_container_c<CompContainer2, C, C1, C2>);
     }
 }
 

From 79c1da4d5fe81baf2f3a3c6c36266b3db9078ce7 Mon Sep 17 00:00:00 2001
From: Nitish Bharambe <nitish.bharambe@alliander.com>
Date: Tue, 26 Aug 2025 10:31:43 +0200
Subject: [PATCH 17/17] workaround compiler bug and address end()

Signed-off-by: Nitish Bharambe <nitish.bharambe@alliander.com>
---
 .../include/power_grid_model/container_fwd.hpp    | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
index 5ae5a8cda8..5b0f7dc5bc 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -10,15 +10,22 @@
 
 namespace power_grid_model::common {
 
-template <typename ContainerType, typename... RetrievableType>
-concept component_container_c = (requires(ContainerType const& c, ID id, Idx2D idx2d) {
+namespace detail {
+template <typename ContainerType, typename RetrievableType>
+concept single_component_container_c = requires(ContainerType const& c, ID id, Idx2D idx2d) {
     { c.template citer<RetrievableType>().begin() } -> std::forward_iterator;
     { c.template citer<RetrievableType>().end() } -> std::forward_iterator;
     { *(c.template citer<RetrievableType>().begin()) } -> std::same_as<RetrievableType const&>;
-    { *(c.template citer<RetrievableType>().end()) } -> std::same_as<RetrievableType const&>;
+    {
+        c.template citer<RetrievableType>().end()
+    } -> std::same_as<decltype(c.template citer<RetrievableType>().begin())>;
     { c.template get_item<RetrievableType>(id) } -> std::convertible_to<RetrievableType const&>;
     { c.template size<RetrievableType>() } -> std::same_as<Idx>;
     { c.template get_seq<RetrievableType>(idx2d) } -> std::same_as<Idx>;
-} && ...);
+};
+} // namespace detail
+
+template <typename ContainerType, typename... RetrievableType>
+concept component_container_c = (detail::single_component_container_c<ContainerType, RetrievableType> && ...);
 
 } // namespace power_grid_model::common