Handle three windings transformer terminal connection action properly in woodbury DC security analysis

Signed-off-by: Bertrand Rix <bertrand.rix@artelys.com>

Author: obrix

src/main/java/com/powsybl/openloadflow/dc/fastdc/ConnectivityBreakAnalysis.java

@@ -151,7 +151,7 @@ private static void detectPotentialConnectivityBreak(LfNetwork lfNetwork, DenseM
      */
     private static boolean isConnectivityPotentiallyModifiedByContingencyAndOperatorStrategy(LfNetwork lfNetwork, States states, PropagatedContingency contingency,
                                                                                              Map<String, ComputedContingencyElement> contingencyElementByBranch, List<LfAction> operatorStrategyLfActions,
-                                                                                             Map<LfAction, ComputedElement> actionElementByBranch, EquationSystem<DcVariableType, DcEquationType> equationSystem) {
+                                                                                             Map<LfAction, List<ComputedElement>> actionElementByBranch, EquationSystem<DcVariableType, DcEquationType> equationSystem) {
         List<ComputedContingencyElement> contingencyElements = contingency.getBranchIdsToOpen().keySet().stream()
                 .map(contingencyElementByBranch::get)
                 .collect(Collectors.toList());
@@ -161,8 +161,9 @@ private static boolean isConnectivityPotentiallyModifiedByContingencyAndOperator
         // it is not necessary to consider them to ensure that there is no loss of connectivity.
         List<ComputedElement> actionElements = operatorStrategyLfActions.stream()
                 .map(actionElementByBranch::get)
+                .flatMap(Collection::stream)
                 .filter(actionElement -> actionElement instanceof ComputedSwitchBranchElement computedSwitchBranchElement && !computedSwitchBranchElement.isEnabled())
-                .collect(Collectors.toList());
+                .toList();
         return isGroupOfElementsBreakingConnectivity(lfNetwork, states.contingencyStates(), contingencyElements, states.actionStates(), actionElements, equationSystem);
     }
 
@@ -221,13 +222,13 @@ private static List<ConnectivityAnalysisResult> computeConnectivityData(LfNetwor
      */
     private static ConnectivityAnalysisResult computeConnectivityAnalysisResult(LfNetwork lfNetwork,
                                                                                           PropagatedContingency contingency, Map<String, ComputedContingencyElement> contingencyElementByBranch,
-                                                                                          List<LfAction> lfActions, Map<LfAction, ComputedElement> actionElementByBranch) {
+                                                                                          List<LfAction> lfActions, Map<LfAction, List<ComputedElement>> actionElementByBranch) {
         GraphConnectivity<LfBus, LfBranch> connectivity = lfNetwork.getConnectivity();
 
         // concatenate all computed elements, to apply them on the connectivity
         List<ComputedElement> modifyingConnectivityCandidates = Stream.concat(
                 contingency.getBranchIdsToOpen().keySet().stream().map(contingencyElementByBranch::get),
-                lfActions.stream().map(actionElementByBranch::get)
+                lfActions.stream().map(actionElementByBranch::get).flatMap(Collection::stream)
         ).sorted(Comparator.comparing(element -> element.getLfBranch().getId())).toList();
 
         // we confirm the breaking of connectivity by network connectivity
@@ -354,7 +355,7 @@ public static ConnectivityBreakAnalysisResults run(DcLoadFlowContext loadFlowCon
      */
     public static ConnectivityAnalysisResult processPostContingencyAndPostOperatorStrategyConnectivityAnalysisResult(DcLoadFlowContext loadFlowContext, ConnectivityAnalysisResult postContingencyConnectivityAnalysisResult,
                                                                                                                      Map<String, ComputedContingencyElement> contingencyElementByBranch, DenseMatrix contingenciesStates,
-                                                                                                                     List<LfAction> lfActions, Map<LfAction, ComputedElement> actionElementsIndexByLfAction, DenseMatrix actionsStates) {
+                                                                                                                     List<LfAction> lfActions, Map<LfAction, List<ComputedElement>> actionElementsIndexByLfAction, DenseMatrix actionsStates) {
         // if there is no topological action, no need to process anything as the connectivity has not changed from post contingency result
         boolean hasAnyTopologicalAction = lfActions.stream().anyMatch(lfAction -> lfAction instanceof AbstractLfBranchAction<?>);
         if (!hasAnyTopologicalAction) {

src/main/java/com/powsybl/openloadflow/sa/WoodburyDcSecurityAnalysis.java

@@ -126,7 +126,7 @@ private double[] calculatePostContingencyStates(DcLoadFlowContext loadFlowContex
      */
     private double[] calculatePostContingencyAndOperatorStrategyStates(DcLoadFlowContext loadFlowContext, DenseMatrix contingenciesStates, double[] flowStates,
                                                                        ConnectivityAnalysisResult connectivityAnalysisResult, Map<String, ComputedContingencyElement> contingencyElementByBranch,
-                                                                       Map<LfAction, ComputedElement> actionElementByLfAction, DenseMatrix actionsStates, ReportNode reportNode) {
+                                                                       Map<LfAction, List<ComputedElement>> actionElementByLfAction, DenseMatrix actionsStates, ReportNode reportNode) {
         PropagatedContingency contingency = connectivityAnalysisResult.getPropagatedContingency();
         Set<LfBus> disabledBuses = connectivityAnalysisResult.getDisabledBuses();
         Set<LfBranch> partialDisabledBranches = connectivityAnalysisResult.getPartialDisabledBranches();
@@ -145,6 +145,7 @@ private double[] calculatePostContingencyAndOperatorStrategyStates(DcLoadFlowCon
                 .collect(Collectors.toList());
         List<ComputedElement> actionElements = operatorStrategyLfActions.stream()
                 .map(actionElementByLfAction::get)
+                .flatMap(Collection::stream)
                 .filter(actionElement -> !elementsToReconnect.contains(actionElement.getLfBranch().getId()))
                 .collect(Collectors.toList());
 
@@ -365,29 +366,31 @@ private void addPostContingencyAndOperatorStrategyResults(WoodburyContext woodbu
         });
     }
 
-    private static Map<LfAction, ComputedElement> createActionElementsIndexByLfAction(Map<String, LfAction> lfActionById, EquationSystem<DcVariableType, DcEquationType> equationSystem) {
-        Map<LfAction, ComputedElement> computedElements = lfActionById.values().stream()
-                .map(lfAction -> {
-                    ComputedElement element;
-                    if (lfAction instanceof AbstractLfTapChangerAction<?> abstractLfTapChangerAction) {
-                        element = new ComputedTapPositionChangeElement(abstractLfTapChangerAction.getChange(), equationSystem);
-                    } else if (lfAction instanceof AbstractLfBranchAction<?> abstractLfBranchAction && !abstractLfBranchAction.getEnabledBranches().isEmpty()) {
-                        element = new ComputedSwitchBranchElement(abstractLfBranchAction.getEnabledBranches().getFirst(), true, equationSystem);
-                    } else if (lfAction instanceof AbstractLfBranchAction<?> abstractLfBranchAction && !abstractLfBranchAction.getDisabledBranches().isEmpty()) {
-                        element = new ComputedSwitchBranchElement(abstractLfBranchAction.getDisabledBranches().getFirst(), false, equationSystem);
-                    } else {
-                        throw new IllegalStateException("Only tap position change and branch enabling/disabling are supported in WoodburyDcSecurityAnalysis");
-                    }
-                    return Map.entry(lfAction, element);
-                })
-                .filter(e -> e.getValue().getLfBranchEquation() != null)
-                .collect(Collectors.toMap(
-                        Map.Entry::getKey,
-                        Map.Entry::getValue,
-                        (existing, replacement) -> existing,
-                        LinkedHashMap::new
-                ));
-        ComputedElement.setComputedElementIndexes(computedElements.values());
+    private static Map<LfAction, List<ComputedElement>> createActionElementsIndexByLfAction(Map<String, LfAction> lfActionById, EquationSystem<DcVariableType, DcEquationType> equationSystem) {
+        Map<LfAction, List<ComputedElement>> computedElements = new HashMap<>();
+        lfActionById.values().forEach(lfAction -> {
+            List<ComputedElement> elements = new ArrayList<>();
+            switch (lfAction) {
+                case AbstractLfTapChangerAction<?> abstractLfTapChangerAction -> {
+                    elements.add(new ComputedTapPositionChangeElement(abstractLfTapChangerAction.getChange(), equationSystem));
+                }
+                case
+                    AbstractLfBranchAction<?> abstractLfBranchAction when !abstractLfBranchAction.getEnabledBranches().isEmpty() -> {
+                    elements.addAll(abstractLfBranchAction.getEnabledBranches().stream().map(
+                        e -> new ComputedSwitchBranchElement(e, true, equationSystem)).toList());
+                }
+                case
+                    AbstractLfBranchAction<?> abstractLfBranchAction when !abstractLfBranchAction.getDisabledBranches().isEmpty() -> {
+                    elements.addAll(abstractLfBranchAction.getDisabledBranches().stream().map(
+                        e -> new ComputedSwitchBranchElement(e, false, equationSystem)).toList());
+                }
+                default -> {
+                    throw new IllegalStateException("Only tap position change and branch enabling/disabling are supported in WoodburyDcSecurityAnalysis");
+                }
+            }
+            computedElements.put(lfAction, elements.stream().filter(e -> e.getLfBranchEquation() != null).toList());
+        });
+        ComputedElement.setComputedElementIndexes(computedElements.values().stream().flatMap(Collection::stream).toList());
         return computedElements;
     }
 
@@ -449,11 +452,11 @@ protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<Propag
             ConnectivityBreakAnalysis.ConnectivityBreakAnalysisResults connectivityBreakAnalysisResults = ConnectivityBreakAnalysis.run(context, propagatedContingencies);
 
             // the map is indexed by lf actions as different kind of actions can be given on the same branch
-            Map<LfAction, ComputedElement> actionElementsIndexByLfAction = createActionElementsIndexByLfAction(lfActionById, context.getEquationSystem());
+            Map<LfAction, List<ComputedElement>> actionElementsIndexByLfAction = createActionElementsIndexByLfAction(lfActionById, context.getEquationSystem());
 
             // compute states with +1 -1 to model the actions in Woodbury engine
             // note that the number of columns in the matrix depends on the number of distinct branches affected by the action elements
-            DenseMatrix actionsStates = ComputedElement.calculateElementsStates(context, actionElementsIndexByLfAction.values());
+            DenseMatrix actionsStates = ComputedElement.calculateElementsStates(context, actionElementsIndexByLfAction.values().stream().flatMap(Collection::stream).toList());
 
             // save base state for later restoration after each contingency/action
             NetworkState networkState = NetworkState.save(lfNetwork);

src/test/java/com/powsybl/openloadflow/sa/OpenSecurityAnalysisWithActionsTest.java

@@ -1869,6 +1869,50 @@ void testTerminalsConnectionActionWith3WindingsTransformer() {
         assertEquals(11.226, result.getOperatorStrategyResults().getFirst().getNetworkResult().getBranchResult("LINE_12").getP1(), LoadFlowAssert.DELTA_POWER);
     }
 
+    @Test
+    void testTerminalsConnectionActionWith3WindingsTransformerAc() {
+        LoadFlowParameters parameters = new LoadFlowParameters();
+        parameters.setDistributedSlack(true);
+        parameters.setComponentMode(LoadFlowParameters.ComponentMode.ALL_CONNECTED);
+        SecurityAnalysisParameters securityAnalysisParameters = new SecurityAnalysisParameters();
+        securityAnalysisParameters.setLoadFlowParameters(parameters);
+        testTerminalsConnectionActionWith3WindingsTransformer(securityAnalysisParameters);
+    }
+
+    @Test
+    void testTerminalsConnectionActionWith3WindingsTransformerFastDc() {
+        LoadFlowParameters parameters = new LoadFlowParameters();
+        parameters.setDistributedSlack(true);
+        parameters.setDc(true);
+        parameters.setComponentMode(LoadFlowParameters.ComponentMode.ALL_CONNECTED);
+        SecurityAnalysisParameters securityAnalysisParameters = new SecurityAnalysisParameters();
+        securityAnalysisParameters.setLoadFlowParameters(parameters);
+        OpenSecurityAnalysisParameters ext = new OpenSecurityAnalysisParameters()
+            .setDcFastMode(true);
+        securityAnalysisParameters.addExtension(OpenSecurityAnalysisParameters.class, ext);
+        testTerminalsConnectionActionWith3WindingsTransformer(securityAnalysisParameters);
+    }
+
+    void testTerminalsConnectionActionWith3WindingsTransformer(SecurityAnalysisParameters parameters) {
+        Network network = VoltageControlNetworkFactory.createNetworkWithT3wt();
+
+        List<Contingency> contingencies = Stream.of("LOAD_4")
+            .map(id -> new Contingency(id, new LoadContingency(id)))
+            .toList();
+
+        List<Action> actions = List.of(new TerminalsConnectionAction("disconnect3WT", "T3wT", true));
+        List<OperatorStrategy> operatorStrategies = List.of(new OperatorStrategy("Strategy3WT", ContingencyContext.specificContingency("LOAD_4"), new TrueCondition(), List.of("disconnect3WT")));
+
+        List<StateMonitor> monitors = createAllBranchesMonitors(network);
+        SecurityAnalysisResult result = runSecurityAnalysis(network, contingencies, monitors, parameters,
+            operatorStrategies, actions, ReportNode.NO_OP);
+
+        assertTrue(result.getOperatorStrategyResults().stream().findAny().isPresent());
+
+        // Only flow related to G1 and LD2 should be present
+        assertEquals(11.2, result.getOperatorStrategyResults().getFirst().getNetworkResult().getBranchResult("LINE_12").getP1(), 1e-1);
+    }
+
     @Test
     void testOperatorStrategyNoMoreBusVoltageControlled() throws IOException {
         Network network = EurostagFactory.fix(EurostagTutorialExample1Factory.create());