Add switch actions in Fast DC Security Analysis

docs/security/parameters.md

@@ -59,7 +59,7 @@ Please note that fast mode has a few limitations:
 it is considered completely disabled, and no results are reported for this branch.
 - AC emulation of HVDC lines is disabled, as it is not yet supported.
 Instead, the [active power setpoint](../loadflow/loadflow.md#computing-hvdc-power-flow) mode is used to control the active power flow through these lines. 
-- Only PST remedial actions are supported for now.
+- Only PST and topological (except for transformer closing) remedial actions are supported for now.
 - Slack relocation following the application of a contingency is not supported.
 As a result, security analysis is carried out only in slack component, and not necessarily in the largest one.
 - Customizing the way contingency imbalances are compensated via `contingencyActivePowerLossDistribution` parameter is not supported.

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

@@ -16,23 +16,24 @@
 import com.powsybl.openloadflow.dc.equations.DcVariableType;
 import com.powsybl.openloadflow.equations.Equation;
 import com.powsybl.openloadflow.equations.EquationSystem;
+import com.powsybl.openloadflow.graph.GraphConnectivity;
 import com.powsybl.openloadflow.network.LfBranch;
 import com.powsybl.openloadflow.network.LfBus;
 
-import java.util.Collection;
+import java.util.*;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  * @author Gaël Macherel {@literal <gael.macherel@artelys.com>}
  */
-public class ComputedElement {
+public abstract class AbstractComputedElement {
     private int computedElementIndex = -1; // index of the element in the rhs for +1-1
     private int localIndex = -1; // local index of the element : index of the element in the matrix used in the setAlphas method
     private double alphaForWoodburyComputation = Double.NaN;
     private final LfBranch lfBranch;
     private final ClosedBranchSide1DcFlowEquationTerm branchEquation;
 
-    public ComputedElement(LfBranch lfBranch, ClosedBranchSide1DcFlowEquationTerm branchEquation) {
+    protected AbstractComputedElement(LfBranch lfBranch, ClosedBranchSide1DcFlowEquationTerm branchEquation) {
         this.lfBranch = lfBranch;
         this.branchEquation = branchEquation;
     }
@@ -69,25 +70,39 @@ public ClosedBranchSide1DcFlowEquationTerm getLfBranchEquation() {
         return branchEquation;
     }
 
-    public static void setComputedElementIndexes(Collection<? extends ComputedElement> elements) {
+    /**
+     * Set the indexes of the computed elements in the +1-1 rhs, used in Woodbury calculations.
+     * The indexes depend on the number of distinct branches affected by the elements.
+     * Those affecting the same branch share the same +1-1 rhs column.
+     */
+    public static void setComputedElementIndexes(Collection<? extends AbstractComputedElement> elements) {
         int index = 0;
-        for (ComputedElement element : elements) {
-            element.setComputedElementIndex(index++);
+        Map<LfBranch, Integer> branchesToRhsIndex = new HashMap<>();
+        for (AbstractComputedElement element : elements) {
+            LfBranch elementLfBranch = element.getLfBranch();
+            Integer elementIndex = branchesToRhsIndex.get(elementLfBranch);
+
+            if (elementIndex == null) {
+                branchesToRhsIndex.put(elementLfBranch, index);
+                element.setComputedElementIndex(index++);
+            } else {
+                element.setComputedElementIndex(elementIndex);
+            }
         }
     }
 
-    public static void setLocalIndexes(Collection<? extends ComputedElement> elements) {
+    public static void setLocalIndexes(Collection<? extends AbstractComputedElement> elements) {
         int index = 0;
-        for (ComputedElement element : elements) {
+        for (AbstractComputedElement element : elements) {
             element.setLocalIndex(index++);
         }
     }
 
     /**
      * Fills the right hand side with +1/-1 to model a branch contingency or action.
      */
-    private static void fillRhs(EquationSystem<DcVariableType, DcEquationType> equationSystem, Collection<? extends ComputedElement> computedElements, Matrix rhs) {
-        for (ComputedElement element : computedElements) {
+    private static void fillRhs(EquationSystem<DcVariableType, DcEquationType> equationSystem, Collection<? extends AbstractComputedElement> computedElements, Matrix rhs) {
+        for (AbstractComputedElement element : computedElements) {
             LfBranch lfBranch = element.getLfBranch();
             if (lfBranch.getBus1() == null || lfBranch.getBus2() == null) {
                 continue;
@@ -109,23 +124,27 @@ private static void fillRhs(EquationSystem<DcVariableType, DcEquationType> equat
         }
     }
 
-    public static DenseMatrix initRhs(EquationSystem<DcVariableType, DcEquationType> equationSystem, Collection<? extends ComputedElement> elements) {
+    public static DenseMatrix initRhs(EquationSystem<DcVariableType, DcEquationType> equationSystem, Collection<? extends AbstractComputedElement> elements) {
+        // the number of columns of the rhs equals the number of distinct branches affected by the computed elements
+        // those affecting the same branch share the same column
+        int columnCount = (int) elements.stream().map(AbstractComputedElement::getLfBranch).filter(Objects::nonNull).distinct().count();
         // otherwise, defining the rhs matrix will result in integer overflow
         int equationCount = equationSystem.getIndex().getSortedEquationsToSolve().size();
         int maxElements = Integer.MAX_VALUE / (equationCount * Double.BYTES);
-        if (elements.size() > maxElements) {
-            throw new PowsyblException("Too many elements " + elements.size()
+        if (columnCount > maxElements) {
+            throw new PowsyblException("Too many elements " + columnCount
                     + ", maximum is " + maxElements + " for a system with " + equationCount + " equations");
         }
-
-        DenseMatrix rhs = new DenseMatrix(equationCount, elements.size());
+        DenseMatrix rhs = new DenseMatrix(equationCount, columnCount);
         fillRhs(equationSystem, elements, rhs);
         return rhs;
     }
 
-    public static DenseMatrix calculateElementsStates(DcLoadFlowContext loadFlowContext, Collection<? extends ComputedElement> computedElements) {
+    public static DenseMatrix calculateElementsStates(DcLoadFlowContext loadFlowContext, Collection<? extends AbstractComputedElement> computedElements) {
         DenseMatrix elementsStates = initRhs(loadFlowContext.getEquationSystem(), computedElements); // rhs with +1 -1 on computed elements
         loadFlowContext.getJacobianMatrix().solveTransposed(elementsStates);
         return elementsStates;
     }
+
+    public abstract void applyToConnectivity(GraphConnectivity<LfBus, LfBranch> connectivity);
 }

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

@@ -18,13 +18,11 @@
 import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.LfNetwork;
 
-import java.util.Collection;
-
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  * @author Gaël Macherel {@literal <gael.macherel@artelys.com>}
  */
-public final class ComputedContingencyElement extends ComputedElement {
+public final class ComputedContingencyElement extends AbstractComputedElement {
 
     private final ContingencyElement element;
 
@@ -38,13 +36,11 @@ public ContingencyElement getElement() {
         return element;
     }
 
-    public static void applyToConnectivity(LfNetwork lfNetwork, GraphConnectivity<LfBus, LfBranch> connectivity, Collection<ComputedContingencyElement> breakingConnectivityElements) {
-        breakingConnectivityElements.stream()
-                .map(ComputedContingencyElement::getElement)
-                .map(ContingencyElement::getId)
-                .distinct()
-                .map(lfNetwork::getBranchById)
-                .filter(b -> b.getBus1() != null && b.getBus2() != null)
-                .forEach(connectivity::removeEdge);
+    @Override
+    public void applyToConnectivity(GraphConnectivity<LfBus, LfBranch> connectivity) {
+        LfBranch lfBranch = getLfBranch();
+        if (lfBranch.getBus1() != null && lfBranch.getBus2() != null) {
+            connectivity.removeEdge(lfBranch);
+        }
     }
 }

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

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2024, Coreso SA (https://www.coreso.eu/) and TSCNET Services GmbH (https://www.tscnet.eu/)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+package com.powsybl.openloadflow.dc.fastdc;
+
+import com.powsybl.openloadflow.dc.equations.ClosedBranchSide1DcFlowEquationTerm;
+import com.powsybl.openloadflow.dc.equations.DcEquationType;
+import com.powsybl.openloadflow.dc.equations.DcVariableType;
+import com.powsybl.openloadflow.equations.EquationSystem;
+import com.powsybl.openloadflow.graph.GraphConnectivity;
+import com.powsybl.openloadflow.network.ElementType;
+import com.powsybl.openloadflow.network.LfBranch;
+import com.powsybl.openloadflow.network.LfBus;
+
+/**
+ * @author Pierre Arvy {@literal <pierre.arvy@artelys.com>}
+ */
+public final class ComputedSwitchBranchElement extends AbstractComputedElement {
+
+    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));
+        this.enabled = enabled;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void applyToConnectivity(GraphConnectivity<LfBus, LfBranch> connectivity) {
+        LfBranch lfBranch = getLfBranch();
+        if (lfBranch.getBus1() != null && lfBranch.getBus2() != null) {
+            if (isEnabled()) {
+                connectivity.addEdge(lfBranch.getBus1(), lfBranch.getBus2(), lfBranch);
+            } else {
+                connectivity.removeEdge(lfBranch);
+            }
+        }
+    }
+}

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

@@ -11,13 +11,16 @@
 import com.powsybl.openloadflow.dc.equations.DcEquationType;
 import com.powsybl.openloadflow.dc.equations.DcVariableType;
 import com.powsybl.openloadflow.equations.EquationSystem;
+import com.powsybl.openloadflow.graph.GraphConnectivity;
 import com.powsybl.openloadflow.network.ElementType;
+import com.powsybl.openloadflow.network.LfBranch;
+import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.TapPositionChange;
 
 /**
  * @author Pierre Arvy {@literal <pierre.arvy@artelys.com>}
  */
-public final class ComputedTapPositionChangeElement extends ComputedElement {
+public final class ComputedTapPositionChangeElement extends AbstractComputedElement {
 
     private final TapPositionChange tapPositionChange;
 
@@ -29,4 +32,9 @@ public ComputedTapPositionChangeElement(TapPositionChange tapPositionChange, Equ
     public TapPositionChange getTapPositionChange() {
         return tapPositionChange;
     }
+
+    @Override
+    public void applyToConnectivity(GraphConnectivity<LfBus, LfBranch> connectivity) {
+        // nothing to do
+    }
 }