AC vectorized network

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

@@ -7,15 +7,15 @@
  */
 package com.powsybl.openloadflow.ac;
 
-import com.powsybl.openloadflow.ac.equations.asym.AsymmetricalAcEquationSystemCreator;
-import com.powsybl.openloadflow.equations.JacobianMatrix;
-import com.powsybl.openloadflow.lf.AbstractLoadFlowContext;
-import com.powsybl.openloadflow.ac.equations.AcEquationSystemCreator;
 import com.powsybl.openloadflow.ac.equations.AcEquationType;
 import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.ac.equations.asym.AsymmetricalAcEquationSystemCreator;
+import com.powsybl.openloadflow.ac.equations.vector.AcVectorizedEquationSystemCreator;
 import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.equations.EquationVector;
+import com.powsybl.openloadflow.equations.JacobianMatrix;
 import com.powsybl.openloadflow.equations.TargetVector;
+import com.powsybl.openloadflow.lf.AbstractLoadFlowContext;
 import com.powsybl.openloadflow.network.LfNetwork;
 
 /**
@@ -47,7 +47,7 @@ public JacobianMatrix<AcVariableType, AcEquationType> getJacobianMatrix() {
     public EquationSystem<AcVariableType, AcEquationType> getEquationSystem() {
         if (equationSystem == null) {
             var creator = parameters.isAsymmetrical() ? new AsymmetricalAcEquationSystemCreator(network, parameters.getEquationSystemCreationParameters())
-                                                      : new AcEquationSystemCreator(network, parameters.getEquationSystemCreationParameters());
+                                                      : new AcVectorizedEquationSystemCreator(network, parameters.getEquationSystemCreationParameters());
             equationSystem = creator.create();
         }
         return equationSystem;

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

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2023, RTE (http://www.rte-france.com)
+ * 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/.
+ */
+package com.powsybl.openloadflow.ac.equations;
+
+import com.powsybl.openloadflow.equations.EquationSystem;
+
+import java.util.Objects;
+
+/**
+ * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
+ */
+public class AcEquationSystemCreationContext {
+
+    private final EquationSystem<AcVariableType, AcEquationType> equationSystem;
+
+    public AcEquationSystemCreationContext(EquationSystem<AcVariableType, AcEquationType> equationSystem) {
+        this.equationSystem = Objects.requireNonNull(equationSystem);
+    }
+
+    public EquationSystem<AcVariableType, AcEquationType> getEquationSystem() {
+        return equationSystem;
+    }
+}

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

@@ -8,7 +8,6 @@
 package com.powsybl.openloadflow.ac.equations;
 
 import com.powsybl.iidm.network.TwoSides;
