Support of asymmetrical transformer

src/main/java/com/powsybl/openloadflow/ac/AcTargetVector.java

@@ -8,12 +8,16 @@
 package com.powsybl.openloadflow.ac;
 
 import com.powsybl.commons.PowsyblException;
+import com.powsybl.iidm.network.extensions.WindingConnectionType;
 import com.powsybl.openloadflow.ac.equations.AcEquationType;
 import com.powsybl.openloadflow.ac.equations.AcVariableType;
 import com.powsybl.openloadflow.equations.Equation;
 import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.equations.TargetVector;
 import com.powsybl.openloadflow.network.*;
+import com.powsybl.openloadflow.util.ComplexPart;
+import com.powsybl.openloadflow.util.Fortescue;
+import org.apache.commons.math3.complex.Complex;
 
 import java.util.*;
 
@@ -67,11 +71,22 @@ private static double getReactivePowerControlTarget(LfBranch branch) {
  public static void init(Equation<AcVariableType, AcEquationType> equation, LfNetwork network, double[] targets) {
  switch (equation.getType()) {
  case BUS_TARGET_P:
- targets[equation.getColumn()] = network.getBus(equation.getElementNum()).getTargetP();
+ // at this stage getTargetP() returns both generation and load effects at bus in case of a balanced load flow
+ // but in the case of an unbalanced load flow it contains only the generation effects
+ // because loads depends on variables with the Fortescue transform and might be handled as equation terms instead
+ // However, in some specific cases, additional targets terms might be necessary:
+
+ // in the case the bus is modeled with ABC variables, the load is of constant current type,
+ // and supposing the nodal balances are modeled using current for the positive sequence,
+ // then the targed is a current fixed value
+ targets[equation.getColumn()] = network.getBus(equation.getElementNum()).getTargetP()
+ + getFortescueTarget(network.getBus(equation.getElementNum()), ComplexPart.REAL, Fortescue.SequenceType.POSITIVE);
  break;
 
  case BUS_TARGET_Q:
- targets[equation.getColumn()] = network.getBus(equation.getElementNum()).getTargetQ();
+ // see the comment for BUS_TARGET_P
+ targets[equation.getColumn()] = network.getBus(equation.getElementNum()).getTargetQ()
+ + getFortescueTarget(network.getBus(equation.getElementNum()), ComplexPart.IMAGINARY, Fortescue.SequenceType.POSITIVE);
  break;
 
  case BUS_TARGET_V:
@@ -114,15 +129,31 @@ public static void init(Equation<AcVariableType, AcEquationType> equation, LfNet
  targets[equation.getColumn()] = LfBranch.getA(network.getBranch(equation.getElementNum()));
  break;
 
+ case BUS_TARGET_IX_ZERO:
+ // see the comment for BUS_TARGET_P
+ targets[equation.getColumn()] = getFortescueTarget(network.getBus(equation.getElementNum()), ComplexPart.REAL, Fortescue.SequenceType.ZERO);
+ break;
+
+ case BUS_TARGET_IY_ZERO:
+ // see the comment for BUS_TARGET_P
+ targets[equation.getColumn()] = getFortescueTarget(network.getBus(equation.getElementNum()), ComplexPart.IMAGINARY, Fortescue.SequenceType.ZERO);
+ break;
+
+ case BUS_TARGET_IX_NEGATIVE:
+ // see the comment for BUS_TARGET_P
+ targets[equation.getColumn()] = getFortescueTarget(network.getBus(equation.getElementNum()), ComplexPart.REAL, Fortescue.SequenceType.NEGATIVE);
+ break;
+
+ case BUS_TARGET_IY_NEGATIVE:
+ // see the comment for BUS_TARGET_P
+ targets[equation.getColumn()] = getFortescueTarget(network.getBus(equation.getElementNum()), ComplexPart.IMAGINARY, Fortescue.SequenceType.NEGATIVE);
+ break;
+
  case DISTR_RHO,
- DISTR_SHUNT_B,
- DUMMY_TARGET_P,
- DUMMY_TARGET_Q,
- BUS_DISTR_SLACK_P,
- BUS_TARGET_IX_ZERO,
- BUS_TARGET_IY_ZERO,
- BUS_TARGET_IX_NEGATIVE,
- BUS_TARGET_IY_NEGATIVE:
+ DISTR_SHUNT_B,
+ DUMMY_TARGET_P,
+ DUMMY_TARGET_Q,
+ BUS_DISTR_SLACK_P:
  targets[equation.getColumn()] = 0;
  break;
 
@@ -133,6 +164,37 @@ public static void init(Equation<AcVariableType, AcEquationType> equation, LfNet
  targets[equation.getColumn()] -= equation.rhs();
  }
 
+ public static double getFortescueTarget(LfBus bus, ComplexPart complexPart, Fortescue.SequenceType sequenceType) {
+ LfAsymBus asymBus = bus.getAsym();
+ Complex target = Complex.ZERO;
+ if (asymBus != null) {
+ // we use the detection of the asymmetry extension at bus to check if we are in asymmetrical calculation
+ // in this case, load target is set to zero and the constant-balanced load model (in 3 phased representation) is replaced by a model depending on v1, v2, v0 (equivalent fortescue representation)
+ WindingConnectionType windingConnectionType = null;
+ if (asymBus.getLoadWye1() != null) {
+ windingConnectionType = WindingConnectionType.Y_GROUNDED;
+ } else if (asymBus.getLoadDelta1() != null) {
+ windingConnectionType = WindingConnectionType.DELTA;
+ }
+
+ if (windingConnectionType != null) {
+ if (sequenceType == Fortescue.SequenceType.ZERO) {
+ target = asymBus.getIzeroTarget(windingConnectionType).multiply(-1.);
+ } else if (sequenceType == Fortescue.SequenceType.POSITIVE) {
+ target = asymBus.getIpositiveTarget(windingConnectionType).multiply(-1.);
+ } else {
+ target = asymBus.getInegativeTarget(windingConnectionType).multiply(-1.);
+ }
+ }
+ }
+
+ if (complexPart == ComplexPart.REAL) {
+ return target.getReal();
+ } else {
+ return target.getImaginary();
+ }
+ }
+
  public AcTargetVector(LfNetwork network, EquationSystem<AcVariableType, AcEquationType> equationSystem) {
  super(network, equationSystem, AcTargetVector::init);
  }

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

@@ -14,7 +14,7 @@
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  */
-abstract class AbstractBranchAcFlowEquationTerm extends AbstractElementEquationTerm<LfBranch, AcVariableType, AcEquationType> {
+public abstract class AbstractBranchAcFlowEquationTerm extends AbstractElementEquationTerm<LfBranch, AcVariableType, AcEquationType> {
 
  protected final double b1;
  protected final double b2;

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

@@ -39,40 +39,32 @@ public abstract class AbstractClosedBranchAcFlowEquationTerm extends AbstractBra
 
  protected final List<Variable<AcVariableType>> variables = new ArrayList<>();
 
- public static AcVariableType getVoltageMagnitudeType(Fortescue.SequenceType sequenceType) {
- return switch (sequenceType) {
- case POSITIVE -> AcVariableType.BUS_V;
- case NEGATIVE -> AcVariableType.BUS_V_NEGATIVE;
- case ZERO -> AcVariableType.BUS_V_ZERO;
- };
- }
-
- public static AcVariableType getVoltageAngleType(Fortescue.SequenceType sequenceType) {
- return switch (sequenceType) {
- case POSITIVE -> AcVariableType.BUS_PHI;
- case NEGATIVE -> AcVariableType.BUS_PHI_NEGATIVE;
- case ZERO -> AcVariableType.BUS_PHI_ZERO;
- };
- }
-
  protected AbstractClosedBranchAcFlowEquationTerm(LfBranch branch, LfBus bus1, LfBus bus2, VariableSet<AcVariableType> variableSet,
  boolean deriveA1, boolean deriveR1, Fortescue.SequenceType sequenceType) {
  super(branch);
  Objects.requireNonNull(bus1);
  Objects.requireNonNull(bus2);
  Objects.requireNonNull(variableSet);
- AcVariableType vType = getVoltageMagnitudeType(sequenceType);
- AcVariableType angleType = getVoltageAngleType(sequenceType);
- v1Var = variableSet.getVariable(bus1.getNum(), vType);
- v2Var = variableSet.getVariable(bus2.getNum(), vType);
- ph1Var = variableSet.getVariable(bus1.getNum(), angleType);
- ph2Var = variableSet.getVariable(bus2.getNum(), angleType);
+
+ v1Var = createV1Var(bus1, variableSet, sequenceType);
+ ph1Var = createPh1Var(bus1, variableSet, sequenceType);
+ v2Var = createV2Var(bus2, variableSet, sequenceType);
+ ph2Var = createPh2Var(bus2, variableSet, sequenceType);
+
  a1Var = deriveA1 ? variableSet.getVariable(branch.getNum(), AcVariableType.BRANCH_ALPHA1) : null;
  r1Var = deriveR1 ? variableSet.getVariable(branch.getNum(), AcVariableType.BRANCH_RHO1) : null;
- variables.add(v1Var);
- variables.add(v2Var);
- variables.add(ph1Var);
- variables.add(ph2Var);
+ if (v1Var != null) {
+ variables.add(v1Var);
+ }
+ if (v2Var != null) {
+ variables.add(v2Var);
+ }
+ if (ph1Var != null) {
+ variables.add(ph1Var);
+ }
+ if (ph2Var != null) {
+ variables.add(ph2Var);
+ }
  if (a1Var != null) {
  variables.add(a1Var);
  }
@@ -81,23 +73,51 @@ protected AbstractClosedBranchAcFlowEquationTerm(LfBranch branch, LfBus bus1, Lf
  }
  }
 
+ protected Variable<AcVariableType> createV1Var(LfBus bus1, VariableSet<AcVariableType> variableSet, Fortescue.SequenceType sequenceType) {
+ return variableSet.getVariable(bus1.getNum(), AcVariableType.BUS_V);
+ }
+
+ protected Variable<AcVariableType> createPh1Var(LfBus bus1, VariableSet<AcVariableType> variableSet, Fortescue.SequenceType sequenceType) {
+ return variableSet.getVariable(bus1.getNum(), AcVariableType.BUS_PHI);
+ }
+
+ protected Variable<AcVariableType> createV2Var(LfBus bus2, VariableSet<AcVariableType> variableSet, Fortescue.SequenceType sequenceType) {
+ return variableSet.getVariable(bus2.getNum(), AcVariableType.BUS_V);
+ }
+
+ protected Variable<AcVariableType> createPh2Var(LfBus bus2, VariableSet<AcVariableType> variableSet, Fortescue.SequenceType sequenceType) {
+ return variableSet.getVariable(bus2.getNum(), AcVariableType.BUS_PHI);
+ }
+
  public Variable<AcVariableType> getA1Var() {
  return a1Var;
  }
 
  protected double v1() {
+ if (v1Var == null) {
+ return 0.;
+ }
  return sv.get(v1Var.getRow());
  }
 
  protected double v2() {
+ if (v2Var == null) {
+ return 0.;
+ }
  return sv.get(v2Var.getRow());
  }
 
  protected double ph1() {
+ if (ph1Var == null) {
+ return 0.;
+ }
  return sv.get(ph1Var.getRow());
  }
 
  protected double ph2() {
+ if (ph2Var == null) {
+ return 0.;
+ }
  return sv.get(ph2Var.getRow());
  }