Transformer continuous voltage control outer loop

geofjamg · geofjamg · commit 2c5c2e68481f · 2026-04-13T13:40:42.000+02:00
Signed-off-by: Geoffroy Jamgotchian &lt;geoffroy.jamgotchian@rte-france.com&gt;
diff --git a/src/main/java/com/powsybl/openloadflow/OpenLoadFlowParameters.java b/src/main/java/com/powsybl/openloadflow/OpenLoadFlowParameters.java
@@ -473,7 +473,8 @@ public enum VoltageInitModeOverride {
     public enum TransformerVoltageControlMode {
         WITH_GENERATOR_VOLTAGE_CONTROL,
         AFTER_GENERATOR_VOLTAGE_CONTROL,
-        INCREMENTAL_VOLTAGE_CONTROL
+        INCREMENTAL_VOLTAGE_CONTROL,
+        CONTINUOUS_VOLTAGE_CONTROL
     }
 
     public enum ShuntVoltageControlMode {
diff --git a/src/main/java/com/powsybl/openloadflow/OpenLoadFlowProvider.java b/src/main/java/com/powsybl/openloadflow/OpenLoadFlowProvider.java
@@ -105,6 +105,7 @@ private void updateAcState(Network network, LoadFlowParameters parameters, OpenL
                                                                           parameters.isWriteSlackBus(),
                                                                           parameters.isPhaseShifterRegulationOn(),
                                                                           parameters.isTransformerVoltageControlOn(),
+                                                                          parametersExt.getTransformerVoltageControlMode(),
                                                                           parametersExt.isTransformerReactivePowerControl(),
                                                                           (parameters.isDistributedSlack() || parametersExt.isAreaInterchangeControl()) && (parameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD || parameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD) && parametersExt.isLoadPowerFactorConstant(),
                                                                           parameters.isDc(),
@@ -229,6 +230,7 @@ private LoadFlowResult.ComponentResult processResult(Network network, DcLoadFlow
                                                                       parameters.isWriteSlackBus(),
                                                                       parameters.isPhaseShifterRegulationOn(),
                                                                       parameters.isTransformerVoltageControlOn(),
+                                                                      parametersExt.getTransformerVoltageControlMode(),
                                                                       false,
                                                                       false,
                                                                       true,
diff --git a/src/main/java/com/powsybl/openloadflow/ac/outerloop/AbstractTransformerVoltageControlOuterLoop.java b/src/main/java/com/powsybl/openloadflow/ac/outerloop/AbstractTransformerVoltageControlOuterLoop.java
@@ -21,7 +21,7 @@
  */
 public abstract class AbstractTransformerVoltageControlOuterLoop implements AcOuterLoop {
 
-    private static final Logger LOGGER = LoggerFactory.getLogger(AbstractTransformerVoltageControlOuterLoop.class);
+    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractTransformerVoltageControlOuterLoop.class);
 
     private static final double MIN_TARGET_DEADBAND_KV = 0.1; // kV
 
diff --git a/src/main/java/com/powsybl/openloadflow/ac/outerloop/ContinuousTransformerVoltageControlOuterLoop.java b/src/main/java/com/powsybl/openloadflow/ac/outerloop/ContinuousTransformerVoltageControlOuterLoop.java
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2026, 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.ac.outerloop;
+
+import com.powsybl.commons.report.ReportNode;
+import com.powsybl.openloadflow.ac.AcOuterLoopContext;
+import com.powsybl.openloadflow.lf.outerloop.OuterLoopResult;
+import com.powsybl.openloadflow.lf.outerloop.OuterLoopStatus;
+import com.powsybl.openloadflow.network.LfBranch;
+import com.powsybl.openloadflow.network.LfNetwork;
+import com.powsybl.openloadflow.network.PiModel;
+import com.powsybl.openloadflow.network.VoltageControl;
+
+/**
+ * @author Anne Tilloy {@literal <anne.tilloy at rte-france.com>}
+ */
+public class ContinuousTransformerVoltageControlOuterLoop extends AbstractTransformerVoltageControlOuterLoop {
+
+    public static final String NAME = "ContinuousTransformerVoltageControl";
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public void initialize(AcOuterLoopContext context) {
+        for (LfBranch controllerBranch : context.getNetwork().<LfBranch>getControllerElements(VoltageControl.Type.TRANSFORMER)) {
+            if (controllerBranch.isConnectedAtBothSides()) {
+                controllerBranch.setVoltageControlEnabled(true);
+            }
+        }
+        context.getNetwork().fixTransformerVoltageControls();
+    }
+
+    @Override
+    public OuterLoopResult check(AcOuterLoopContext context, ReportNode reportNode) {
+        OuterLoopStatus status = OuterLoopStatus.STABLE;
+        if (context.getIteration() == 0) {
+            LfNetwork network = context.getNetwork();
+            for (LfBranch controllerBranch : network.<LfBranch>getControllerElements(VoltageControl.Type.TRANSFORMER)) {
+                controllerBranch.setVoltageControlEnabled(false);
+
+                // clip the rho shift to min or max if needed
+                PiModel piModel = controllerBranch.getPiModel();
+                double r1Value = piModel.getR1();
+                if (piModel.clipR1()) {
+                    status = OuterLoopStatus.UNSTABLE;
+                    LOGGER.trace("Clip voltage ratio of '{}': {} -> {}", controllerBranch.getId(), r1Value, piModel.getContinuousR1());
+                }
+            }
+        }
+        return new OuterLoopResult(this, status);
+    }
+}
diff --git a/src/main/java/com/powsybl/openloadflow/lf/outerloop/config/AbstractAcOuterLoopConfig.java b/src/main/java/com/powsybl/openloadflow/lf/outerloop/config/AbstractAcOuterLoopConfig.java
@@ -106,6 +106,7 @@ protected static Optional<AcOuterLoop> createTransformerVoltageControlOuterLoop(
                 case WITH_GENERATOR_VOLTAGE_CONTROL -> new SimpleTransformerVoltageControlOuterLoop();
                 case AFTER_GENERATOR_VOLTAGE_CONTROL -> new TransformerVoltageControlOuterLoop(useInitialTapPosition, generatorVoltageControlMinNominalVoltage);
                 case INCREMENTAL_VOLTAGE_CONTROL -> new IncrementalTransformerVoltageControlOuterLoop(incrementalTransformerVoltageControlOuterLoopMaxTapShift);
+                case CONTINUOUS_VOLTAGE_CONTROL -> new ContinuousTransformerVoltageControlOuterLoop();
             };
             return Optional.of(outerLoop);
         }
diff --git a/src/main/java/com/powsybl/openloadflow/network/LfNetworkStateUpdateParameters.java b/src/main/java/com/powsybl/openloadflow/network/LfNetworkStateUpdateParameters.java
@@ -7,6 +7,8 @@
  */
 package com.powsybl.openloadflow.network;
 
+import com.powsybl.openloadflow.OpenLoadFlowParameters;
+
 import java.util.Objects;
 
 /**
@@ -22,6 +24,8 @@ public class LfNetworkStateUpdateParameters {
 
     private final boolean transformerVoltageControlOn;
 
+    private final OpenLoadFlowParameters.TransformerVoltageControlMode transformerVoltageControlMode;
+
     private final boolean transformerReactivePowerControlOn;
 
     private final boolean loadPowerFactorConstant;
@@ -36,17 +40,19 @@ public class LfNetworkStateUpdateParameters {
 
     private final ReferenceBusSelectionMode referenceBusSelectionMode;
 
-    private boolean simulateAutomationSystems;
+    private final boolean simulateAutomationSystems;
 
     public LfNetworkStateUpdateParameters(boolean reactiveLimits, boolean writeSlackBus, boolean phaseShifterRegulationOn,
-                                          boolean transformerVoltageControlOn, boolean transformerReactivePowerControlOn, boolean loadPowerFactorConstant, boolean dc,
+                                          boolean transformerVoltageControlOn, OpenLoadFlowParameters.TransformerVoltageControlMode transformerVoltageControlMode,
+                                          boolean transformerReactivePowerControlOn, boolean loadPowerFactorConstant, boolean dc,
                                           boolean breakers, ReactivePowerDispatchMode reactivePowerDispatchMode,
                                           boolean writeReferenceTerminals, ReferenceBusSelectionMode referenceBusSelectionMode,
                                           boolean simulateAutomationSystems) {
         this.reactiveLimits = reactiveLimits;
         this.writeSlackBus = writeSlackBus;
         this.phaseShifterRegulationOn = phaseShifterRegulationOn;
         this.transformerVoltageControlOn = transformerVoltageControlOn;
+        this.transformerVoltageControlMode = transformerVoltageControlMode;
         this.transformerReactivePowerControlOn = transformerReactivePowerControlOn;
         this.loadPowerFactorConstant = loadPowerFactorConstant;
         this.dc = dc;
@@ -73,6 +79,10 @@ public boolean isTransformerVoltageControlOn() {
         return transformerVoltageControlOn;
     }
 
+    public OpenLoadFlowParameters.TransformerVoltageControlMode getTransformerVoltageControlMode() {
+        return transformerVoltageControlMode;
+    }
+
     public boolean isTransformerReactivePowerControlOn() {
         return transformerReactivePowerControlOn;
     }
diff --git a/src/main/java/com/powsybl/openloadflow/network/PiModel.java b/src/main/java/com/powsybl/openloadflow/network/PiModel.java
@@ -61,6 +61,8 @@ public interface PiModel {
 
     void roundR1ToClosestTap();
 
+    boolean clipR1();
+
     boolean shiftOneTapPositionToChangeA1(Direction direction);
 
     Optional<Direction> updateTapPositionToReachNewR1(double deltaR1, int maxTapShift, AllowedDirection allowedDirection);
diff --git a/src/main/java/com/powsybl/openloadflow/network/PiModelArray.java b/src/main/java/com/powsybl/openloadflow/network/PiModelArray.java
@@ -294,6 +294,23 @@ public void roundR1ToClosestTap() {
         r1 = Double.NaN;
     }
 
+    @Override
+    public boolean clipR1() {
+        if (Double.isNaN(r1)) {
+            return false; // nothing to do because r1 has not been modified
+        }
+        if (r1 < minR1) {
+            r1 = minR1;
+            tapPositionIndex = lowTapPosition;
+            return true;
+        } else if (r1 > maxR1) {
+            r1 = maxR1;
+            tapPositionIndex = lowTapPosition + models.size() - 1;
+            return true;
+        }
+        return false;
+    }
+
     @Override
     public boolean shiftOneTapPositionToChangeA1(Direction direction) {
         // an increase direction means that A1 should increase.
diff --git a/src/main/java/com/powsybl/openloadflow/network/SimplePiModel.java b/src/main/java/com/powsybl/openloadflow/network/SimplePiModel.java
@@ -153,6 +153,11 @@ public void roundR1ToClosestTap() {
         throw new IllegalStateException("R1 rounding is not supported in simple Pi model implementation");
     }
 
+    @Override
+    public boolean clipR1() {
+        throw new IllegalStateException("R1 clipping is not supported in simple Pi model implementation");
+    }
+
     @Override
     public boolean shiftOneTapPositionToChangeA1(Direction direction) {
         throw new IllegalStateException(NO_TAP_POSITION_ERROR);
diff --git a/src/main/java/com/powsybl/openloadflow/network/impl/LfBranchImpl.java b/src/main/java/com/powsybl/openloadflow/network/impl/LfBranchImpl.java
@@ -10,6 +10,7 @@
 import com.powsybl.commons.PowsyblException;
 import com.powsybl.iidm.network.*;
 import com.powsybl.iidm.network.extensions.LineFortescue;
+import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.sa.LimitReductionManager;
 import com.powsybl.openloadflow.util.PerUnit;
@@ -29,6 +30,8 @@ public class LfBranchImpl extends AbstractImpedantLfBranch {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(LfBranchImpl.class);
 
+    public static final String RTC_CONTINUOUS_RATIO = "continuousRatio";
+
     private final Ref<Branch<?>> branchRef;
 
     protected LfBranchImpl(LfNetwork network, LfBus bus1, LfBus bus2, PiModel piModel, Branch<?> branch, LfNetworkParameters parameters) {
@@ -370,10 +373,15 @@ public void updateState(LfNetworkStateUpdateParameters parameters, LfNetworkUpda
                     rtc.unsetSolvedTapPosition();
                 } else if (parameters.isTransformerVoltageControlOn() && isVoltageController()
                         || parameters.isTransformerReactivePowerControlOn() && isTransformerReactivePowerController()) { // it means there is a regulating ratio tap changer
-                    double baseRatio = Transformers.getRatioPerUnitBase(twt);
-                    double rho = getPiModel().getR1() * twt.getRatedU1() / twt.getRatedU2() * baseRatio;
-                    double ptcRho = twt.getPhaseTapChanger() != null ? twt.getPhaseTapChanger().getCurrentStep().getRho() : 1;
-                    updateSolvedTapPosition(rtc, ptcRho, rho);
+                    if (parameters.getTransformerVoltageControlMode() == OpenLoadFlowParameters.TransformerVoltageControlMode.CONTINUOUS_VOLTAGE_CONTROL) {
+                        rtc.unsetSolvedTapPosition();
+                        rtc.setProperty(RTC_CONTINUOUS_RATIO, Double.toString(getPiModel().getR1()));
+                    } else {
+                        double baseRatio = Transformers.getRatioPerUnitBase(twt);
+                        double rho = getPiModel().getR1() * twt.getRatedU1() / twt.getRatedU2() * baseRatio;
+                        double ptcRho = twt.getPhaseTapChanger() != null ? twt.getPhaseTapChanger().getCurrentStep().getRho() : 1;
+                        updateSolvedTapPosition(rtc, ptcRho, rho);
+                    }
                 } else {
                     rtc.setSolvedTapPosition(rtc.getTapPosition());
                 }
diff --git a/src/test/java/com/powsybl/openloadflow/ac/AcLoadFlowTransformerVoltageControlTest.java b/src/test/java/com/powsybl/openloadflow/ac/AcLoadFlowTransformerVoltageControlTest.java
@@ -19,7 +19,11 @@
 import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.OpenLoadFlowProvider;
 import com.powsybl.openloadflow.ac.solver.NewtonRaphsonStoppingCriteriaType;
-import com.powsybl.openloadflow.network.*;
+import com.powsybl.openloadflow.network.FourBusNetworkFactory;
+import com.powsybl.openloadflow.network.HvdcNetworkFactory;
+import com.powsybl.openloadflow.network.SlackBusSelectionMode;
+import com.powsybl.openloadflow.network.VoltageControlNetworkFactory;
+import com.powsybl.openloadflow.network.impl.LfBranchImpl;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -1310,4 +1314,26 @@ void rxgbChangeOnRtcControlTest(boolean twtSplitShuntAdmittance,
         assertActivePowerEquals(tap2p2, t2wt.getTerminal2());
         assertVoltageEquals(tap2v, bus3);
     }
+
+    @Test
+    void continuousVoltageControlT2wtTest() {
+        selectNetwork(VoltageControlNetworkFactory.createNetworkWithT2wt());
+
+        parameters.setTransformerVoltageControlOn(true);
+        parametersExt.setTransformerVoltageControlMode(OpenLoadFlowParameters.TransformerVoltageControlMode.CONTINUOUS_VOLTAGE_CONTROL);
+        t2wt.getRatioTapChanger()
+                .setTargetDeadband(0)
+                .setRegulating(true)
+                .setTapPosition(0)
+                .setRegulationTerminal(t2wt.getTerminal2())
+                .setTargetV(34.0);
+
+        LoadFlowResult result = loadFlowRunner.run(network, parameters);
+        assertTrue(result.isFullyConverged());
+        assertVoltageEquals(134.281, bus2);
+        assertVoltageEquals(34, t2wt.getTerminal2().getBusView().getBus());
+        assertNull(t2wt.getRatioTapChanger().getSolvedTapPosition());
+        assertEquals(0, t2wt.getRatioTapChanger().getTapPosition());
+        assertEquals(1.088171, Double.parseDouble(t2wt.getRatioTapChanger().getProperty(LfBranchImpl.RTC_CONTINUOUS_RATIO)), DELTA_RHO);
+    }
 }
diff --git a/src/test/java/com/powsybl/openloadflow/ac/NonImpedantBranchWithBreakerIssueTest.java b/src/test/java/com/powsybl/openloadflow/ac/NonImpedantBranchWithBreakerIssueTest.java
@@ -10,6 +10,7 @@
 import com.powsybl.iidm.network.Bus;
 import com.powsybl.iidm.network.Network;
 import com.powsybl.math.matrix.DenseMatrixFactory;
+import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.network.impl.Networks;
 import org.junit.jupiter.api.Test;
@@ -36,7 +37,7 @@ void busBreakerAndNonImpedantBranchIssue() {
             new AcloadFlowEngine(context)
                     .run();
         }
-        lfNetwork.updateState(new LfNetworkStateUpdateParameters(false, false, false, false, false, false, false, false, ReactivePowerDispatchMode.Q_EQUAL_PROPORTION, false, ReferenceBusSelectionMode.FIRST_SLACK, false));
+        lfNetwork.updateState(new LfNetworkStateUpdateParameters(false, false, false, false, OpenLoadFlowParameters.TransformerVoltageControlMode.WITH_GENERATOR_VOLTAGE_CONTROL, false, false, false, false, ReactivePowerDispatchMode.Q_EQUAL_PROPORTION, false, ReferenceBusSelectionMode.FIRST_SLACK, false));
         for (Bus bus : network.getBusView().getBuses()) {
             assertEquals(400, bus.getV(), 0);
             assertEquals(0, bus.getAngle(), 0);
@@ -57,7 +58,7 @@ void busBreakerAndNonImpedantBranchIssueRef() {
             new AcloadFlowEngine(context)
                     .run();
         }
-        lfNetwork.updateState(new LfNetworkStateUpdateParameters(false, false, false, false, false, false, false, false, ReactivePowerDispatchMode.Q_EQUAL_PROPORTION, false, ReferenceBusSelectionMode.FIRST_SLACK, false));
+        lfNetwork.updateState(new LfNetworkStateUpdateParameters(false, false, false, false, OpenLoadFlowParameters.TransformerVoltageControlMode.WITH_GENERATOR_VOLTAGE_CONTROL, false, false, false, false, ReactivePowerDispatchMode.Q_EQUAL_PROPORTION, false, ReferenceBusSelectionMode.FIRST_SLACK, false));
         assertEquals(-100, network.getGenerator("G1").getTerminal().getQ(), 0);
         assertEquals(-100, network.getGenerator("G2").getTerminal().getQ(), 0);
     }

Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,8 @@ public enum VoltageInitModeOverride {`
`473`	`473`	`public enum TransformerVoltageControlMode {`
`474`	`474`	`WITH_GENERATOR_VOLTAGE_CONTROL,`
`475`	`475`	`AFTER_GENERATOR_VOLTAGE_CONTROL,`
`476`		`- INCREMENTAL_VOLTAGE_CONTROL`
	`476`	`+ INCREMENTAL_VOLTAGE_CONTROL,`
	`477`	`+ CONTINUOUS_VOLTAGE_CONTROL`
`477`	`478`	`}`
`478`	`479`
`479`	`480`	`public enum ShuntVoltageControlMode {`
Original file line number	Diff line number	Diff line change
`@@ -106,6 +106,7 @@ protected static Optional<AcOuterLoop> createTransformerVoltageControlOuterLoop(`
`106`	`106`	`case WITH_GENERATOR_VOLTAGE_CONTROL -> new SimpleTransformerVoltageControlOuterLoop();`
`107`	`107`	`case AFTER_GENERATOR_VOLTAGE_CONTROL -> new TransformerVoltageControlOuterLoop(useInitialTapPosition, generatorVoltageControlMinNominalVoltage);`
`108`	`108`	`case INCREMENTAL_VOLTAGE_CONTROL -> new IncrementalTransformerVoltageControlOuterLoop(incrementalTransformerVoltageControlOuterLoopMaxTapShift);`
	`109`	`+ case CONTINUOUS_VOLTAGE_CONTROL -> new ContinuousTransformerVoltageControlOuterLoop();`
`109`	`110`	`};`
`110`	`111`	`return Optional.of(outerLoop);`
`111`	`112`	`}`