-import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.lf.AbstractEquationSystemUpdater;
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.util.EvaluableConstants;
@@ -21,25 +20,27 @@
  */
 public class AcEquationSystemUpdater extends AbstractEquationSystemUpdater<AcVariableType, AcEquationType> {
 
-    private final AcEquationSystemCreationParameters parameters;
+    private final AcEquationSystemCreator creator;
 
-    public AcEquationSystemUpdater(EquationSystem<AcVariableType, AcEquationType> equationSystem,
-                                   AcEquationSystemCreationParameters parameters) {
-        super(equationSystem, LoadFlowModel.AC);
-        this.parameters = Objects.requireNonNull(parameters);
+    private final AcEquationSystemCreationContext creationContext;
+
+    public AcEquationSystemUpdater(AcEquationSystemCreator creator, AcEquationSystemCreationContext creationContext) {
+        super(creationContext.getEquationSystem(), LoadFlowModel.AC);
+        this.creator = Objects.requireNonNull(creator);
+        this.creationContext = Objects.requireNonNull(creationContext);
     }
 
     private void updateVoltageControls(LfBus bus) {
         LfZeroImpedanceNetwork zn = bus.getZeroImpedanceNetwork(loadFlowModel);
         if (zn == null) {
-            bus.getGeneratorVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateGeneratorVoltageControl(voltageControl.getMainVoltageControl(), equationSystem));
-            bus.getTransformerVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateTransformerVoltageControlEquations(voltageControl.getMainVoltageControl(), equationSystem));
-            bus.getShuntVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateShuntVoltageControlEquations(voltageControl.getMainVoltageControl(), equationSystem));
+            bus.getGeneratorVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateGeneratorVoltageControl(voltageControl.getMainVoltageControl(), creationContext));
+            bus.getTransformerVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateTransformerVoltageControlEquations(voltageControl.getMainVoltageControl(), creationContext));
+            bus.getShuntVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateShuntVoltageControlEquations(voltageControl.getMainVoltageControl(), creationContext));
         } else {
             for (LfBus zb : zn.getGraph().vertexSet()) {
-                zb.getGeneratorVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateGeneratorVoltageControl(voltageControl.getMainVoltageControl(), equationSystem));
-                zb.getTransformerVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateTransformerVoltageControlEquations(voltageControl.getMainVoltageControl(), equationSystem));
-                zb.getShuntVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateShuntVoltageControlEquations(voltageControl.getMainVoltageControl(), equationSystem));
+                zb.getGeneratorVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateGeneratorVoltageControl(voltageControl.getMainVoltageControl(), creationContext));
+                zb.getTransformerVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateTransformerVoltageControlEquations(voltageControl.getMainVoltageControl(), creationContext));
+                zb.getShuntVoltageControl().ifPresent(voltageControl -> AcEquationSystemCreator.updateShuntVoltageControlEquations(voltageControl.getMainVoltageControl(), creationContext));
             }
         }
     }
