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`.
 
+**maxVoltageRemoteControlDistance**
+Defines the maximum distance allowed between the remote regulated bus and the voltage controller (requires `voltageRemoteControl` to be set to `true`).
+This distance is measured in number of branches separating the two buses. 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.
+If `maxVoltageRemoteControlDistance` 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_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME = "maxVoltageRemoteControlDistance";
+
     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_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME, ParameterType.INTEGER, "Maximum voltage remote control distance", LfNetworkParameters.MAX_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 maxVoltageRemoteControlDistance = LfNetworkParameters.MAX_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 getMaxVoltageRemoteControlDistance() {
+        return maxVoltageRemoteControlDistance;
+    }
+
+    public OpenLoadFlowParameters setMaxVoltageRemoteControlDistance(int maxVoltageRemoteControlDistance) {
+        this.maxVoltageRemoteControlDistance = maxVoltageRemoteControlDistance;
+        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))
+                .setMaxVoltageRemoteControlDistance(config.getIntProperty(MAX_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME, LfNetworkParameters.MAX_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_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME))
+                .ifPresent(prop -> this.setMaxVoltageRemoteControlDistance(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_VOLTAGE_REMOTE_CONTROL_DISTANCE_PARAM_NAME, maxVoltageRemoteControlDistance);
         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())
+                .setMaxVoltageRemoteControlDistance(parametersExt.getMaxVoltageRemoteControlDistance());
     }
 
     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.getMaxVoltageRemoteControlDistance() == extension2.getMaxVoltageRemoteControlDistance();
     }
 
     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())
+                    .setMaxVoltageRemoteControlDistance(extension.getMaxVoltageRemoteControlDistance());
 
             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_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 maxVoltageRemoteControlDistance = MAX_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.maxVoltageRemoteControlDistance = other.maxVoltageRemoteControlDistance;
     }
 
     public SlackBusSelector getSlackBusSelector() {
@@ -597,6 +602,15 @@ public LfNetworkParameters setAreaInterchangeControlAreaType(String areaIntercha
         return this;
     }
 
+    public int getMaxVoltageRemoteControlDistance() {
+        return maxVoltageRemoteControlDistance;
+    }
+
+    public LfNetworkParameters setMaxVoltageRemoteControlDistance(int maxVoltageRemoteControlDistance) {
+        this.maxVoltageRemoteControlDistance = maxVoltageRemoteControlDistance;
+        return this;
+    }
+
     @Override
     public String toString() {
         return "LfNetworkParameters(" +
@@ -638,6 +652,7 @@ public String toString() {
                 ", fictitiousGeneratorVoltageControlCheckMode=" + fictitiousGeneratorVoltageControlCheckMode +
                 ", areaInterchangeControl=" + areaInterchangeControl +
                 ", areaInterchangeControlAreaType=" + areaInterchangeControlAreaType +
+                ", maxVoltageRemoteControlDistance=" + maxVoltageRemoteControlDistance +
                 ')';
     }
 }

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.getMaxVoltageRemoteControlDistance() > 0 && distanceBetweenBuses(controlledBus, controllerBus, parameters.getMaxVoltageRemoteControlDistance()) > parameters.getMaxVoltageRemoteControlDistance()) {
+                    LOGGER.warn("Voltage controlled bus '{}' is too far from controller bus '{}' (maximumVoltageRemoteControlDistance is set to {}). The bus switches to local voltage control and target voltage is rescaled from {} to {}",
+                            controlledBus.getId(), controllerBus.getId(), parameters.getMaxVoltageRemoteControlDistance(), controllerTargetV, controllerTargetV * controllerBus.getNominalV() / controlledBus.getNominalV());
+                    Reports.reportTooFarControlledBus(controlledBus.getNetwork().getReportNode(), controllerBus.getId(), controlledBus.getId(), parameters.getMaxVoltageRemoteControlDistance());
+                } 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 maxVoltageRemoteControlDistance) {
+        reportNode.newReportNode()
+                .withMessageTemplate("tooFarControllerBus", "Remote voltage controlled bus ${controlledBusId} is too far from controller bus ${controllerBusId} (maxVoltageRemoteControlDistance is set to ${maxVoltageRemoteControlDistance}). Switching to local voltage control")
+                .withUntypedValue(CONTROLLED_BUS_ID, controlledBusId)
+                .withUntypedValue(CONTROLLER_BUS_ID, controllerBusId)
+                .withUntypedValue("maxVoltageRemoteControlDistance", maxVoltageRemoteControlDistance)
+                .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)")