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..5b0f7dc5bc
--- /dev/null
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp
@@ -0,0 +1,31 @@
+// 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::common {
+
+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<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
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..50cd5fc65f
--- /dev/null
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/container_queries.hpp
@@ -0,0 +1,25 @@
+// 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 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 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);
+}
+
+} // namespace power_grid_model::main_core
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..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
@@ -28,18 +28,9 @@ 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 <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/state_queries.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state_queries.hpp
index 4d92566c7d..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
@@ -9,6 +9,7 @@
 #include "../all_components.hpp"
 
 namespace power_grid_model::main_core {
+
 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 745e5f1dc3..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
@@ -4,8 +4,7 @@
 
 #pragma once
 
-#include "state.hpp"
-#include "state_queries.hpp"
+#include "container_queries.hpp"
 
 #include "../all_components.hpp"
 
@@ -14,94 +13,85 @@ 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 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 register_topo_components(MainModelState<ComponentContainer> const& state, std::vector<ResType>& target,
-                                        ResFunc&& func) {
-    auto const begin = get_component_citer<Component>(state).begin();
-    auto const end = get_component_citer<Component>(state).end();
+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();
 
     target.resize(std::distance(begin, end));
     std::transform(begin, end, target.begin(), std::forward<ResFunc>(func));
 }
 
-} // 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);
+    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 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, branch.from_node()),
-                         get_component_sequence_idx<Node>(state, branch.to_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()),
+                         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, branch3.node_1()),
-                          get_component_sequence_idx<Node>(state, branch3.node_2()),
-                          get_component_sequence_idx<Node>(state, branch3.node_3())};
+    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()),
+                          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, source.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());
     });
 }
 
 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, shunt.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());
     });
 }
 
 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) {
-    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()); });
-
-    detail::register_topo_components<Component>(state, comp_topo.load_gen_type,
-                                                [](GenericLoadGen const& load_gen) { return load_gen.type(); });
+    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) {
+                                      return get_component_sequence_idx<Node>(components, load_gen.node());
+                                  });
+
+    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 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.voltage_sensor_node_idx, [&state](GenericVoltageSensor const& voltage_sensor) {
-            return get_component_sequence_idx<Node>(state, voltage_sensor.measured_object());
+    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) {
+            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) {
-    detail::register_topo_components<Component>(
-        state, comp_topo.power_sensor_object_idx, [&state](GenericPowerSensor const& power_sensor) {
+    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) {
             using enum MeasuredTerminalType;
 
             auto const measured_object = power_sensor.measured_object();
@@ -110,85 +100,139 @@ 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>(components, measured_object);
             case source:
-                return get_component_sequence_idx<Source>(state, measured_object);
+                return get_component_sequence_idx<Source>(components, measured_object);
             case shunt:
-                return get_component_sequence_idx<Shunt>(state, measured_object);
+                return get_component_sequence_idx<Shunt>(components, measured_object);
             case load:
                 [[fallthrough]];
             case generator:
-                return get_component_sequence_idx<GenericLoadGen>(state, 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, measured_object);
+                return get_component_sequence_idx<Branch3>(components, measured_object);
             case node:
-                return get_component_sequence_idx<Node>(state, 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());
             }
         });
 
-    detail::register_topo_components<Component>(
-        state, comp_topo.power_sensor_terminal_type,
+    apply_registration<Component>(
+        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) {
-    detail::register_topo_components<Component>(
-        state, comp_topo.current_sensor_object_idx, [&state](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>(state, measured_object);
-            case branch3_1:
-                [[fallthrough]];
-            case branch3_2:
-                [[fallthrough]];
-            case branch3_3:
-                return get_component_sequence_idx<Branch3>(state, measured_object);
-            default:
-                throw MissingCaseForEnumError("Current sensor idx to seq transformation",
-                                              current_sensor.get_terminal_type());
-            }
-        });
-
-    detail::register_topo_components<Component>(
-        state, comp_topo.current_sensor_terminal_type,
+    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) {
+                                      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(); });
 }
 
 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) {
-    detail::register_topo_components<Component>(
-        state, comp_topo.regulated_object_idx, [&state](Regulator const& regulator) {
+    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) {
             switch (regulator.regulated_object_type()) {
             case ComponentType::branch:
-                return get_component_sequence_idx<Branch>(state, regulator.regulated_object());
+                return get_component_sequence_idx<Branch>(components, regulator.regulated_object());
             case ComponentType::branch3:
-                return get_component_sequence_idx<Branch3>(state, 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();
+    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 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())};
     });
+    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 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()),
+                                static_cast<IntS>(branch3.status_3())};
+    });
+    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 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(); });
+}
+
+} // namespace detail
+
+template <typename ComponentContainer>
+    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);
+    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;
+}
+
+template <typename ComponentContainer>
+    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);
+    detail::register_connections_components<Branch3>(components, comp_conn);
+    detail::register_connections_components<Source>(components, comp_conn);
+    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..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,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_.components));
     }
 
     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 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();
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..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&> &&
-                      main_core::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 3475a7e048..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 main_core::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(main_core::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(main_core::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(main_core::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 main_core::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 main_core::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 main_core::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 main_core::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(main_core::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 a6bd14e8f9..7663e768eb 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(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::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>);
+    }
 }
 
 } // namespace power_grid_model
diff --git a/tests/cpp_unit_tests/test_optimizer.hpp b/tests/cpp_unit_tests/test_optimizer.hpp
index ae5def1a85..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 main_core::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 main_core::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 main_core::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 245b105934..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> && main_core::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 main_core::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 main_core::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 main_core::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);