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());
     }