Allow meshed control transformers

power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp

@@ -41,7 +41,8 @@ using EdgeWeight = int64_t;
 using RankedTransformerGroups = std::vector<std::vector<Idx2D>>;
 
 constexpr auto infty = std::numeric_limits<Idx>::max();
-constexpr Idx2D unregulated_idx = {.group = -1, .pos = -1};
+constexpr auto last_rank = infty - 1;
+constexpr Idx2D unregulated_idx = {-1, -1};
 struct TrafoGraphVertex {
     bool is_source{};
 };
@@ -284,9 +285,6 @@ inline void process_edges_dijkstra(Idx v, std::vector<EdgeWeight>& vertex_distan
             if (u == s && vertex_distances[s] + weight < vertex_distances[t]) {
                 vertex_distances[t] = vertex_distances[s] + weight;
                 pq.emplace(vertex_distances[t], t);
-            } else if (u == t && vertex_distances[t] + weight < vertex_distances[s]) {
-                vertex_distances[s] = vertex_distances[t] + weight;
-                pq.emplace(vertex_distances[s], s);
             }
         }
     }
@@ -328,11 +326,16 @@ inline auto get_edge_weights(TransformerGraph const& graph) -> TrafoGraphEdgePro
         // situations can happen.
         // The logic still holds in meshed grids, albeit operating a more complex graph.
         if (!is_unreachable(edge_src_rank) || !is_unreachable(edge_tgt_rank)) {
-            if (edge_src_rank != edge_tgt_rank - 1) {
-                throw AutomaticTapInputError("The control side of a transformer regulator should be relatively further "
-                                             "away from the source than the tap side.\n");
+            if ((edge_src_rank == infty) || (edge_tgt_rank == infty)) {
+                throw AutomaticTapInputError("The transformer is being controlled from non source side towards source "
+                                             "side.\n");
+            } else if (edge_src_rank != edge_tgt_rank - 1) {
+                // Control side is also controlled by a closer regulated transformer.
+                // Make this transformer have the lowest possible priority.
+                result.emplace_back(graph[e].regulated_idx, last_rank);
+            } else {
+                result.emplace_back(graph[e].regulated_idx, edge_tgt_rank);
             }
-            result.emplace_back(graph[e].regulated_idx, edge_tgt_rank);
         }
     }
 

tests/cpp_unit_tests/test_tap_position_optimizer.cpp

@@ -422,7 +422,10 @@ TEST_CASE("Test Transformer ranking") {
 
         SUBCASE("Ranking complete the graph") {
             // The test grid 1 is not compatible with the updated logic for step up transformers
-            CHECK_THROWS_AS(pgm_tap::rank_transformers(state), AutomaticTapInputError);
+            pgm_tap::RankedTransformerGroups order = pgm_tap::rank_transformers(state);
+            pgm_tap::RankedTransformerGroups const ref_order{
+                {{Idx2D{3, 0}, Idx2D{3, 1}, Idx2D{4, 0}}, {Idx2D{3, 2}}, {Idx2D{3, 3}, Idx2D{3, 4}}}};
+            CHECK(order == ref_order);
         }
     }
 
@@ -507,6 +510,62 @@ TEST_CASE("Test Transformer ranking") {
              {Idx2D{.group = 3, .pos = 2}, Idx2D{.group = 3, .pos = 3}, Idx2D{.group = 3, .pos = 5}}}};
         CHECK(order == ref_order);
     }
