Contingency refactoring

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

@@ -14,10 +14,7 @@
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.io.Writer;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
 
 /**
  * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
@@ -38,6 +35,8 @@ public class LfContingency {
 
     private final Set<LfGenerator> generators;
 
+    private final Set<LfGenerator> participatingGeneratorsToBeRemoved = new HashSet<>();
+
     private double activePowerLoss = 0;
 
     public LfContingency(String id, int index, Set<LfBus> disabledBuses, Set<LfBranch> disabledBranches, Map<LfShunt, Double> shuntsShift,
@@ -92,7 +91,7 @@ public double getActivePowerLoss() {
         return activePowerLoss;
     }
 
-    public void apply(LoadFlowParameters parameters) {
+    public void apply(LoadFlowParameters.BalanceType balanceType) {
         for (LfBranch branch : disabledBranches) {
             branch.setDisabled(true);
         }
@@ -106,7 +105,7 @@ public void apply(LoadFlowParameters parameters) {
         for (var e : busesLoadShift.entrySet()) {
             LfBus bus = e.getKey();
             PowerShift shift = e.getValue();
-            bus.setLoadTargetP(bus.getLoadTargetP() - getUpdatedLoadP0(bus, parameters.getBalanceType(), shift.getActive(), shift.getVariableActive()));
+            bus.setLoadTargetP(bus.getLoadTargetP() - getUpdatedLoadP0(bus, balanceType, shift.getActive(), shift.getVariableActive()));
             bus.setLoadTargetQ(bus.getLoadTargetQ() - shift.getReactive());
             bus.getLoads().setAbsVariableLoadTargetP(bus.getLoads().getAbsVariableLoadTargetP() - Math.abs(shift.getVariableActive()) * PerUnit.SB);
         }
@@ -118,6 +117,7 @@ public void apply(LoadFlowParameters parameters) {
             generator.setParticipating(false);
             if (generator.getGeneratorControlType() != LfGenerator.GeneratorControlType.OFF) {
                 generator.setGeneratorControlType(LfGenerator.GeneratorControlType.OFF);
+                participatingGeneratorsToBeRemoved.add(generator);
             } else {
                 bus.setGenerationTargetQ(bus.getGenerationTargetQ() - generator.getTargetQ());
             }
@@ -131,14 +131,37 @@ public void apply(LoadFlowParameters parameters) {
 
     public static double getUpdatedLoadP0(LfBus bus, LoadFlowParameters.BalanceType balanceType, double initialP0, double initialVariableActivePower) {
         double factor = 0.0;
-        if (balanceType == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD) {
-            factor = Math.abs(initialP0) / (bus.getLoads().getAbsVariableLoadTargetP() / PerUnit.SB);
-        } else if (balanceType == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD) {
-            factor = initialVariableActivePower / (bus.getLoads().getAbsVariableLoadTargetP() / PerUnit.SB);
+        if (bus.getLoads().getLoadCount() > 0) {
+            if (balanceType == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD) {
+                factor = Math.abs(initialP0) / (bus.getLoads().getAbsVariableLoadTargetP() / PerUnit.SB);
+            } else if (balanceType == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD) {
+                factor = initialVariableActivePower / (bus.getLoads().getAbsVariableLoadTargetP() / PerUnit.SB);
+            }
         }
         return initialP0 + (bus.getLoadTargetP() - bus.getInitialLoadTargetP()) * factor;
     }
 
+    public Set<LfGenerator> getParticipatingGeneratorsToBeRemoved() {
+        return participatingGeneratorsToBeRemoved;
+    }
+
+    public Set<LfBus> getLoadAndGeneratorBuses() {
+        Set<LfBus> affectedBuses = new HashSet<>();
+        for (var e : busesLoadShift.entrySet()) {
+            LfBus bus = e.getKey();
+            if (bus != null) {
+                affectedBuses.add(bus);
+            }
+        }
+        for (LfGenerator generator : generators) {
+            LfBus bus = generator.getBus();
+            if (bus != null) {
+                affectedBuses.add(bus);
+            }
+        }
+        return affectedBuses;
+    }
+
     public void writeJson(Writer writer) {
         Objects.requireNonNull(writer);
         try (JsonGenerator jsonGenerator = new JsonFactory()

src/main/java/com/powsybl/openloadflow/network/impl/PropagatedContingency.java

@@ -10,6 +10,7 @@
 import com.powsybl.contingency.Contingency;
 import com.powsybl.contingency.ContingencyElement;
 import com.powsybl.iidm.network.*;
+import com.powsybl.iidm.network.extensions.HvdcAngleDroopActivePowerControl;
 import com.powsybl.iidm.network.extensions.LoadDetail;
 import com.powsybl.openloadflow.graph.GraphDecrementalConnectivity;
 import com.powsybl.openloadflow.network.*;
@@ -104,11 +105,11 @@ private static PowerShift getLoadPowerShift(Load load, boolean slackDistribution
     }
 
     public static List<PropagatedContingency> createListForSensitivityAnalysis(Network network, List<Contingency> contingencies,
-                                                                               boolean slackDistributionOnConformLoad) {
+                                                                               boolean slackDistributionOnConformLoad, boolean hvdcAcEmulation) {
         List<PropagatedContingency> propagatedContingencies = new ArrayList<>();
         for (int index = 0; index < contingencies.size(); index++) {
             Contingency contingency = contingencies.get(index);
-            PropagatedContingency propagatedContingency = PropagatedContingency.create(network, contingency, index, false, false, slackDistributionOnConformLoad);
+            PropagatedContingency propagatedContingency = PropagatedContingency.create(network, contingency, index, false, false, slackDistributionOnConformLoad, hvdcAcEmulation);
             Optional<Switch> coupler = propagatedContingency.switchesToOpen.stream().filter(PropagatedContingency::isCoupler).findFirst();
             if (coupler.isEmpty()) {
                 propagatedContingencies.add(propagatedContingency);
@@ -123,24 +124,26 @@ public static List<PropagatedContingency> createListForSensitivityAnalysis(Netwo
 
     public static List<PropagatedContingency> createListForSecurityAnalysis(Network network, List<Contingency> contingencies,
                                                                             Set<Switch> allSwitchesToOpen, boolean shuntCompensatorVoltageControlOn,
-                                                                            boolean slackDistributionOnConformLoad) {
+                                                                            boolean slackDistributionOnConformLoad, boolean hvdcAcEmulation) {
         List<PropagatedContingency> propagatedContingencies = new ArrayList<>();
         for (int index = 0; index < contingencies.size(); index++) {
             Contingency contingency = contingencies.get(index);
             PropagatedContingency propagatedContingency =
-                    PropagatedContingency.create(network, contingency, index, shuntCompensatorVoltageControlOn, true, slackDistributionOnConformLoad);
+                    PropagatedContingency.create(network, contingency, index, shuntCompensatorVoltageControlOn, true, slackDistributionOnConformLoad, hvdcAcEmulation);
             propagatedContingencies.add(propagatedContingency);
             allSwitchesToOpen.addAll(propagatedContingency.switchesToOpen);
         }
         return propagatedContingencies;
     }
 
     private static PropagatedContingency create(Network network, Contingency contingency, int index, boolean shuntCompensatorVoltageControlOn,
-                                                boolean withBreakers, boolean slackDistributionOnConformLoad) {
+                                                boolean withBreakers, boolean slackDistributionOnConformLoad, boolean hvdcAcEmulation) {
         Set<Switch> switchesToOpen = new HashSet<>();
         Set<Terminal> terminalsToDisconnect =  new HashSet<>();
         Set<String> branchIdsToOpen = new HashSet<>();
         Set<String> hvdcIdsToOpen = new HashSet<>();
+        Set<VscConverterStation> vscsToLose = new HashSet<>();
+        Set<LccConverterStation> lccsToLose = new HashSet<>();
         Set<Load> loadsToLose = new HashSet<>();
         Set<Generator> generatorsToLose = new HashSet<>();
         Set<ShuntCompensator> shuntsToLose = new HashSet<>();
@@ -160,7 +163,26 @@ private static PropagatedContingency create(Network network, Contingency conting
                     if (hvdcLine == null) {
                         throw new PowsyblException("HVDC line '" + element.getId() + "' not found in the network");
                     }
-                    hvdcIdsToOpen.add(element.getId());
+                    HvdcAngleDroopActivePowerControl control = hvdcLine.getExtension(HvdcAngleDroopActivePowerControl.class);
+                    if (control != null && control.isEnabled() && hvdcAcEmulation) {
+                        // Not depending on AC or DC computation.
+                        throw new PowsyblException("Contingency on HVDC line '" + element.getId() + "' with AC emulation control: not supported yet.");
+                    }
+                    hvdcIdsToOpen.add(element.getId()); // FIXME: try to use it only for HVDC in AC emulation.
+                    if (hvdcLine.getConverterStation1() instanceof VscConverterStation) {
+                        VscConverterStation vsc1 = (VscConverterStation) hvdcLine.getConverterStation1();
+                        vscsToLose.add(vsc1);
+                    } else {
+                        LccConverterStation lcc1 = (LccConverterStation) hvdcLine.getConverterStation1();
+                        lccsToLose.add(lcc1);
+                    }
+                    if (hvdcLine.getConverterStation2() instanceof VscConverterStation) {
+                        VscConverterStation vsc2 = (VscConverterStation) hvdcLine.getConverterStation2();
+                        vscsToLose.add(vsc2);
+                    } else {
+                        LccConverterStation lcc2 = (LccConverterStation) hvdcLine.getConverterStation2();
+                        lccsToLose.add(lcc2);
+                    }
                     break;
                 case DANGLING_LINE:
                     // dangling line check is done inside tripping
@@ -218,6 +240,14 @@ private static PropagatedContingency create(Network network, Contingency conting
                     shuntsToLose.add((ShuntCompensator) connectable);
                     break;
 
+                case HVDC_CONVERTER_STATION:
+                    if (connectable instanceof VscConverterStation) {
+                        vscsToLose.add((VscConverterStation) connectable);
+                    } else {
+                        lccsToLose.add((LccConverterStation) connectable);
+                    }
+                    break;
+
                 case BUSBAR_SECTION:
                     // we don't care
                     break;
@@ -235,6 +265,9 @@ private static PropagatedContingency create(Network network, Contingency conting
         for (Generator generator : generatorsToLose) {
             generatorIdsToLose.add(generator.getId());
         }
+        for (VscConverterStation vsc : vscsToLose) {
+            generatorIdsToLose.add(vsc.getId());
+        }
         for (Load load : loadsToLose) {
             Bus bus = withBreakers ? load.getTerminal().getBusBreakerView().getBus()
                                    : load.getTerminal().getBusView().getBus();
@@ -243,6 +276,16 @@ private static PropagatedContingency create(Network network, Contingency conting
                         .add(getLoadPowerShift(load, slackDistributionOnConformLoad));
             }
         }
+        for (LccConverterStation lcc : lccsToLose) {
+            Bus bus = withBreakers ? lcc.getTerminal().getBusBreakerView().getBus()
+                    : lcc.getTerminal().getBusView().getBus();
+            if (bus != null) {
+                // No variable active part for a LCC.
+                loadIdsToShift.computeIfAbsent(bus.getId(), k -> new PowerShift())
+                        .add(new PowerShift(HvdcConverterStations.getConverterStationTargetP(lcc) / PerUnit.SB, 0,
+                                HvdcConverterStations.getLccConverterStationLoadTargetQ(lcc) / PerUnit.SB));
+            }
+        }
         for (ShuntCompensator shunt : shuntsToLose) {
             double nominalV = shunt.getTerminal().getVoltageLevel().getNominalV();
             shuntIdsToShift.put(shunt.getId(), shunt.getB() * nominalV * nominalV / PerUnit.SB);
@@ -291,10 +334,6 @@ public Optional<LfContingency> toLfContingency(LfNetwork network, boolean useSma
         // reset connectivity to discard triggered branches
         connectivity.reset();
 
-        if (!hvdcIdsToOpen.isEmpty()) {
-            throw new UnsupportedOperationException("HVDC line contingency not supported");
-        }
-
         Map<LfShunt, Double> shunts = new HashMap<>(1);
         for (var e : shuntIdsToShift.entrySet()) {
             LfShunt shunt = network.getShuntById(e.getKey());

src/main/java/com/powsybl/openloadflow/sa/AcSecurityAnalysis.java

@@ -68,7 +68,8 @@ SecurityAnalysisReport runSync(String workingVariantId, SecurityAnalysisParamete
         // try to find all switches impacted by at least one contingency and for each contingency the branches impacted
         Set<Switch> allSwitchesToOpen = new HashSet<>();
         List<PropagatedContingency> propagatedContingencies = PropagatedContingency.createListForSecurityAnalysis(network, contingencies, allSwitchesToOpen,
-                lfParameters.isShuntCompensatorVoltageControlOn(), lfParameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD);
+                lfParameters.isShuntCompensatorVoltageControlOn(), lfParameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD,
+                lfParameters.isHvdcAcEmulation());
 
         AcLoadFlowParameters acParameters = OpenLoadFlowParameters.createAcParameters(network, lfParameters, lfParametersExt, matrixFactory, connectivityFactory, Reporter.NO_OP, true, false);
 
@@ -146,7 +147,7 @@ private SecurityAnalysisResult runSimulations(LfNetwork network, List<Propagated
                     PropagatedContingency propagatedContingency = contingencyIt.next();
                     propagatedContingency.toLfContingency(network, true)
                             .ifPresent(lfContingency -> { // only process contingencies that impact the network
-                                lfContingency.apply(loadFlowParameters);
+                                lfContingency.apply(loadFlowParameters.getBalanceType());
 
                                 distributedMismatch(network, lfContingency.getActivePowerLoss(), loadFlowParameters, openLoadFlowParameters);
 

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

@@ -21,10 +21,7 @@
 import com.powsybl.openloadflow.equations.Quantity;
 import com.powsybl.openloadflow.graph.GraphDecrementalConnectivity;
 import com.powsybl.openloadflow.graph.GraphDecrementalConnectivityFactory;
-import com.powsybl.openloadflow.network.LfBranch;
-import com.powsybl.openloadflow.network.LfBus;
-import com.powsybl.openloadflow.network.LfElement;
-import com.powsybl.openloadflow.network.LfNetwork;
+import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.network.impl.HvdcConverterStations;
 import com.powsybl.openloadflow.network.impl.LfDanglingLineBus;
 import com.powsybl.openloadflow.network.impl.PropagatedContingency;
@@ -553,8 +550,8 @@ public void fillRhs(Matrix rhs, Map<LfBus, Double> participationByBus) {
 
         boolean updateConnectivityWeights(Set<LfBus> nonConnectedBuses) {
             mainComponentWeights = variableElements.entrySet().stream()
-                .filter(entry -> !nonConnectedBuses.contains((LfBus) entry.getKey()))
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+                    .filter(entry -> !nonConnectedBuses.contains((LfBus) entry.getKey()))
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
             return mainComponentWeights.size() != variableElements.size();
         }
     }
@@ -709,7 +706,7 @@ public void checkContingencies(LfNetwork lfNetwork, List<PropagatedContingency>
                 }
             }
             contingency.getBranchIdsToOpen().removeAll(branchesToRemove);
-            if (contingency.getBranchIdsToOpen().isEmpty() && contingency.getHvdcIdsToOpen().isEmpty() && contingency.getGeneratorIdsToLose().isEmpty() && contingency.getLoadIdsToShift().isEmpty()) {
+            if (contingency.getBranchIdsToOpen().isEmpty() && contingency.getGeneratorIdsToLose().isEmpty() && contingency.getLoadIdsToShift().isEmpty()) {
                 LOGGER.warn("Contingency {} has no impact", contingency.getContingency().getId());
             }
         }