Add nb of synchronous components in SA post contingency

Signed-off-by: Guillaume Verger <guillaume.verger@artelys.com>

src/main/java/com/powsybl/openloadflow/network/LfContingency.java

@@ -28,6 +28,8 @@ public class LfContingency {
 
     private final int index;
 
+    private final int nbSynchronousComponents;
+
     private final Set<LfBus> disabledBuses;
 
     private final Set<LfBranch> disabledBranches;
@@ -42,10 +44,11 @@ public class LfContingency {
 
     private double activePowerLoss = 0;
 
-    public LfContingency(String id, int index, Set<LfBus> disabledBuses, Set<LfBranch> disabledBranches, Map<LfShunt, AdmittanceShift> shuntsShift,
+    public LfContingency(String id, int index, int nbSynchronousComponents, Set<LfBus> disabledBuses, Set<LfBranch> disabledBranches, Map<LfShunt, AdmittanceShift> shuntsShift,
                          Map<LfBus, PowerShift> busesLoadShift, Set<LfGenerator> lostGenerators, Set<LfHvdc> disabledHvdcs) {
         this.id = Objects.requireNonNull(id);
         this.index = index;
+        this.nbSynchronousComponents = nbSynchronousComponents;
         this.disabledBuses = Objects.requireNonNull(disabledBuses);
         this.disabledBranches = Objects.requireNonNull(disabledBranches);
         this.disabledHvdcs = Objects.requireNonNull(disabledHvdcs);
@@ -71,6 +74,10 @@ public int getIndex() {
         return index;
     }
 
+    public int getNbSynchronousComponents() {
+        return nbSynchronousComponents;
+    }
+
     public Set<LfBus> getDisabledBuses() {
         return disabledBuses;
     }

src/main/java/com/powsybl/openloadflow/network/impl/PropagatedContingency.java

@@ -299,6 +299,7 @@ public Optional<LfContingency> toLfContingency(LfNetwork network) {
 
         // add to contingency description buses and branches that won't be part of the main connected
         // component in post contingency state
+        int nbSynchronousComponents = connectivity.getNbConnectedComponents();
         Set<LfBus> buses = connectivity.getVerticesRemovedFromMainComponent();
         Set<LfBranch> branches = new HashSet<>(connectivity.getEdgesRemovedFromMainComponent());
 
@@ -352,6 +353,6 @@ public Optional<LfContingency> toLfContingency(LfNetwork network) {
             return Optional.empty();
         }
 
-        return Optional.of(new LfContingency(contingency.getId(), index, buses, branches, shunts, busesLoadShift, generators, hvdcs));
+        return Optional.of(new LfContingency(contingency.getId(), index, nbSynchronousComponents, buses, branches, shunts, busesLoadShift, generators, hvdcs));
     }
 }

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

@@ -35,6 +35,7 @@
 import com.powsybl.security.*;
 import com.powsybl.security.action.Action;
 import com.powsybl.security.monitor.StateMonitor;
+import com.powsybl.security.results.ConnectivityResult;
 import com.powsybl.security.results.OperatorStrategyResult;
 import com.powsybl.security.results.PostContingencyResult;
 import com.powsybl.security.results.PreContingencyResult;
@@ -246,11 +247,14 @@ private PostContingencyResult runPostContingencySimulation(LfNetwork network, Ac
         LOGGER.info("Post contingency '{}' simulation done on network {} in {} ms", lfContingency.getId(),
                 network, stopwatch.elapsed(TimeUnit.MILLISECONDS));
 
+        var connectivityResult = new ConnectivityResult(lfContingency.getNbSynchronousComponents() - 1, 0, 0, 0, Collections.emptySet());
+
         return new PostContingencyResult(contingency, status,
                                          new LimitViolationsResult(postContingencyLimitViolationManager.getLimitViolations()),
                                          postContingencyNetworkResult.getBranchResults(),
                                          postContingencyNetworkResult.getBusResults(),
-                                         postContingencyNetworkResult.getThreeWindingsTransformerResults());
+                                         postContingencyNetworkResult.getThreeWindingsTransformerResults(),
+                                         connectivityResult);
     }
 
     private Optional<OperatorStrategyResult> runActionSimulation(LfNetwork network, AcLoadFlowContext context, OperatorStrategy operatorStrategy,

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

@@ -33,10 +33,7 @@
 import com.powsybl.security.detectors.DefaultLimitViolationDetector;
 import com.powsybl.security.detectors.LoadingLimitType;
 import com.powsybl.security.monitor.StateMonitor;
-import com.powsybl.security.results.BranchResult;
-import com.powsybl.security.results.OperatorStrategyResult;
-import com.powsybl.security.results.PostContingencyResult;
-import com.powsybl.security.results.PreContingencyResult;
+import com.powsybl.security.results.*;
 import com.powsybl.security.strategy.OperatorStrategy;
 import com.powsybl.sensitivity.*;
 import org.apache.commons.lang3.tuple.Pair;
@@ -201,8 +198,10 @@ private List<PostContingencyResult> createPostContingencyResults(DcSecurityAnaly
                 }
             });
 
+            ConnectivityResult connectivityResult = new ConnectivityResult(0, 0, 0, 0, Collections.emptySet());
+
             PostContingencyResult pcResult = new PostContingencyResult(contingency, PostContingencyComputationStatus.CONVERGED, new ArrayList<>(violations.values()),
-                    new ArrayList<>(postContingencyBranchResults.values()), Collections.emptyList(), Collections.emptyList());
+                    new ArrayList<>(postContingencyBranchResults.values()), Collections.emptyList(), Collections.emptyList(), connectivityResult);
             context.getPostContingencyResultPerContingencyId().put(contingency.getId(), pcResult);
             postContingencyResults.add(pcResult);
         }

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

