Check target voltage plausibility on Transformers and Shunt Compensators

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

@@ -304,7 +304,7 @@ private Optional<List<String>> processSecondaryVoltageControl(List<LfSecondaryVo
                 .stream()
                 .filter(e -> {
                     double newTargetV = e.getValue();
-                    return LfGenerator.isTargetVoltageNotPlausible(newTargetV, minPlausibleTargetVoltage, maxPlausibleTargetVoltage);
+                    return !VoltageControl.isTargetVoltagePlausible(newTargetV, minPlausibleTargetVoltage, maxPlausibleTargetVoltage);
                 })
                 .map(e -> {
                     // convert target to Kv for better display

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

@@ -40,10 +40,6 @@ static double qToK(LfGenerator generator, double q) {
         return (2 * q - maxQ - minQ) / (maxQ - minQ);
     }
 
-    static boolean isTargetVoltageNotPlausible(double targetV, double minPlausibleTargetVoltage, double maxPlausibleTargetVoltage) {
-        return targetV < minPlausibleTargetVoltage || targetV > maxPlausibleTargetVoltage;
-    }
-
     String getId();
 
     String getOriginalId();

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

@@ -241,6 +241,14 @@ public Optional<LfBus> findMainVisibleControlledBus() {
         }
     }
 
+    public static boolean checkTargetV(double targetV, double nominalV, LfNetworkParameters parameters) {
+        return nominalV <= parameters.getMinNominalVoltageTargetVoltageCheck() || isTargetVoltagePlausible(targetV, parameters.getMinPlausibleTargetVoltage(), parameters.getMaxPlausibleTargetVoltage());
+    }
+
+    public static boolean isTargetVoltagePlausible(double targetV, double minPlausibleTargetVoltage, double maxPlausibleTargetVoltage) {
+        return targetV >= minPlausibleTargetVoltage && targetV <= maxPlausibleTargetVoltage;
+    }
+
     @Override
     public String toString() {
         return "VoltageControl(type=" + type

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

@@ -327,25 +327,45 @@ void addBattery(Battery generator, LfNetworkParameters parameters, LfNetworkLoad
         add(LfBatteryImpl.create(generator, network, parameters, report));
     }
 
-    void setShuntCompensators(List<ShuntCompensator> shuntCompensators, LfNetworkParameters parameters, LfTopoConfig topoConfig) {
+    void setShuntCompensators(List<ShuntCompensator> shuntCompensators, LfNetworkParameters parameters, LfTopoConfig topoConfig, LfNetworkLoadingReport report) {
         if (!parameters.isShuntVoltageControl() && !shuntCompensators.isEmpty()) {
             shunt = new LfShuntImpl(shuntCompensators, network, this, false, parameters, topoConfig);
         } else {
-            List<ShuntCompensator> controllerShuntCompensators = shuntCompensators.stream()
-                    .filter(ShuntCompensator::isVoltageRegulatorOn)
-                    .toList();
+            List<ShuntCompensator> controllerShuntCompensators = new ArrayList<>();
+            List<ShuntCompensator> fixedShuntCompensators = new ArrayList<>();
+            shuntCompensators.forEach(sc -> {
+                if (checkVoltageControl(sc, parameters, report)) {
+                    controllerShuntCompensators.add(sc);
+                } else {
+                    fixedShuntCompensators.add(sc);
+                }
+            });
+
             if (!controllerShuntCompensators.isEmpty()) {
                 controllerShunt = new LfShuntImpl(controllerShuntCompensators, network, this, true, parameters, topoConfig);
             }
-            List<ShuntCompensator> fixedShuntCompensators = shuntCompensators.stream()
-                    .filter(sc -> !sc.isVoltageRegulatorOn())
-                    .toList();
             if (!fixedShuntCompensators.isEmpty()) {
                 shunt = new LfShuntImpl(fixedShuntCompensators, network, this, false, parameters, topoConfig);
             }
         }
     }
 
+    static boolean checkVoltageControl(ShuntCompensator shuntCompensator, LfNetworkParameters parameters, LfNetworkLoadingReport report) {
+        double nominalV = shuntCompensator.getRegulatingTerminal().getVoltageLevel().getNominalV();
+        double targetV = shuntCompensator.getTargetV();
+        if (!shuntCompensator.isVoltageRegulatorOn()) {
+            return false;
+        }
+        if (!VoltageControl.checkTargetV(targetV / nominalV, nominalV, parameters)) {
+            LOGGER.trace("Shunt compensator '{}' has an inconsistent target voltage: {} pu: Shunt voltage control discarded", shuntCompensator.getId(), targetV);
+            if (report != null) {
+                report.shuntsWithInconsistentTargetVoltage++;
+            }
+            return false;
+        }
+        return true;
+    }
+
     @Override
     public void invalidateGenerationTargetP() {
         generationTargetP = null;

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

@@ -278,8 +278,7 @@ protected boolean checkIfGeneratorIsInsideActivePowerLimitsForVoltageControl(LfN
 
     public static boolean checkTargetV(String generatorId, double targetV, double nominalV, LfNetworkParameters parameters, LfNetworkLoadingReport report) {
         // check that targetV has a plausible value (wrong nominal voltage issue)
-        if (nominalV > parameters.getMinNominalVoltageTargetVoltageCheck() &&
-                LfGenerator.isTargetVoltageNotPlausible(targetV, parameters.getMinPlausibleTargetVoltage(), parameters.getMaxPlausibleTargetVoltage())) {
+        if (!VoltageControl.checkTargetV(targetV, nominalV, parameters)) {
             LOGGER.trace("Generator '{}' has an inconsistent target voltage: {} pu: generator voltage control discarded",
                 generatorId, targetV);
             if (report != null) {

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

@@ -400,7 +400,7 @@ public void visitHvdcConverterStation(HvdcConverterStation<?> converterStation)
         });
 
         if (!shuntCompensators.isEmpty()) {
-            lfBus.setShuntCompensators(shuntCompensators, parameters, topoConfig);
+            lfBus.setShuntCompensators(shuntCompensators, parameters, topoConfig, report);
         }
 
         return lfBus;
@@ -627,6 +627,14 @@ private static void createTransformerVoltageControl(LfNetwork lfNetwork, RatioTa
         double targetValue = rtc.getTargetV() / regulatingTerminalNominalV;
         Double targetDeadband = rtc.getTargetDeadband() > 0 ? rtc.getTargetDeadband() / regulatingTerminalNominalV : null;
 
+        if (!VoltageControl.checkTargetV(targetValue, controlledBus.getNominalV(), parameters)) {
+            LOGGER.trace("RatioTapChanger on transformer '{}' has an inconsistent target voltage: {} pu: Rtc voltage control discarded", controllerBranchId, targetValue);
+            if (report != null) {
+                report.ratioTapChangersWithInconsistentTargetVoltage++;
+            }
+            return;
+        }
+
         controlledBus.getTransformerVoltageControl().ifPresentOrElse(vc -> {
             LOGGER.trace("Controlled bus '{}' already has a transformer voltage control: a shared control is created", controlledBus.getId());
             if (FastMath.abs(vc.getTargetValue() - targetValue) > TARGET_V_EPSILON) {
@@ -705,7 +713,12 @@ private static void createShuntVoltageControl(LfNetwork lfNetwork, ShuntCompensa
             LOGGER.warn("Voltage controller shunt {} is out of voltage: no voltage control created", shuntCompensator.getId());
             return;
         }
-        LfShunt controllerShunt = controllerBus.getControllerShunt().orElseThrow();
+        Optional<LfShunt> controllerShuntOpt = controllerBus.getControllerShunt();
+        if (controllerShuntOpt.isEmpty()) {
+            // The shunt voltage control has been discarded
+            return;
+        }
+        LfShunt controllerShunt = controllerShuntOpt.get();
         LfBus controlledBus = getLfBus(shuntCompensator.getRegulatingTerminal(), lfNetwork, parameters.isBreakers());
         if (controlledBus == null) {
             LOGGER.warn("Regulating terminal of voltage controller shunt {} is out of voltage: no voltage control created", shuntCompensator.getId());
@@ -843,15 +856,12 @@ private LfNetwork create(int numCC, int numSC, Network network, List<Bus> buses,
             LOGGER.warn("Network {}: {} branches have been discarded because connected to same bus at both ends",
                     lfNetwork, report.branchesDiscardedBecauseConnectedToSameBusAtBothEnds);
         }
-        if (report.linesWithDifferentNominalVoltageAtBothEnds > 0) {
-            LOGGER.warn("Network {}: {} lines have a different nominal voltage at both ends: a ratio has been added",
-                    lfNetwork, report.linesWithDifferentNominalVoltageAtBothEnds);
-        }
         if (report.nonImpedantBranches > 0) {
             LOGGER.warn("Network {}: {} branches are non impedant", lfNetwork, report.nonImpedantBranches);
         }
 
         if (report.generatorsWithInconsistentTargetVoltage > 0) {
+            Reports.reportGeneratorsDiscardedFromVoltageControlBecauseTargetVIsInconsistent(reportNode, report.generatorsWithInconsistentTargetVoltage);
             LOGGER.warn("Network {}: {} generators have an inconsistent target voltage and have been discarded from voltage control",
                     lfNetwork, report.generatorsWithInconsistentTargetVoltage);
         }
@@ -871,6 +881,18 @@ private LfNetwork create(int numCC, int numSC, Network network, List<Bus> buses,
                     lfNetwork, report.transformerReactivePowerControlDiscardedBecauseControllerBranchIsOpen);
         }
 
+        if (report.ratioTapChangersWithInconsistentTargetVoltage > 0) {
+            Reports.reportRatioTapChangersDiscardedFromVoltageControlBecauseTargetVIsInconsistent(reportNode, report.ratioTapChangersWithInconsistentTargetVoltage);
+            LOGGER.warn("Network {}: {} ratio tap changers have an inconsistent target voltage and have been discarded from voltage control",
+                    lfNetwork, report.ratioTapChangersWithInconsistentTargetVoltage);
+        }
+
+        if (report.shuntsWithInconsistentTargetVoltage > 0) {
+            Reports.reportShuntsDiscardedFromVoltageControlBecauseTargetVIsInconsistent(reportNode, report.shuntsWithInconsistentTargetVoltage);
+            LOGGER.warn("Network {}: {} shunts have an inconsistent target voltage and have been discarded from voltage control",
+                    lfNetwork, report.shuntsWithInconsistentTargetVoltage);
+        }
+
         if (parameters.getDebugDir() != null) {
             Path debugDir = DebugUtil.getDebugDir(parameters.getDebugDir());
             String dateStr = ZonedDateTime.now().format(DATE_TIME_FORMAT);

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

@@ -30,8 +30,6 @@ public class LfNetworkLoadingReport {
 
     int branchesDiscardedBecauseConnectedToSameBusAtBothEnds = 0;
 
-    int linesWithDifferentNominalVoltageAtBothEnds = 0;
-
     int nonImpedantBranches = 0;
 
     int generatorsWithInconsistentTargetVoltage = 0;
@@ -41,4 +39,8 @@ public class LfNetworkLoadingReport {
     int transformerVoltageControlDiscardedBecauseControllerBranchIsOpen = 0;
 
     int transformerReactivePowerControlDiscardedBecauseControllerBranchIsOpen = 0;
+
+    int ratioTapChangersWithInconsistentTargetVoltage = 0;
+
+    int shuntsWithInconsistentTargetVoltage = 0;
 }

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

@@ -24,6 +24,10 @@ public final class Reports {
     private static final String ITERATION = "iteration";
     private static final String NETWORK_ID = "networkId";
     private static final String IMPACTED_GENERATOR_COUNT = "impactedGeneratorCount";
+
+    private static final String IMPACTED_RTC_COUNT = "impactedRatioTapChangerCount";
+
+    private static final String IMPACTED_SHUNT_COUNT = "impactedShuntCount";
     private static final String BUS_ID = "busId";
     private static final String CONTROLLER_BUS_ID = "controllerBusId";
     private static final String CONTROLLED_BUS_ID = "controlledBusId";
@@ -294,6 +298,30 @@ public static void reportGeneratorsDiscardedFromVoltageControlBecauseTargetPIsOu
                 .add();
     }
 
+    public static void reportGeneratorsDiscardedFromVoltageControlBecauseTargetVIsInconsistent(ReportNode reportNode, int impactedGeneratorCount) {
+        reportNode.newReportNode()
+                .withMessageTemplate("generatorsDiscardedFromVoltageControlBecauseTargetVIsInconsistent", "${impactedGeneratorCount} generators have been discarded from voltage control because targetV is inconsistent")
+                .withUntypedValue(IMPACTED_GENERATOR_COUNT, impactedGeneratorCount)
+                .withSeverity(TypedValue.WARN_SEVERITY)
+                .add();
+    }
+
+    public static void reportRatioTapChangersDiscardedFromVoltageControlBecauseTargetVIsInconsistent(ReportNode reportNode, int impactedRatioTapChangerCount) {
+        reportNode.newReportNode()
+                .withMessageTemplate("ratioTapChangersDiscardedFromVoltageControlBecauseTargetVIsInconsistent", "${impactedRatioTapChangerCount} ratio tap changers have been discarded from voltage control because targetV is inconsistent")
+                .withUntypedValue(IMPACTED_RTC_COUNT, impactedRatioTapChangerCount)
+                .withSeverity(TypedValue.WARN_SEVERITY)
+                .add();
+    }
+
+    public static void reportShuntsDiscardedFromVoltageControlBecauseTargetVIsInconsistent(ReportNode reportNode, int impactedShuntCount) {
+        reportNode.newReportNode()
+                .withMessageTemplate("shuntsDiscardedFromVoltageControlBecauseTargetVIsInconsistent", "${impactedShuntCount} shunts have been discarded from voltage control because targetV is inconsistent")
+                .withUntypedValue(IMPACTED_SHUNT_COUNT, impactedShuntCount)
+                .withSeverity(TypedValue.WARN_SEVERITY)
+                .add();
+    }
+
     public static void reportAcLfComplete(ReportNode reportNode, boolean success, String solverStatus, String outerloopStatus) {
         TypedValue severity = success ? TypedValue.INFO_SEVERITY : TypedValue.ERROR_SEVERITY;
         String successText = success ? "successfully" : "with error";

src/test/java/com/powsybl/openloadflow/ac/AcLoadFlowReportTest.java

@@ -63,6 +63,7 @@ void testEsgTutoDetailedNrLogsLf() throws IOException {
     @Test
     void testShuntVoltageControlOuterLoopReport() throws IOException {
         Network network = ShuntNetworkFactory.createWithTwoShuntCompensators();
+        network.getShuntCompensator("SHUNT2").setVoltageRegulatorOn(true).setTargetV(600); // not plausible targetV, will be discarded and reported
         ReportNode reportNode = ReportNode.newRootReportNode()
                 .withMessageTemplate("testReport", "Test Report")
                 .build();
@@ -110,7 +111,7 @@ void testTransformerReactivePowerControlOuterLoopReport() throws IOException {
 
     @Test
     void testMultipleComponents() throws IOException {
-        Network network = ConnectedComponentNetworkFactory.createThreeCcLinkedByASingleBus();
+        Network network = ConnectedComponentNetworkFactory.createThreeCcLinkedByASingleBusWithInconsistentVoltages();
         // open everything at bus b4 to create 3 components
         network.getBusBreakerView().getBus("b4").getConnectedTerminalStream().forEach(Terminal::disconnect);
 
@@ -119,7 +120,9 @@ void testMultipleComponents() throws IOException {
         // CC2 SC2 has no generator connected. Ignored in for DC and AC.
         network.getGenerator("g10").disconnect();
 
-        var lfParameters = new LoadFlowParameters().setConnectedComponentMode(LoadFlowParameters.ConnectedComponentMode.ALL);
+        var lfParameters = new LoadFlowParameters().setConnectedComponentMode(LoadFlowParameters.ConnectedComponentMode.ALL)
+                .setTransformerVoltageControlOn(true);
+        OpenLoadFlowParameters.create(lfParameters).setMinNominalVoltageTargetVoltageCheck(0.5);
 
         LoadFlowProvider provider = new OpenLoadFlowProvider(new DenseMatrixFactory(), new NaiveGraphConnectivityFactory<>(LfBus::getNum));
         LoadFlow.Runner runner = new LoadFlow.Runner(provider);

src/test/java/com/powsybl/openloadflow/ac/AcLoadFlowShuntTest.java

@@ -439,6 +439,18 @@ void testIncrementalVoltageControl() {
         assertEquals(0, shunt.getSectionCount());
     }
 
+    @Test
+    void testNotPlausibleTargetV() {
+        parameters.setShuntCompensatorVoltageControlOn(true);
+        shunt.setSectionCount(0);
+        shunt.setVoltageRegulatorOn(true);
+        shunt.setTargetV(600);
+        LoadFlowResult result2 = loadFlowRunner.run(network, parameters);
+        assertTrue(result2.isFullyConverged());
+        assertVoltageEquals(388.581, bus3);
+        assertEquals(0, shunt.getSectionCount());
+    }
+
     @Test
     void testIncrementalVoltageRemote() {
         Network network = VoltageControlNetworkFactory.createWithShuntSharedRemoteControl();

src/test/java/com/powsybl/openloadflow/ac/AcLoadFlowTransformerVoltageControlTest.java

@@ -254,6 +254,38 @@ void voltageControlT2wtTest8() {
         assertEquals(4, t2wt.getRatioTapChanger().getTapPosition());
     }
 
+    @Test
+    void voltageControlT2wtNonPlausibleTargetV() {
+        selectNetwork(VoltageControlNetworkFactory.createNetworkWithT2wt2());
+        parameters.setTransformerVoltageControlOn(true);
+        parametersExt.setTransformerVoltageControlMode(OpenLoadFlowParameters.TransformerVoltageControlMode.INCREMENTAL_VOLTAGE_CONTROL);
+
+        t2wt.getRatioTapChanger()
+                .setTargetDeadband(0)
+                .setRegulating(false)
+                .setTapPosition(7)
+                .setRegulationTerminal(t2wt.getTerminal2())
+                .setTargetV(34.0);
+        LoadFlowResult result = loadFlowRunner.run(network, parameters);
+        assertTrue(result.isFullyConverged());
+        assertFalse(t2wt.getRatioTapChanger().isRegulating());
+        assertVoltageEquals(134.281, bus2);
+        assertVoltageEquals(27.0, t2wt.getTerminal2().getBusView().getBus());
+        assertEquals(7, t2wt.getRatioTapChanger().getTapPosition());
+
+        t2wt.getRatioTapChanger()
+                .setTargetDeadband(0)
+                .setRegulating(true)
+                .setTapPosition(7)
+                .setRegulationTerminal(t2wt.getTerminal2())
+                .setTargetV(60);
+        result = loadFlowRunner.run(network, parameters);
+        assertTrue(result.isFullyConverged());
+        assertVoltageEquals(134.281, bus2);
+        assertVoltageEquals(27.0, t2wt.getTerminal2().getBusView().getBus());
+        assertEquals(7, t2wt.getRatioTapChanger().getTapPosition());
+    }
+
     @Test
     void remoteVoltageControlT2wtTest() {
         selectNetwork(VoltageControlNetworkFactory.createNetworkWithT2wt());
@@ -675,6 +707,25 @@ void voltageControlT3wtTest() {
         assertEquals(2, t3wt.getLeg2().getRatioTapChanger().getTapPosition());
     }
 
+    @Test
+    void voltageControlT3wtNonPlausibleTargetV() {
+        selectNetwork(VoltageControlNetworkFactory.createNetworkWithT3wt());
+
+        t3wt.getLeg2().getRatioTapChanger()
+                .setTargetDeadband(0)
+                .setRegulating(true)
+                .setTapPosition(2)
+                .setRegulationTerminal(t3wt.getLeg2().getTerminal())
+                .setTargetV(60);
+
+        parameters.setTransformerVoltageControlOn(true);
+
+        LoadFlowResult result = loadFlowRunner.run(network, parameters);
+        assertTrue(result.isFullyConverged());
+        assertVoltageEquals(28.147, bus3);
+        assertEquals(2, t3wt.getLeg2().getRatioTapChanger().getTapPosition());
+    }
+
     @Test
     void remoteVoltageControlT3wtTest() {
         selectNetwork(VoltageControlNetworkFactory.createNetworkWithT3wt());

src/test/java/com/powsybl/openloadflow/network/ConnectedComponentNetworkFactory.java

@@ -308,6 +308,28 @@ public static Network createThreeCcLinkedByASingleBus() {
         return network;
     }
 
+    public static Network createThreeCcLinkedByASingleBusWithInconsistentVoltages() {
+        Network network = createThreeCcLinkedByASingleBus();
+        Bus b2 = network.getBusBreakerView().getBus("b2");
+        createGenerator(b2, "g2_bis", 0, 2);
+        Bus b3 = network.getBusBreakerView().getBus("b3");
+        Bus b3Bis = createBus(network, "b3_s", "b3_bis", 1);
+
+        var t2wt = createTransformer(network, "b3_s", b3, b3Bis, "l35", 0.1f, 1d);
+        t2wt.newRatioTapChanger()
+            .beginStep()
+                .setRho(1)
+            .endStep()
+            .setTapPosition(0)
+            .setLoadTapChangingCapabilities(true)
+            .setRegulating(true)
+            .setTargetV(2)
+            .setTargetDeadband(0)
+            .setRegulationTerminal(t2wt.getTerminal1())
+            .add();
+        return network;
+    }
+
     /**
      * <pre>
      * b1 (d1) ----------+                               b6 (g6) ---PTC----+