AC Security Analysis with operator strategies

src/main/java/com/powsybl/openloadflow/ac/equations/AbstractHvdcAcEmulationFlowEquationTerm.java

@@ -14,12 +14,15 @@
 import com.powsybl.openloadflow.network.LfHvdc;
 
 import java.util.List;
+import java.util.Objects;
 
 /**
  * @author Anne Tilloy <anne.tilloy at rte-france.com>
  */
 public abstract class AbstractHvdcAcEmulationFlowEquationTerm extends AbstractNamedEquationTerm<AcVariableType, AcEquationType> {
 
+    protected final LfHvdc hvdc;
+
     protected final Variable<AcVariableType> ph1Var;
 
     protected final Variable<AcVariableType> ph2Var;
@@ -30,17 +33,16 @@ public abstract class AbstractHvdcAcEmulationFlowEquationTerm extends AbstractNa
 
     protected final double p0;
 
-    protected final LfHvdc hvdc;
-
     protected final double lossFactor1;
 
     protected final double lossFactor2;
 
     protected AbstractHvdcAcEmulationFlowEquationTerm(LfHvdc hvdc, LfBus bus1, LfBus bus2, VariableSet<AcVariableType> variableSet) {
+        super(!Objects.requireNonNull(hvdc).isDisabled());
+        this.hvdc = hvdc;
         ph1Var = variableSet.getVariable(bus1.getNum(), AcVariableType.BUS_PHI);
         ph2Var = variableSet.getVariable(bus2.getNum(), AcVariableType.BUS_PHI);
         variables = List.of(ph1Var, ph2Var);
-        this.hvdc = hvdc;
         k = hvdc.getDroop() * 180 / Math.PI;
         p0 = hvdc.getP0();
         lossFactor1 = hvdc.getConverterStation1().getLossFactor() / 100;

src/main/java/com/powsybl/openloadflow/ac/equations/AbstractShuntCompensatorEquationTerm.java

@@ -25,7 +25,8 @@ public abstract class AbstractShuntCompensatorEquationTerm extends AbstractNamed
     protected final Variable<AcVariableType> vVar;
 
     protected AbstractShuntCompensatorEquationTerm(LfShunt shunt, LfBus bus, VariableSet<AcVariableType> variableSet) {
-        this.shunt = Objects.requireNonNull(shunt);
+        super(!Objects.requireNonNull(shunt).isDisabled());
+        this.shunt = shunt;
         Objects.requireNonNull(bus);
         Objects.requireNonNull(variableSet);
         vVar = variableSet.getVariable(bus.getNum(), AcVariableType.BUS_V);

src/main/java/com/powsybl/openloadflow/equations/AbstractBranchEquationTerm.java

@@ -19,7 +19,8 @@ public abstract class AbstractBranchEquationTerm<V extends Enum<V> & Quantity, E
     protected final LfBranch branch;
 
     protected AbstractBranchEquationTerm(LfBranch branch) {
-        this.branch = Objects.requireNonNull(branch);
+        super(!Objects.requireNonNull(branch).isDisabled());
+        this.branch = branch;
     }
 
     @Override

src/main/java/com/powsybl/openloadflow/equations/AbstractBusEquationTerm.java

@@ -19,7 +19,8 @@ public abstract class AbstractBusEquationTerm<V extends Enum<V> & Quantity, E ex
     protected final LfBus bus;
 
     protected AbstractBusEquationTerm(LfBus bus) {
-        this.bus = Objects.requireNonNull(bus);
+        super(!Objects.requireNonNull(bus).isDisabled());
+        this.bus = bus;
     }
 
     @Override

src/main/java/com/powsybl/openloadflow/equations/AbstractEquationTerm.java

@@ -17,12 +17,20 @@ public abstract class AbstractEquationTerm<V extends Enum<V> & Quantity, E exten
 
     private Equation<V, E> equation;
 
-    private boolean active = true;
+    private boolean active;
 
     protected StateVector sv;
 
     protected EquationTerm<V, E> self = this;
 
+    protected AbstractEquationTerm() {
+        this(true);
+    }
+
+    protected AbstractEquationTerm(boolean active) {
+        this.active = active;
+    }
+
     @Override
     public void setStateVector(StateVector sv) {
         this.sv = Objects.requireNonNull(sv);

src/main/java/com/powsybl/openloadflow/equations/AbstractNamedEquationTerm.java

@@ -15,6 +15,10 @@
  */
 public abstract class AbstractNamedEquationTerm<V extends Enum<V> & Quantity, E extends Enum<E> & Quantity> extends AbstractEquationTerm<V, E> {
 
+    protected AbstractNamedEquationTerm(boolean active) {
+        super(active);
+    }
+
     protected abstract String getName();
 
     @Override

src/main/java/com/powsybl/openloadflow/equations/Equation.java

@@ -66,11 +66,12 @@ public boolean isActive() {
         return active;
     }
 
-    public void setActive(boolean active) {
+    public Equation<V, E> setActive(boolean active) {
         if (active != this.active) {
             this.active = active;
             equationSystem.notifyEquationChange(this, active ? EquationEventType.EQUATION_ACTIVATED : EquationEventType.EQUATION_DEACTIVATED);
         }
+        return this;
     }
 
     public Equation<V, E> addTerm(EquationTerm<V, E> term) {

src/main/java/com/powsybl/openloadflow/equations/EquationSystem.java

@@ -8,6 +8,7 @@
 
 import com.powsybl.commons.PowsyblException;
 import com.powsybl.openloadflow.network.ElementType;
+import com.powsybl.openloadflow.network.LfElement;
 import com.powsybl.openloadflow.network.LfNetwork;
 import org.apache.commons.lang3.tuple.Pair;
 
@@ -101,6 +102,21 @@ public <T extends EquationTerm<V, E>> T getEquationTerm(ElementType elementType,
                 .orElseThrow(() -> new PowsyblException("Equation term not found"));
     }
 
+    public Equation<V, E> createEquation(LfElement element, E type) {
+        Objects.requireNonNull(element);
+        Objects.requireNonNull(type);
+        if (element.getType() != type.getElementType()) {
+            throw new PowsyblException("Incorrect equation type: " + type);
+        }
+        Pair<Integer, E> p = Pair.of(element.getNum(), type);
+        Equation<V, E> equation = equations.get(p);
+        if (equation == null) {
+            equation = addEquation(p)
+                    .setActive(!element.isDisabled());
+        }
+        return equation;
+    }
+
     public Equation<V, E> createEquation(int num, E type) {
         Pair<Integer, E> p = Pair.of(num, type);
         Equation<V, E> equation = equations.get(p);

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

@@ -11,16 +11,21 @@
  */
 public class BranchState extends ElementState<LfBranch> {
 
-    private final double a1;
-    private final double r1;
+    private double a1 = Double.NaN;
+    private double r1 = Double.NaN;
     private final boolean phaseControlEnabled;
     private final boolean voltageControlEnabled;
+    private Integer tapPosition;
 
     public BranchState(LfBranch branch) {
         super(branch);
         PiModel piModel = branch.getPiModel();
-        a1 = piModel.getA1();
-        r1 = piModel.getR1();
+        if (piModel instanceof PiModelArray) {
+            tapPosition = piModel.getTapPosition();
+        } else {
+            a1 = piModel.getA1();
+            r1 = piModel.getR1();
+        }
         phaseControlEnabled = branch.isPhaseControlEnabled();
         voltageControlEnabled = branch.isVoltageControlEnabled();
     }
@@ -29,8 +34,15 @@ public BranchState(LfBranch branch) {
     public void restore() {
         super.restore();
         PiModel piModel = element.getPiModel();
-        piModel.setA1(a1);
-        piModel.setR1(r1);
+        if (tapPosition != null) {
+            piModel.setTapPosition(tapPosition);
+        }
+        if (!Double.isNaN(a1)) {
+            piModel.setA1(a1);
+        }
+        if (!Double.isNaN(r1)) {
+            piModel.setR1(r1);
+        }
         element.setPhaseControlEnabled(phaseControlEnabled);
         element.setVoltageControlEnabled(voltageControlEnabled);
     }

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

@@ -0,0 +1,190 @@
+/**
+ * Copyright (c) 2022, RTE (http://www.rte-france.com)
+ * 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/.
+ */
+package com.powsybl.openloadflow.network;
+
+import com.powsybl.commons.PowsyblException;
+import com.powsybl.openloadflow.graph.GraphConnectivity;
+import com.powsybl.security.action.Action;
+import com.powsybl.security.action.LineConnectionAction;
+import com.powsybl.security.action.PhaseTapChangerTapPositionAction;
+import com.powsybl.security.action.SwitchAction;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * @author Anne Tilloy <anne.tilloy at rte-france.com>
+ */
+public class LfAction {
+
+    private static final class TapPositionChange {
+
+        private final LfBranch branch;
+
+        private final int value;
+
+        private final boolean relative;
+
+        private TapPositionChange(LfBranch branch, int value, boolean relative) {
+            this.branch = Objects.requireNonNull(branch);
+            this.value = value;
+            this.relative = relative;
+        }
+
+        public LfBranch getBranch() {
+            return branch;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public boolean isRelative() {
+            return relative;
+        }
+    }
+
+    private final String id;
+
+    private LfBranch disabledBranch; // switch to open
+
+    private LfBranch enabledBranch; // switch to close
+
+    private TapPositionChange tapPositionChange;
+
+    public LfAction(Action action, LfNetwork network) {
+        this.id = Objects.requireNonNull(action.getId());
+        Objects.requireNonNull(network);
+        LfBranch branch;
+        switch (action.getType()) {
+            case SwitchAction.NAME:
+                SwitchAction switchAction = (SwitchAction) action;
+                branch = network.getBranchById(switchAction.getSwitchId());
+                checkBranch(branch, switchAction.getSwitchId());
+                if (switchAction.isOpen()) {
+                    disabledBranch = branch;
+                } else {
+                    enabledBranch = branch;
+                }
+                break;
+            case LineConnectionAction.NAME:
+                LineConnectionAction lineConnectionAction = (LineConnectionAction) action;
+                branch = network.getBranchById(lineConnectionAction.getLineId());
+                checkBranch(branch, lineConnectionAction.getLineId());
+                if (lineConnectionAction.isOpenSide1() && lineConnectionAction.isOpenSide2()) {
+                    disabledBranch = branch;
+                } else {
+                    throw new UnsupportedOperationException("Line connection action: only open line at both sides is supported yet.");
+                }
+                break;
+            case PhaseTapChangerTapPositionAction.NAME:
+                PhaseTapChangerTapPositionAction phaseTapChangerTapPositionAction = (PhaseTapChangerTapPositionAction) action;
+                branch = network.getBranchById(phaseTapChangerTapPositionAction.getTransformerId()); // only two windings transformer for the moment.
+                checkBranch(branch, phaseTapChangerTapPositionAction.getTransformerId()); // how to check that it is really a phase tap changer?
+                if (branch.getPiModel() instanceof SimplePiModel) {
+                    throw new UnsupportedOperationException("Phase tap changer tap connection action: only one tap in the branch {" + phaseTapChangerTapPositionAction.getTransformerId() + "}");
+                } else {
+                    tapPositionChange = new TapPositionChange(branch, phaseTapChangerTapPositionAction.getValue(), phaseTapChangerTapPositionAction.isRelativeValue());
+                }
+                break;
+            default:
+                throw new UnsupportedOperationException("Unsupported action type: " + action.getType());
+        }
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public LfBranch getDisabledBranch() {
+        return disabledBranch;
+    }
+
+    public LfBranch getEnabledBranch() {
+        return enabledBranch;
+    }
+
+    public static void apply(List<LfAction> actions, LfNetwork network, LfContingency contingency) {
+        Objects.requireNonNull(actions);
+        Objects.requireNonNull(network);
+
+        // first process connectivity part of actions
+        updateConnectivity(actions, network, contingency);
+
+        // then process remaining changes of actions
+        for (LfAction action : actions) {
+            action.apply();
+        }
+    }
+
+    private static void updateConnectivity(List<LfAction> actions, LfNetwork network, LfContingency contingency) {
+        GraphConnectivity<LfBus, LfBranch> connectivity = network.getConnectivity();
+
+        // re-update connectivity according to post contingency state (revert after LfContingency apply)
+        connectivity.startTemporaryChanges();
+        contingency.getDisabledBranches().forEach(connectivity::removeEdge);
+
+        // update connectivity according to post action state
+        connectivity.startTemporaryChanges();
+        for (LfAction action : actions) {
+            action.updateConnectivity(connectivity);
+        }
+
+        // add to action description buses and branches that won't be part of the main connected
+        // component in post action state.
+        Set<LfBus> removedBuses = connectivity.getVerticesRemovedFromMainComponent();
+        removedBuses.forEach(bus -> bus.setDisabled(true));
+        Set<LfBranch> removedBranches = new HashSet<>(connectivity.getEdgesRemovedFromMainComponent());
+        // we should manage branches open at one side.
+        for (LfBus bus : removedBuses) {
+            bus.getBranches().stream().filter(b -> !b.isConnectedAtBothSides()).forEach(removedBranches::add);
+        }
+        removedBranches.forEach(branch -> branch.setDisabled(true));
+
+        // add to action description buses and branches that will be part of the main connected
+        // component in post action state.
+        Set<LfBus> addedBuses = connectivity.getVerticesAddedToMainComponent();
+        addedBuses.forEach(bus -> bus.setDisabled(false));
+        Set<LfBranch> addedBranches = new HashSet<>(connectivity.getEdgesAddedToMainComponent());
+        // we should manage branches open at one side.
+        for (LfBus bus : addedBuses) {
+            bus.getBranches().stream().filter(b -> !b.isConnectedAtBothSides()).forEach(addedBranches::add);
+        }
+        addedBranches.forEach(branch -> branch.setDisabled(false));
+
+        // reset connectivity to discard post contingency connectivity and post action connectivity
+        connectivity.undoTemporaryChanges();
+        connectivity.undoTemporaryChanges();
+    }
+
+    public void updateConnectivity(GraphConnectivity<LfBus, LfBranch> connectivity) {
+        if (disabledBranch != null && disabledBranch.getBus1() != null && disabledBranch.getBus2() != null) {
+            connectivity.removeEdge(disabledBranch);
+        }
+        if (enabledBranch != null) {
+            connectivity.addEdge(enabledBranch.getBus1(), enabledBranch.getBus2(), enabledBranch);
+        }
+    }
+
+    public void apply() {
+        if (tapPositionChange != null) {
+            LfBranch branch = tapPositionChange.getBranch();
+            int tapPosition = branch.getPiModel().getTapPosition();
+            int value = tapPositionChange.getValue();
+            int newTapPosition = tapPositionChange.isRelative() ? tapPosition + value : value;
+            branch.getPiModel().setTapPosition(newTapPosition);
+        }
+    }
+
+    private static void checkBranch(LfBranch branch, String branchId) {
+        if (branch == null) {
+            throw new PowsyblException("Branch " + branchId + " not found in the network");
+        }
+    }
+}

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

@@ -546,6 +546,7 @@ public GraphConnectivity<LfBus, LfBranch> getConnectivity() {
             getBranches().stream()
                     .filter(b -> b.getBus1() != null && b.getBus2() != null)
                     .forEach(b -> connectivity.addEdge(b.getBus1(), b.getBus2(), b));
+            connectivity.setMainComponentVertex(getSlackBus());
         }
         return connectivity;
     }

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

@@ -81,4 +81,8 @@ enum AllowedDirection {
     boolean setMinZ(double minZ, boolean dc);
 
     void setBranch(LfBranch branch);
+
+    int getTapPosition();
+
+    PiModel setTapPosition(int tapPosition);
 }