@@ -2258,4 +2258,32 @@ void testSaDcPhaseTapChangerTapPositionAction() {
         assertEquals(network.getLine("S_SO_2").getTerminal1().getP(), brRel.getP1(), LoadFlowAssert.DELTA_POWER);
         assertEquals(network.getBranch("S_SO_2").getTerminal2().getP(), brRel.getP2(), LoadFlowAssert.DELTA_POWER);
     }
+
+    @Test
+    void testConnectivityResultWhenNoSplit() throws IOException {
+        Network network = ConnectedComponentNetworkFactory.createTwoComponentWithGeneratorAndLoad();
+        List<StateMonitor> monitors = createAllBranchesMonitors(network);
+        List<Contingency> contingencies = List.of(new Contingency("line", new BranchContingency("l12")));
+        SecurityAnalysisResult result = runSecurityAnalysis(network, contingencies, monitors, new SecurityAnalysisParameters(), Reporter.NO_OP);
+
+        var postContingencyResult = result.getPostContingencyResults().get(0);
+
+        assertSame(PostContingencyComputationStatus.CONVERGED, postContingencyResult.getStatus());
+
+        assertEquals(0, postContingencyResult.getConnectivityResult().getCreatedSynchronousComponentCount());
+    }
+
+    @Test
+    void testConnectivityResultOnSplit() throws IOException {
+        Network network = ConnectedComponentNetworkFactory.createTwoComponentWithGeneratorAndLoad();
+        List<StateMonitor> monitors = createAllBranchesMonitors(network);
+        List<Contingency> contingencies = List.of(new Contingency("line", new BranchContingency("l34")));
+        SecurityAnalysisResult result = runSecurityAnalysis(network, contingencies, monitors, new SecurityAnalysisParameters(), Reporter.NO_OP);
+
+        PostContingencyResult postContingencyResult = result.getPostContingencyResults().get(0);
+
+        assertSame(PostContingencyComputationStatus.CONVERGED, postContingencyResult.getStatus());
+
+        assertEquals(1, postContingencyResult.getConnectivityResult().getCreatedSynchronousComponentCount());
+    }
 }