Substation automation system

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

@@ -102,4 +102,11 @@ protected static Optional<AcOuterLoop> createPhaseControlOuterLoop(LoadFlowParam
     protected static Optional<AcOuterLoop> createPhaseControlOuterLoop(LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
         return createPhaseControlOuterLoop(parameters, parametersExt.getPhaseShifterControlMode());
     }
+
+    protected static Optional<AcOuterLoop> createAutomationSystemOuterLoop(OpenLoadFlowParameters parametersExt) {
+        if (parametersExt.isSimulateAutomationSystems()) {
+            return Optional.of(new AutomationSystemOuterLoop());
+        }
+        return Optional.empty();
+    }
 }

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

@@ -33,6 +33,8 @@ public List<AcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowPa
         createTransformerVoltageControlOuterLoop(parameters, parametersExt).ifPresent(outerLoops::add);
         // shunt compensator voltage control
         createShuntVoltageControlOuterLoop(parameters, parametersExt).ifPresent(outerLoops::add);
+        // automation system
+        createAutomationSystemOuterLoop(parametersExt).ifPresent(outerLoops::add);
         return outerLoops;
     }
 }

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

@@ -32,7 +32,8 @@ public class ExplicitAcOuterLoopConfig extends AbstractAcOuterLoopConfig {
                                                      SecondaryVoltageControlOuterLoop.NAME,
                                                      ShuntVoltageControlOuterLoop.NAME,
                                                      SimpleTransformerVoltageControlOuterLoop.NAME,
-                                                     TransformerVoltageControlOuterLoop.NAME);
+                                                     TransformerVoltageControlOuterLoop.NAME,
+                                                     AutomationSystemOuterLoop.NAME);
 
     private static Optional<AcOuterLoop> createOuterLoop(String name, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
         return switch (name) {
@@ -57,6 +58,7 @@ private static Optional<AcOuterLoop> createOuterLoop(String name, LoadFlowParame
             case TransformerVoltageControlOuterLoop.NAME -> createTransformerVoltageControlOuterLoop(parameters,
                                                                                                      OpenLoadFlowParameters.TransformerVoltageControlMode.AFTER_GENERATOR_VOLTAGE_CONTROL,
                                                                                                      parametersExt.getIncrementalTransformerVoltageControlOuterLoopMaxTapShift());
+            case AutomationSystemOuterLoop.NAME -> createAutomationSystemOuterLoop(parametersExt);
             default -> throw new PowsyblException("Unknown outer loop '" + name + "'");
         };
     }

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

@@ -212,6 +212,8 @@ public class OpenLoadFlowParameters extends AbstractExtension<LoadFlowParameters
 
     private static final String DC_APPROXIMATION_TYPE_PARAM_NAME = "dcApproximationType";
 
+    public static final String SIMULATE_AUTOMATION_SYSTEMS_PARAM_NAME = "simulateAutomationSystems";
+
     private static <E extends Enum<E>> List<Object> getEnumPossibleValues(Class<E> enumClass) {
         return EnumSet.allOf(enumClass).stream().map(Enum::name).collect(Collectors.toList());
     }
@@ -271,7 +273,8 @@ private static <E extends Enum<E>> List<Object> getEnumPossibleValues(Class<E> e
         new Parameter(MAX_VOLTAGE_CHANGE_STATE_VECTOR_SCALING_MAX_DPHI_PARAM_NAME, ParameterType.DOUBLE, "Max voltage angle change for the max voltage change state vector scaling", MaxVoltageChangeStateVectorScaling.DEFAULT_MAX_DPHI),
         new Parameter(LINE_PER_UNIT_MODE_PARAM_NAME, ParameterType.STRING, "Line per unit mode", LinePerUnitMode.IMPEDANCE.name(), getEnumPossibleValues(LinePerUnitMode.class)),
         new Parameter(USE_LOAD_MODEL_PARAM_NAME, ParameterType.BOOLEAN, "Use load model (with voltage dependency) for simulation", LfNetworkParameters.USE_LOAD_MODE_DEFAULT_VALUE),
-        new Parameter(DC_APPROXIMATION_TYPE_PARAM_NAME, ParameterType.STRING, "DC approximation type", DcEquationSystemCreationParameters.DC_APPROXIMATION_TYPE_DEFAULT_VALUE.name(), getEnumPossibleValues(DcApproximationType.class))
+        new Parameter(DC_APPROXIMATION_TYPE_PARAM_NAME, ParameterType.STRING, "DC approximation type", DcEquationSystemCreationParameters.DC_APPROXIMATION_TYPE_DEFAULT_VALUE.name(), getEnumPossibleValues(DcApproximationType.class)),
+        new Parameter(SIMULATE_AUTOMATION_SYSTEMS_PARAM_NAME, ParameterType.BOOLEAN, "Automatons simulation", LfNetworkParameters.SIMULATE_AUTOMATION_SYSTEMS_DEFAULT_VALUE)
     );
 
     public enum VoltageInitModeOverride {
@@ -423,6 +426,8 @@ public enum ReactiveRangeCheckMode {
 
     private DcApproximationType dcApproximationType = DcEquationSystemCreationParameters.DC_APPROXIMATION_TYPE_DEFAULT_VALUE;
 
+    private boolean simulateAutomationSystems = LfNetworkParameters.SIMULATE_AUTOMATION_SYSTEMS_DEFAULT_VALUE;
+
     @Override
     public String getName() {
         return "open-load-flow-parameters";
@@ -965,6 +970,15 @@ public OpenLoadFlowParameters setDcApproximationType(DcApproximationType dcAppro
         return this;
     }
 
+    public boolean isSimulateAutomationSystems() {
+        return simulateAutomationSystems;
+    }
+
+    public OpenLoadFlowParameters setSimulateAutomationSystems(boolean simulateAutomationSystems) {
+        this.simulateAutomationSystems = simulateAutomationSystems;
+        return this;
+    }
+
     public static OpenLoadFlowParameters load() {
         return load(PlatformConfig.defaultConfig());
     }
@@ -1031,7 +1045,7 @@ public static OpenLoadFlowParameters load(PlatformConfig platformConfig) {
                 .setLinePerUnitMode(config.getEnumProperty(LINE_PER_UNIT_MODE_PARAM_NAME, LinePerUnitMode.class, LfNetworkParameters.LINE_PER_UNIT_MODE_DEFAULT_VALUE))
                 .setUseLoadModel(config.getBooleanProperty(USE_LOAD_MODEL_PARAM_NAME, LfNetworkParameters.USE_LOAD_MODE_DEFAULT_VALUE))
                 .setDcApproximationType(config.getEnumProperty(DC_APPROXIMATION_TYPE_PARAM_NAME, DcApproximationType.class, DcEquationSystemCreationParameters.DC_APPROXIMATION_TYPE_DEFAULT_VALUE))
-            );
+                .setSimulateAutomationSystems(config.getBooleanProperty(SIMULATE_AUTOMATION_SYSTEMS_PARAM_NAME, LfNetworkParameters.SIMULATE_AUTOMATION_SYSTEMS_DEFAULT_VALUE)));
         return parameters;
     }
 
@@ -1157,6 +1171,8 @@ public OpenLoadFlowParameters update(Map<String, String> properties) {
                 .ifPresent(prop -> this.setUseLoadModel(Boolean.parseBoolean(prop)));
         Optional.ofNullable(properties.get(DC_APPROXIMATION_TYPE_PARAM_NAME))
                 .ifPresent(prop -> this.setDcApproximationType(DcApproximationType.valueOf(prop)));
+        Optional.ofNullable(properties.get(SIMULATE_AUTOMATION_SYSTEMS_PARAM_NAME))
+                .ifPresent(prop -> this.setSimulateAutomationSystems(Boolean.parseBoolean(prop)));
         return this;
     }
 
@@ -1217,6 +1233,7 @@ public Map<String, Object> toMap() {
         map.put(LINE_PER_UNIT_MODE_PARAM_NAME, linePerUnitMode);
         map.put(USE_LOAD_MODEL_PARAM_NAME, useLoadModel);
         map.put(DC_APPROXIMATION_TYPE_PARAM_NAME, dcApproximationType);
+        map.put(SIMULATE_AUTOMATION_SYSTEMS_PARAM_NAME, simulateAutomationSystems);
         return map;
     }
 
@@ -1339,7 +1356,8 @@ static LfNetworkParameters getNetworkParameters(LoadFlowParameters parameters, O
                 .setAsymmetrical(parametersExt.isAsymmetrical())
                 .setMinNominalVoltageTargetVoltageCheck(parametersExt.getMinNominalVoltageTargetVoltageCheck())
                 .setLinePerUnitMode(parametersExt.getLinePerUnitMode())
-                .setUseLoadModel(parametersExt.isUseLoadModel());
+                .setUseLoadModel(parametersExt.isUseLoadModel())
+                .setSimulateAutomationSystems(parametersExt.isSimulateAutomationSystems());
     }
 
     public static AcLoadFlowParameters createAcParameters(Network network, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt,
@@ -1554,7 +1572,8 @@ public static boolean equals(LoadFlowParameters parameters1, LoadFlowParameters
                 extension1.getMaxVoltageChangeStateVectorScalingMaxDphi() == extension2.getMaxVoltageChangeStateVectorScalingMaxDphi() &&
                 extension1.getLinePerUnitMode() == extension2.getLinePerUnitMode() &&
                 extension1.isUseLoadModel() == extension2.isUseLoadModel() &&
-                extension1.getDcApproximationType() == extension2.getDcApproximationType();
+                extension1.getDcApproximationType() == extension2.getDcApproximationType() &&
+                extension1.isSimulateAutomationSystems() == extension2.isSimulateAutomationSystems();
     }
 
     public static LoadFlowParameters clone(LoadFlowParameters parameters) {

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

@@ -33,6 +33,7 @@
 import com.powsybl.openloadflow.lf.outerloop.OuterLoop;
 import com.powsybl.openloadflow.lf.outerloop.OuterLoopStatus;
 import com.powsybl.openloadflow.network.*;
+import com.powsybl.openloadflow.network.impl.LfNetworkList;
 import com.powsybl.openloadflow.network.impl.LfNetworkLoaderImpl;
 import com.powsybl.openloadflow.network.impl.Networks;
 import com.powsybl.openloadflow.network.util.ZeroImpedanceFlows;
@@ -106,6 +107,7 @@ private static LoadFlowResult.ComponentResult.Status convertStatus(AcLoadFlowRes
 
     private GraphConnectivityFactory<LfBus, LfBranch> getConnectivityFactory(OpenLoadFlowParameters parametersExt) {
         return parametersExt.isNetworkCacheEnabled() && !parametersExt.getActionableSwitchesIds().isEmpty()
+                || parametersExt.isSimulateAutomationSystems()
                 ? new NaiveGraphConnectivityFactory<>(LfBus::getNum)
                 : connectivityFactory;
     }
@@ -153,7 +155,9 @@ private LoadFlowResult runAc(Network network, LoadFlowParameters parameters, Ope
             results = new AcLoadFlowFromCache(network, parameters, parametersExt, acParameters, reporter)
                     .run();
         } else {
-            results = AcloadFlowEngine.run(network, new LfNetworkLoaderImpl(), acParameters, reporter);
+            try (LfNetworkList lfNetworkList = Networks.load(network, acParameters.getNetworkParameters(), new LfTopoConfig(), reporter)) {
+                results = AcloadFlowEngine.run(lfNetworkList.getList(), acParameters);
+            }
         }
 
         // we reset the state if at least one component needs a network update.

src/main/java/com/powsybl/openloadflow/ac/AcloadFlowEngine.java

@@ -20,7 +20,6 @@
 import com.powsybl.openloadflow.lf.outerloop.DistributedSlackContextData;
 import com.powsybl.openloadflow.lf.outerloop.OuterLoopStatus;
 import com.powsybl.openloadflow.network.LfNetwork;
-import com.powsybl.openloadflow.network.LfNetworkLoader;
 import com.powsybl.openloadflow.network.util.PreviousValueVoltageInitializer;
 import com.powsybl.openloadflow.network.util.VoltageInitializer;
 import com.powsybl.openloadflow.util.Reports;
@@ -196,9 +195,8 @@ public AcLoadFlowResult run() {
         return result;
     }
 
-    public static <T> List<AcLoadFlowResult> run(T network, LfNetworkLoader<T> networkLoader, AcLoadFlowParameters parameters, Reporter reporter) {
-        return LfNetwork.load(network, networkLoader, parameters.getNetworkParameters(), reporter)
-                .stream()
+    public static List<AcLoadFlowResult> run(List<LfNetwork> lfNetworks, AcLoadFlowParameters parameters) {
+        return lfNetworks.stream()
                 .map(n -> {
                     if (n.isValid()) {
                         try (AcLoadFlowContext context = new AcLoadFlowContext(n, parameters)) {

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

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2023, 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.ac.outerloop;
+
+import com.powsybl.commons.reporter.Reporter;
+import com.powsybl.openloadflow.ac.AcOuterLoopContext;
+import com.powsybl.openloadflow.graph.GraphConnectivity;
+import com.powsybl.openloadflow.lf.outerloop.OuterLoopStatus;
+import com.powsybl.openloadflow.network.*;
+import com.powsybl.openloadflow.network.impl.LfSwitch;
+import com.powsybl.openloadflow.util.PerUnit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
+ */
+public class AutomationSystemOuterLoop implements AcOuterLoop {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(AutomationSystemOuterLoop.class);
+
+    public static final String NAME = "AutomationSystem";
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public OuterLoopStatus check(AcOuterLoopContext context, Reporter reporter) {
+        OuterLoopStatus status = OuterLoopStatus.STABLE;
+        LfNetwork network = context.getNetwork();
+        Set<LfBranch> branchesToOpen = new HashSet<>();
+        Set<LfBranch> branchesToClose = new HashSet<>();
+        for (LfOverloadManagementSystem system : network.getOverloadManagementSystems()) {
+            LfBranch branchToMonitor = system.getMonitoredBranch();
+            if (branchToMonitor.isConnectedAtBothSides()) {
+                double i1 = branchToMonitor.getI1().eval();
+                double threshold = system.getThreshold();
+                if (i1 > threshold) {
+                    double ib = PerUnit.ib(branchToMonitor.getBus1().getNominalV());
+                    LfSwitch switchToOperate = system.getSwitchToOperate();
+                    if (system.isSwitchOpen() && switchToOperate.isConnectedAtBothSides()) {
+                        LOGGER.debug("Line '{}' is overloaded ({} A > {} A), open switch '{}'",
+                                branchToMonitor.getId(), i1 * ib, threshold * ib, switchToOperate.getId());
+                        branchesToOpen.add(switchToOperate);
+                    } else if (!system.isSwitchOpen() && !switchToOperate.isConnectedAtBothSides()) {
+                        LOGGER.debug("Line '{}' is overloaded ({} A > {} A), close switch '{}'",
+                                branchToMonitor.getId(), i1 * ib, threshold * ib, switchToOperate.getId());
+                        branchesToClose.add(switchToOperate);
+                    }
+                }
+            }
+        }
+
+        if (branchesToOpen.size() + branchesToClose.size() > 0) {
+            GraphConnectivity<LfBus, LfBranch> connectivity = network.getConnectivity();
+            branchesToOpen.forEach(connectivity::removeEdge);
+            branchesToClose.forEach(branch -> connectivity.addEdge(branch.getBus1(), branch.getBus2(), branch));
+            LfAction.updateBusesAndBranchStatus(connectivity);
+            status = OuterLoopStatus.UNSTABLE;
+        }
+
+        return status;
+    }
+}

src/main/java/com/powsybl/openloadflow/graph/EvenShiloachGraphDecrementalConnectivity.java

@@ -80,6 +80,11 @@ protected void updateComponents() {
         computeConnectivity();
     }
 
+    @Override
+    public boolean supportTemporaryChangesNesting() {
+        return false;
+    }
+
     @Override
     public void startTemporaryChanges() {
         if (!getModificationsContexts().isEmpty()) {

src/main/java/com/powsybl/openloadflow/graph/GraphConnectivity.java

@@ -42,6 +42,8 @@ public interface GraphConnectivity<V, E> {
 
     void removeEdge(E edge);
 
+    boolean supportTemporaryChangesNesting();
+
     /**
      * Start recording topological changes to undo them later by a {@link #undoTemporaryChanges} call.
      */

src/main/java/com/powsybl/openloadflow/graph/MinimumSpanningTreeGraphConnectivity.java

@@ -45,6 +45,11 @@ protected void updateConnectivity(EdgeRemove<V, E> edgeRemove) {
         }
     }
 
+    @Override
+    public boolean supportTemporaryChangesNesting() {
+        return true;
+    }
+
     @Override
     public void startTemporaryChanges() {
         super.startTemporaryChanges();

src/main/java/com/powsybl/openloadflow/graph/NaiveGraphConnectivity.java

@@ -28,6 +28,11 @@ public NaiveGraphConnectivity(ToIntFunction<V> numGetter) {
         this.numGetter = Objects.requireNonNull(numGetter);
     }
 
+    @Override
+    public boolean supportTemporaryChangesNesting() {
+        return true;
+    }
+
     protected void updateComponents() {
         if (components == null) {
             components = new int[getGraph().vertexSet().size()];

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

@@ -122,6 +122,8 @@ public double getLowValue() {
         }
     }
 
+    protected final List<LfOverloadManagementSystem> overloadManagementSystems = new ArrayList<>();
+
     public LfNetwork(int numCC, int numSC, SlackBusSelector slackBusSelector, int maxSlackBusCount,
                      GraphConnectivityFactory<LfBus, LfBranch> connectivityFactory, Reporter reporter) {
         this.numCC = numCC;
@@ -601,6 +603,12 @@ public GraphConnectivity<LfBus, LfBranch> getConnectivity() {
                     .filter(b -> b.getBus1() != null && b.getBus2() != null)
                     .forEach(b -> connectivity.addEdge(b.getBus1(), b.getBus2(), b));
             connectivity.setMainComponentVertex(getSlackBus());
+            // this is necessary to create a first temporary changes level in order to allow
+            // some outer loop to change permanently the connectivity (with automation systems for instance)
+            // this one will never be reverted
+            if (connectivity.supportTemporaryChangesNesting()) {
+                connectivity.startTemporaryChanges();
+            }
         }
         return connectivity;
     }
@@ -735,6 +743,14 @@ public List<LfBus> getControlledBuses(VoltageControl.Type type) {
                 .collect(Collectors.toList());
     }
 
+    public void addOverloadManagementSystem(LfOverloadManagementSystem overloadManagementSystem) {
+        overloadManagementSystems.add(Objects.requireNonNull(overloadManagementSystem));
+    }
+
+    public List<LfOverloadManagementSystem> getOverloadManagementSystems() {
+        return overloadManagementSystems;
+    }
+
     @Override
     public String toString() {
         return getId();

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

@@ -53,6 +53,8 @@ public class LfNetworkParameters {
 
     public static final Set<Country> SLACK_BUS_COUNTRY_FILTER_DEFAULT_VALUE = Collections.emptySet();
 
+    public static final boolean SIMULATE_AUTOMATION_SYSTEMS_DEFAULT_VALUE = false;
+
     private SlackBusSelector slackBusSelector = new FirstSlackBusSelector(SLACK_BUS_COUNTRY_FILTER_DEFAULT_VALUE);
 
     private GraphConnectivityFactory<LfBus, LfBranch> connectivityFactory = new EvenShiloachGraphDecrementalConnectivityFactory<>();
@@ -121,6 +123,8 @@ public class LfNetworkParameters {
 
     private boolean useLoadModel = USE_LOAD_MODE_DEFAULT_VALUE;
 
+    private boolean simulateAutomationSystems = SIMULATE_AUTOMATION_SYSTEMS_DEFAULT_VALUE;
+
     public LfNetworkParameters() {
     }
 
@@ -156,7 +160,9 @@ public LfNetworkParameters(LfNetworkParameters other) {
         this.secondaryVoltageControl = other.secondaryVoltageControl;
         this.cacheEnabled = other.cacheEnabled;
         this.asymmetrical = other.asymmetrical;
+        this.linePerUnitMode = other.linePerUnitMode;
         this.useLoadModel = other.useLoadModel;
+        this.simulateAutomationSystems = other.simulateAutomationSystems;
     }
 
     public SlackBusSelector getSlackBusSelector() {
@@ -466,6 +472,15 @@ public LfNetworkParameters setUseLoadModel(boolean useLoadModel) {
         return this;
     }
 
+    public boolean isSimulateAutomationSystems() {
+        return simulateAutomationSystems;
+    }
+
+    public LfNetworkParameters setSimulateAutomationSystems(boolean simulateAutomationSystems) {
+        this.simulateAutomationSystems = simulateAutomationSystems;
+        return this;
+    }
+
     @Override
     public String toString() {
         return "LfNetworkParameters(" +
@@ -500,6 +515,7 @@ public String toString() {
                 ", minNominalVoltageTargetVoltageCheck=" + minNominalVoltageTargetVoltageCheck +
                 ", linePerUnitMode=" + linePerUnitMode +
                 ", useLoadModel=" + useLoadModel +
+                ", simulateAutomationSystems=" + simulateAutomationSystems +
                 ')';
     }
 }