PyPI - GridCalEngine - Versions diffs - 5.4.0b1__tar.gz → 5.4.0b2__tar.gz - Mend

Files changed (835) hide show

{gridcalengine-5.4.0b1 → gridcalengine-5.4.0b2}/GridCalEngine/Compilers/circuit_to_data.py RENAMED Viewed

@@ -57,30 +57,13 @@ def delta2StarAdmittance(Yab: complex,
     :param Yca:
     :return: Ya, Yb, Yc
     """
-    return np.array([
-        (Yab * Ybc + Ybc * Yca + Yca * Yab) / (Ybc + 1e-20),
-        (Yab * Ybc + Ybc * Yca + Yca * Yab) / (Yca + 1e-20),
-        (Yab * Ybc + Ybc * Yca + Yca * Yab) / (Yab + 1e-20)
+    return 1 / 3 * np.array([
+        [Yab + Yca, -Yab, -Yca],
+        [-Yab, Yab + Ybc, -Ybc],
+        [-Yca, -Ybc, Ybc + Yca]
     ])
-# def delta2StarCurrent(Iab: complex,
-#                       Ibc: complex,
-#                       Ica: complex):
-#     """
-#     Converts delta to star in currents
-#     :param Iab:
-#     :param Ibc:
-#     :param Ica:
-#     :return: Ia, Ib, Ic
-#     """
-#     return np.array([
-#         Iab - Ica,
-#         Ibc - Iab,
-#         Ica - Ibc
-#     ])
 def set_bus_control_voltage(i: int,
                             j: int,
                             remote_control: bool,
@@ -356,18 +339,25 @@ def get_load_data(data: LoadData,
                         data.I3_star[3 * ii + 1] = complex(elm.Ir2_prof[t_idx], elm.Ii2_prof[t_idx])
                         data.I3_star[3 * ii + 2] = complex(elm.Ir3_prof[t_idx], elm.Ii3_prof[t_idx])
-                        data.Y3_star[3 * ii + 0] = complex(elm.G1_prof[t_idx], elm.B1_prof[t_idx])
-                        data.Y3_star[3 * ii + 1] = complex(elm.G2_prof[t_idx], elm.B2_prof[t_idx])
-                        data.Y3_star[3 * ii + 2] = complex(elm.G3_prof[t_idx], elm.B3_prof[t_idx])
+                        data.Y3_star[3 * ii + 0, 0] = complex(elm.G1_prof[t_idx], elm.B1_prof[t_idx])
+                        data.Y3_star[3 * ii + 1, 1] = complex(elm.G2_prof[t_idx], elm.B2_prof[t_idx])
+                        data.Y3_star[3 * ii + 2, 2] = complex(elm.G3_prof[t_idx], elm.B3_prof[t_idx])
                     elif elm.conn == ShuntConnectionType.Delta:
                         data.S3_delta[3 * ii + 0] = complex(elm.Pa_prof[t_idx], elm.Qa_prof[t_idx])
                         data.S3_delta[3 * ii + 1] = complex(elm.Pb_prof[t_idx], elm.Qb_prof[t_idx])
                         data.S3_delta[3 * ii + 2] = complex(elm.Pc_prof[t_idx], elm.Qc_prof[t_idx])
-                        data.Y3_delta[3 * ii + 0] = complex(elm.G1_prof[t_idx], elm.B1_prof[t_idx])
-                        data.Y3_delta[3 * ii + 1] = complex(elm.G2_prof[t_idx], elm.B2_prof[t_idx])
-                        data.Y3_delta[3 * ii + 2] = complex(elm.G3_prof[t_idx], elm.B3_prof[t_idx])
+                        if elm.G1 > 0 and elm.G2 > 0 and elm.G3 > 0:
+                            data.Y3_star[3 * ii:3 * ii + 3, [0, 1, 2]] = delta2StarAdmittance(
+                                Yab=complex(elm.G1_prof[t_idx], -elm.B1_prof[t_idx]),
+                                Ybc=complex(elm.G2_prof[t_idx], -elm.B2_prof[t_idx]),
+                                Yca=complex(elm.G3_prof[t_idx], -elm.B3_prof[t_idx])
+                            )
+                        else:
+                            data.Y3_delta[3 * ii + 0] = complex(elm.G1_prof[t_idx], -elm.B1_prof[t_idx])
+                            data.Y3_delta[3 * ii + 1] = complex(elm.G2_prof[t_idx], -elm.B2_prof[t_idx])
+                            data.Y3_delta[3 * ii + 2] = complex(elm.G3_prof[t_idx], -elm.B3_prof[t_idx])
                         data.I3_delta[3 * ii + 0] = complex(elm.Ir1_prof[t_idx], elm.Ii1_prof[t_idx])
                         data.I3_delta[3 * ii + 1] = complex(elm.Ir2_prof[t_idx], elm.Ii2_prof[t_idx])
@@ -400,9 +390,9 @@ def get_load_data(data: LoadData,
                             data.I3_star[3 * ii + 1] = complex(elm.Ir2, elm.Ii2)
                             data.I3_star[3 * ii + 2] = complex(elm.Ir3, elm.Ii3)
-                            data.Y3_star[3 * ii + 0] = complex(elm.G1, -elm.B1) * 3
-                            data.Y3_star[3 * ii + 1] = complex(elm.G2, -elm.B2) * 3
-                            data.Y3_star[3 * ii + 2] = complex(elm.G3, -elm.B3) * 3
+                            data.Y3_star[3 * ii + 0, 0] = complex(elm.G1, -elm.B1)
+                            data.Y3_star[3 * ii + 1, 1] = complex(elm.G2, -elm.B2)
+                            data.Y3_star[3 * ii + 2, 2] = complex(elm.G3, -elm.B3)
                         elif elm.conn == ShuntConnectionType.Delta:
                             data.S3_delta[3 * ii + 0] = complex(elm.Pa, elm.Qa)
@@ -410,7 +400,7 @@ def get_load_data(data: LoadData,
                             data.S3_delta[3 * ii + 2] = complex(elm.Pc, elm.Qc)
                             if elm.G1 > 0 and elm.G2 > 0 and elm.G3 > 0:
-                                data.Y3_star[3 * ii + idx3] = delta2StarAdmittance(
+                                data.Y3_star[3*ii:3*ii+3, [0,1,2]] = delta2StarAdmittance(
                                     Yab=complex(elm.G1, -elm.B1),
                                     Ybc=complex(elm.G2, -elm.B2),
                                     Yca=complex(elm.G3, -elm.B3)
@@ -746,13 +736,13 @@ def get_shunt_data(
                 if fill_three_phase:
                     if elm.conn == ShuntConnectionType.Star or elm.conn == ShuntConnectionType.GroundedStar:
-                        data.Y3_star[3 * ii + 0] = complex(elm.Ga_prof[t_idx], elm.Ba_prof[t_idx])
-                        data.Y3_star[3 * ii + 1] = complex(elm.Gb_prof[t_idx], elm.Bb_prof[t_idx])
-                        data.Y3_star[3 * ii + 2] = complex(elm.Gc_prof[t_idx], elm.Bc_prof[t_idx])
+                        data.Y3_star[3 * ii + 0, 0] = complex(elm.Ga_prof[t_idx], elm.Ba_prof[t_idx])
+                        data.Y3_star[3 * ii + 1, 1] = complex(elm.Gb_prof[t_idx], elm.Bb_prof[t_idx])
+                        data.Y3_star[3 * ii + 2, 2] = complex(elm.Gc_prof[t_idx], elm.Bc_prof[t_idx])
                     elif elm.conn == ShuntConnectionType.Delta:
-                        data.Y3_star[3 * ii + idx3] = delta2StarAdmittance(
+                        data.Y3_star[3*ii:3*ii+3, [0,1,2]] = delta2StarAdmittance(
                             Yab=complex(elm.Ga_prof[t_idx], elm.Ba_prof[t_idx]),
                             Ybc=complex(elm.Gb_prof[t_idx], elm.Bb_prof[t_idx]),
                             Yca=complex(elm.Gc_prof[t_idx], elm.Bc_prof[t_idx])
@@ -769,13 +759,13 @@ def get_shunt_data(
                     if elm.conn == ShuntConnectionType.Star or elm.conn == ShuntConnectionType.GroundedStar:
-                        data.Y3_star[3 * ii + 0] = complex(elm.Ga, elm.Ba)
-                        data.Y3_star[3 * ii + 1] = complex(elm.Gb, elm.Bb)
-                        data.Y3_star[3 * ii + 2] = complex(elm.Gc, elm.Bc)
+                        data.Y3_star[3 * ii + 0, 0] = complex(elm.Ga, elm.Ba)
+                        data.Y3_star[3 * ii + 1, 1] = complex(elm.Gb, elm.Bb)
+                        data.Y3_star[3 * ii + 2, 2] = complex(elm.Gc, elm.Bc)
                     elif elm.conn == ShuntConnectionType.Delta:
-                        data.Y3_star[3 * ii + idx3] = delta2StarAdmittance(
+                        data.Y3_star[3*ii:3*ii+3, [0,1,2]] = delta2StarAdmittance(
                             Yab=complex(elm.Ga, elm.Ba),
                             Ybc=complex(elm.Gb, elm.Bb),
                             Yca=complex(elm.Gc, elm.Bc)
@@ -822,13 +812,13 @@ def get_shunt_data(
                 if fill_three_phase:
                     if elm.conn == ShuntConnectionType.Star or elm.conn == ShuntConnectionType.GroundedStar:
-                        data.Y3_star[3 * ii + 0] = complex(elm.Ga_prof[t_idx], elm.Ba_prof[t_idx])
-                        data.Y3_star[3 * ii + 1] = complex(elm.Gb_prof[t_idx], elm.Bb_prof[t_idx])
-                        data.Y3_star[3 * ii + 2] = complex(elm.Gc_prof[t_idx], elm.Bc_prof[t_idx])
+                        data.Y3_star[3 * ii + 0, 0] = complex(elm.Ga_prof[t_idx], elm.Ba_prof[t_idx])
+                        data.Y3_star[3 * ii + 1, 1] = complex(elm.Gb_prof[t_idx], elm.Bb_prof[t_idx])
+                        data.Y3_star[3 * ii + 2, 2] = complex(elm.Gc_prof[t_idx], elm.Bc_prof[t_idx])
                     elif elm.conn == ShuntConnectionType.Delta:
-                        data.Y3_star[3 * ii + idx3] = delta2StarAdmittance(
+                        data.Y3_star[3*ii:3*ii+3, [0,1,2]] = delta2StarAdmittance(
                             Yab=complex(elm.Ga_prof[t_idx], elm.Ba_prof[t_idx]),
                             Ybc=complex(elm.Gb_prof[t_idx], elm.Bb_prof[t_idx]),
                             Yca=complex(elm.Gc_prof[t_idx], elm.Bc_prof[t_idx])
@@ -867,13 +857,13 @@ def get_shunt_data(
                     if elm.conn == ShuntConnectionType.Star or elm.conn == ShuntConnectionType.GroundedStar:
-                        data.Y3_star[3 * ii + 0] = complex(elm.Ga, elm.Ba)
-                        data.Y3_star[3 * ii + 1] = complex(elm.Gb, elm.Bb)
-                        data.Y3_star[3 * ii + 2] = complex(elm.Gc, elm.Bc)
+                        data.Y3_star[3 * ii + 0, 0] = complex(elm.Ga, elm.Ba)
+                        data.Y3_star[3 * ii + 1, 1] = complex(elm.Gb, elm.Bb)
+                        data.Y3_star[3 * ii + 2, 2] = complex(elm.Gc, elm.Bc)
                     elif elm.conn == ShuntConnectionType.Delta:
-                        data.Y3_star[3 * ii + idx3] = delta2StarAdmittance(
+                        data.Y3_star[3*ii:3*ii+3, [0,1,2]] = delta2StarAdmittance(
                             Yab=complex(elm.Ga, elm.Ba),
                             Ybc=complex(elm.Gb, elm.Bb),
                             Yca=complex(elm.Gc, elm.Bc)
@@ -2370,7 +2360,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
         opf_results=opf_results,
         use_stored_guess=use_stored_guess,
         control_remote_voltage=control_remote_voltage,
-        fill_three_phase= fill_three_phase
+        fill_three_phase=fill_three_phase
     )
     get_battery_data(

@@ -615,7 +615,7 @@ def get_bentayga_pf_options(opt: PowerFlowOptions):
     :return:
     """
     solver_dict = {SolverType.NR: btg.PowerFlowSolvers.NewtonRaphson,
-                   SolverType.DC: btg.PowerFlowSolvers.LinearDc,
+                   SolverType.Linear: btg.PowerFlowSolvers.LinearDc,
                    # SolverType.HELM: nn.NativeSolverType.HELM,
                    # SolverType.IWAMOTO: nn.NativeSolverType.IWAMOTO,
                    SolverType.LM: btg.PowerFlowSolvers.LevenbergMarquardt,

@@ -2240,7 +2240,7 @@ def get_gslv_pf_options(opt: PowerFlowOptions) -> "pg.PowerFlowOptions":
     :return:
     """
     solver_dict = {SolverType.NR: pg.SolverType.NR,
-                   SolverType.DC: pg.SolverType.DC,
+                   SolverType.Linear: pg.SolverType.DC,
                    SolverType.HELM: pg.SolverType.HELM,
                    SolverType.IWAMOTO: pg.SolverType.IWAMOTO,
                    SolverType.LM: pg.SolverType.LM,

@@ -1107,7 +1107,7 @@ def get_newton_pa_pf_options(opt: PowerFlowOptions) -> "npa.PowerFlowOptions":
     :return:
     """
     solver_dict = {SolverType.NR: npa.SolverType.NR,
-                   SolverType.DC: npa.SolverType.DC,
+                   SolverType.Linear: npa.SolverType.Linear,
                    SolverType.HELM: npa.SolverType.HELM,
                    SolverType.IWAMOTO: npa.SolverType.IWAMOTO,
                    SolverType.LM: npa.SolverType.LM,

@@ -37,7 +37,7 @@ class LoadData:
         self.I3_star = np.zeros(self.nelm * 3, dtype=complex)
         self.Y3_delta = np.zeros(self.nelm * 3, dtype=complex)
-        self.Y3_star = np.zeros(self.nelm * 3, dtype=complex)
+        self.Y3_star = np.zeros((self.nelm * 3, 3), dtype=complex)
         # reliability
         self.mttf: Vec = np.zeros(nelm, dtype=float)

@@ -829,11 +829,14 @@ class NumericalCircuit:
             Ct=self.passive_branch_data.Ct.tocsc(),
         )
-    def get_linear_admittance_matrices(self, indices: SimulationIndices) -> ycalc.LinearAdmittanceMatrices:
+    def get_linear_admittance_matrices(self, indices: SimulationIndices | None = None) -> ycalc.LinearAdmittanceMatrices:
         """
-        :return:
+        Get the linear admittances
+        :return:LinearAdmittanceMatrices
         """
+        if indices is None:
+            indices = self.get_simulation_indices()
         return ycalc.compute_linear_admittances(
             nbr=self.nbr,
             X=self.passive_branch_data.X,

@@ -34,7 +34,7 @@ class ShuntData:
         self.Y: CxVec = np.zeros(nelm, dtype=complex)
         # self.Y3_delta = np.zeros(self.nelm * 3, dtype=complex)
-        self.Y3_star = np.zeros(self.nelm * 3, dtype=complex)
+        self.Y3_star = np.zeros((self.nelm * 3, 3), dtype=complex)
         self.qmin: Vec = np.zeros(nelm, dtype=float)
         self.qmax: Vec = np.zeros(nelm, dtype=float)

@@ -673,7 +673,7 @@ class Line(BranchParent):
         :param Imax: Maximum current in kA
         :param freq: System frequency in Hz
         :param Sbase: Base power in MVA (take always 100 MVA)
-        :param apply_to_profile: modify the profile is checked
+        :param apply_to_profile: modify the ratings profile if checked
         :return self pointer
         """
         self.R, self.X, self.B, new_rate = get_line_impedances_with_c(r_ohm=r_ohm,
@@ -691,8 +691,11 @@ class Line(BranchParent):
         self._length = length
         if apply_to_profile:
-            prof_old = self.rate_prof.toarray()
-            self.rate_prof.set(prof_old * new_rate / old_rate)
+            if old_rate != 0.0:
+                prof_old = self.rate_prof.toarray()
+                self.rate_prof.set(prof_old * new_rate / old_rate)
+            else:
+                self.rate_prof.fill(new_rate)
         return self

@@ -28,7 +28,7 @@ class Battery(Generator):
         'energy',
     )
-    def __init__(self, name='batt', idtag=None, P=0.0, power_factor=0.8, vset=1.0,
+    def __init__(self, name='batt', idtag=None, code="", P=0.0, power_factor=0.8, vset=1.0,
                  is_controlled=True, Qmin=-9999, Qmax=9999, Snom=9999, Enom=9999,
                  Pmin=-9999, Pmax=9999,
                  Cost=1.0, active=True, Sbase=100,
@@ -77,6 +77,7 @@ class Battery(Generator):
         """
         Generator.__init__(self, name=name,
                            idtag=idtag,
+                           code=code,
                            P=P,
                            power_factor=power_factor,
                            vset=vset,

@@ -100,8 +100,19 @@ class BranchParent(PhysicalDevice):
                                 device_type=device_type)
         # connectivity
-        self._bus_from = bus_from
-        self._bus_to = bus_to
+        if bus_from is None:
+            self._bus_from = None
+        elif isinstance(bus_from, Bus):
+            self._bus_from = bus_from
+        else:
+            raise Exception(f"Bus from is a strange value {bus_from}")
+        if bus_to is None:
+            self._bus_to = None
+        elif isinstance(bus_to, Bus):
+            self._bus_to = bus_to
+        else:
+            raise Exception(f"Bus from is a strange value {bus_from}")
         self.active = bool(active)
         self._active_prof = Profile(default_value=self.active, data_type=bool)

@@ -3,8 +3,10 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 # from GridCalEngine.Devices.Parents.editable_device import EditableDevice
-from GridCalEngine.Devices.measurement import (PiMeasurement, PfMeasurement, QiMeasurement, QfMeasurement,
-                                               VmMeasurement, VmMeasurement, IfMeasurement, IfMeasurement)
+from GridCalEngine.Devices.measurement import (PiMeasurement, PfMeasurement, PtMeasurement,
+                                               QiMeasurement, QfMeasurement, QtMeasurement,
+                                               VmMeasurement, VaMeasurement,
+                                               IfMeasurement, ItMeasurement)
 from GridCalEngine.Devices.Aggregation import *
 from GridCalEngine.Devices.Branches import *

GridCalEngine 5.4.0b1__tar.gz → 5.4.0b2__tar.gz

GridCalEngine 5.4.0b1tar.gz → 5.4.0b2tar.gz