Support of switch contingency in sensitivity analysis and refactoring

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

@@ -9,9 +9,7 @@
 import com.powsybl.openloadflow.util.Evaluable;
 import com.powsybl.security.results.BusResult;
 
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 
 /**
  * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
@@ -151,7 +149,9 @@ default boolean isParticipating() {
         return false;
     }
 
-    BusResult createBusResult();
+    default List<BusResult> createBusResults() {
+        return Collections.emptyList();
+    }
 
     /**
      * Find bus + parallel branches neighbors.

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

@@ -11,7 +11,6 @@
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.util.Evaluable;
 import com.powsybl.openloadflow.util.PerUnit;
-import com.powsybl.security.results.BusResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -542,11 +541,6 @@ public Evaluable getQ() {
         return q;
     }
 
-    @Override
-    public BusResult createBusResult() {
-        return new BusResult(getVoltageLevelId(), getId(), v, getAngle());
-    }
-
     @Override
     public Map<LfBus, List<LfBranch>> findNeighbors() {
         Map<LfBus, List<LfBranch>> neighbors = new LinkedHashMap<>(branches.size());

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

@@ -9,8 +9,11 @@
 import com.powsybl.iidm.network.Bus;
 import com.powsybl.iidm.network.extensions.SlackTerminal;
 import com.powsybl.openloadflow.network.LfNetwork;
+import com.powsybl.security.results.BusResult;
 
+import java.util.List;
 import java.util.Objects;
+import java.util.stream.Collectors;
 
 /**
  * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
@@ -27,18 +30,23 @@ public class LfBusImpl extends AbstractLfBus {
 
     private final boolean participating;
 
-    protected LfBusImpl(Bus bus, LfNetwork network, double v, double angle, boolean distributedOnConformLoad, boolean participating) {
+    private final boolean breakers;
+
+    protected LfBusImpl(Bus bus, LfNetwork network, double v, double angle, boolean distributedOnConformLoad,
+                        boolean participating, boolean breakers) {
         super(network, v, angle, distributedOnConformLoad);
         this.bus = bus;
         nominalV = bus.getVoltageLevel().getNominalV();
         lowVoltageLimit = bus.getVoltageLevel().getLowVoltageLimit();
         highVoltageLimit = bus.getVoltageLevel().getHighVoltageLimit();
         this.participating = participating;
+        this.breakers = breakers;
     }
 
-    public static LfBusImpl create(Bus bus, LfNetwork network, boolean distributedOnConformLoad, boolean participating) {
+    public static LfBusImpl create(Bus bus, LfNetwork network, boolean distributedOnConformLoad, boolean participating,
+                                   boolean breakers) {
         Objects.requireNonNull(bus);
-        return new LfBusImpl(bus, network, bus.getV(), bus.getAngle(), distributedOnConformLoad, participating);
+        return new LfBusImpl(bus, network, bus.getV(), bus.getAngle(), distributedOnConformLoad, participating, breakers);
     }
 
     @Override
@@ -87,4 +95,14 @@ public void updateState(boolean reactiveLimits, boolean writeSlackBus, boolean d
     public boolean isParticipating() {
         return participating;
     }
+
+    @Override
+    public List<BusResult> createBusResults() {
+        if (breakers) {
+            return List.of(new BusResult(getVoltageLevelId(), bus.getId(), v, getAngle()));
+        } else {
+            return bus.getVoltageLevel().getBusBreakerView().getBusesFromBusViewBusId(bus.getId())
+                    .stream().map(b -> new BusResult(getVoltageLevelId(), b.getId(), v, getAngle())).collect(Collectors.toList());
+        }
+    }
 }

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

@@ -222,7 +222,7 @@ private static Bus getBus(Terminal terminal, boolean breakers) {
 
     private static LfBusImpl createBus(Bus bus, LfNetworkParameters parameters, LfNetwork lfNetwork, LoadingContext loadingContext,
                                        LfNetworkLoadingReport report, List<LfNetworkLoaderPostProcessor> postProcessors) {
-        LfBusImpl lfBus = LfBusImpl.create(bus, lfNetwork, parameters.isDistributedOnConformLoad(), participateToSlackDistribution(parameters, bus));
+        LfBusImpl lfBus = LfBusImpl.create(bus, lfNetwork, parameters.isDistributedOnConformLoad(), participateToSlackDistribution(parameters, bus), parameters.isBreakers());
 
         List<ShuntCompensator> shuntCompensators = new ArrayList<>();
 

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

@@ -14,6 +14,8 @@
 
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
 
 /**
  * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
@@ -111,4 +113,22 @@ public static List<LfNetwork> load(Network network, SlackBusSelector slackBusSel
     public static List<LfNetwork> load(Network network, LfNetworkParameters parameters, Reporter reporter) {
         return LfNetwork.load(network, new LfNetworkLoaderImpl(), parameters, reporter);
     }
+
+    public static List<LfNetwork> load(Network network, LfNetworkParameters networkParameters,
+                                       Set<Switch> switchesToOpen, Reporter reporter) {
+        if (switchesToOpen.isEmpty()) {
+            return load(network, networkParameters, reporter);
+        } else {
+            String tmpVariantId = "olf-tmp-" + UUID.randomUUID();
+            network.getVariantManager().cloneVariant(network.getVariantManager().getWorkingVariantId(), tmpVariantId);
+            try {
+                network.getSwitchStream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
+                        .forEach(sw -> sw.setRetained(false));
+                switchesToOpen.forEach(sw -> sw.setRetained(true));
+                return load(network, networkParameters, reporter);
+            } finally {
+                network.getVariantManager().removeVariant(tmpVariantId);
+            }
+        }
+    }
 }

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

@@ -103,36 +103,23 @@ private static PowerShift getLoadPowerShift(Load load, boolean slackDistribution
                               load.getQ0() / PerUnit.SB);
     }
 
-    public static List<PropagatedContingency> createListForSensitivityAnalysis(Network network, List<Contingency> contingencies,
-                                                                               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, hvdcAcEmulation, false);
-            propagatedContingencies.add(propagatedContingency);
-        }
-        return propagatedContingencies;
-    }
-
-    public static List<PropagatedContingency> createListForSecurityAnalysis(Network network, List<Contingency> contingencies,
-                                                                            Set<Switch> allSwitchesToOpen, boolean shuntCompensatorVoltageControlOn,
-                                                                            boolean slackDistributionOnConformLoad, boolean hvdcAcEmulation,
-                                                                            boolean contingencyPropagation) {
+    public static List<PropagatedContingency> createList(Network network, List<Contingency> contingencies,
+                                                         Set<Switch> allSwitchesToOpen, boolean shuntCompensatorVoltageControlOn,
+                                                         boolean slackDistributionOnConformLoad, boolean hvdcAcEmulation,
+                                                         boolean contingencyPropagation) {
         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, hvdcAcEmulation, contingencyPropagation);
+                    PropagatedContingency.create(network, contingency, index, shuntCompensatorVoltageControlOn, slackDistributionOnConformLoad, hvdcAcEmulation, contingencyPropagation);
             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 hvdcAcEmulation,
-                                                boolean contingencyPropagation) {
+                                                boolean slackDistributionOnConformLoad, boolean hvdcAcEmulation, boolean contingencyPropagation) {
         Set<Switch> switchesToOpen = new HashSet<>();
         Set<Terminal> terminalsToDisconnect =  new HashSet<>();
 
@@ -148,6 +135,8 @@ private static PropagatedContingency create(Network network, Contingency conting
             }
         }
 
+        boolean breakers = !switchesToOpen.isEmpty();
+
         Set<String> branchIdsToOpen = new LinkedHashSet<>();
         Set<String> hvdcIdsToOpen = new HashSet<>();
         Set<String> generatorIdsToLose = new HashSet<>();
@@ -170,7 +159,7 @@ private static PropagatedContingency create(Network network, Contingency conting
 
                 case LOAD:
                     Load load = (Load) connectable;
-                    addPowerShift(load.getTerminal(), loadIdsToShift, getLoadPowerShift(load, slackDistributionOnConformLoad), withBreakers);
+                    addPowerShift(load.getTerminal(), loadIdsToShift, getLoadPowerShift(load, slackDistributionOnConformLoad), breakers);
                     break;
 
                 case SHUNT_COMPENSATOR:
@@ -195,7 +184,7 @@ private static PropagatedContingency create(Network network, Contingency conting
                         LccConverterStation lcc = (LccConverterStation) connectable;
                         PowerShift lccPowerShift = new PowerShift(HvdcConverterStations.getConverterStationTargetP(lcc) / PerUnit.SB, 0,
                                 HvdcConverterStations.getLccConverterStationLoadTargetQ(lcc) / PerUnit.SB);
-                        addPowerShift(lcc.getTerminal(), loadIdsToShift, lccPowerShift, withBreakers);
+                        addPowerShift(lcc.getTerminal(), loadIdsToShift, lccPowerShift, breakers);
                     }
                     break;
 
@@ -219,8 +208,8 @@ private static PropagatedContingency create(Network network, Contingency conting
                                          generatorIdsToLose, loadIdsToShift, shuntIdsToShift);
     }
 
-    private static void addPowerShift(Terminal terminal, Map<String, PowerShift> loadIdsToShift, PowerShift powerShift, boolean withBreakers) {
-        Bus bus = withBreakers ? terminal.getBusBreakerView().getBus() : terminal.getBusView().getBus();
+    private static void addPowerShift(Terminal terminal, Map<String, PowerShift> loadIdsToShift, PowerShift powerShift, boolean breakers) {
+        Bus bus = breakers ? terminal.getBusBreakerView().getBus() : terminal.getBusView().getBus();
         if (bus != null) {
             loadIdsToShift.computeIfAbsent(bus.getId(), k -> new PowerShift()).add(powerShift);
         }

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

@@ -54,7 +54,7 @@ protected void addResults(StateMonitor monitor, Consumer<LfBranch> branchConsume
             network.getBuses().stream()
                     .filter(lfBus -> monitor.getVoltageLevelIds().contains(lfBus.getVoltageLevelId()))
                     .filter(lfBus -> !lfBus.isDisabled())
-                    .forEach(lfBus -> busResults.add(lfBus.createBusResult()));
+                    .forEach(lfBus -> busResults.addAll(lfBus.createBusResults()));
         }
 
         if (!monitor.getThreeWindingsTransformerIds().isEmpty()) {

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

@@ -13,7 +13,6 @@
 import com.powsybl.contingency.Contingency;
 import com.powsybl.iidm.network.Network;
 import com.powsybl.iidm.network.Switch;
-import com.powsybl.iidm.network.TopologyKind;
 import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.math.matrix.MatrixFactory;
 import com.powsybl.openloadflow.OpenLoadFlowParameters;
@@ -39,6 +38,9 @@
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 
+/**
+ * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
+ */
 public class AcSecurityAnalysis extends AbstractSecurityAnalysis {
 
     protected AcSecurityAnalysis(Network network, MatrixFactory matrixFactory, GraphConnectivityFactory<LfBus, LfBranch> connectivityFactory,
@@ -69,14 +71,16 @@ 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,
+        List<PropagatedContingency> propagatedContingencies = PropagatedContingency.createList(network, contingencies, allSwitchesToOpen,
                 lfParameters.isShuntCompensatorVoltageControlOn(), lfParameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD,
                 lfParameters.isHvdcAcEmulation(), securityAnalysisParametersExt.isContingencyPropagation());
 
-        AcLoadFlowParameters acParameters = OpenLoadFlowParameters.createAcParameters(network, lfParameters, lfParametersExt, matrixFactory, connectivityFactory, saReporter, true, false);
+        boolean breakers = !allSwitchesToOpen.isEmpty();
+
+        AcLoadFlowParameters acParameters = OpenLoadFlowParameters.createAcParameters(network, lfParameters, lfParametersExt, matrixFactory, connectivityFactory, saReporter, breakers, false);
 
         // create networks including all necessary switches
-        List<LfNetwork> lfNetworks = createNetworks(allSwitchesToOpen, acParameters.getNetworkParameters(), saReporter);
+        List<LfNetwork> lfNetworks = Networks.load(network, acParameters.getNetworkParameters(), allSwitchesToOpen, saReporter);
 
         // run simulation on largest network
         SecurityAnalysisResult result;
@@ -98,22 +102,6 @@ SecurityAnalysisReport runSync(String workingVariantId, SecurityAnalysisParamete
         return new SecurityAnalysisReport(result);
     }
 
-    List<LfNetwork> createNetworks(Set<Switch> allSwitchesToOpen, LfNetworkParameters networkParameters,
-                                   Reporter saReporter) {
-        List<LfNetwork> lfNetworks;
-        String tmpVariantId = "olf-tmp-" + UUID.randomUUID();
-        network.getVariantManager().cloneVariant(network.getVariantManager().getWorkingVariantId(), tmpVariantId);
-        try {
-            network.getSwitchStream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
-                    .forEach(sw -> sw.setRetained(false));
-            allSwitchesToOpen.forEach(sw -> sw.setRetained(true));
-            lfNetworks = Networks.load(network, networkParameters, saReporter);
-        } finally {
-            network.getVariantManager().removeVariant(tmpVariantId);
-        }
-        return lfNetworks;
-    }
-
     public static void distributedMismatch(LfNetwork network, double mismatch, LoadFlowParameters loadFlowParameters,
                                            OpenLoadFlowParameters openLoadFlowParameters) {
         if (loadFlowParameters.isDistributedSlack() && Math.abs(mismatch) > 0) {
@@ -181,8 +169,7 @@ private SecurityAnalysisResult runSimulations(LfNetwork network, List<Propagated
                 }
             }
 
-            return new SecurityAnalysisResult(new LimitViolationsResult(preContingencyComputationOk,
-                                                                        preContingencyLimitViolationManager.getLimitViolations()),
+            return new SecurityAnalysisResult(new LimitViolationsResult(preContingencyComputationOk, preContingencyLimitViolationManager.getLimitViolations()),
                                               postContingencyResults,
                                               preContingencyNetworkResult.getBranchResults(),
                                               preContingencyNetworkResult.getBusResults(),
@@ -224,8 +211,7 @@ private PostContingencyResult runPostContingencySimulation(LfNetwork network, Ac
                 network, stopwatch.elapsed(TimeUnit.MILLISECONDS));
 
         return new PostContingencyResult(contingency,
-                                         new LimitViolationsResult(postContingencyComputationOk,
-                                                                   postContingencyLimitViolationManager.getLimitViolations()),
+                                         new LimitViolationsResult(postContingencyComputationOk, postContingencyLimitViolationManager.getLimitViolations()),
                                          postContingencyNetworkResult.getBranchResults(),
                                          postContingencyNetworkResult.getBusResults(),
                                          postContingencyNetworkResult.getThreeWindingsTransformerResults());