Computing Hvdc line loss in AC emulation

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,13 +49,14 @@ 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();
  pMaxFromCS2toCS1 = hvdc.getPMaxFromCS2toCS1();
  }
 
- protected double rawP(double p0, double k, double ph1, double ph2) {
+ protected double rawP(double ph1, double ph2) {
  return p0 + k * (ph1 - ph2);
  }
 
@@ -78,6 +83,15 @@ protected double getVscLossMultiplier() {
  return (1 - lossFactor1) * (1 - lossFactor2);
  }
 
+ protected double getAbsActivePowerWithLosses(double boundedP, double lossController, double lossNonController) {
+ double lineInputPower = (1 - lossController) * Math.abs(boundedP);
+ return (1 - lossNonController) * (lineInputPower - getHvdcLineLosses(lineInputPower, r));
+ }
+
+ protected static double getHvdcLineLosses(double lineInputPower, double r) {
+ return HvdcUtils.getHvdcLineLosses(lineInputPower, 1, r);
+ }
+
  @Override
  public List<Variable<AcVariableType>> getVariables() {
  return variables;

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

@@ -24,9 +24,9 @@ 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 boundedP = boundedP(rawP(ph1, ph2));
+ // if converterStation1 is controller, then p1 is positive, otherwise it is negative
+ return isController(boundedP) ? boundedP : -getAbsActivePowerWithLosses(boundedP, lossFactor1, lossFactor2);
  }
 
  private static boolean isController(double rawP) {
@@ -38,9 +38,9 @@ private boolean isInOperatingRange(double rawP) {
  }
 
  protected double dp1dph1(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
+ double rawP = rawP(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/ac/equations/HvdcAcEmulationSide2ActiveFlowEquationTerm.java

@@ -24,9 +24,9 @@ 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 boundedP = boundedP(rawP(ph1, ph2));
+ // if converterStation2 is controller, then p2 is positive, otherwise it is negative
+ return isController(boundedP) ? -boundedP : -getAbsActivePowerWithLosses(boundedP, lossFactor2, lossFactor1);
  }
 
  private boolean isController(double rawP) {
@@ -38,9 +38,9 @@ private boolean isInOperatingRange(double rawP) {
  }
 
  private double dp2dph1(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
+ double rawP = rawP(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());
@@ -276,8 +290,10 @@ void testHvdcPowerAcEmulation() {
  @Test
  void testHvdcDirectionChangeAcEmulation() {
  Network network = HvdcNetworkFactory.createHvdcInAcEmulationInSymetricNetwork();
+ network.getHvdcLine("hvdc12").setR(0.1d);
  LoadFlow.Runner loadFlowRunner = new LoadFlow.Runner(new OpenLoadFlowProvider(new DenseMatrixFactory()));
- LoadFlowResult result = loadFlowRunner.run(network, new LoadFlowParameters());
+ LoadFlowParameters parameters = new LoadFlowParameters().setHvdcAcEmulation(true);
+ LoadFlowResult result = loadFlowRunner.run(network, parameters);
  assertTrue(result.isFullyConverged());
 
  double pg2 = network.getGenerator("g2").getTerminal().getP();
@@ -293,10 +309,21 @@ 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, parameters);
+ assertTrue(result.isFullyConverged());
+ double pcs1r0 = network.getVscConverterStation("cs1").getTerminal().getP();
+ double pcs2r0 = network.getVscConverterStation("cs2").getTerminal().getP();
+ assertTrue(pcs1r0 > 0, "Power enters at cs1");
+ assertTrue(pcs2r0 < 0, "Power delivered by cs2");
+ assertTrue(Math.abs(pcs2r0 + pcs1r0) < Math.abs(pcs2 - pcs1)); // 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());
+ result = loadFlowRunner.run(network, parameters);
  assertTrue(result.isFullyConverged());
 
  pg2 = network.getGenerator("g2").getTerminal().getP();
@@ -312,6 +339,16 @@ 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, parameters);
+ assertTrue(result.isFullyConverged());
+ pcs1r0 = network.getVscConverterStation("cs1").getTerminal().getP();
+ pcs2r0 = network.getVscConverterStation("cs2").getTerminal().getP();
+ assertTrue(pcs2r0 > 0, "Power enters at cs2");
+ assertTrue(pcs1r0 < 0, "Power delivered by cs1");
+ assertTrue(Math.abs(pcs2r0 + pcs1r0) < Math.abs(pcs2 - pcs1)); // Check that loss with R=0 is lower than loss with R!=0
  }
 
  @Test
@@ -464,7 +501,7 @@ void testAcEmuWithOperationalLimits() {
 
  // Active flow capped at limit. Output has losses (due to VSC stations)
  assertEquals(170, network.getHvdcConverterStation("cs2").getTerminal().getP(), DELTA_POWER);
- assertEquals(-166.280, network.getHvdcConverterStation("cs3").getTerminal().getP(), DELTA_POWER);
+ assertEquals(-166.263, network.getHvdcConverterStation("cs3").getTerminal().getP(), DELTA_POWER);
 
  // now invert power direction
  HvdcAngleDroopActivePowerControl activePowerControl = network.getHvdcLine("hvdc23").getExtension(HvdcAngleDroopActivePowerControl.class);
@@ -473,7 +510,7 @@ void testAcEmuWithOperationalLimits() {
  assertTrue(result.isFullyConverged());
 
  // Active flow capped at other direction's limit. Output has losses (due to VSC stations)
- assertEquals(-176.062, network.getHvdcConverterStation("cs2").getTerminal().getP(), DELTA_POWER);
+ assertEquals(-176.042, network.getHvdcConverterStation("cs2").getTerminal().getP(), DELTA_POWER);
  assertEquals(180, network.getHvdcConverterStation("cs3").getTerminal().getP(), DELTA_POWER);
  }
 
@@ -493,15 +530,15 @@ void testAcEmuAndPMax() {
 
  // Active flow capped at limit. Output has losses (due to VSC stations)
  assertActivePowerEquals(170, network.getHvdcConverterStation("cs2").getTerminal());
- assertActivePowerEquals(-166.280, network.getHvdcConverterStation("cs3").getTerminal());
+ assertActivePowerEquals(-166.263, network.getHvdcConverterStation("cs3").getTerminal());
 
  // now invert power direction
  HvdcAngleDroopActivePowerControl activePowerControl = network.getHvdcLine("hvdc23").getExtension(HvdcAngleDroopActivePowerControl.class);
  activePowerControl.setP0(-activePowerControl.getP0());
  result = loadFlowRunner.run(network, p);
  assertTrue(result.isFullyConverged());
 
- assertActivePowerEquals(-166.280, network.getHvdcConverterStation("cs2").getTerminal());
+ assertActivePowerEquals(-166.263, network.getHvdcConverterStation("cs2").getTerminal());
  assertActivePowerEquals(170, network.getHvdcConverterStation("cs3").getTerminal());
  }
 

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

@@ -1293,9 +1293,9 @@ void testVSCLossAcEmulation() {
  List<StateMonitor> monitors = createNetworkMonitors(network);
  SecurityAnalysisResult result = runSecurityAnalysis(network, contingencies, monitors, new SecurityAnalysisParameters(),
  operatorStrategies, actions, ReportNode.NO_OP);
- assertEquals(193.822, result.getPreContingencyResult().getNetworkResult().getBranchResult("l34").getP1(), LoadFlowAssert.DELTA_POWER);
+ assertEquals(193.799, result.getPreContingencyResult().getNetworkResult().getBranchResult("l34").getP1(), LoadFlowAssert.DELTA_POWER);
  assertEquals(0.0, getPostContingencyResult(result, "contingency").getNetworkResult().getBranchResult("l34").getP1(), LoadFlowAssert.DELTA_POWER);
- assertEquals(193.822, getOperatorStrategyResult(result, "strategy").getNetworkResult().getBranchResult("l34").getP1(), LoadFlowAssert.DELTA_POWER);
+ assertEquals(193.799, getOperatorStrategyResult(result, "strategy").getNetworkResult().getBranchResult("l34").getP1(), LoadFlowAssert.DELTA_POWER);
  }
 
  @Test
@@ -1343,8 +1343,8 @@ void testHvdcDisconnectedThenConnectedByStrategy() {
 
  OperatorStrategyResult operatorStrategyResult = getOperatorStrategyResult(result, "strategyL1");
  assertEquals(198.158, operatorStrategyResult.getNetworkResult().getBranchResult("l12Bis").getP1(), DELTA_POWER);
- assertEquals(193.822, operatorStrategyResult.getNetworkResult().getBranchResult("l34").getP1(), DELTA_POWER);
- assertEquals(106.177, operatorStrategyResult.getNetworkResult().getBranchResult("l14").getP1(), DELTA_POWER);
+ assertEquals(193.799, operatorStrategyResult.getNetworkResult().getBranchResult("l34").getP1(), DELTA_POWER);
+ assertEquals(106.201, operatorStrategyResult.getNetworkResult().getBranchResult("l14").getP1(), DELTA_POWER);
 
  // without AC emulation
  SecurityAnalysisParameters parameters = new SecurityAnalysisParameters();