+
+    SUBCASE("Full grid 3 - For Meshed grid with low priority ranks") {
+        // =====Test Grid=====
+        // ________[0]________
+        //  |              |
+        //  |              |
+        //  |              [1]
+        //  |              |
+        // _|______[2]_____|__
+        //          |
+        //         [3]
+        TestState state;
+        std::vector<NodeInput> nodes{{0, 10e3}, {1, 10e3}, {2, 10e3}, {3, 10e3}};
+        main_core::add_component<Node>(state, nodes.begin(), nodes.end(), 50.0);
+
+        std::vector<TransformerInput> transformers{get_transformer(11, 0, 1, BranchSide::to),
+                                                   get_transformer(12, 1, 2, BranchSide::from),
+                                                   get_transformer(13, 2, 3, BranchSide::from)};
+        main_core::add_component<Transformer>(state, transformers.begin(), transformers.end(), 50.0);
+
+        std::vector<LineInput> lines{get_line_input(21, 0, 2)};
+        main_core::add_component<Line>(state, lines.begin(), lines.end(), 50.0);
+
+        std::vector<SourceInput> sources{{31, 0, 1, 1.0, 0, nan, nan, nan}};
+        main_core::add_component<Source>(state, sources.begin(), sources.end(), 50.0);
+
+        std::vector<TransformerTapRegulatorInput> regulators{get_regulator(41, 11, ControlSide::to),
+                                                             get_regulator(42, 12, ControlSide::to),
+                                                             get_regulator(43, 13, ControlSide::to)};
+        main_core::add_component<TransformerTapRegulator>(state, regulators.begin(), regulators.end(), 50.0);
+
+        state.components.set_construction_complete();
+
+        pgm_tap::RankedTransformerGroups order = pgm_tap::rank_transformers(state);
+        pgm_tap::RankedTransformerGroups const ref_order{{{Idx2D{3, 0}}, {Idx2D{3, 2}}}, {{Idx2D{3, 1}}}};
+        CHECK(order == ref_order);
+    }
+
+    SUBCASE("Controlling from non source to source transformer") {
+        TestState state;
+        std::vector<NodeInput> nodes{{.id = 0, .u_rated = 150e3}, {.id = 1, .u_rated = 10e3}};
+        main_core::add_component<Node>(state, nodes.begin(), nodes.end(), 50.0);
+
+        std::vector<TransformerInput> transformers{get_transformer(2, 0, 1, BranchSide::from)};
+        main_core::add_component<Transformer>(state, transformers.begin(), transformers.end(), 50.0);
+
+        std::vector<SourceInput> sources{SourceInput{.id = 3, .node = 0, .status = IntS{1}, .u_ref = 1.0}};
+        main_core::add_component<Source>(state, sources.begin(), sources.end(), 50.0);
+
+        std::vector<TransformerTapRegulatorInput> regulators{get_regulator(4, 2, ControlSide::from)};
+        main_core::add_component<TransformerTapRegulator>(state, regulators.begin(), regulators.end(), 50.0);
+
+        state.components.set_construction_complete();
+
+        CHECK_THROWS_AS(pgm_tap::rank_transformers(state), AutomaticTapInputError);
+    }
 }
 
 namespace optimizer::tap_position_optimizer::test {

tests/unit/test_error_handling.py

@@ -315,10 +315,22 @@ def test_transformer_tap_regulator_control_side_not_closer_to_source():
     transformer_input["to_node"] = [1]
     transformer_input["from_status"] = [1]
     transformer_input["to_status"] = [1]
+    transformer_input["u1"] = [1e4]
+    transformer_input["u2"] = [4e2]
+    transformer_input["sn"] = [1e5]
+    transformer_input["uk"] = [0.1]
+    transformer_input["pk"] = [1e3]
+    transformer_input["i0"] = [1.0e-6]
+    transformer_input["p0"] = [0.1]
     transformer_input["winding_from"] = [1]
     transformer_input["winding_to"] = [1]
     transformer_input["clock"] = [0]
     transformer_input["tap_side"] = [1]
+    transformer_input["tap_pos"] = [0]
+    transformer_input["tap_nom"] = [0]
+    transformer_input["tap_min"] = [-1]
+    transformer_input["tap_max"] = [1]
+    transformer_input["tap_size"] = [100]
 
     source_input = initialize_array("input", "source", 1)
     source_input["id"] = [3]
@@ -330,6 +342,8 @@ def test_transformer_tap_regulator_control_side_not_closer_to_source():
     transformer_tap_regulator_input["id"] = [4]
     transformer_tap_regulator_input["regulated_object"] = [2]
     transformer_tap_regulator_input["status"] = [1]
+    transformer_tap_regulator_input["u_set"] = [10]
+    transformer_tap_regulator_input["u_band"] = [200]
     transformer_tap_regulator_input["control_side"] = [0]
 
     model = PowerGridModel(