@@ -51,12 +52,12 @@ public void onGeneratorVoltageControlChange(LfBus controllerBus, boolean newVolt
 
     @Override
     public void onTransformerPhaseControlChange(LfBranch controllerBranch, boolean newPhaseControlEnabled) {
-        AcEquationSystemCreator.updateTransformerPhaseControlEquations(controllerBranch.getPhaseControl().orElseThrow(), equationSystem);
+        AcEquationSystemCreator.updateTransformerPhaseControlEquations(controllerBranch.getPhaseControl().orElseThrow(), creationContext);
     }
 
     @Override
     public void onGeneratorReactivePowerControlChange(LfBus controllerBus, boolean newReactiveControllerEnabled) {
-        controllerBus.getGeneratorReactivePowerControl().ifPresent(generatorReactivePowerControl -> AcEquationSystemCreator.updateGeneratorReactivePowerControlBranchEquations(generatorReactivePowerControl, equationSystem));
+        controllerBus.getGeneratorReactivePowerControl().ifPresent(generatorReactivePowerControl -> AcEquationSystemCreator.updateGeneratorReactivePowerControlBranchEquations(generatorReactivePowerControl, creationContext));
     }
 
     @Override
@@ -106,14 +107,14 @@ public void onDisableChange(LfElement element, boolean disabled) {
                 bus.getGeneratorVoltageControl().ifPresent(vc -> updateVoltageControls(vc.getControlledBus()));
                 bus.getTransformerVoltageControl().ifPresent(vc -> updateVoltageControls(vc.getControlledBus()));
                 bus.getShuntVoltageControl().ifPresent(vc -> updateVoltageControls(vc.getControlledBus()));
-                bus.getGeneratorReactivePowerControl().ifPresent(reactivePowerControl -> AcEquationSystemCreator.updateGeneratorReactivePowerControlBranchEquations(reactivePowerControl, equationSystem));
+                bus.getGeneratorReactivePowerControl().ifPresent(reactivePowerControl -> AcEquationSystemCreator.updateGeneratorReactivePowerControlBranchEquations(reactivePowerControl, creationContext));
                 break;
             case BRANCH:
                 LfBranch branch = (LfBranch) element;
                 AcEquationSystemCreator.updateBranchEquations(branch);
                 branch.getVoltageControl().ifPresent(vc -> updateVoltageControls(vc.getControlledBus()));
-                branch.getPhaseControl().ifPresent(phaseControl -> AcEquationSystemCreator.updateTransformerPhaseControlEquations(phaseControl, equationSystem));
-                branch.getGeneratorReactivePowerControl().ifPresent(reactivePowerControl -> AcEquationSystemCreator.updateGeneratorReactivePowerControlBranchEquations(reactivePowerControl, equationSystem));
+                branch.getPhaseControl().ifPresent(phaseControl -> AcEquationSystemCreator.updateTransformerPhaseControlEquations(phaseControl, creationContext));
+                branch.getGeneratorReactivePowerControl().ifPresent(reactivePowerControl -> AcEquationSystemCreator.updateGeneratorReactivePowerControlBranchEquations(reactivePowerControl, creationContext));
                 break;
             case SHUNT_COMPENSATOR:
                 LfShunt shunt = (LfShunt) element;
@@ -131,13 +132,13 @@ private void recreateDistributionEquations(LfZeroImpedanceNetwork network) {
         for (LfBus bus : network.getGraph().vertexSet()) {
             bus.getGeneratorVoltageControl()
                     .filter(voltageControl -> voltageControl.getMergeStatus() == VoltageControl.MergeStatus.MAIN)
-                    .ifPresent(voltageControl -> AcEquationSystemCreator.recreateReactivePowerDistributionEquations(bus.getNetwork(), voltageControl, equationSystem, parameters));
+                    .ifPresent(voltageControl -> creator.recreateReactivePowerDistributionEquations(voltageControl, creationContext));
             bus.getTransformerVoltageControl()
                     .filter(voltageControl -> voltageControl.getMergeStatus() == VoltageControl.MergeStatus.MAIN)
-                    .ifPresent(voltageControl -> AcEquationSystemCreator.recreateR1DistributionEquations(bus.getNetwork(), voltageControl, equationSystem));
+                    .ifPresent(voltageControl -> AcEquationSystemCreator.recreateR1DistributionEquations(network.getNetwork(), voltageControl, creationContext));
             bus.getShuntVoltageControl()
                     .filter(voltageControl -> voltageControl.getMergeStatus() == VoltageControl.MergeStatus.MAIN)
-                    .ifPresent(voltageControl -> AcEquationSystemCreator.recreateShuntSusceptanceDistributionEquations(bus.getNetwork(), voltageControl, equationSystem));
+                    .ifPresent(voltageControl -> AcEquationSystemCreator.recreateShuntSusceptanceDistributionEquations(network.getNetwork(), voltageControl, creationContext));
         }
     }
 

src/main/java/com/powsybl/openloadflow/ac/equations/asym/AsymmetricalAcEquationSystemCreator.java

@@ -10,7 +10,6 @@
 
 import com.powsybl.iidm.network.TwoSides;
 import com.powsybl.openloadflow.ac.equations.*;
-import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.equations.EquationTerm;
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.util.ComplexPart;
@@ -29,8 +28,10 @@ public AsymmetricalAcEquationSystemCreator(LfNetwork network, AcEquationSystemCr
     }
 
     @Override
-    protected void createBusEquation(LfBus bus, EquationSystem<AcVariableType, AcEquationType> equationSystem) {
-        super.createBusEquation(bus, equationSystem);
+    protected void createBusEquation(LfBus bus, AcEquationSystemCreationContext creationContext) {
+        super.createBusEquation(bus, creationContext);
+
+        var equationSystem = creationContext.getEquationSystem();
 
         // addition of asymmetric equations, supposing that existing v, theta, p and q are linked to the positive sequence
         LfAsymBus asymBus = bus.getAsym();
@@ -98,7 +99,9 @@ protected void createBusEquation(LfBus bus, EquationSystem<AcVariableType, AcEqu
     }
 
     @Override
-    protected void createImpedantBranch(LfBranch branch, LfBus bus1, LfBus bus2, EquationSystem<AcVariableType, AcEquationType> equationSystem) {
+    protected void createImpedantBranch(LfBranch branch, LfBus bus1, LfBus bus2, AcEquationSystemCreationContext creationContext) {
+        var equationSystem = creationContext.getEquationSystem();
+
         // positive sequence
         EquationTerm<AcVariableType, AcEquationType> p1 = null;
         EquationTerm<AcVariableType, AcEquationType> q1 = null;
@@ -171,7 +174,7 @@ protected void createImpedantBranch(LfBranch branch, LfBus bus1, LfBus bus2, Equ
         }
 
         // positive
-        createImpedantBranchEquations(branch, bus1, bus2, equationSystem, p1, q1, i1, p2, q2, i2, p1, q1, i1, p2, q2, i2, null, null, null, null, null, null);
+        createImpedantBranchEquations(branch, bus1, bus2, creationContext, p1, q1, i1, p2, q2, i2, p1, q1, i1, p2, q2, i2, null, null, null, null, null, null);
 
         // zero
         if (ixz1 != null) {
@@ -217,10 +220,10 @@ protected void createImpedantBranch(LfBranch branch, LfBus bus1, LfBus bus2, Equ
                     .addTerm(iyn2);
         }
 
-        createGeneratorReactivePowerControlBranchEquation(branch, bus1, bus2, equationSystem, deriveA1, deriveR1);
+        createGeneratorReactivePowerControlBranchEquation(branch, bus1, bus2, creationContext, deriveA1, deriveR1);
 
-        createTransformerPhaseControlEquations(branch, bus1, bus2, equationSystem, deriveA1, deriveR1);
+        createTransformerPhaseControlEquations(branch, bus1, bus2, creationContext, deriveA1, deriveR1);
 
-        createTransformerReactivePowerControlEquations(branch, equationSystem);
+        createTransformerReactivePowerControlEquations(branch, creationContext);
     }
 }

src/main/java/com/powsybl/openloadflow/ac/equations/vector/AbstractBranchVectorAcFlowEquationTerm.java

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021, RTE (http://www.rte-france.com)
+ * 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/.
+ */
+package com.powsybl.openloadflow.ac.equations.vector;
+
+import com.powsybl.openloadflow.ac.equations.AcEquationType;
+import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.equations.AbstractNamedEquationTerm;
+import com.powsybl.openloadflow.network.ElementType;
+
+import java.util.Objects;
+
+/**
+ * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
+ */
+public abstract class AbstractBranchVectorAcFlowEquationTerm extends AbstractNamedEquationTerm<AcVariableType, AcEquationType> {
+
+    protected final AcBranchVector branchVector;
+
+    protected final int num;
+
+    protected AbstractBranchVectorAcFlowEquationTerm(AcBranchVector branchVector, int num) {
+        super(!Objects.requireNonNull(branchVector).disabled[num]);
+        this.branchVector = Objects.requireNonNull(branchVector);
+        this.num = num;
+    }
+
+    @Override
+    public ElementType getElementType() {
+        return ElementType.BRANCH;
+    }
+
+    @Override
+    public int getElementNum() {
+        return num;
+    }
+}

src/main/java/com/powsybl/openloadflow/ac/equations/vector/AbstractClosedBranchVectorAcFlowEquationTerm.java

@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2019, RTE (http://www.rte-france.com)
+ * 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/.
+ */
+package com.powsybl.openloadflow.ac.equations.vector;
+
+import com.powsybl.math.matrix.DenseMatrix;
+import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.equations.Variable;
+import com.powsybl.openloadflow.equations.VariableSet;
+import com.powsybl.openloadflow.util.Fortescue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import static com.powsybl.openloadflow.ac.equations.AbstractClosedBranchAcFlowEquationTerm.getVoltageAngleType;
+import static com.powsybl.openloadflow.ac.equations.AbstractClosedBranchAcFlowEquationTerm.getVoltageMagnitudeType;
+import static com.powsybl.openloadflow.network.PiModel.A2;
+
+/**
+ * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
+ */
+public abstract class AbstractClosedBranchVectorAcFlowEquationTerm extends AbstractBranchVectorAcFlowEquationTerm {
+
+    protected final Variable<AcVariableType> v1Var;
+
+    protected final Variable<AcVariableType> v2Var;
+
+    protected final Variable<AcVariableType> ph1Var;
+
+    protected final Variable<AcVariableType> ph2Var;
+
+    protected final Variable<AcVariableType> a1Var;
+
+    protected final Variable<AcVariableType> r1Var;
+
+    protected final List<Variable<AcVariableType>> variables = new ArrayList<>();
+
+    protected AbstractClosedBranchVectorAcFlowEquationTerm(AcBranchVector branchVector, int branchNum, int bus1Num, int bus2Num,
+                                                           VariableSet<AcVariableType> variableSet, boolean deriveA1, boolean deriveR1,
+                                                           Fortescue.SequenceType sequenceType) {
+        super(branchVector, branchNum);
+        Objects.requireNonNull(variableSet);
+        AcVariableType vType = getVoltageMagnitudeType(sequenceType);
+        AcVariableType angleType = getVoltageAngleType(sequenceType);
+        v1Var = variableSet.getVariable(bus1Num, vType);
+        v2Var = variableSet.getVariable(bus2Num, vType);
+        ph1Var = variableSet.getVariable(bus1Num, angleType);
+        ph2Var = variableSet.getVariable(bus2Num, angleType);
+        a1Var = deriveA1 ? variableSet.getVariable(branchNum, AcVariableType.BRANCH_ALPHA1) : null;
+        r1Var = deriveR1 ? variableSet.getVariable(branchNum, AcVariableType.BRANCH_RHO1) : null;
+        variables.add(v1Var);
+        variables.add(v2Var);
+        variables.add(ph1Var);
+        variables.add(ph2Var);
+        if (a1Var != null) {
+            variables.add(a1Var);
+        }
+        if (r1Var != null) {
+            variables.add(r1Var);
+        }
+    }
+
+    public Variable<AcVariableType> getA1Var() {
+        return a1Var;
+    }
+
+    protected double v1() {
+        return sv.get(v1Var.getRow());
+    }
+
+    protected double v2() {
+        return sv.get(v2Var.getRow());
+    }
+
+    protected double ph1() {
+        return sv.get(ph1Var.getRow());
+    }
+
+    protected double ph2() {
+        return sv.get(ph2Var.getRow());
+    }
+
+    protected double r1() {
+        return r1Var != null ? sv.get(r1Var.getRow()) : branchVector.r1[num];
+    }
+
+    protected double a1() {
+        return a1Var != null ? sv.get(a1Var.getRow()) : branchVector.a1[num];
+    }
+
+    public static double theta1(double ksi, double ph1, double a1, double ph2) {
+        return ksi - a1 + A2 - ph1 + ph2;
+    }
+
+    public static double theta2(double ksi, double ph1, double a1, double ph2) {
+        return ksi + a1 - A2 + ph1 - ph2;
+    }
+
+    protected abstract double calculateSensi(double dph1, double dph2, double dv1, double dv2, double da1, double dr1);
+
+    @Override
+    public double calculateSensi(DenseMatrix dx, int column) {
+        Objects.requireNonNull(dx);
+        double dph1 = dx.get(ph1Var.getRow(), column);
+        double dph2 = dx.get(ph2Var.getRow(), column);
+        double dv1 = dx.get(v1Var.getRow(), column);
+        double dv2 = dx.get(v2Var.getRow(), column);
+        double da1 = a1Var != null ? dx.get(a1Var.getRow(), column) : 0;
+        double dr1 = r1Var != null ? dx.get(r1Var.getRow(), column) : 0;
+        return calculateSensi(dph1, dph2, dv1, dv2, da1, dr1);
+    }
+
+    @Override
+    public List<Variable<AcVariableType>> getVariables() {
+        return variables;
+    }
+}