Add parameter to define min nominal voltage for unrealistic state check (#1217)

Signed-off-by: Didier Vidal <didier.vidal_externe@rte-france.com>
Co-authored-by: jeandemanged <damien.jeandemange@artelys.com>

Author: vidaldid-rte

docs/loadflow/parameters.md

@@ -320,8 +320,9 @@ The default values are `0.8` and `1.2` and they must be greater or equal to `0`.
 **minRealisticVoltage** and **maxRealisticVoltage**  
 These parameters are used to identify if the AC Solver has converged to an unrealistic state.
 
-For any component where a bus voltage is solved outside these per-unit
-thresholds, the component solution is deemed unrealistic and its solution status is flagged as failed.
+If there is any bus in a voltage level, in pu, higher than 'minNominalVoltageRealisticVoltageCheck', with 
+a computed voltage outside these per-unit thresholds, the component solution is deemed unrealistic and 
+its solution status is flagged as failed.
 
 If `voltageRemoteControlRobustMode` is set to true, the check of unrealistic voltage is done after the 
 ReactiveLimits outerloop has been used. In addition, the ReactiveLimits outerloop uses these values as a 
@@ -330,6 +331,21 @@ their reactive diagram.
 
 The default values are `0.5` and `2.0` and they must be greater or equal to `0`.
 
+**minNominalVoltageRealisticVoltageCheck**
+This parameter defines the minimal nominal voltage, in kV, for which a bus oustide of **minRealisticVoltage**
+and **maxRealisticVoltage** will stop the simulation.
+
+Unrealistic voltages -particularly in high-voltage substations- can trigger automated protections or other 
+hazardous phenomena, potentially causing significant impacts to the system. Steady-state simulation may not 
+accurately account for these effects. Therefore, results obtained under such conditions should be interpreted 
+with caution.
+
+A configuration that offers both reliable simulation results and resilience to local observability issues could, 
+for example, use 0.8 and 1.2 p.u. for **minRealisticVoltage** and **maxRealisticVoltage**, respectively, 
+and 100 kV for **minNominalVoltageRealisticVoltageCheck**.
+
+The default value is 0 kV.
+
 **reactiveRangeCheckMode**  
 Open Load Flow discards voltage control for generators with a too small reactive power range, because in practice a too
 small reactive power ranger means limited to zero voltage control capability.
@@ -396,9 +412,11 @@ Allows to ignore active power limits during calculations. Active power limits ar
 Disables voltage control for generators with `targetP` outside the interval [`minP`, `maxP`]. The default value is `false`.
 
 **minNominalVoltageTargetVoltageCheck**  
-This parameter defines the minimal nominal voltage to check the target of voltage control in per-unit.
-The default value is `20 kV`, meaning that under the controlled buses of voltage levels under this value are ignored from the check.
-It must be greater or equal to `0 kV`.
+This parameter defines the minimal nominal voltage, in kV, for which the plausible voltage target checks are applied.
+ 
+Above this voltage level, voltage targets that are, in pu, outside 'minPlausibleTargetVoltage' - 'maxPlausibleTargetVoltage' are ignored.
+
+The default value is `20 kV`. It must be greater or equal to `0 kV`.
 
 **reactivePowerDispatchMode**  
 This parameter defines how reactive power is split among generators with controls (voltage or reactive power).

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

@@ -206,6 +206,8 @@ public enum FictitiousGeneratorVoltageControlCheckMode {
 
     public static final String MAX_REALISTIC_VOLTAGE_PARAM_NAME = "maxRealisticVoltage";
 
+    public static final String MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK_PARAM_NAME = "minNominalVoltageRealisticVoltageCheck";
+
     public static final String MIN_NOMINAL_VOLTAGE_TARGET_VOLTAGE_CHECK_PARAM_NAME = "minNominalVoltageTargetVoltageCheck";
 
     public static final String REACTIVE_RANGE_CHECK_MODE_PARAM_NAME = "reactiveRangeCheckMode";
@@ -390,6 +392,7 @@ public static List<Object> getAcSolverTypePossibleValues() {
         new Parameter(MAX_PLAUSIBLE_TARGET_VOLTAGE_PARAM_NAME, ParameterType.DOUBLE, "Max plausible target voltage", LfNetworkParameters.MAX_PLAUSIBLE_TARGET_VOLTAGE_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, VOLTAGE_CONTROLS_CATEGORY_KEY),
         new Parameter(MIN_REALISTIC_VOLTAGE_PARAM_NAME, ParameterType.DOUBLE, "Min realistic voltage", AcLoadFlowParameters.DEFAULT_MIN_REALISTIC_VOLTAGE, ParameterScope.FUNCTIONAL, VOLTAGE_CONTROLS_CATEGORY_KEY),
         new Parameter(MAX_REALISTIC_VOLTAGE_PARAM_NAME, ParameterType.DOUBLE, "Max realistic voltage", AcLoadFlowParameters.DEFAULT_MAX_REALISTIC_VOLTAGE, ParameterScope.FUNCTIONAL, VOLTAGE_CONTROLS_CATEGORY_KEY),
+        new Parameter(MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK_PARAM_NAME, ParameterType.DOUBLE, "Min nominal voltage realistic voltage check", AcLoadFlowParameters.DEFAULT_MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK, ParameterScope.FUNCTIONAL, VOLTAGE_CONTROLS_CATEGORY_KEY),
         new Parameter(REACTIVE_RANGE_CHECK_MODE_PARAM_NAME, ParameterType.STRING, "Reactive range check mode", LfNetworkParameters.REACTIVE_RANGE_CHECK_MODE_DEFAULT_VALUE.name(), getEnumPossibleValues(ReactiveRangeCheckMode.class), ParameterScope.FUNCTIONAL, GENERATOR_VOLTAGE_CONTROL_CATEGORY_KEY),
         new Parameter(LOW_IMPEDANCE_THRESHOLD_PARAM_NAME, ParameterType.DOUBLE, "Low impedance threshold in per unit", LfNetworkParameters.LOW_IMPEDANCE_THRESHOLD_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, MODEL_CATEGORY_KEY),
         new Parameter(NETWORK_CACHE_ENABLED_PARAM_NAME, ParameterType.BOOLEAN, "Network cache enabled", LfNetworkParameters.CACHE_ENABLED_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, FAST_RESTART_CATEGORY_KEY),
@@ -539,6 +542,8 @@ public enum LowImpedanceBranchMode {
 
     private double maxRealisticVoltage = AcLoadFlowParameters.DEFAULT_MAX_REALISTIC_VOLTAGE;
 
+    private double minNominalVoltageRealisticVoltageCheck = AcLoadFlowParameters.DEFAULT_MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK;
+
     private double lowImpedanceThreshold = LfNetworkParameters.LOW_IMPEDANCE_THRESHOLD_DEFAULT_VALUE;
 
     public enum ReactiveRangeCheckMode {
@@ -962,6 +967,15 @@ public OpenLoadFlowParameters setMaxRealisticVoltage(double maxRealisticVoltage)
         return this;
     }
 
+    public double getMinNominalVoltageRealisticVoltageCheck() {
+        return minNominalVoltageRealisticVoltageCheck;
+    }
+
+    public OpenLoadFlowParameters setMinNominalVoltageRealisticVoltageCheck(double minNominalVoltageRealisticVoltageCheck) {
+        this.minNominalVoltageRealisticVoltageCheck = minNominalVoltageRealisticVoltageCheck;
+        return this;
+    }
+
     public ReactiveRangeCheckMode getReactiveRangeCheckMode() {
         return reactiveRangeCheckMode;
     }
@@ -1455,6 +1469,7 @@ public OpenLoadFlowParameters update(PlatformConfig platformConfig) {
                     config.getOptionalDoubleProperty(MAX_PLAUSIBLE_TARGET_VOLTAGE_PARAM_NAME).ifPresent(this::setMaxPlausibleTargetVoltage);
                     config.getOptionalDoubleProperty(MIN_REALISTIC_VOLTAGE_PARAM_NAME).ifPresent(this::setMinRealisticVoltage);
                     config.getOptionalDoubleProperty(MAX_REALISTIC_VOLTAGE_PARAM_NAME).ifPresent(this::setMaxRealisticVoltage);
+                    config.getOptionalDoubleProperty(MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK_PARAM_NAME).ifPresent(this::setMinNominalVoltageRealisticVoltageCheck);
                     config.getOptionalEnumProperty(REACTIVE_RANGE_CHECK_MODE_PARAM_NAME, ReactiveRangeCheckMode.class)
                             .ifPresent(this::setReactiveRangeCheckMode);
                     config.getOptionalDoubleProperty(LOW_IMPEDANCE_THRESHOLD_PARAM_NAME).ifPresent(this::setLowImpedanceThreshold);
@@ -1580,6 +1595,8 @@ public OpenLoadFlowParameters update(Map<String, String> properties) {
                 .ifPresent(prop -> this.setMinRealisticVoltage(Double.parseDouble(prop)));
         Optional.ofNullable(properties.get(MAX_REALISTIC_VOLTAGE_PARAM_NAME))
                 .ifPresent(prop -> this.setMaxRealisticVoltage(Double.parseDouble(prop)));
+        Optional.ofNullable(properties.get(MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK_PARAM_NAME))
+                .ifPresent(prop -> this.setMinNominalVoltageRealisticVoltageCheck(Double.parseDouble(prop)));
         Optional.ofNullable(properties.get(REACTIVE_RANGE_CHECK_MODE_PARAM_NAME))
                 .ifPresent(prop -> this.setReactiveRangeCheckMode(ReactiveRangeCheckMode.valueOf(prop)));
         Optional.ofNullable(properties.get(LOW_IMPEDANCE_THRESHOLD_PARAM_NAME))
@@ -1710,6 +1727,7 @@ public Map<String, Object> toMap() {
         map.put(MAX_PLAUSIBLE_TARGET_VOLTAGE_PARAM_NAME, maxPlausibleTargetVoltage);
         map.put(MIN_REALISTIC_VOLTAGE_PARAM_NAME, minRealisticVoltage);
         map.put(MAX_REALISTIC_VOLTAGE_PARAM_NAME, maxRealisticVoltage);
+        map.put(MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK_PARAM_NAME, minNominalVoltageRealisticVoltageCheck);
         map.put(REACTIVE_RANGE_CHECK_MODE_PARAM_NAME, reactiveRangeCheckMode);
         map.put(LOW_IMPEDANCE_THRESHOLD_PARAM_NAME, lowImpedanceThreshold);
         map.put(NETWORK_CACHE_ENABLED_PARAM_NAME, networkCacheEnabled);
@@ -1977,7 +1995,8 @@ public static AcLoadFlowParameters createAcParameters(LoadFlowParameters paramet
                 .setSolverFactory(solverFactory, parameters)
                 .setVoltageRemoteControlRobustMode(parametersExt.isVoltageRemoteControlRobustMode())
                 .setMinRealisticVoltage(parametersExt.minRealisticVoltage)
-                .setMaxRealisticVoltage(parametersExt.maxRealisticVoltage);
+                .setMaxRealisticVoltage(parametersExt.maxRealisticVoltage)
+                .setMinNominalVoltageRealisticVoltageCheck(parametersExt.getMinNominalVoltageRealisticVoltageCheck());
     }
 
     public static DcLoadFlowParameters createDcParameters(Network network, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt,
@@ -2158,6 +2177,7 @@ public static boolean equals(LoadFlowParameters parameters1, LoadFlowParameters
                 extension1.isVoltageRemoteControlRobustMode() == extension2.isVoltageRemoteControlRobustMode() &&
                 extension1.isForceTargetQInReactiveLimits() == extension2.isForceTargetQInReactiveLimits() &&
                 extension1.isDisableInconsistentVoltageControls() == extension2.isDisableInconsistentVoltageControls() &&
+                extension1.getMinNominalVoltageRealisticVoltageCheck() == extension2.getMinNominalVoltageRealisticVoltageCheck() &&
                 extension1.isExtrapolateReactiveLimits() == extension2.isExtrapolateReactiveLimits();
     }
 
@@ -2205,6 +2225,7 @@ public static LoadFlowParameters clone(LoadFlowParameters parameters) {
                     .setMaxPlausibleTargetVoltage(extension.getMaxPlausibleTargetVoltage())
                     .setMinRealisticVoltage(extension.getMinRealisticVoltage())
                     .setMaxRealisticVoltage(extension.getMaxRealisticVoltage())
+                    .setMinNominalVoltageRealisticVoltageCheck(extension.getMinNominalVoltageRealisticVoltageCheck())
                     .setReactiveRangeCheckMode(extension.getReactiveRangeCheckMode())
                     .setLowImpedanceThreshold(extension.getLowImpedanceThreshold())
                     .setNetworkCacheEnabled(extension.isNetworkCacheEnabled())

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

@@ -30,6 +30,7 @@ public class AcLoadFlowParameters extends AbstractLoadFlowParameters<AcLoadFlowP
 
     public static final double DEFAULT_MIN_REALISTIC_VOLTAGE = 0.5;
     public static final double DEFAULT_MAX_REALISTIC_VOLTAGE = 2;
+    public static final double DEFAULT_MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK = 0;
 
     private AcEquationSystemCreationParameters equationSystemCreationParameters = new AcEquationSystemCreationParameters();
 
@@ -53,6 +54,8 @@ public class AcLoadFlowParameters extends AbstractLoadFlowParameters<AcLoadFlowP
 
     private double maxRealisticVoltage = DEFAULT_MAX_REALISTIC_VOLTAGE;
 
+    private double minNominalVoltageRealisticVoltageCheck = DEFAULT_MIN_NOMINAL_VOLTAGE_REALISTIC_VOLTAGE_CHECK;
+
     public AcEquationSystemCreationParameters getEquationSystemCreationParameters() {
         return equationSystemCreationParameters;
     }
@@ -148,6 +151,15 @@ public AcLoadFlowParameters setMaxRealisticVoltage(double maxRealisticVoltage) {
         return this;
     }
 
+    public double getMinNominalVoltageRealisticVoltageCheck() {
+        return minNominalVoltageRealisticVoltageCheck;
+    }
+
+    public AcLoadFlowParameters setMinNominalVoltageRealisticVoltageCheck(double minNominalVoltageRealisticVoltageCheck) {
+        this.minNominalVoltageRealisticVoltageCheck = minNominalVoltageRealisticVoltageCheck;
+        return this;
+    }
+
     @Override
     public String toString() {
         return "AcLoadFlowParameters(" +
@@ -165,6 +177,7 @@ public String toString() {
                 ", voltageRemoteControlRobustMode=" + voltageRemoteControlRobustMode +
                 ", minRealisticVoltage=" + minRealisticVoltage +
                 ", maxRealisticVoltage=" + maxRealisticVoltage +
+                ", minNominalVoltageRealisticVoltageCheck=" + minNominalVoltageRealisticVoltageCheck +
                 ')';
     }
 }

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

@@ -96,7 +96,8 @@ private void runOuterLoop(AcOuterLoop outerLoop, AcOuterLoopContext outerLoopCon
                 }
 
                 // if not yet stable, restart solver
-                runningContext.lastSolverResult = runAcSolverAndCheckRealisticState(solver, new PreviousValueVoltageInitializer(), reportNode, checkUnrealistic);
+                runningContext.lastSolverResult = runAcSolverAndCheckRealisticState(solver, new PreviousValueVoltageInitializer(), reportNode, checkUnrealistic,
+                        outerLoopContext.getLoadFlowContext().getParameters());
 
                 runningContext.nrTotalIterations.add(runningContext.lastSolverResult.getIterations());
                 runningContext.outerLoopTotalIterations++;
@@ -108,8 +109,11 @@ private void runOuterLoop(AcOuterLoop outerLoop, AcOuterLoopContext outerLoopCon
                 && runningContext.outerLoopTotalIterations < context.getParameters().getMaxOuterLoopIterations());
 
         if (!checkUnrealistic && runningContext.lastUnrealisticStateFixingLoop == outerLoop && runningContext.lastSolverResult.getStatus() == AcSolverStatus.CONVERGED) {
+
             // This is time to check the unrealistic state and create a report if needed
-            boolean isStateUnrealistic = isStateUnrealistic(context.getNetwork().getReportNode());
+            boolean isStateUnrealistic = isStateUnrealistic(context.getNetwork().getReportNode(),
+                    outerLoopContext.getLoadFlowContext().getParameters().getMinNominalVoltageRealisticVoltageCheck());
+
             if (isStateUnrealistic) {
                 runningContext.lastSolverResult = new AcSolverResult(AcSolverStatus.UNREALISTIC_STATE,
                                                                      runningContext.lastSolverResult.getIterations(),
@@ -122,7 +126,8 @@ private void runOuterLoop(AcOuterLoop outerLoop, AcOuterLoopContext outerLoopCon
         }
     }
 
-    private boolean isStateUnrealistic(ReportNode reportNode) {
+    private boolean isStateUnrealistic(ReportNode reportNode, double minNominalVoltageRealisticVoltageCheck) {
+
         EquationSystem<AcVariableType, AcEquationType> equationSystem = context.getEquationSystem();
         AcLoadFlowParameters parameters = context.getParameters();
         LfNetwork network = context.getNetwork();
@@ -131,7 +136,10 @@ private boolean isStateUnrealistic(ReportNode reportNode) {
             if (v.getType() == AcVariableType.BUS_V && !network.getBus(v.getElementNum()).isFictitious()) {
                 double value = equationSystem.getStateVector().get(v.getRow());
                 if (value < parameters.getMinRealisticVoltage() || value > parameters.getMaxRealisticVoltage()) {
-                    busesOutOfNormalVoltageRange.put(network.getBus(v.getElementNum()).getId(), value);
+                    // only consider unrealistic if nominal voltage high enough
+                    if (network.getBus(v.getElementNum()).getNominalV() >= minNominalVoltageRealisticVoltageCheck) {
+                        busesOutOfNormalVoltageRange.put(network.getBus(v.getElementNum()).getId(), value);
+                    }
                 }
             }
         }
@@ -150,10 +158,10 @@ private boolean isStateUnrealistic(ReportNode reportNode) {
     }
 
     private AcSolverResult runAcSolverAndCheckRealisticState(AcSolver solver, VoltageInitializer voltageInitializer,
-                                                             ReportNode reportNode, boolean checkUnrealistic) {
+                                                             ReportNode reportNode, boolean checkUnrealistic, AcLoadFlowParameters parameters) {
         AcSolverResult result = solver.run(voltageInitializer, reportNode);
 
-        if (checkUnrealistic && result.getStatus() == AcSolverStatus.CONVERGED && isStateUnrealistic(reportNode)) {
+        if (checkUnrealistic && result.getStatus() == AcSolverStatus.CONVERGED && isStateUnrealistic(reportNode, parameters.getMinNominalVoltageRealisticVoltageCheck())) {
             result = new AcSolverResult(AcSolverStatus.UNREALISTIC_STATE, result.getIterations(), result.getSlackBusActivePowerMismatch());
         }
 
@@ -230,7 +238,7 @@ public AcLoadFlowResult run() {
         boolean checkUnrealisticStates = runningContext.lastUnrealisticStateFixingLoop == null;
 
         // initial solver run
-        runningContext.lastSolverResult = runAcSolverAndCheckRealisticState(solver, voltageInitializer, reportNode, checkUnrealisticStates);
+        runningContext.lastSolverResult = runAcSolverAndCheckRealisticState(solver, voltageInitializer, reportNode, checkUnrealisticStates, context.getParameters());
 
         runningContext.nrTotalIterations.add(runningContext.lastSolverResult.getIterations());