DC sensitivity analysis: remove factors in connectivity break analysis (#1073)

Signed-off-by: p-arvy <[email protected]>

Author: p-arvy

src/main/java/com/powsybl/openloadflow/sensi/ConnectivityBreakAnalysis.java

@@ -23,8 +23,6 @@
 import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.LfNetwork;
 import com.powsybl.openloadflow.network.impl.PropagatedContingency;
-import com.powsybl.sensitivity.SensitivityAnalysisResult;
-import com.powsybl.sensitivity.SensitivityResultWriter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -136,10 +134,9 @@ private static boolean isGroupOfElementsBreakingConnectivity(LfNetwork lfNetwork
         return false;
     }
 
-    private static List<ConnectivityAnalysisResult> computeConnectivityData(LfNetwork lfNetwork, AbstractSensitivityAnalysis.SensitivityFactorHolder<DcVariableType, DcEquationType> factorHolder,
-                                                                            List<PropagatedContingency> potentiallyBreakingConnectivityContingencies, Map<String, ComputedContingencyElement> contingencyElementByBranch,
-                                                                            List<PropagatedContingency> nonBreakingConnectivityContingencies,
-                                                                            SensitivityResultWriter resultWriter) {
+    private static List<ConnectivityAnalysisResult> computeConnectivityData(LfNetwork lfNetwork, List<PropagatedContingency> potentiallyBreakingConnectivityContingencies,
+                                                                            Map<String, ComputedContingencyElement> contingencyElementByBranch,
+                                                                            List<PropagatedContingency> nonBreakingConnectivityContingencies) {
         if (potentiallyBreakingConnectivityContingencies.isEmpty()) {
             return Collections.emptyList();
         }
@@ -165,16 +162,10 @@ private static List<ConnectivityAnalysisResult> computeConnectivityData(LfNetwor
                     nonBreakingConnectivityContingencies.add(contingency);
                 } else {
                     // only compute for factors that have to be computed for this contingency lost
-                    List<AbstractSensitivityAnalysis.LfSensitivityFactor<DcVariableType, DcEquationType>> lfFactors = factorHolder.getFactorsForContingencies(List.of(contingency.getContingency().getId()));
-                    if (!lfFactors.isEmpty()) {
-                        Set<String> elementsToReconnect = computeElementsToReconnect(connectivity, breakingConnectivityElements);
-                        ConnectivityAnalysisResult connectivityAnalysisResult = new ConnectivityAnalysisResult(elementsToReconnect, connectivity, lfNetwork);
-                        connectivityAnalysisResult.setPropagatedContingency(contingency);
-                        connectivityAnalysisResults.add(connectivityAnalysisResult);
-                    } else {
-                        // write contingency status
-                        resultWriter.writeContingencyStatus(contingency.getIndex(), SensitivityAnalysisResult.Status.SUCCESS);
-                    }
+                    Set<String> elementsToReconnect = computeElementsToReconnect(connectivity, breakingConnectivityElements);
+                    ConnectivityAnalysisResult connectivityAnalysisResult = new ConnectivityAnalysisResult(elementsToReconnect, connectivity, lfNetwork);
+                    connectivityAnalysisResult.setPropagatedContingency(contingency);
+                    connectivityAnalysisResults.add(connectivityAnalysisResult);
                 }
             } finally {
                 connectivity.undoTemporaryChanges();
@@ -288,8 +279,7 @@ private static void fillRhsContingency(LfNetwork lfNetwork, EquationSystem<DcVar
         }
     }
 
-    public static ConnectivityBreakAnalysisResults run(DcLoadFlowContext loadFlowContext, AbstractSensitivityAnalysis.SensitivityFactorHolder<DcVariableType, DcEquationType> factorHolder,
-                                                       List<PropagatedContingency> contingencies, SensitivityResultWriter resultWriter) {
+    public static ConnectivityBreakAnalysisResults run(DcLoadFlowContext loadFlowContext, List<PropagatedContingency> contingencies) {
         // index contingency elements by branch id
         Map<String, ComputedContingencyElement> contingencyElementByBranch = createContingencyElementsIndexByBranchId(contingencies, loadFlowContext.getNetwork(), loadFlowContext.getEquationSystem());
 
@@ -311,8 +301,8 @@ public static ConnectivityBreakAnalysisResults run(DcLoadFlowContext loadFlowCon
 
         // this second method process all contingencies that potentially break connectivity and using graph algorithms
         // find remaining contingencies that do not break connectivity
-        List<ConnectivityAnalysisResult> connectivityAnalysisResults = computeConnectivityData(loadFlowContext.getNetwork(), factorHolder,
-                potentiallyBreakingConnectivityContingencies, contingencyElementByBranch, nonBreakingConnectivityContingencies, resultWriter);
+        List<ConnectivityAnalysisResult> connectivityAnalysisResults = computeConnectivityData(loadFlowContext.getNetwork(),
+                potentiallyBreakingConnectivityContingencies, contingencyElementByBranch, nonBreakingConnectivityContingencies);
         LOGGER.info("After graph based connectivity analysis, {} contingencies do not break connectivity, {} contingencies break connectivity",
                 nonBreakingConnectivityContingencies.size(), connectivityAnalysisResults.size());
 

src/main/java/com/powsybl/openloadflow/sensi/DcSensitivityAnalysis.java

@@ -244,12 +244,6 @@ private void calculateSensitivityValuesForAContingency(DcLoadFlowContext loadFlo
                                                            Set<LfBus> disabledBuses, List<ParticipatingElement> participatingElements, Set<String> elementsToReconnect,
                                                            SensitivityResultWriter resultWriter, ReportNode reportNode, Set<LfBranch> partialDisabledBranches, boolean rhsChangedAfterConnectivityBreak) {
         List<LfSensitivityFactor<DcVariableType, DcEquationType>> factors = validFactorHolder.getFactorsForContingency(contingency.getContingency().getId());
-        if (factors.isEmpty()) {
-            // no factor no more computation
-            resultWriter.writeContingencyStatus(contingency.getIndex(), SensitivityAnalysisResult.Status.SUCCESS);
-            return;
-        }
-
         List<ComputedContingencyElement> contingencyElements = contingency.getBranchIdsToOpen().keySet().stream()
                 .filter(element -> !elementsToReconnect.contains(element))
                 .map(contingencyElementByBranch::get)
@@ -545,8 +539,19 @@ public void analyse(Network network, List<PropagatedContingency> contingencies,
                 // calculate sensitivity values for pre-contingency network
                 calculateSensitivityValues(validFactorHolder.getFactorsForBaseNetwork(), factorsStates, flowStates, null, resultWriter, new DisabledNetwork());
 
+                // filter contingencies without factors
+                List<PropagatedContingency> contingenciesWithFactors = new ArrayList<>();
+                contingencies.forEach(contingency -> {
+                    List<AbstractSensitivityAnalysis.LfSensitivityFactor<DcVariableType, DcEquationType>> lfFactors = validFactorHolder.getFactorsForContingencies(List.of(contingency.getContingency().getId()));
+                    if (!lfFactors.isEmpty()) {
+                        contingenciesWithFactors.add(contingency);
+                    } else {
+                        resultWriter.writeContingencyStatus(contingency.getIndex(), SensitivityAnalysisResult.Status.SUCCESS);
+                    }
+                });
+
                 // compute states with +1 -1 to model the contingencies and run connectivity analysis
-                ConnectivityBreakAnalysis.ConnectivityBreakAnalysisResults connectivityBreakAnalysisResults = ConnectivityBreakAnalysis.run(loadFlowContext, validFactorHolder, contingencies, resultWriter);
+                ConnectivityBreakAnalysis.ConnectivityBreakAnalysisResults connectivityBreakAnalysisResults = ConnectivityBreakAnalysis.run(loadFlowContext, contingenciesWithFactors);
 
                 LOGGER.info("Processing contingencies with no connectivity break");