Computing Hvdc line loss in AC emulation

pom.xml

@@ -54,7 +54,7 @@
  <slf4jtoys.version>1.6.3</slf4jtoys.version>
  <asciitable.version>0.3.2</asciitable.version>
 
- <powsybl-core.version>6.4.0</powsybl-core.version>
+ <powsybl-core.version>6.4.1</powsybl-core.version>
  </properties>
 
  <build>

src/main/java/com/powsybl/openloadflow/ac/equations/AbstractHvdcAcEmulationFlowEquationTerm.java

@@ -13,6 +13,8 @@
 import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.LfHvdc;
 
+import com.powsybl.iidm.network.util.HvdcUtils;
+
 import java.util.List;
 
 /**
@@ -30,6 +32,8 @@ public abstract class AbstractHvdcAcEmulationFlowEquationTerm extends AbstractEl
 
  protected final double p0;
 
+ protected final double r;
+
  protected final double lossFactor1;
 
  protected final double lossFactor2;
@@ -45,6 +49,7 @@ protected AbstractHvdcAcEmulationFlowEquationTerm(LfHvdc hvdc, LfBus bus1, LfBus
  variables = List.of(ph1Var, ph2Var);
  k = hvdc.getDroop() * 180 / Math.PI;
  p0 = hvdc.getP0();
+ r = hvdc.getR();
  lossFactor1 = hvdc.getConverterStation1().getLossFactor() / 100;
  lossFactor2 = hvdc.getConverterStation2().getLossFactor() / 100;
  pMaxFromCS1toCS2 = hvdc.getPMaxFromCS1toCS2();
@@ -78,6 +83,10 @@ protected double getVscLossMultiplier() {
  return (1 - lossFactor1) * (1 - lossFactor2);
  }
 
+ protected static double getHvdcLineLosses(double rectifierPDc, double r) {
+ return HvdcUtils.getHvdcLineLosses(rectifierPDc, 1, r);
+ }
+
  @Override
  public List<Variable<AcVariableType>> getVariables() {
  return variables;

src/main/java/com/powsybl/openloadflow/ac/equations/HvdcAcEmulationSide1ActiveFlowEquationTerm.java

@@ -24,9 +24,13 @@ public HvdcAcEmulationSide1ActiveFlowEquationTerm(LfHvdc hvdc, LfBus bus1, LfBus
  }
 
  private double p1(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
- double boundedP = boundedP(rawP);
- return (isController(rawP) ? 1 : getVscLossMultiplier()) * boundedP;
+ double rawP = boundedP(rawP(p0, k, ph1, ph2));
+ if (isController(rawP)) {
+ return rawP;
+ } else {
+ double rectifierPDc = (1 - lossFactor1) * rawP;
+ return (1 - lossFactor2) * (rectifierPDc - getHvdcLineLosses(rectifierPDc, r));
+ }
  }
 
  private static boolean isController(double rawP) {

src/main/java/com/powsybl/openloadflow/ac/equations/HvdcAcEmulationSide2ActiveFlowEquationTerm.java

@@ -24,9 +24,13 @@ public HvdcAcEmulationSide2ActiveFlowEquationTerm(LfHvdc hvdc, LfBus bus1, LfBus
  }
 
  private double p2(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
- double boundedP = boundedP(rawP);
- return -(isController(rawP) ? 1 : getVscLossMultiplier()) * boundedP;
+ double rawP = boundedP(rawP(p0, k, ph1, ph2));
+ if (isController(rawP)) {
+ return -rawP;
+ } else {
+ double rectifierPDc = -(1 - lossFactor2) * rawP;
+ return (1 - lossFactor1) * (rectifierPDc + getHvdcLineLosses(rectifierPDc, r));
+ }
  }
 
  private boolean isController(double rawP) {
@@ -40,7 +44,7 @@ private boolean isInOperatingRange(double rawP) {
  private double dp2dph1(double ph1, double ph2) {
  double rawP = rawP(p0, k, ph1, ph2);
  if (isInOperatingRange(rawP)) {
- return -(isController(rawP) ? 1 : getVscLossMultiplier()) * k;
+ return -(isController(rawP) ? 1 : getVscLossMultiplier()) * k; // derivative of cable loss is neglected
  } else {
  return 0;
  }

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

@@ -30,6 +30,8 @@ public interface LfHvdc extends LfElement {
 
  double getDroop();
 
+ double getR();
+
  double getP0();
 
  boolean isAcEmulation();

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

@@ -37,6 +37,10 @@ public class LfHvdcImpl extends AbstractElement implements LfHvdc {
 
  private double p0 = Double.NaN;
 
+ private double r = Double.NaN;
+
+ private double nominalV = Double.NaN;
+
  private LfVscConverterStation converterStation1;
 
  private LfVscConverterStation converterStation2;
@@ -52,6 +56,8 @@ public LfHvdcImpl(String id, LfBus bus1, LfBus bus2, LfNetwork network, HvdcLine
  this.id = Objects.requireNonNull(id);
  this.bus1 = bus1;
  this.bus2 = bus2;
+ this.nominalV = hvdcLine.getNominalV();
+ this.r = hvdcLine.getR();
  HvdcAngleDroopActivePowerControl droopControl = hvdcLine.getExtension(HvdcAngleDroopActivePowerControl.class);
  this.acEmulation = acEmulation && droopControl != null && droopControl.isEnabled();
  if (this.acEmulation) {
@@ -128,6 +134,11 @@ public double getDroop() {
  return droop / PerUnit.SB;
  }
 
+ @Override
+ public double getR() {
+ return r / PerUnit.zb(nominalV);
+ }
+
  @Override
  public double getP0() {
  return p0 / PerUnit.SB;

src/test/java/com/powsybl/openloadflow/EquationsTest.java

@@ -257,6 +257,7 @@ void hvdcTest() {
  Mockito.doReturn(false).when(hvdc).isDisabled();
  Mockito.doReturn(DROOP).when(hvdc).getDroop();
  Mockito.doReturn(P_0).when(hvdc).getP0();
+ Mockito.doReturn(0d).when(hvdc).getR();
  Mockito.doReturn(Double.MAX_VALUE).when(hvdc).getPMaxFromCS1toCS2();
  Mockito.doReturn(Double.MAX_VALUE).when(hvdc).getPMaxFromCS2toCS1();
  LfVscConverterStationImpl station1 = Mockito.mock(LfVscConverterStationImpl.class, new RuntimeExceptionAnswer());

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

@@ -267,6 +267,20 @@ void testHvdcPowerAcEmulation() {
  LoadFlow.Runner loadFlowRunner = new LoadFlow.Runner(new OpenLoadFlowProvider(new DenseMatrixFactory()));
  LoadFlowResult result = loadFlowRunner.run(network, new LoadFlowParameters());
  assertTrue(result.isFullyConverged());
+ // AC Emulation takes into account cable loss
+ assertActivePowerEquals(198.158, network.getHvdcConverterStation("cs2").getTerminal());
+ assertActivePowerEquals(-193.799, network.getHvdcConverterStation("cs3").getTerminal());
+ assertActivePowerEquals(-304.359, network.getGenerator("g1").getTerminal());
+ assertActivePowerEquals(300.0, network.getLoad("l4").getTerminal());
+ }
+
+ @Test
+ void testHvdcPowerAcEmulationWithoutR() {
+ Network network = HvdcNetworkFactory.createHvdcLinkedByTwoLinesAndSwitch();
+ network.getHvdcLine("hvdc23").setR(0d); //Removing resistance to ignore cable loss
+ LoadFlow.Runner loadFlowRunner = new LoadFlow.Runner(new OpenLoadFlowProvider(new DenseMatrixFactory()));
+ LoadFlowResult result = loadFlowRunner.run(network, new LoadFlowParameters());
+ assertTrue(result.isFullyConverged());
  assertActivePowerEquals(198.158, network.getHvdcConverterStation("cs2").getTerminal());
  assertActivePowerEquals(-193.822, network.getHvdcConverterStation("cs3").getTerminal());
  assertActivePowerEquals(-304.335, network.getGenerator("g1").getTerminal());
@@ -293,7 +307,16 @@ void testHvdcDirectionChangeAcEmulation() {
  assertTrue(pcs2 < 0, "Power delivered by cs2");
  assertTrue(Math.abs(pcs1) > Math.abs(pcs2), "Loss at HVDC output");
 
+ // Test if removing line resistance increases the power transit
+ network.getHvdcLine("hvdc12").setR(0d);
+ result = loadFlowRunner.run(network, new LoadFlowParameters());
+ assertTrue(result.isFullyConverged());
+ double pcs1r0 = network.getVscConverterStation("cs1").getTerminal().getP();
+ double pcs2r0 = network.getVscConverterStation("cs2").getTerminal().getP();
+ assertTrue(pcs1r0 - pcs2r0 < pcs1 - pcs2); // Check that loss with R=0 is lower than loss with R!=0
+
  // Reverse power flow direction
+ network.getHvdcLine("hvdc12").setR(0.1d);
  network.getGenerator("g2").setTargetP(5);
  network.getGenerator("g1").setTargetP(0);
  result = loadFlowRunner.run(network, new LoadFlowParameters());
@@ -312,6 +335,14 @@ void testHvdcDirectionChangeAcEmulation() {
  assertTrue(pcs2 > 0, "Power enters at cs2");
  assertTrue(pcs1 < 0, "Power delivered by cs1");
  assertTrue(Math.abs(pcs2) > Math.abs(pcs1), "Loss at HVDC output");
+
+ // Test if removing line resistance increases the power transit in symetric network
+ network.getHvdcLine("hvdc12").setR(0d);
+ result = loadFlowRunner.run(network, new LoadFlowParameters());
+ assertTrue(result.isFullyConverged());
+ pcs1r0 = network.getVscConverterStation("cs1").getTerminal().getP();
+ pcs2r0 = network.getVscConverterStation("cs2").getTerminal().getP();
+ assertTrue(pcs2r0 - pcs1r0 < pcs2 - pcs1); // Check that loss with R=0 is lower than loss with R!=0
  }
 
  @Test
@@ -450,6 +481,7 @@ void testAcEmuWithOperationalLimits() {
  Network network = HvdcNetworkFactory.createHvdcLinkedByTwoLinesAndSwitch(HvdcConverterStation.HvdcType.VSC);
  // without limit p=195
  network.getHvdcLine("hvdc23")
+ .setR(0d) //Removing resistance to ignore cable loss
  .newExtension(HvdcOperatorActivePowerRangeAdder.class)
  .withOprFromCS2toCS1(180)
  .withOprFromCS1toCS2(170)
@@ -482,6 +514,7 @@ void testAcEmuAndPMax() {
  Network network = HvdcNetworkFactory.createHvdcLinkedByTwoLinesAndSwitch(HvdcConverterStation.HvdcType.VSC);
  // without limit p=195
  network.getHvdcLine("hvdc23")
+ .setR(0d) //Removing resistance to ignore cable loss
  .setMaxP(170);
 
  LoadFlow.Runner loadFlowRunner = new LoadFlow.Runner(new OpenLoadFlowProvider(new DenseMatrixFactory()));

src/test/java/com/powsybl/openloadflow/sa/OpenSecurityAnalysisWithActionsTest.java

@@ -1284,6 +1284,7 @@ void testVSCLossAcEmulation() {
  // but other converter station keeps its voltage control capability.
  // remedial action re-enables the ac emulation of the hvdc line.
  Network network = HvdcNetworkFactory.createHvdcLinkedByTwoLinesAndSwitch(HvdcConverterStation.HvdcType.VSC);
+ network.getHvdcLine("hvdc23").setR(0d); //Removing resistance to ignore cable loss
  List<Contingency> contingencies = List.of(new Contingency("contingency", new LineContingency("l12")));
  List<Action> actions = List.of(new SwitchAction("action", "s2", false));
  List<OperatorStrategy> operatorStrategies = List.of(new OperatorStrategy("strategy",
@@ -1330,6 +1331,7 @@ void testHvdcDisconnectedThenConnectedByStrategy() {
  List<StateMonitor> monitors = createNetworkMonitors(network);
 
  // with AC emulation first
+ network.getHvdcLine("hvdc23").setR(0d); //Removing resistance to ignore cable loss in AC emulation
  SecurityAnalysisResult result = runSecurityAnalysis(network, contingencies, monitors, new SecurityAnalysisParameters(),
  operatorStrategies, actions, ReportNode.NO_OP);
 
@@ -1349,6 +1351,7 @@ void testHvdcDisconnectedThenConnectedByStrategy() {
  // without AC emulation
  SecurityAnalysisParameters parameters = new SecurityAnalysisParameters();
  parameters.getLoadFlowParameters().setHvdcAcEmulation(false);
+ network.getHvdcLine("hvdc23").setR(0.1d); //Putting back resistance of the cable to keep same old behaviour
  SecurityAnalysisResult result2 = runSecurityAnalysis(network, contingencies, monitors, parameters,
  operatorStrategies, actions, ReportNode.NO_OP);