[WIP] Check too far generator voltage remote control

docs/loadflow/parameters.md

@@ -140,6 +140,12 @@ If set to false, any existing voltage remote control is converted to a local con
 according to the nominal voltage ratio between the remote regulated bus and the equipment terminal bus.  
 The default value is `true`.
 
+**maxGeneratorVoltageRemoteControlDistance**
+Defines the maximum distance allowed between the remote regulated bus and the voltage controller generator (requires `voltageRemoteControl` to be set to `true`).
+This distance is measured in number of branches separating the controlled bus and the generator. If the distance is higher than this parameter, then the voltage remote control is converted to a local control, rescaling the target voltage according to the nominal voltage ratio between the remote regulated bus and the equipment terminal bus. (This criteria covers also remote voltage control of static variable compensators, VSC converters and batteries)
+If `maxGeneratorVoltageRemoteControlDistance` is set to `0` (or a negative value), there is no distance checking.
+The default value is `2`.
+
 **voltagePerReactivePowerControl**  
 Whether simulation of static VAR compensators with voltage control enabled and a slope defined should be enabled
 (See [voltage per reactive power control extension](inv:powsyblcore:*:*:#voltage-per-reactive-power-control-extension)).  

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

@@ -276,6 +276,8 @@ public enum FictitiousGeneratorVoltageControlCheckMode {
 
     public static final String AREA_INTERCHANGE_P_MAX_MISMATCH_PARAM_NAME = "areaInterchangePMaxMismatch";
 
+    public static final String MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME = "maxGeneratorVoltageRemoteControlDistance";
+
     public static <E extends Enum<E>> List<Object> getEnumPossibleValues(Class<E> enumClass) {
         return EnumSet.allOf(enumClass).stream().map(Enum::name).collect(Collectors.toList());
     }
@@ -413,7 +415,8 @@ public static <E extends Enum<E>> List<Object> getEnumPossibleValues(Class<E> en
         new Parameter(FICTITIOUS_GENERATOR_VOLTAGE_CONTROL_CHECK_MODE, ParameterType.STRING, "Specifies fictitious generators active power checks exemption for voltage control", OpenLoadFlowParameters.FICTITIOUS_GENERATOR_VOLTAGE_CONTROL_CHECK_MODE_DEFAULT_VALUE.name(), getEnumPossibleValues(FictitiousGeneratorVoltageControlCheckMode.class), ParameterScope.FUNCTIONAL, GENERATOR_VOLTAGE_CONTROL_CATEGORY_KEY),
         new Parameter(AREA_INTERCHANGE_CONTROL_PARAM_NAME, ParameterType.BOOLEAN, "Area interchange control", AREA_INTERCHANGE_CONTROL_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, SLACK_DISTRIBUTION_CATEGORY_KEY),
         new Parameter(AREA_INTERCHANGE_CONTROL_AREA_TYPE_PARAM_NAME, ParameterType.STRING, "Area type for area interchange control", LfNetworkParameters.AREA_INTERCHANGE_CONTROL_AREA_TYPE_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, SLACK_DISTRIBUTION_CATEGORY_KEY),
-        new Parameter(AREA_INTERCHANGE_P_MAX_MISMATCH_PARAM_NAME, ParameterType.DOUBLE, "Area interchange max active power mismatch", AREA_INTERCHANGE_P_MAX_MISMATCH_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, SLACK_DISTRIBUTION_CATEGORY_KEY)
+        new Parameter(AREA_INTERCHANGE_P_MAX_MISMATCH_PARAM_NAME, ParameterType.DOUBLE, "Area interchange max active power mismatch", AREA_INTERCHANGE_P_MAX_MISMATCH_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, SLACK_DISTRIBUTION_CATEGORY_KEY),
+        new Parameter(MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME, ParameterType.INTEGER, "Maximum voltage remote control distance", LfNetworkParameters.MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_DEFAULT_VALUE, ParameterScope.FUNCTIONAL, GENERATOR_VOLTAGE_CONTROL_CATEGORY_KEY)
     );
 
     public enum VoltageInitModeOverride {
@@ -597,6 +600,8 @@ public enum ReactiveRangeCheckMode {
 
     private double areaInterchangePMaxMismatch = AREA_INTERCHANGE_P_MAX_MISMATCH_DEFAULT_VALUE;
 
+    private int maxGeneratorVoltageRemoteControlDistance = LfNetworkParameters.MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_DEFAULT_VALUE;
+
     public static double checkParameterValue(double parameterValue, boolean condition, String parameterName) {
         if (!condition) {
             throw new IllegalArgumentException("Invalid value for parameter " + parameterName + ": " + parameterValue);
@@ -1322,6 +1327,15 @@ public OpenLoadFlowParameters setAreaInterchangePMaxMismatch(double areaIntercha
         return this;
     }
 
+    public int getMaxGeneratorVoltageRemoteControlDistance() {
+        return maxGeneratorVoltageRemoteControlDistance;
+    }
+
+    public OpenLoadFlowParameters setMaxGeneratorVoltageRemoteControlDistance(int maxGeneratorVoltageRemoteControlDistance) {
+        this.maxGeneratorVoltageRemoteControlDistance = maxGeneratorVoltageRemoteControlDistance;
+        return this;
+    }
+
     public static OpenLoadFlowParameters load() {
         return load(PlatformConfig.defaultConfig());
     }
@@ -1400,7 +1414,8 @@ public static OpenLoadFlowParameters load(PlatformConfig platformConfig) {
                 .setGeneratorVoltageControlMinNominalVoltage(config.getDoubleProperty(GENERATOR_VOLTAGE_CONTROL_MIN_NOMINAL_VOLTAGE_PARAM_NAME, GENERATOR_VOLTAGE_CONTROL_MIN_NOMINAL_VOLTAGE_DEFAULT_VALUE))
                 .setAreaInterchangeControl(config.getBooleanProperty(AREA_INTERCHANGE_CONTROL_PARAM_NAME, AREA_INTERCHANGE_CONTROL_DEFAULT_VALUE))
                 .setAreaInterchangeControlAreaType(config.getStringProperty(AREA_INTERCHANGE_CONTROL_AREA_TYPE_PARAM_NAME, LfNetworkParameters.AREA_INTERCHANGE_CONTROL_AREA_TYPE_DEFAULT_VALUE))
-                .setAreaInterchangePMaxMismatch(config.getDoubleProperty(AREA_INTERCHANGE_P_MAX_MISMATCH_PARAM_NAME, AREA_INTERCHANGE_P_MAX_MISMATCH_DEFAULT_VALUE)));
+                .setAreaInterchangePMaxMismatch(config.getDoubleProperty(AREA_INTERCHANGE_P_MAX_MISMATCH_PARAM_NAME, AREA_INTERCHANGE_P_MAX_MISMATCH_DEFAULT_VALUE))
+                .setMaxGeneratorVoltageRemoteControlDistance(config.getIntProperty(MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME, LfNetworkParameters.MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_DEFAULT_VALUE)));
         return parameters;
     }
 
@@ -1561,6 +1576,8 @@ public OpenLoadFlowParameters update(Map<String, String> properties) {
                 .ifPresent(this::setAreaInterchangeControlAreaType);
         Optional.ofNullable(properties.get(AREA_INTERCHANGE_P_MAX_MISMATCH_PARAM_NAME))
                 .ifPresent(prop -> this.setAreaInterchangePMaxMismatch(Double.parseDouble(prop)));
+        Optional.ofNullable(properties.get(MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME))
+                .ifPresent(prop -> this.setMaxGeneratorVoltageRemoteControlDistance(Integer.parseInt(prop)));
         return this;
     }
 
@@ -1637,6 +1654,7 @@ public Map<String, Object> toMap() {
         map.put(AREA_INTERCHANGE_CONTROL_PARAM_NAME, areaInterchangeControl);
         map.put(AREA_INTERCHANGE_CONTROL_AREA_TYPE_PARAM_NAME, areaInterchangeControlAreaType);
         map.put(AREA_INTERCHANGE_P_MAX_MISMATCH_PARAM_NAME, areaInterchangePMaxMismatch);
+        map.put(MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME, maxGeneratorVoltageRemoteControlDistance);
         return map;
     }
 
@@ -1793,7 +1811,8 @@ static LfNetworkParameters getNetworkParameters(LoadFlowParameters parameters, O
                 .setVoltageTargetPriorities(parametersExt.getVoltageTargetPriorities())
                 .setFictitiousGeneratorVoltageControlCheckMode(parametersExt.getFictitiousGeneratorVoltageControlCheckMode())
                 .setAreaInterchangeControl(parametersExt.isAreaInterchangeControl())
-                .setAreaInterchangeControlAreaType(parametersExt.getAreaInterchangeControlAreaType());
+                .setAreaInterchangeControlAreaType(parametersExt.getAreaInterchangeControlAreaType())
+                .setMaxGeneratorVoltageRemoteControlDistance(parametersExt.getMaxGeneratorVoltageRemoteControlDistance());
     }
 
     public static AcLoadFlowParameters createAcParameters(Network network, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt,
@@ -2046,7 +2065,8 @@ public static boolean equals(LoadFlowParameters parameters1, LoadFlowParameters
                 extension1.getFictitiousGeneratorVoltageControlCheckMode() == extension2.getFictitiousGeneratorVoltageControlCheckMode() &&
                 extension1.isAreaInterchangeControl() == extension2.isAreaInterchangeControl() &&
                 Objects.equals(extension1.getAreaInterchangeControlAreaType(), extension2.getAreaInterchangeControlAreaType()) &&
-                extension1.getAreaInterchangePMaxMismatch() == extension2.getAreaInterchangePMaxMismatch();
+                extension1.getAreaInterchangePMaxMismatch() == extension2.getAreaInterchangePMaxMismatch() &&
+                extension1.getMaxGeneratorVoltageRemoteControlDistance() == extension2.getMaxGeneratorVoltageRemoteControlDistance();
     }
 
     public static LoadFlowParameters clone(LoadFlowParameters parameters) {
@@ -2142,7 +2162,8 @@ public static LoadFlowParameters clone(LoadFlowParameters parameters) {
                     .setFictitiousGeneratorVoltageControlCheckMode(extension.getFictitiousGeneratorVoltageControlCheckMode())
                     .setAreaInterchangeControl(extension.isAreaInterchangeControl())
                     .setAreaInterchangeControlAreaType(extension.getAreaInterchangeControlAreaType())
-                    .setAreaInterchangePMaxMismatch(extension.getAreaInterchangePMaxMismatch());
+                    .setAreaInterchangePMaxMismatch(extension.getAreaInterchangePMaxMismatch())
+                    .setMaxGeneratorVoltageRemoteControlDistance(extension.getMaxGeneratorVoltageRemoteControlDistance());
 
             if (extension2 != null) {
                 parameters2.addExtension(OpenLoadFlowParameters.class, extension2);

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

@@ -58,6 +58,8 @@ public class LfNetworkParameters {
 
     public static final String AREA_INTERCHANGE_CONTROL_AREA_TYPE_DEFAULT_VALUE = "ControlArea";
 
+    public static final int MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_DEFAULT_VALUE = 2;
+
     private SlackBusSelector slackBusSelector = new FirstSlackBusSelector(SLACK_BUS_COUNTRY_FILTER_DEFAULT_VALUE);
 
     private GraphConnectivityFactory<LfBus, LfBranch> connectivityFactory = new EvenShiloachGraphDecrementalConnectivityFactory<>();
@@ -148,6 +150,8 @@ public class LfNetworkParameters {
 
     private String areaInterchangeControlAreaType = AREA_INTERCHANGE_CONTROL_AREA_TYPE_DEFAULT_VALUE;
 
+    private int maxGeneratorVoltageRemoteControlDistance = MAX_GENERATOR_VOLTAGE_REMOTE_CONTROL_DISTANCE_DEFAULT_VALUE;
+
     public LfNetworkParameters() {
     }
 
@@ -194,6 +198,7 @@ public LfNetworkParameters(LfNetworkParameters other) {
         this.fictitiousGeneratorVoltageControlCheckMode = other.fictitiousGeneratorVoltageControlCheckMode;
         this.areaInterchangeControl = other.areaInterchangeControl;
         this.areaInterchangeControlAreaType = other.areaInterchangeControlAreaType;
+        this.maxGeneratorVoltageRemoteControlDistance = other.maxGeneratorVoltageRemoteControlDistance;
     }
 
     public SlackBusSelector getSlackBusSelector() {
@@ -597,6 +602,15 @@ public LfNetworkParameters setAreaInterchangeControlAreaType(String areaIntercha
         return this;
     }
 
+    public int getMaxGeneratorVoltageRemoteControlDistance() {
+        return maxGeneratorVoltageRemoteControlDistance;
+    }
+
+    public LfNetworkParameters setMaxGeneratorVoltageRemoteControlDistance(int maxGeneratorVoltageRemoteControlDistance) {
+        this.maxGeneratorVoltageRemoteControlDistance = maxGeneratorVoltageRemoteControlDistance;
+        return this;
+    }
+
     @Override
     public String toString() {
         return "LfNetworkParameters(" +
@@ -638,6 +652,7 @@ public String toString() {
                 ", fictitiousGeneratorVoltageControlCheckMode=" + fictitiousGeneratorVoltageControlCheckMode +
                 ", areaInterchangeControl=" + areaInterchangeControl +
                 ", areaInterchangeControlAreaType=" + areaInterchangeControlAreaType +
+                ", maxGeneratorVoltageRemoteControlDistance=" + maxGeneratorVoltageRemoteControlDistance +
                 ')';
     }
 }

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

@@ -30,6 +30,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static com.powsybl.openloadflow.util.BusDistance.distanceBetweenBuses;
 import static com.powsybl.openloadflow.util.DebugUtil.DATE_TIME_FORMAT;
 import static com.powsybl.openloadflow.util.Markers.PERFORMANCE_MARKER;
 
@@ -127,14 +128,24 @@ private static void createVoltageControls(List<LfBus> lfBuses, LfNetworkParamete
                     }
                 });
 
-                if (parameters.isGeneratorVoltageRemoteControl() || controlledBus == controllerBus) {
+                boolean keepVoltageRemoteControl = false;
+                if (!parameters.isGeneratorVoltageRemoteControl() && controlledBus != controllerBus) {
+                    LOGGER.warn("Remote voltage control is not activated. The voltage target of {} with remote control is rescaled from {} to {}",
+                            controllerBus.getId(), controllerTargetV, controllerTargetV * controllerBus.getNominalV() / controlledBus.getNominalV());
+                } else if (parameters.getMaxGeneratorVoltageRemoteControlDistance() > 0 && distanceBetweenBuses(controlledBus, controllerBus, parameters.getMaxGeneratorVoltageRemoteControlDistance()) > parameters.getMaxGeneratorVoltageRemoteControlDistance()) {
+                    LOGGER.warn("Voltage controlled bus '{}' is too far from controller bus '{}' (maxGeneratorVoltageRemoteControlDistance is set to {}). The bus switches to local voltage control and target voltage is rescaled from {} to {}",
+                            controlledBus.getId(), controllerBus.getId(), parameters.getMaxGeneratorVoltageRemoteControlDistance(), controllerTargetV, controllerTargetV * controllerBus.getNominalV() / controlledBus.getNominalV());
+                    Reports.reportTooFarControlledBus(controlledBus.getNetwork().getReportNode(), controllerBus.getId(), controlledBus.getId(), parameters.getMaxGeneratorVoltageRemoteControlDistance());
+                } else {
+                    keepVoltageRemoteControl = true;
+                }
+
+                if (keepVoltageRemoteControl) {
                     controlledBus.getGeneratorVoltageControl().ifPresentOrElse(
                         vc -> updateGeneratorVoltageControl(vc, controllerBus, controllerTargetV),
                         () -> createGeneratorVoltageControl(controlledBus, controllerBus, controllerTargetV, voltageControls, parameters));
                 } else {
                     // if voltage remote control deactivated and remote control, set local control instead
-                    LOGGER.warn("Remote voltage control is not activated. The voltage target of {} with remote control is rescaled from {} to {}",
-                            controllerBus.getId(), controllerTargetV, controllerTargetV * controllerBus.getNominalV() / controlledBus.getNominalV());
                     controlledBus.getGeneratorVoltageControl().ifPresentOrElse(
                         vc -> updateGeneratorVoltageControl(vc, controllerBus, controllerTargetV), // updating only to check targetV uniqueness
                         () -> createGeneratorVoltageControl(controllerBus, controllerBus, controllerTargetV, voltageControls, parameters));

src/main/java/com/powsybl/openloadflow/util/BusDistance.java

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2024, 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/.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+package com.powsybl.openloadflow.util;
+
+import com.powsybl.openloadflow.network.LfBus;
+
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * @author Sylvestre Prabakaran {@literal <sylvestre.prabakaran at rte-france.com>}
+ */
+public final class BusDistance {
+
+    private BusDistance() {
+    }
+
+    /**
+     * Breadth first search algorithm to compute distance between two LfBus in a network
+     * @param bus1              first LfBus (from which the breadth first search starts)
+     * @param bus2              second LfBus (searched bus)
+     * @param maxDistanceSearch the algorithm searches until this range and stops after this limit (or if every bus have been checked)
+     * @return                  measured distance (number of branches) or Integer.MAX_VALUE if bus2 is not found
+     */
+    public static int distanceBetweenBuses(LfBus bus1, LfBus bus2, int maxDistanceSearch) {
+        Objects.requireNonNull(bus1);
+        Objects.requireNonNull(bus2);
+        if (bus1.equals(bus2)) {
+            return 0;
+        }
+        Set<LfBus> busesToCheck = new HashSet<>();
+        Set<LfBus> checkedBuses = new HashSet<>();
+        busesToCheck.add(bus1);
+        checkedBuses.add(bus1);
+        for (int distance = 1; distance <= maxDistanceSearch; distance++) {
+            busesToCheck = busesToCheck.stream()
+                    .flatMap(bus -> bus.findNeighbors().keySet().stream())
+                    .collect(Collectors.toSet());
+            busesToCheck.removeAll(checkedBuses);
+            if (busesToCheck.contains(bus2)) {
+                return distance;
+            } else if (busesToCheck.isEmpty()) {
+                return Integer.MAX_VALUE;
+            }
+            checkedBuses.addAll(busesToCheck);
+        }
+        return Integer.MAX_VALUE;
+    }
+}

src/main/java/com/powsybl/openloadflow/util/Reports.java

@@ -71,6 +71,16 @@ public static void reportNotUniqueControlledBus(ReportNode reportNode, String ge
                 .add();
     }
 
+    public static void reportTooFarControlledBus(ReportNode reportNode, String controllerBusId, String controlledBusId, int maxGeneratorVoltageRemoteControlDistance) {
+        reportNode.newReportNode()
+                .withMessageTemplate("tooFarControllerBus", "Remote voltage controlled bus ${controlledBusId} is too far from controller bus ${controllerBusId} (maxGeneratorVoltageRemoteControlDistance is set to ${maxGeneratorVoltageRemoteControlDistance}). Switching to local voltage control")
+                .withUntypedValue(CONTROLLED_BUS_ID, controlledBusId)
+                .withUntypedValue(CONTROLLER_BUS_ID, controllerBusId)
+                .withUntypedValue("maxGeneratorVoltageRemoteControlDistance", maxGeneratorVoltageRemoteControlDistance)
+                .withSeverity(TypedValue.WARN_SEVERITY)
+                .add();
+    }
+
     public static void reportNotUniqueTargetVControllerBus(ReportNode reportNode, String generatorIds, String controllerBusId, Double keptTargetV, Double rejectedTargetV) {
         reportNode.newReportNode()
                 .withMessageTemplate("notUniqueTargetVControllerBus", "Generators [${generatorIds}] are connected to the same bus ${controllerBusId} with different target voltages: ${keptTargetV} kV (kept) and ${rejectedTargetV} kV (rejected)")