ContingencyLoadFlowParameters extension support in Security Analysis

docs/security/parameters.md

@@ -85,11 +85,11 @@ the [`OpenLoadFlowParameters`](../loadflow/parameters.md#specific-parameters) sp
 - `distributedSlack`: Refer to [`distributedSlack` in powsybl-core](inv:powsyblcore:*:*#simulation/loadflow/configuration)
 - `areaInterchangeControl`: Refer to [`areaInterchangeControl` in powsybl-open-loadflow](../loadflow/parameters.md#specific-parameters)
 - `balanceType`: Refer to [`balanceType` in powsybl-core](inv:powsyblcore:*:*#simulation/loadflow/configuration)
+- `outerLoopNames` : Refer to [`outerLoopNames` in powsybl-open-loadflow](../loadflow/parameters.md#specific-parameters)
 
 To customize these parameters for a contingency, add to the `Contingency` object a `ContingencyLoadFlowParameters` extension where you may configure the parameters.
 
-The behaviour is not implemented yet.
-It will be as follows:
+The behaviour is as follows:
 - When the extension is added: The specified parameters override the corresponding SA input parameters.
 - When the extension is absent: The load flow parameters provided in the SA input parameters are applied.
 

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

@@ -31,6 +31,8 @@
 import com.powsybl.openloadflow.dc.equations.DcEquationSystemCreationParameters;
 import com.powsybl.openloadflow.graph.GraphConnectivityFactory;
 import com.powsybl.openloadflow.lf.AbstractLoadFlowParameters;
+import com.powsybl.openloadflow.lf.outerloop.config.AbstractAcOuterLoopConfig;
+import com.powsybl.openloadflow.lf.outerloop.config.AbstractDcOuterLoopConfig;
 import com.powsybl.openloadflow.lf.outerloop.config.AcOuterLoopConfig;
 import com.powsybl.openloadflow.lf.outerloop.config.DcOuterLoopConfig;
 import com.powsybl.openloadflow.lf.outerloop.config.DefaultAcOuterLoopConfig;
@@ -1824,14 +1826,14 @@ public static AcLoadFlowParameters createAcParameters(Network network, LoadFlowP
     }
 
     static List<AcOuterLoop> createAcOuterLoops(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
-        AcOuterLoopConfig outerLoopConfig = AcOuterLoopConfig.findOuterLoopConfig()
+        AcOuterLoopConfig outerLoopConfig = AbstractAcOuterLoopConfig.getOuterLoopConfig()
                 .orElseGet(() -> parametersExt.getOuterLoopNames() != null ? new ExplicitAcOuterLoopConfig()
                                                                            : new DefaultAcOuterLoopConfig());
         return outerLoopConfig.configure(parameters, parametersExt);
     }
 
     static List<DcOuterLoop> createDcOuterLoops(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
-        DcOuterLoopConfig outerLoopConfig = DcOuterLoopConfig.findOuterLoopConfig()
+        DcOuterLoopConfig outerLoopConfig = AbstractDcOuterLoopConfig.getOuterLoopConfig()
                 .orElseGet(() -> parametersExt.getOuterLoopNames() != null ? new ExplicitDcOuterLoopConfig()
                                                                            : new DefaultDcOuterLoopConfig());
         return outerLoopConfig.configure(parameters, parametersExt);

src/main/java/com/powsybl/openloadflow/ac/outerloop/AcAreaInterchangeControlOuterLoop.java

@@ -7,6 +7,7 @@
  */
 package com.powsybl.openloadflow.ac.outerloop;
 
+import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.ac.AcLoadFlowContext;
 import com.powsybl.openloadflow.ac.AcLoadFlowParameters;
 import com.powsybl.openloadflow.ac.AcOuterLoopContext;
@@ -30,6 +31,12 @@ public AcAreaInterchangeControlOuterLoop(ActivePowerDistribution activePowerDist
         super(activePowerDistribution, new DistributedSlackOuterLoop(activePowerDistribution, slackBusPMaxMismatch), slackBusPMaxMismatch, areaInterchangePMaxMismatch, LOGGER);
     }
 
+    public static AcAreaInterchangeControlOuterLoop create(LoadFlowParameters.BalanceType balanceType, boolean loadPowerFactorConstant, boolean useActiveLimits,
+                                                           double slackBusPMaxMismatch, double areaInterchangePMaxMismatch) {
+        ActivePowerDistribution activePowerDistribution = ActivePowerDistribution.create(balanceType, loadPowerFactorConstant, useActiveLimits);
+        return new AcAreaInterchangeControlOuterLoop(activePowerDistribution, slackBusPMaxMismatch, areaInterchangePMaxMismatch);
+    }
+
     @Override
     public double getSlackBusActivePowerMismatch(AcOuterLoopContext context) {
         return context.getLastSolverResult().getSlackBusActivePowerMismatch();

src/main/java/com/powsybl/openloadflow/ac/outerloop/DistributedSlackOuterLoop.java

@@ -8,6 +8,7 @@
 package com.powsybl.openloadflow.ac.outerloop;
 
 import com.powsybl.commons.report.ReportNode;
+import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.ac.AcLoadFlowContext;
 import com.powsybl.openloadflow.ac.AcLoadFlowParameters;
 import com.powsybl.openloadflow.ac.AcOuterLoopContext;
@@ -45,6 +46,12 @@ public DistributedSlackOuterLoop(ActivePowerDistribution activePowerDistribution
         this.slackBusPMaxMismatch = slackBusPMaxMismatch;
     }
 
+    public static DistributedSlackOuterLoop create(LoadFlowParameters.BalanceType balanceType, boolean loadPowerFactorConstant, boolean useActiveLimits,
+                                            double slackBusPMaxMismatch) {
+        ActivePowerDistribution activePowerDistribution = ActivePowerDistribution.create(balanceType, loadPowerFactorConstant, useActiveLimits);
+        return new DistributedSlackOuterLoop(activePowerDistribution, slackBusPMaxMismatch);
+    }
+
     @Override
     public String getName() {
         return NAME;

src/main/java/com/powsybl/openloadflow/dc/DcAreaInterchangeControlOuterLoop.java

@@ -8,6 +8,7 @@
 package com.powsybl.openloadflow.dc;
 
 import com.powsybl.commons.report.ReportNode;
+import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.dc.equations.DcEquationType;
 import com.powsybl.openloadflow.dc.equations.DcVariableType;
 import com.powsybl.openloadflow.lf.outerloop.AbstractAreaInterchangeControlOuterLoop;
@@ -31,6 +32,12 @@ public DcAreaInterchangeControlOuterLoop(ActivePowerDistribution activePowerDist
         super(activePowerDistribution, new DcNoAreaOuterLoop(), slackBusPMaxMismatch, areaInterchangePMaxMismatch, LOGGER);
     }
 
+    public static DcAreaInterchangeControlOuterLoop create(LoadFlowParameters.BalanceType balanceType, boolean loadPowerFactorConstant, boolean useActiveLimits,
+                                                           double slackBusPMaxMismatch, double areaInterchangePMaxMismatch) {
+        ActivePowerDistribution activePowerDistribution = ActivePowerDistribution.create(balanceType, loadPowerFactorConstant, useActiveLimits);
+        return new DcAreaInterchangeControlOuterLoop(activePowerDistribution, slackBusPMaxMismatch, areaInterchangePMaxMismatch);
+    }
+
     @Override
     public double getSlackBusActivePowerMismatch(DcOuterLoopContext context) {
         List<LfBus> buses = context.getNetwork().getBuses();

src/main/java/com/powsybl/openloadflow/lf/outerloop/config/AbstractAcOuterLoopConfig.java

@@ -7,39 +7,47 @@
  */
 package com.powsybl.openloadflow.lf.outerloop.config;
 
+import com.google.common.base.Suppliers;
 import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.ac.outerloop.*;
-import com.powsybl.openloadflow.network.util.ActivePowerDistribution;
+import com.powsybl.openloadflow.sa.extensions.ContingencyLoadFlowParameters;
 import com.powsybl.openloadflow.util.PerUnit;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.Optional;
+import java.util.function.Supplier;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  */
-abstract class AbstractAcOuterLoopConfig implements AcOuterLoopConfig {
+public abstract class AbstractAcOuterLoopConfig implements AcOuterLoopConfig {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AbstractAcOuterLoopConfig.class);
 
+    private static final Supplier<Optional<AcOuterLoopConfig>> CONFIG_SUPPLIER = Suppliers.memoize(AcOuterLoopConfig::findOuterLoopConfig);
+
     protected AbstractAcOuterLoopConfig() {
     }
 
-    protected static Optional<AcOuterLoop> createDistributedSlackOuterLoop(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
-        if (parameters.isDistributedSlack()) {
-            ActivePowerDistribution activePowerDistribution = ActivePowerDistribution.create(parameters.getBalanceType(), parametersExt.isLoadPowerFactorConstant(), parametersExt.isUseActiveLimits());
-            return Optional.of(new DistributedSlackOuterLoop(activePowerDistribution, parametersExt.getSlackBusPMaxMismatch()));
+    public static Optional<AcOuterLoopConfig> getOuterLoopConfig() {
+        return CONFIG_SUPPLIER.get();
+    }
+
+    protected static Optional<AcOuterLoop> createDistributedSlackOuterLoop(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, ContingencyLoadFlowParameters contingencyParameters) {
+        if (contingencyParameters.isDistributedSlack(parameters)) {
+            return Optional.of(DistributedSlackOuterLoop.create(contingencyParameters.getBalanceType(parameters), parametersExt.isLoadPowerFactorConstant(), parametersExt.isUseActiveLimits(),
+                    parametersExt.getSlackBusPMaxMismatch()));
         }
         return Optional.empty();
     }
 
-    protected static Optional<AcOuterLoop> createAreaInterchangeControlOuterLoop(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
-        if (parametersExt.isAreaInterchangeControl()) {
-            ActivePowerDistribution activePowerDistribution = ActivePowerDistribution.create(parameters.getBalanceType(), parametersExt.isLoadPowerFactorConstant(), parametersExt.isUseActiveLimits());
-            return Optional.of(new AcAreaInterchangeControlOuterLoop(activePowerDistribution, parametersExt.getSlackBusPMaxMismatch(), parametersExt.getAreaInterchangePMaxMismatch()));
+    protected static Optional<AcOuterLoop> createAreaInterchangeControlOuterLoop(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, ContingencyLoadFlowParameters contingencyParameters) {
+        if (contingencyParameters.isAreaInterchangeControl(parametersExt)) {
+            return Optional.of(AcAreaInterchangeControlOuterLoop.create(contingencyParameters.getBalanceType(parameters), parametersExt.isLoadPowerFactorConstant(), parametersExt.isUseActiveLimits(),
+                    parametersExt.getSlackBusPMaxMismatch(), parametersExt.getAreaInterchangePMaxMismatch()));
         }
         return Optional.empty();
     }
@@ -137,7 +145,7 @@ protected static Optional<AcOuterLoop> createAutomationSystemOuterLoop(OpenLoadF
         return Optional.empty();
     }
 
-    static List<AcOuterLoop> filterInconsistentOuterLoops(List<AcOuterLoop> outerLoops) {
+    public static List<AcOuterLoop> filterInconsistentOuterLoops(List<AcOuterLoop> outerLoops) {
         if (outerLoops.stream().anyMatch(AcAreaInterchangeControlOuterLoop.class::isInstance)) {
             return outerLoops.stream().filter(o -> {
                 if (o instanceof DistributedSlackOuterLoop) {

src/main/java/com/powsybl/openloadflow/lf/outerloop/config/AbstractDcOuterLoopConfig.java

@@ -7,26 +7,35 @@
  */
 package com.powsybl.openloadflow.lf.outerloop.config;
 
+import com.google.common.base.Suppliers;
 import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.dc.DcAreaInterchangeControlOuterLoop;
 import com.powsybl.openloadflow.dc.DcIncrementalPhaseControlOuterLoop;
 import com.powsybl.openloadflow.dc.DcOuterLoop;
 import com.powsybl.openloadflow.network.util.ActivePowerDistribution;
+import com.powsybl.openloadflow.sa.extensions.ContingencyLoadFlowParameters;
 
 import java.util.Optional;
+import java.util.function.Supplier;
 
 /**
  * @author Valentin Mouradian {@literal <valentin.mouradian at artelys.com>}
  */
-abstract class AbstractDcOuterLoopConfig implements DcOuterLoopConfig {
+public abstract class AbstractDcOuterLoopConfig implements DcOuterLoopConfig {
+
+    public static final Supplier<Optional<DcOuterLoopConfig>> CONFIG_SUPPLIER = Suppliers.memoize(DcOuterLoopConfig::findOuterLoopConfig);
 
     protected AbstractDcOuterLoopConfig() {
     }
 
-    protected static Optional<DcOuterLoop> createAreaInterchangeControlOuterLoop(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
-        if (parametersExt.isAreaInterchangeControl()) {
-            ActivePowerDistribution activePowerDistribution = ActivePowerDistribution.create(parameters.getBalanceType(), parametersExt.isLoadPowerFactorConstant(), parametersExt.isUseActiveLimits());
+    public static Optional<DcOuterLoopConfig> getOuterLoopConfig() {
+        return CONFIG_SUPPLIER.get();
+    }
+
+    protected static Optional<DcOuterLoop> createAreaInterchangeControlOuterLoop(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, ContingencyLoadFlowParameters contingencyParameters) {
+        if (contingencyParameters.isAreaInterchangeControl(parametersExt)) {
+            ActivePowerDistribution activePowerDistribution = ActivePowerDistribution.create(contingencyParameters.getBalanceType(parameters), parametersExt.isLoadPowerFactorConstant(), parametersExt.isUseActiveLimits());
             return Optional.of(new DcAreaInterchangeControlOuterLoop(activePowerDistribution, parametersExt.getSlackBusPMaxMismatch(), parametersExt.getAreaInterchangePMaxMismatch()));
         }
         return Optional.empty();

src/main/java/com/powsybl/openloadflow/lf/outerloop/config/DefaultAcOuterLoopConfig.java

@@ -10,6 +10,7 @@
 import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.ac.outerloop.*;
+import com.powsybl.openloadflow.sa.extensions.ContingencyLoadFlowParameters;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -21,11 +22,16 @@ public class DefaultAcOuterLoopConfig extends AbstractAcOuterLoopConfig {
 
     @Override
     public List<AcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
+        return configure(parameters, parametersExt, new ContingencyLoadFlowParameters());
+    }
+
+    @Override
+    public List<AcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, ContingencyLoadFlowParameters contingencyParameters) {
         List<AcOuterLoop> outerLoops = new ArrayList<>(5);
         // primary frequency control
-        createDistributedSlackOuterLoop(parameters, parametersExt).ifPresent(outerLoops::add);
+        createDistributedSlackOuterLoop(parameters, parametersExt, contingencyParameters).ifPresent(outerLoops::add);
         // area interchange control
-        createAreaInterchangeControlOuterLoop(parameters, parametersExt).ifPresent(outerLoops::add);
+        createAreaInterchangeControlOuterLoop(parameters, parametersExt, contingencyParameters).ifPresent(outerLoops::add);
         // secondary voltage control
         createSecondaryVoltageControlOuterLoop(parametersExt).ifPresent(outerLoops::add);
         // primary voltage control

src/main/java/com/powsybl/openloadflow/lf/outerloop/config/DefaultDcOuterLoopConfig.java

@@ -10,6 +10,7 @@
 import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.dc.DcOuterLoop;
+import com.powsybl.openloadflow.sa.extensions.ContingencyLoadFlowParameters;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -21,11 +22,16 @@ public class DefaultDcOuterLoopConfig extends AbstractDcOuterLoopConfig {
 
     @Override
     public List<DcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
+        return configure(parameters, parametersExt, new ContingencyLoadFlowParameters());
+    }
+
+    @Override
+    public List<DcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, ContingencyLoadFlowParameters contingencyParameters) {
         List<DcOuterLoop> outerLoops = new ArrayList<>(2);
         // incremental phase control
         createIncrementalPhaseControlOuterLoop(parameters).ifPresent(outerLoops::add);
         // area interchange control
-        createAreaInterchangeControlOuterLoop(parameters, parametersExt).ifPresent(outerLoops::add);
+        createAreaInterchangeControlOuterLoop(parameters, parametersExt, contingencyParameters).ifPresent(outerLoops::add);
         return outerLoops;
     }
 }

src/main/java/com/powsybl/openloadflow/lf/outerloop/config/ExplicitAcOuterLoopConfig.java

@@ -14,6 +14,7 @@
 import com.powsybl.openloadflow.lf.outerloop.AbstractAreaInterchangeControlOuterLoop;
 import com.powsybl.openloadflow.lf.outerloop.AbstractIncrementalPhaseControlOuterLoop;
 import com.powsybl.openloadflow.lf.outerloop.OuterLoop;
+import com.powsybl.openloadflow.sa.extensions.ContingencyLoadFlowParameters;
 
 import java.util.List;
 import java.util.Map;
@@ -41,11 +42,11 @@ public class ExplicitAcOuterLoopConfig extends AbstractAcOuterLoopConfig {
                                                      IncrementalTransformerReactivePowerControlOuterLoop.NAME,
                                                      AbstractAreaInterchangeControlOuterLoop.NAME);
 
-    private static Optional<AcOuterLoop> createOuterLoop(String name, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
+    private static Optional<AcOuterLoop> createOuterLoop(String name, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, ContingencyLoadFlowParameters contingencyParameters) {
         return switch (name) {
             case AbstractIncrementalPhaseControlOuterLoop.NAME -> createPhaseControlOuterLoop(parameters,
                                                                                                OpenLoadFlowParameters.PhaseShifterControlMode.INCREMENTAL);
-            case DistributedSlackOuterLoop.NAME -> createDistributedSlackOuterLoop(parameters, parametersExt);
+            case DistributedSlackOuterLoop.NAME -> createDistributedSlackOuterLoop(parameters, parametersExt, contingencyParameters);
             case IncrementalShuntVoltageControlOuterLoop.NAME -> createShuntVoltageControlOuterLoop(parameters,
                                                                                                     OpenLoadFlowParameters.ShuntVoltageControlMode.INCREMENTAL_VOLTAGE_CONTROL);
             case IncrementalTransformerVoltageControlOuterLoop.NAME -> createTransformerVoltageControlOuterLoop(parameters,
@@ -72,7 +73,7 @@ private static Optional<AcOuterLoop> createOuterLoop(String name, LoadFlowParame
                                                                                                      parametersExt.getGeneratorVoltageControlMinNominalVoltage());
             case AutomationSystemOuterLoop.NAME -> createAutomationSystemOuterLoop(parametersExt);
             case IncrementalTransformerReactivePowerControlOuterLoop.NAME -> createTransformerReactivePowerControlOuterLoop(parametersExt);
-            case AbstractAreaInterchangeControlOuterLoop.NAME -> createAreaInterchangeControlOuterLoop(parameters, parametersExt);
+            case AbstractAreaInterchangeControlOuterLoop.NAME -> createAreaInterchangeControlOuterLoop(parameters, parametersExt, contingencyParameters);
             default -> throw new PowsyblException("Unknown outer loop '" + name + "' for AC load flow");
         };
     }
@@ -90,8 +91,13 @@ private static void checkTypeUnicity(List<AcOuterLoop> outerLoops) {
 
     @Override
     public List<AcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
-        List<AcOuterLoop> outerLoops = Objects.requireNonNull(parametersExt.getOuterLoopNames()).stream()
-                .flatMap(name -> createOuterLoop(name, parameters, parametersExt).stream())
+        return configure(parameters, parametersExt, new ContingencyLoadFlowParameters());
+    }
+
+    @Override
+    public List<AcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, ContingencyLoadFlowParameters contingencyParameters) {
+        List<AcOuterLoop> outerLoops = Objects.requireNonNull(contingencyParameters.getOuterLoopNames(parametersExt)).stream()
+                .flatMap(name -> createOuterLoop(name, parameters, parametersExt, contingencyParameters).stream())
                 .toList();
         checkTypeUnicity(outerLoops);
         return filterInconsistentOuterLoops(outerLoops);