Bug fix: support of factors with SKIP status after contingencies (#476)

Signed-off-by: Anne Tilloy <anne.tilloy@rte-france.com>
Signed-off-by: Geoffroy Jamgotchian <geoffroy.jamgotchian@rte-france.com>

Author: annetill

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

@@ -556,9 +556,6 @@ protected List<SensitivityFactorGroup<V, E>> createFactorGroups(List<LfSensitivi
         Map<Pair<SensitivityVariableType, String>, SensitivityFactorGroup<V, E>> groupIndexedById = new LinkedHashMap<>(factors.size());
         // index factors by variable config
         for (LfSensitivityFactor<V, E> factor : factors) {
-            if (factor.getStatus() == LfSensitivityFactor.Status.SKIP) {
-                continue;
-            }
             Pair<SensitivityVariableType, String> id = Pair.of(factor.getVariableType(), factor.getVariableId());
             if (factor instanceof SingleVariableLfSensitivityFactor) {
                 SingleVariableLfSensitivityFactor<V, E> singleVarFactor = (SingleVariableLfSensitivityFactor<V, E>) factor;
@@ -635,6 +632,8 @@ protected void setPredefinedResults(Collection<LfSensitivityFactor<V, E>> lfFact
                 if (!factor.isFunctionConnectedToSlackComponent(connectedComponent)) {
                     factor.setFunctionPredefinedResult(Double.NaN);
                 }
+            } else {
+                throw new IllegalStateException("Unexpected factor status: " + factor.getStatus());
             }
         }
     }
@@ -651,18 +650,32 @@ protected boolean rescaleGlsk(List<SensitivityFactorGroup<V, E>> factorGroups, S
         return rescaled;
     }
 
-    protected void writeSkippedFactors(Collection<LfSensitivityFactor<V, E>> lfFactors, SensitivityValueWriter valueWriter) {
-        List<LfSensitivityFactor<V, E>> skippedFactors = lfFactors.stream().filter(factor -> factor.getStatus() == LfSensitivityFactor.Status.SKIP).collect(Collectors.toList());
-
-        // SKIP factors are for factors where both variable and function elements are not in the main connected componant.
-        // Therefore, their sensitivity and reference values are set to NaN.
-        skippedFactors.forEach(factor -> valueWriter.write(factor.getIndex(), -1, Double.NaN, Double.NaN));
-
-        Set<String> skippedVariables = skippedFactors.stream().map(LfSensitivityFactor::getVariableId).collect(Collectors.toSet());
+    /**
+     * Write zero or skip factors to output and send a new factor holder containing only other valid ones.
+     * IMPORTANT: this is only a base case test (factor status only deal with base case). We do not output anything
+     * on post contingency if factor is already invalid (skip o zero) on base case.
+     */
+    protected SensitivityFactorHolder<V, E> writeInvalidFactors(SensitivityFactorHolder<V, E> factorHolder, SensitivityValueWriter valueWriter) {
+        Set<String> skippedVariables = new LinkedHashSet<>();
+        SensitivityFactorHolder<V, E> validFactorHolder = new SensitivityFactorHolder<>();
+        for (var factor : factorHolder.getAllFactors()) {
+            // directly write output for zero and invalid factors
+            if (factor.getStatus() == LfSensitivityFactor.Status.ZERO) {
+                // ZERO status is for factors where variable element is in the main connected component and reference element is not.
+                // Therefore, the sensitivity is known to value 0, but the reference cannot be known and is set to NaN.
+                valueWriter.write(factor.getIndex(), -1, 0, Double.NaN);
+            } else if (factor.getStatus() == LfSensitivityFactor.Status.SKIP) {
+                valueWriter.write(factor.getIndex(), -1, Double.NaN, Double.NaN);
+                skippedVariables.add(factor.getVariableId());
+            } else {
+                validFactorHolder.addFactor(factor);
+            }
+        }
         if (!skippedVariables.isEmpty() && LOGGER.isWarnEnabled()) {
             LOGGER.warn("Skipping all factors with variables: '{}', as they cannot be found in the network",
                     String.join(", ", skippedVariables));
         }
+        return validFactorHolder;
     }
 
     public void checkContingencies(LfNetwork lfNetwork, List<PropagatedContingency> contingencies) {

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

@@ -49,10 +49,7 @@ public AcSensitivityAnalysis(MatrixFactory matrixFactory, GraphDecrementalConnec
     private void calculateSensitivityValues(List<LfSensitivityFactor<AcVariableType, AcEquationType>> lfFactors, List<SensitivityFactorGroup<AcVariableType, AcEquationType>> factorGroups, DenseMatrix factorsState,
                                             int contingencyIndex, SensitivityValueWriter valueWriter) {
         Set<LfSensitivityFactor<AcVariableType, AcEquationType>> lfFactorsSet = new HashSet<>(lfFactors);
-        // ZERO status is for factors where variable element is in the main connected component and reference element is not.
-        // Therefore, the sensitivity is known to value 0, but the reference cannot be known and is set to NaN.
-        lfFactors.stream().filter(factor -> factor.getStatus() == LfSensitivityFactor.Status.ZERO)
-                .forEach(factor -> valueWriter.write(factor.getIndex(), contingencyIndex, 0, Double.NaN));
+
         // VALID_ONLY_FOR_FUNCTION status is for factors where variable element is not in the main connected component but reference element is.
         // Therefore, the sensitivity is known to value 0 and the reference value can be computed.
         lfFactors.stream().filter(factor -> factor.getStatus() == LfSensitivityFactor.Status.VALID_ONLY_FOR_FUNCTION)
@@ -208,16 +205,13 @@ public void analyse(Network network, List<PropagatedContingency> contingencies,
         );
 
         Map<String, SensitivityVariableSet> variableSetsById = variableSets.stream().collect(Collectors.toMap(SensitivityVariableSet::getId, Function.identity()));
-        SensitivityFactorHolder<AcVariableType, AcEquationType> factorHolder = readAndCheckFactors(network, variableSetsById, factorReader, lfNetwork);
-        List<LfSensitivityFactor<AcVariableType, AcEquationType>> lfFactors = factorHolder.getAllFactors();
-        LOGGER.info("Running AC sensitivity analysis with {} factors and {} contingencies",  lfFactors.size(), contingencies.size());
+        SensitivityFactorHolder<AcVariableType, AcEquationType> allFactorHolder = readAndCheckFactors(network, variableSetsById, factorReader, lfNetwork);
+        List<LfSensitivityFactor<AcVariableType, AcEquationType>> allLfFactors = allFactorHolder.getAllFactors();
+        LOGGER.info("Running AC sensitivity analysis with {} factors and {} contingencies",  allLfFactors.size(), contingencies.size());
 
-        writeSkippedFactors(lfFactors, valueWriter);
         // next we only work with valid and valid only for function factors
-        List<LfSensitivityFactor.Status> validFactors = new ArrayList<>();
-        validFactors.add(LfSensitivityFactor.Status.VALID);
-        validFactors.add(LfSensitivityFactor.Status.VALID_ONLY_FOR_FUNCTION);
-        lfFactors = lfFactors.stream().filter(factor -> validFactors.contains(factor.getStatus())).collect(Collectors.toList());
+        var validFactorHolder = writeInvalidFactors(allFactorHolder, valueWriter);
+        var validLfFactors = validFactorHolder.getAllFactors();
 
         // create AC engine
         AcLoadFlowParameters acParameters = OpenLoadFlowParameters.createAcParameters(network, lfParameters, lfParametersExt, matrixFactory, connectivityFactory, reporter, false, true);
@@ -228,7 +222,7 @@ public void analyse(Network network, List<PropagatedContingency> contingencies,
                     .run(reporter);
 
             // index factors by variable group to compute a minimal number of states
-            List<SensitivityFactorGroup<AcVariableType, AcEquationType>> factorGroups = createFactorGroups(lfFactors.stream()
+            List<SensitivityFactorGroup<AcVariableType, AcEquationType>> factorGroups = createFactorGroups(validLfFactors.stream()
                     .filter(factor -> factor.getStatus() == LfSensitivityFactor.Status.VALID).collect(Collectors.toList()));
 
             // compute the participation for each injection factor (+1 on the injection and then -participation factor on all
@@ -269,8 +263,8 @@ public void analyse(Network network, List<PropagatedContingency> contingencies,
             context.getJacobianMatrix().solveTransposed(factorsStates);
 
             // calculate sensitivity values
-            setFunctionReferences(lfFactors);
-            calculateSensitivityValues(factorHolder.getFactorsForBaseNetwork(), factorGroups, factorsStates, -1, valueWriter);
+            setFunctionReferences(validLfFactors);
+            calculateSensitivityValues(validFactorHolder.getFactorsForBaseNetwork(), factorGroups, factorsStates, -1, valueWriter);
 
             GraphDecrementalConnectivity<LfBus> connectivity = lfNetwork.getConnectivity();
 
@@ -282,8 +276,7 @@ public void analyse(Network network, List<PropagatedContingency> contingencies,
 
             // Contingency not breaking connectivity
             for (LfContingency lfContingency : lfContingencies.stream().filter(lfContingency -> lfContingency.getBuses().isEmpty()).collect(Collectors.toSet())) {
-                List<LfSensitivityFactor<AcVariableType, AcEquationType>> contingencyFactors = factorHolder.getFactorsForContingency(lfContingency.getId());
-                contingencyFactors = contingencyFactors.stream().filter(factor -> validFactors.contains(factor.getStatus())).collect(Collectors.toList());
+                List<LfSensitivityFactor<AcVariableType, AcEquationType>> contingencyFactors = validFactorHolder.getFactorsForContingency(lfContingency.getId());
                 contingencyFactors.forEach(lfFactor -> {
                     lfFactor.setSensitivityValuePredefinedResult(null);
                     lfFactor.setFunctionPredefinedResult(null);
@@ -303,8 +296,7 @@ public void analyse(Network network, List<PropagatedContingency> contingencies,
 
             // Contingency breaking connectivity
             for (LfContingency lfContingency : lfContingencies.stream().filter(lfContingency -> !lfContingency.getBuses().isEmpty()).collect(Collectors.toSet())) {
-                List<LfSensitivityFactor<AcVariableType, AcEquationType>> contingencyFactors = factorHolder.getFactorsForContingency(lfContingency.getId());
-                contingencyFactors = contingencyFactors.stream().filter(factor -> validFactors.contains(factor.getStatus())).collect(Collectors.toList());
+                List<LfSensitivityFactor<AcVariableType, AcEquationType>> contingencyFactors = validFactorHolder.getFactorsForContingency(lfContingency.getId());
                 contingencyFactors.forEach(lfFactor -> {
                     lfFactor.setSensitivityValuePredefinedResult(null);
                     lfFactor.setFunctionPredefinedResult(null); });