Ac emulation outerloop

src/main/java/com/powsybl/openloadflow/AbstractAcOuterLoopConfig.java

@@ -112,6 +112,13 @@ protected static Optional<AcOuterLoop> createPhaseControlOuterLoop(LoadFlowParam
  return createPhaseControlOuterLoop(parameters, parametersExt.getPhaseShifterControlMode());
  }
 
+ protected static Optional<AcOuterLoop> createAcEmulationOuterLoop(LoadFlowParameters parameters) {
+ if (parameters.isHvdcAcEmulation()) {
+ return Optional.of(new AcEmulationOuterLoop());
+ }
+ return Optional.empty();
+ }
+
  protected static Optional<AcOuterLoop> createAutomationSystemOuterLoop(OpenLoadFlowParameters parametersExt) {
  if (parametersExt.isSimulateAutomationSystems()) {
  return Optional.of(new AutomationSystemOuterLoop());

src/main/java/com/powsybl/openloadflow/DefaultAcOuterLoopConfig.java

@@ -36,6 +36,8 @@ public List<AcOuterLoop> configure(LoadFlowParameters parameters, OpenLoadFlowPa
  createTransformerReactivePowerControlOuterLoop(parametersExt).ifPresent(outerLoops::add);
  // shunt compensator voltage control
  createShuntVoltageControlOuterLoop(parameters, parametersExt).ifPresent(outerLoops::add);
+ // AC emulation
+ createAcEmulationOuterLoop(parameters).ifPresent(outerLoops::add);
  // automation system
  createAutomationSystemOuterLoop(parametersExt).ifPresent(outerLoops::add);
  return outerLoops;

src/main/java/com/powsybl/openloadflow/ExplicitAcOuterLoopConfig.java

@@ -35,7 +35,8 @@ public class ExplicitAcOuterLoopConfig extends AbstractAcOuterLoopConfig {
  SimpleTransformerVoltageControlOuterLoop.NAME,
  TransformerVoltageControlOuterLoop.NAME,
  AutomationSystemOuterLoop.NAME,
- IncrementalTransformerReactivePowerControlOuterLoop.NAME);
+ IncrementalTransformerReactivePowerControlOuterLoop.NAME,
+ AcEmulationOuterLoop.NAME);
 
  private static Optional<AcOuterLoop> createOuterLoop(String name, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt) {
  return switch (name) {
@@ -65,6 +66,7 @@ private static Optional<AcOuterLoop> createOuterLoop(String name, LoadFlowParame
  parametersExt.getGeneratorVoltageControlMinNominalVoltage());
  case AutomationSystemOuterLoop.NAME -> createAutomationSystemOuterLoop(parametersExt);
  case IncrementalTransformerReactivePowerControlOuterLoop.NAME -> createTransformerReactivePowerControlOuterLoop(parametersExt);
+ case AcEmulationOuterLoop.NAME -> createAcEmulationOuterLoop(parameters);
  default -> throw new PowsyblException("Unknown outer loop '" + name + "'");
  };
  }

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

@@ -43,29 +43,18 @@ protected AbstractHvdcAcEmulationFlowEquationTerm(LfHvdc hvdc, LfBus bus1, LfBus
  ph1Var = variableSet.getVariable(bus1.getNum(), AcVariableType.BUS_PHI);
  ph2Var = variableSet.getVariable(bus2.getNum(), AcVariableType.BUS_PHI);
  variables = List.of(ph1Var, ph2Var);
- k = hvdc.getDroop() * 180 / Math.PI;
- p0 = hvdc.getP0();
+ k = hvdc.getAcEmulationControl().getDroop() * 180 / Math.PI;
+ p0 = hvdc.getAcEmulationControl().getP0();
  lossFactor1 = hvdc.getConverterStation1().getLossFactor() / 100;
  lossFactor2 = hvdc.getConverterStation2().getLossFactor() / 100;
- pMaxFromCS1toCS2 = hvdc.getPMaxFromCS1toCS2();
- pMaxFromCS2toCS1 = hvdc.getPMaxFromCS2toCS1();
+ pMaxFromCS1toCS2 = hvdc.getAcEmulationControl().getPMaxFromCS1toCS2();
+ pMaxFromCS2toCS1 = hvdc.getAcEmulationControl().getPMaxFromCS2toCS1();
  }
 
  protected double rawP(double p0, double k, double ph1, double ph2) {
  return p0 + k * (ph1 - ph2);
  }
 
- protected double boundedP(double rawP) {
- // If there is a maximal active power
- // it is applied at the entry of the controller VSC station
- // on the AC side of the network.
- if (rawP >= 0) {
- return Math.min(rawP, pMaxFromCS1toCS2);
- } else {
- return Math.max(rawP, -pMaxFromCS2toCS1);
- }
- }
-
  protected double ph1() {
  return sv.get(ph1Var.getRow());
  }

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

@@ -7,6 +7,7 @@
  */
 package com.powsybl.openloadflow.ac.equations;
 
+import com.powsybl.iidm.network.TwoSides;
 import com.powsybl.openloadflow.equations.Variable;
 import com.powsybl.openloadflow.equations.VariableSet;
 import com.powsybl.openloadflow.network.LfBus;
@@ -23,31 +24,29 @@ public HvdcAcEmulationSide1ActiveFlowEquationTerm(LfHvdc hvdc, LfBus bus1, LfBus
  super(hvdc, bus1, bus2, variableSet);
  }
 
- private double p1(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
- double boundedP = boundedP(rawP);
- return (isController(rawP) ? 1 : getVscLossMultiplier()) * boundedP;
- }
-
- private static boolean isController(double rawP) {
- return rawP >= 0;
+ private double getSide1LossMultiplier() {
+ return element.getAcEmulationControl().getFeedingSide() == TwoSides.ONE ? 1 : getVscLossMultiplier();
  }
 
- private boolean isInOperatingRange(double rawP) {
- return rawP < pMaxFromCS1toCS2 && rawP > -pMaxFromCS2toCS1;
+ private double p1(double ph1, double ph2) {
+ double boundedP = switch (element.getAcEmulationControl().getAcEmulationStatus()) {
+ case FREE -> rawP(p0, k, ph1, ph2);
+ case BOUNDED -> element.getAcEmulationControl().getFeedingSide() == TwoSides.ONE ? pMaxFromCS1toCS2 : -pMaxFromCS2toCS1;
+ default -> 0;
+ };
+ return getSide1LossMultiplier() * boundedP;
  }
 
- protected double dp1dph1(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
- if (isInOperatingRange(rawP)) {
- return (isController(rawP) ? 1 : getVscLossMultiplier()) * k;
+ protected double dp1dph1() {
+ if (element.getAcEmulationControl().getAcEmulationStatus() == LfHvdc.AcEmulationControl.AcEmulationStatus.FREE) {
+ return getSide1LossMultiplier() * k;
  } else {
  return 0;
  }
  }
 
- protected double dp1dph2(double ph1, double ph2) {
- return -dp1dph1(ph1, ph2);
+ protected double dp1dph2() {
+ return -dp1dph1();
  }
 
  @Override
@@ -59,9 +58,9 @@ public double eval() {
  public double der(Variable<AcVariableType> variable) {
  Objects.requireNonNull(variable);
  if (variable.equals(ph1Var)) {
- return dp1dph1(ph1(), ph2());
+ return dp1dph1();
  } else if (variable.equals(ph2Var)) {
- return dp1dph2(ph1(), ph2());
+ return dp1dph2();
  } else {
  throw new IllegalStateException("Unknown variable: " + variable);
  }

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

@@ -7,6 +7,7 @@
  */
 package com.powsybl.openloadflow.ac.equations;
 
+import com.powsybl.iidm.network.TwoSides;
 import com.powsybl.openloadflow.equations.Variable;
 import com.powsybl.openloadflow.equations.VariableSet;
 import com.powsybl.openloadflow.network.LfBus;
@@ -23,31 +24,29 @@ public HvdcAcEmulationSide2ActiveFlowEquationTerm(LfHvdc hvdc, LfBus bus1, LfBus
  super(hvdc, bus1, bus2, variableSet);
  }
 
- private double p2(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
- double boundedP = boundedP(rawP);
- return -(isController(rawP) ? 1 : getVscLossMultiplier()) * boundedP;
- }
-
- private boolean isController(double rawP) {
- return rawP < 0;
+ private double getSide2LossMultiplier() {
+ return element.getAcEmulationControl().getFeedingSide() == TwoSides.TWO ? 1 : getVscLossMultiplier();
  }
 
- private boolean isInOperatingRange(double rawP) {
- return rawP < pMaxFromCS2toCS1 && rawP > -pMaxFromCS1toCS2;
+ private double p2(double ph1, double ph2) {
+ double boundedP = switch (element.getAcEmulationControl().getAcEmulationStatus()) {
+ case FREE -> -rawP(p0, k, ph1, ph2);
+ case BOUNDED -> element.getAcEmulationControl().getFeedingSide() == TwoSides.TWO ? pMaxFromCS2toCS1 : -pMaxFromCS1toCS2;
+ default -> 0;
+ };
+ return getSide2LossMultiplier() * boundedP;
  }
 
- private double dp2dph1(double ph1, double ph2) {
- double rawP = rawP(p0, k, ph1, ph2);
- if (isInOperatingRange(rawP)) {
- return -(isController(rawP) ? 1 : getVscLossMultiplier()) * k;
+ private double dp2dph1() {
+ if (element.getAcEmulationControl().getAcEmulationStatus() == LfHvdc.AcEmulationControl.AcEmulationStatus.FREE) {
+ return -getSide2LossMultiplier() * k;
  } else {
  return 0;
  }
  }
 
- private double dp2dph2(double ph1, double ph2) {
- return -dp2dph1(ph1, ph2);
+ private double dp2dph2() {
+ return -dp2dph1();
  }
 
  @Override
@@ -59,9 +58,9 @@ public double eval() {
  public double der(Variable<AcVariableType> variable) {
  Objects.requireNonNull(variable);
  if (variable.equals(ph1Var)) {
- return dp2dph1(ph1(), ph2());
+ return dp2dph1();
  } else if (variable.equals(ph2Var)) {
- return dp2dph2(ph1(), ph2());
+ return dp2dph2();
  } else {
  throw new IllegalStateException("Unknown variable: " + variable);
  }

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

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) 2023, Coreso SA (https://www.coreso.eu/) and TSCNET Services GmbH (https://www.tscnet.eu/)
+ * 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.iidm.network.TwoSides;
+import com.powsybl.openloadflow.ac.AcLoadFlowContext;
+import com.powsybl.openloadflow.ac.AcLoadFlowParameters;
+import com.powsybl.openloadflow.ac.AcOuterLoopContext;
+import com.powsybl.openloadflow.ac.equations.AcEquationType;
+import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.lf.outerloop.AbstractAcEmulationOuterLoop;
+import com.powsybl.openloadflow.lf.outerloop.OuterLoopResult;
+import com.powsybl.openloadflow.lf.outerloop.OuterLoopStatus;
+import com.powsybl.openloadflow.network.LfHvdc;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author Hadrien Godard {@literal <hadrien.godard at artelys.com>}
+ */
+public class AcEmulationOuterLoop
+ extends AbstractAcEmulationOuterLoop<AcVariableType, AcEquationType, AcLoadFlowParameters, AcLoadFlowContext, AcOuterLoopContext>
+ implements AcOuterLoop {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(AcEmulationOuterLoop.class);
+ public static final String NAME = "AcEmulation";
+
+ @Override
+ public String getName() {
+ return NAME;
+ }
+
+ private boolean checkFeedingSide(LfHvdc hvdc, ContextData contextData) {
+ String hvdcId = hvdc.getId();
+ LfHvdc.AcEmulationControl acEmulationControl = hvdc.getAcEmulationControl();
+
+ if (acEmulationControl.getFeedingSide() == TwoSides.ONE) {
+ if (hvdc.getP1().eval() < 0) {
+ // Switch feeding side
+ LOGGER.trace("Switching feeding side from One to Two for Hvdc: {}", hvdcId);
+ contextData.incrementFeedingSideSwitchCount(hvdcId);
+ hvdc.updateFeedingSide(TwoSides.TWO);
+ if (contextData.getFeedingSideSwitchCount(hvdcId) == MAX_FEEDING_SIDE_SWITCH) {
+ LOGGER.debug("Two many feeding side switches (flow blocked to 0 MW) for Hvdc: {}", hvdcId);
+ hvdc.updateAcEmulationStatus(LfHvdc.AcEmulationControl.AcEmulationStatus.NULL);
+ }
+ return true;
+ }
+ } else {
+ if (hvdc.getP2().eval() < 0) {
+ // Switch feeding side
+ LOGGER.trace("Switching feeding side from Two to One for Hvdc: {}", hvdcId);
+ contextData.incrementFeedingSideSwitchCount(hvdcId);
+ hvdc.updateFeedingSide(TwoSides.ONE);
+ if (contextData.getFeedingSideSwitchCount(hvdcId) == MAX_FEEDING_SIDE_SWITCH) {
+ LOGGER.debug("Two many feeding side switches (flow blocked to 0 MW) for Hvdc: {}", hvdcId);
+ hvdc.updateAcEmulationStatus(LfHvdc.AcEmulationControl.AcEmulationStatus.NULL);
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean checkMode(LfHvdc hvdc, ContextData contextData) {
+ String hvdcId = hvdc.getId();
+ LfHvdc.AcEmulationControl acEmulationControl = hvdc.getAcEmulationControl();
+
+ // Check for mode switch between FREE and BOUNDED
+ if (acEmulationControl.getAcEmulationStatus() == LfHvdc.AcEmulationControl.AcEmulationStatus.FREE) {
+ // Check Pmax
+ if (acEmulationControl.getFeedingSide() == TwoSides.ONE) {
+ if (hvdc.getP1().eval() > acEmulationControl.getPMaxFromCS1toCS2()) {
+ // Switch mode
+ LOGGER.trace("Bound Hvdc flow to Pmax from CS1 to CS2 for Hvdc: {}", hvdcId);
+ contextData.incrementModeSwitchCount(hvdcId);
+ hvdc.updateAcEmulationStatus(LfHvdc.AcEmulationControl.AcEmulationStatus.BOUNDED);
+ if (contextData.getModeSwitchCount(hvdcId) == MAX_MODE_SWITCH) {
+ LOGGER.debug("Two many mode switches (flow blocked to Pmax from CS1 to CS2) for Hvdc: {}", hvdcId);
+ }
+ return true;
+ }
+ } else {
+ if (hvdc.getP2().eval() > acEmulationControl.getPMaxFromCS2toCS1()) {
+ // Switch mode
+ LOGGER.trace("Bound Hvdc flow to Pmax from CS2 to CS1 for Hvdc: {}", hvdcId);
+ contextData.incrementModeSwitchCount(hvdcId);
+ hvdc.updateAcEmulationStatus(LfHvdc.AcEmulationControl.AcEmulationStatus.BOUNDED);
+ if (contextData.getModeSwitchCount(hvdcId) == MAX_MODE_SWITCH) {
+ LOGGER.debug("Two many mode switches (flow blocked to Pmax from CS2 to CS1) for Hvdc: {}", hvdcId);
+ }
+ return true;
+ }
+ }
+ }
+
+ // Check for mode switch between BOUNDED and FREE
+ if (acEmulationControl.getAcEmulationStatus() == LfHvdc.AcEmulationControl.AcEmulationStatus.BOUNDED) {
+ if (acEmulationControl.getFeedingSide() == TwoSides.ONE) {
+ if (computeRawP1(hvdc) < acEmulationControl.getPMaxFromCS1toCS2()) {
+ // Switch mode
+ LOGGER.trace("Set free the Ac Emulation mode for Hvdc: {}", hvdcId);
+ hvdc.updateAcEmulationStatus(LfHvdc.AcEmulationControl.AcEmulationStatus.FREE);
+ return true;
+ }
+ } else {
+ if (computeRawP2(hvdc) < acEmulationControl.getPMaxFromCS2toCS1()) {
+ // Switch mode
+ LOGGER.trace("Set free the Ac Emulation mode for Hvdc: {}", hvdcId);
+ hvdc.updateAcEmulationStatus(LfHvdc.AcEmulationControl.AcEmulationStatus.FREE);
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public OuterLoopResult check(AcOuterLoopContext context, ReportNode reportNode) {
+ OuterLoopStatus status = OuterLoopStatus.STABLE;
+ ContextData contextData = (ContextData) context.getData();
+
+ for (LfHvdc hvdc : context.getNetwork().getHvdcs()) {
+ if (!hvdc.isAcEmulation() || hvdc.getBus1().isDisabled() || hvdc.getBus2().isDisabled() || hvdc.isDisabled()) {
+ continue;
+ }
+ String hvdcId = hvdc.getId();
+ if (contextData.getFeedingSideSwitchCount(hvdcId) < MAX_FEEDING_SIDE_SWITCH && contextData.getModeSwitchCount(hvdcId) < MAX_MODE_SWITCH) {
+ // First check the feeding side
+ if (checkFeedingSide(hvdc, contextData)) {
+ status = OuterLoopStatus.UNSTABLE;
+ }
+
+ // Second check for Pmax values
+ if (checkMode(hvdc, contextData)) {
+ status = OuterLoopStatus.UNSTABLE;
+ }
+ }
+ }
+
+ return new OuterLoopResult(this, status);
+ }
+}