Operator strategies in sensitivity analysis

src/main/java/com/powsybl/openloadflow/AcLoadFlowFromCache.java

@@ -95,7 +95,7 @@ private List<AcLoadFlowContext> initContexts(NetworkCache.Entry entry) {
 
         // Because of caching, we only need to switch back to working variant but not to remove the variant, thus
         // WorkingVariantReverter is used instead of DefaultVariantCleaner
-        try (LfNetworkList lfNetworkList = Networks.load(network, acParameters.getNetworkParameters(), topoConfig,
+        try (LfNetworkList lfNetworkList = Networks.loadWithReconnectableElements(network, topoConfig, acParameters.getNetworkParameters(),
                 LfNetworkList.WorkingVariantReverter::new, reportNode)) {
             contexts = lfNetworkList.getList()
                     .stream()

src/main/java/com/powsybl/openloadflow/OpenLoadFlowProvider.java

@@ -139,7 +139,7 @@ private LoadFlowResult runAc(Network network, LoadFlowParameters parameters, Ope
             results = new AcLoadFlowFromCache(network, parameters, parametersExt, acParameters, reportNode)
                     .run();
         } else {
-            try (LfNetworkList lfNetworkList = Networks.load(network, acParameters.getNetworkParameters(), new LfTopoConfig(), reportNode)) {
+            try (LfNetworkList lfNetworkList = Networks.loadWithReconnectableElements(network, new LfTopoConfig(), acParameters.getNetworkParameters(), reportNode)) {
                 results = AcloadFlowEngine.run(lfNetworkList.getList(), acParameters);
             }
         }

src/main/java/com/powsybl/openloadflow/dc/equations/AbstractClosedBranchDcFlowEquationTerm.java

@@ -97,7 +97,7 @@ public double calculateSensi(DenseMatrix dx, int column) {
         double dph1 = dx.get(ph1Var.getRow(), column);
         double dph2 = dx.get(ph2Var.getRow(), column);
         double da1 = a1Var != null ? dx.get(a1Var.getRow(), column) : 0;
-        // - eval(0,0,0) to have an exact epression and remove the constant term of the affine function (wich is 0 in practe because A2 = 0)
+        // - eval(0,0,0) to have an exact expression and remove the constant term of the affine function (which is 0 in practice because A2 = 0)
         return eval(dph1, dph2, da1) - eval(0, 0, 0);
     }
 

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

@@ -10,6 +10,8 @@
 import com.powsybl.openloadflow.dc.equations.ClosedBranchSide1DcFlowEquationTerm;
 import com.powsybl.openloadflow.network.LfBranch;
 
+import java.util.Objects;
+
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  * @author Gaël Macherel {@literal <gael.macherel@artelys.com>}
@@ -22,8 +24,8 @@ abstract class AbstractComputedElement {
     private final ClosedBranchSide1DcFlowEquationTerm branchEquation;
 
     protected AbstractComputedElement(LfBranch lfBranch, ClosedBranchSide1DcFlowEquationTerm branchEquation) {
-        this.lfBranch = lfBranch;
-        this.branchEquation = branchEquation;
+        this.lfBranch = Objects.requireNonNull(lfBranch);
+        this.branchEquation = Objects.requireNonNull(branchEquation);
     }
 
     public int getComputedElementIndex() {

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

@@ -7,6 +7,9 @@
  */
 package com.powsybl.openloadflow.dc.fastdc;
 
+import com.powsybl.action.PhaseTapChangerTapPositionAction;
+import com.powsybl.action.SwitchAction;
+import com.powsybl.action.TerminalsConnectionAction;
 import com.powsybl.commons.PowsyblException;
 import com.powsybl.math.matrix.DenseMatrix;
 import com.powsybl.math.matrix.Matrix;
@@ -19,19 +22,29 @@
 import com.powsybl.openloadflow.graph.GraphConnectivity;
 import com.powsybl.openloadflow.network.LfBranch;
 import com.powsybl.openloadflow.network.LfBus;
+import com.powsybl.openloadflow.network.action.AbstractLfBranchAction;
+import com.powsybl.openloadflow.network.action.AbstractLfTapChangerAction;
+import com.powsybl.openloadflow.network.action.LfAction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  * @author Gaël Macherel {@literal <gael.macherel@artelys.com>}
  */
 public interface ComputedElement {
 
+    Logger LOGGER = LoggerFactory.getLogger(ComputedElement.class);
+
     int getComputedElementIndex();
 
     void setComputedElementIndex(final int index);
@@ -119,4 +132,38 @@ static DenseMatrix calculateElementsStates(DcLoadFlowContext loadFlowContext, Co
         loadFlowContext.getJacobianMatrix().solveTransposed(elementsStates);
         return elementsStates;
     }
+
+    static Map<LfAction, ComputedElement> createActionElementsIndexByLfAction(Map<String, LfAction> lfActionById, EquationSystem<DcVariableType, DcEquationType> equationSystem) {
+        Map<LfAction, ComputedElement> computedElements = lfActionById.values().stream()
+                .flatMap(lfAction -> {
+                    ComputedElement element = switch (lfAction.getType()) {
+                        case SwitchAction.NAME, TerminalsConnectionAction.NAME -> {
+                            AbstractLfBranchAction<?> lfBranchAction = (AbstractLfBranchAction<?>) lfAction;
+                            if (lfBranchAction.getEnabledBranch() != null) {
+                                yield ComputedSwitchBranchElement.create(lfBranchAction.getEnabledBranch(), true, equationSystem);
+                            } else if (lfBranchAction.getDisabledBranch() != null) {
+                                yield ComputedSwitchBranchElement.create(lfBranchAction.getDisabledBranch(), false, equationSystem);
+                            }
+                            yield null;
+                        }
+                        case PhaseTapChangerTapPositionAction.NAME ->
+                            new ComputedTapPositionChangeElement(((AbstractLfTapChangerAction<?>) lfAction).getChange(), equationSystem);
+                        default -> throw new IllegalStateException("Only tap position change and branch enabling/disabling are supported in WoodburyDcSecurityAnalysis");
+                    };
+                    if (element == null) {
+                        return Stream.empty();
+                    }
+                    return Stream.of(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());
+        return computedElements;
+    }
+
 }

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

@@ -16,15 +16,24 @@
 import com.powsybl.openloadflow.network.LfBranch;
 import com.powsybl.openloadflow.network.LfBus;
 
+import java.util.Objects;
+
 /**
  * @author Pierre Arvy {@literal <pierre.arvy@artelys.com>}
  */
 public final class ComputedSwitchBranchElement extends AbstractComputedElement implements ComputedElement {
 
     private final boolean enabled; // indicates whether the action opens or closes the branch
 
-    public ComputedSwitchBranchElement(LfBranch lfBranch, boolean enabled, EquationSystem<DcVariableType, DcEquationType> equationSystem) {
-        super(lfBranch, equationSystem.getEquationTerm(ElementType.BRANCH, lfBranch.getNum(), ClosedBranchSide1DcFlowEquationTerm.class));
+    public static ComputedSwitchBranchElement create(LfBranch lfBranch, boolean enabled, EquationSystem<DcVariableType, DcEquationType> equationSystem) {
+        Objects.requireNonNull(lfBranch);
+        Objects.requireNonNull(equationSystem);
+        ClosedBranchSide1DcFlowEquationTerm branchEquation = equationSystem.getEquationTerm(ElementType.BRANCH, lfBranch.getNum(), ClosedBranchSide1DcFlowEquationTerm.class);
+        return new ComputedSwitchBranchElement(lfBranch, enabled, branchEquation);
+    }
+
+    private ComputedSwitchBranchElement(LfBranch lfBranch, boolean enabled, ClosedBranchSide1DcFlowEquationTerm branchEquation) {
+        super(lfBranch, branchEquation);
         this.enabled = enabled;
     }