GridCalEngine 5.3.22__tar.gz → 5.3.23__tar.gz

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Devices/Branches/line.py

@@ -551,7 +551,7 @@ class Line(BranchParent):
         return elm
 
     def fill_design_properties(self, r_ohm: float, x_ohm: float, c_nf: float, length: float,
-                               Imax: float, freq: float, Sbase: float, apply_to_profile: bool = True, ):
+                               Imax: float, freq: float, Sbase: float, apply_to_profile: bool = True, ) -> "Line":
         """
         Fill R, X, B from not-in-per-unit parameters
         :param r_ohm: Resistance per km in OHM/km

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -574,10 +574,10 @@ class OverheadLineType(EditableDevice):
         Bsh1 = self.y_seq[a1, a1].imag * 1e6
 
         z1 = (R1 + 1j * X1) * length / Zbase
-        y1 = 1j * Bsh1 * length * -1e6 / Ybase
+        y1 = 1j * Bsh1 * length * 1e-6 / Ybase
 
         z0 = (R0 + 1j * X0) * length / Zbase
-        y0 = 1j * Bsh0 * length * -1e6 / Ybase
+        y0 = 1j * Bsh0 * length * 1e-6 / Ybase
 
         if round_vals:
             R1 = np.round(z1.real, 6)
@@ -598,7 +598,7 @@ class OverheadLineType(EditableDevice):
             B0 = y0.imag
 
         z2 = (R0 + 1j * X0) * length / Zbase
-        y2 = 1j * Bsh0 * length * -1e6 / Ybase
+        y2 = 1j * Bsh0 * length * 1e-6 / Ybase
 
         # get the rating in MVA = kA * kV
         rate = self.Imax[circuit_index] * Vn * np.sqrt(3)

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Devices/Branches/transformer.py

@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 import numpy as np
-from typing import Tuple, Union, List
+from typing import Tuple
 
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Devices.Substation.bus import Bus
@@ -399,7 +399,8 @@ class Transformer2W(ControllableBranchParent):
 
         return errors
 
-    def fill_design_properties(self, Pcu: float, Pfe: float, I0: float, Vsc: float, Sbase: float, round_vals: bool=False):
+    def fill_design_properties(self, Pcu: float, Pfe: float, I0: float, Vsc: float, Sbase: float,
+                               round_vals: bool=False) -> "Transformer2W":
         """
         Fill R, X, G, B from the short circuit study values
         :param Pcu: copper_losses (kW)
@@ -410,9 +411,20 @@ class Transformer2W(ControllableBranchParent):
         :param round_vals: round the values?
         :return: self pointer
         """
+
+        if self.Sn > 0:
+            nominal_power = self.Sn
+        else:
+            if self.rate > 0:
+                nominal_power = self.rate
+                print(f"{self.name}: Using rate to set compute the impedances...please fill a valid nominal power")
+            else:
+                nominal_power = 1.0
+                print(f"{self.name}: Using 1 to set compute the impedances...please fill a valid nominal power")
+
         tpe = TransformerType(hv_nominal_voltage=self.HV,
                               lv_nominal_voltage=self.LV,
-                              nominal_power=self.rate,
+                              nominal_power=nominal_power,
                               copper_losses=Pcu,
                               iron_losses=Pfe,
                               no_load_current=I0,
@@ -421,6 +433,11 @@ class Transformer2W(ControllableBranchParent):
                               gx_hv1=0.5,
                               name='type from ' + self.name)
 
+        self.Pcu = Pcu
+        self.Pfe = Pfe
+        self.I0 = I0
+        self.Vsc = Vsc
+
         z_series, y_shunt = tpe.get_impedances(VH=self.HV, VL=self.LV, Sbase=Sbase)
 
         if round_vals:

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Devices/Branches/transformer_type.py

@@ -3,7 +3,7 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 from typing import Tuple, Union
-from numpy import sqrt, real, imag
+from numpy import sqrt
 from GridCalEngine.enumerations import TapChangerTypes
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
 from GridCalEngine.Devices.Branches.tap_changer import TapChanger

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Devices/assets.py

@@ -586,7 +586,7 @@ class Assets:
         """
         return self._lines
 
-    def add_line(self, obj: dev.Line, logger: Union[Logger, DataLogger] = Logger()):
+    def add_line(self, obj: dev.Line, logger: Union[Logger, DataLogger] = Logger()) -> dev.Line:
         """
         Add a line object
         :param obj: Line instance
@@ -696,7 +696,7 @@ class Assets:
         """
         return [elm.name for elm in self._transformers2w]
 
-    def add_transformer2w(self, obj: dev.Transformer2W):
+    def add_transformer2w(self, obj: dev.Transformer2W) -> dev.Transformer2W:
         """
         Add a transformer object
         :param obj: Transformer2W instance
@@ -705,6 +705,7 @@ class Assets:
         if self.time_profile is not None:
             obj.ensure_profiles_exist(self.time_profile)
         self._transformers2w.append(obj)
+        return obj
 
     def delete_transformer2w(self, obj: dev.Transformer2W):
         """

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Devices/multi_circuit.py

@@ -2019,11 +2019,21 @@ class MultiCircuit(Assets):
         else:
             nt = self.get_time_number()
 
-        if self.snapshot_time != base_grid.snapshot_time:
+        if (self.snapshot_time.second != base_grid.snapshot_time.second or
+            self.snapshot_time.minute != base_grid.snapshot_time.minute or
+            self.snapshot_time.hour != base_grid.snapshot_time.hour or
+            self.snapshot_time.day != base_grid.snapshot_time.day or 
+            self.snapshot_time.month != base_grid.snapshot_time.month or
+            self.snapshot_time.year != base_grid.snapshot_time.year):
             logger.add_error(msg="Different snapshot times",
                              device_class="snapshot time",
                              value=str(base_grid.get_snapshot_time_unix),
                              expected_value=self.get_snapshot_time_unix)
+        # if self.snapshot_time != base_grid.snapshot_time:
+        #     logger.add_error(msg="Different snapshot times",
+        #                      device_class="snapshot time",
+        #                      value=str(base_grid.get_snapshot_time_unix),
+        #                      expected_value=self.get_snapshot_time_unix)
 
         # --------------------------------------------------------------------------------------------------------------
         # Pass 1: compare this grid with the base to discover added and modified elements

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Simulations/PowerFlow/Formulations/pf_advanced_formulation.py

@@ -206,7 +206,6 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         self.pv = np.array(0, dtype=int)
         self.pqv = np.array(0, dtype=int)
         self.p = np.array(0, dtype=int)
-        self.idx_conv = np.array(0, dtype=int)
 
         self.idx_dVa = np.array(0, dtype=int)
         self.idx_dVm = np.array(0, dtype=int)
@@ -282,19 +281,13 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         k_pt_tau = list()
         k_qf_m = list()
         k_qt_m = list()
-        k_qfzero_beq = list()
         k_v_m = list()
-        # k_v_beq = list()
-        k_vsc = list()
 
         nbr = len(self.tap_phase_control_mode)
         for k in range(nbr):
 
             ctrl_m = self.tap_module_control_mode[k]
             ctrl_tau = self.tap_phase_control_mode[k]
-            # is_conv = self.nc.passive_branch_data.is_converter[k]
-
-            # conv_type = 1 if is_conv else 0
 
             # analyze tap-module controls
             if ctrl_m == TapModuleControl.Vm:
@@ -324,18 +317,12 @@ class PfAdvancedFormulation(PfFormulationTemplate):
             # analyze tap-phase controls
             if ctrl_tau == TapPhaseControl.Pf:
                 k_pf_tau.append(k)
-                # conv_type = 1
 
             elif ctrl_tau == TapPhaseControl.Pt:
                 k_pt_tau.append(k)
-                # conv_type = 1
 
             elif ctrl_tau == TapPhaseControl.fixed:
-                # if ctrl_m == TapModuleControl.fixed:
-                #     conv_type = 1
                 pass
-            # elif ctrl_tau == TapPhaseControl.Droop:
-            #     pass
 
             elif ctrl_tau == 0:
                 pass
@@ -344,23 +331,17 @@ class PfAdvancedFormulation(PfFormulationTemplate):
                 raise Exception(f"Unknown tap phase control mode {ctrl_tau}")
 
         # turn the lists into the final arrays
-        self.idx_conv = np.array(k_vsc, dtype=int)
-
         self.idx_dm = np.r_[k_v_m, k_qf_m, k_qt_m].astype(int)
         self.idx_dtau = np.r_[k_pf_tau, k_pt_tau].astype(int)
-        # self.idx_dbeq = np.r_[k_qfzero_beq, k_v_beq].astype(int)
 
         self.idx_dPf = np.array(k_pf_tau, dtype=int)
-        self.idx_dQf = np.r_[k_qf_m, k_qfzero_beq].astype(int)
+        self.idx_dQf = np.array(k_qf_m, dtype=int)
 
         self.idx_dPt = np.array(k_pt_tau, dtype=int)
         self.idx_dQt = np.array(k_qt_m, dtype=int)
 
         self.m: Vec = self.nc.active_branch_data.tap_module[self.idx_dm]
         self.tau: Vec = self.nc.active_branch_data.tap_angle[self.idx_dtau]
-        # self.beq: Vec = self.nc.passive_branch_data.Beq[self.idx_dbeq]
-
-        # self.Gsw = self.nc.passive_branch_data.G0sw[self.idx_conv]
 
         return k_v_m
 
@@ -373,14 +354,12 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         b = a + len(self.idx_dVm)
         c = b + len(self.idx_dm)
         d = c + len(self.idx_dtau)
-        # e = d + len(self.idx_dbeq)
 
         # update the vectors
         self.Va[self.idx_dVa] = x[0:a]
         self.Vm[self.idx_dVm] = x[a:b]
         self.m = x[b:c]
         self.tau = x[c:d]
-        # self.beq = x[d:e]
 
     def var2x(self) -> Vec:
         """
@@ -391,8 +370,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
             self.Va[self.idx_dVa],
             self.Vm[self.idx_dVm],
             self.m,
-            self.tau,
-            # self.beq,
+            self.tau
         ]
 
     def size(self) -> int:
@@ -400,12 +378,12 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         Size of the jacobian matrix
         :return:
         """
-        return (len(self.idx_dVa)
+        return (
+                len(self.idx_dVa)
                 + len(self.idx_dVm)
                 + len(self.idx_dm)
                 + len(self.idx_dtau)
-                # + len(self.idx_dbeq)
-                )
+        )
 
     def check_error(self, x: Vec) -> Tuple[float, Vec]:
         """
@@ -417,7 +395,6 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         b = a + len(self.idx_dVm)
         c = b + len(self.idx_dm)
         d = c + len(self.idx_dtau)
-        # e = d + len(self.idx_dbeq)
 
         # update the vectors
         Va = self.Va.copy()
@@ -426,7 +403,6 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         Vm[self.idx_dVm] = x[a:b]
         m = x[b:c]
         tau = x[c:d]
-        # beq = x[d:e]
 
         # recompute admittances
         adm = compute_admittances(
@@ -450,16 +426,6 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         # compute the complex voltage
         V = polar_to_rect(Vm, Va)
 
-        # Update converter losses
-        # It = get_It(k=self.idx_conv, V=V, ytf=adm.ytf, ytt=adm.ytt, F=F, T=T)
-        # Itm = np.abs(It)
-        # Itm2 = Itm * Itm
-        # PLoss_IEC = (self.nc.passive_branch_data.alpha3[self.idx_conv] * Itm2
-        #              + self.nc.passive_branch_data.alpha2[self.idx_conv] * Itm2
-        #              + self.nc.passive_branch_data.alpha1[self.idx_conv])
-        #
-        # self.Gsw = PLoss_IEC / np.power(Vm[F[self.idx_conv]], 2.0)
-
         # compute the function residual
         Sbus = compute_zip_power(self.S0, self.I0, self.Y0, Vm)
         Scalc = compute_power(adm.Ybus, V)
@@ -468,7 +434,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
 
         F = self.nc.passive_branch_data.F
         T = self.nc.passive_branch_data.T
-        
+
         Pf = get_Sf(k=self.idx_dPf, Vm=Vm, V=V,
                     yff=adm.yff, yft=adm.yft, F=F, T=T).real
 
@@ -525,16 +491,6 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         # compute the complex voltage
         self.V = polar_to_rect(self.Vm, self.Va)
 
-        # Update converter losses
-        # It = get_It(k=self.idx_conv, V=self.V, ytf=self.adm.ytf, ytt=self.adm.ytt, F=F, T=T)
-        # Itm = np.abs(It)
-        # Itm2 = Itm * Itm
-        # PLoss_IEC = (self.nc.passive_branch_data.alpha3[self.idx_conv] * Itm2
-        #              + self.nc.passive_branch_data.alpha2[self.idx_conv] * Itm2
-        #              + self.nc.passive_branch_data.alpha1[self.idx_conv])
-        #
-        # self.Gsw = PLoss_IEC / np.power(self.Vm[F[self.idx_conv]], 2.0)
-
         # compute the function residual
         Sbus = compute_zip_power(self.S0, self.I0, self.Y0, self.Vm)
         self.Scalc = compute_power(self.adm.Ybus, self.V)
@@ -693,10 +649,10 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         self.Scalc = compute_power(self.adm.Ybus, self.V)
 
         dS = self.Scalc - Sbus  # compute the mismatch
-        
+
         F = self.nc.passive_branch_data.F
         T = self.nc.passive_branch_data.T
-        
+
         Pf = get_Sf(k=self.idx_dPf, Vm=self.Vm, V=self.V,
                     yff=self.adm.yff, yft=self.adm.yft, F=F, T=T).real
 
@@ -736,13 +692,11 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         Vm = self.Vm.copy()
         m = np.ones(self.nc.nbr, dtype=float)
         tau = np.zeros(self.nc.nbr, dtype=float)
-        beq = np.zeros(self.nc.nbr, dtype=float)
 
         Va[self.idx_dVa] = x[0:a]
         Vm[self.idx_dVm] = x[a:b]
         m[self.idx_dm] = x[b:c]
         tau[self.idx_dtau] = x[c:d]
-        # beq[self.idx_dbeq] = x[d:e]
 
         # compute the complex voltage
         V = polar_to_rect(Vm, Va)

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/Simulations/PowerFlow/power_flow_results.py

@@ -308,7 +308,7 @@ class PowerFlowResults(ResultsTemplate):
         :param nc:
         :return:
         """
-        rates = nc.Rates
+        rates = nc.passive_branch_data.rates
         self.loading = self.Sf / (rates + 1e-9)
 
     @property
@@ -437,7 +437,7 @@ class PowerFlowResults(ResultsTemplate):
     def get_bus_df(self) -> pd.DataFrame:
         """
         Get a DataFrame with the buses results
-        :return: DataFrame
+        :return: DataFrame, Vm in p.u., Va in deg, P in MW, Q in MVAr
         """
         return pd.DataFrame(data={'Vm': np.abs(self.voltage),
                                   'Va': np.angle(self.voltage, deg=True),
@@ -448,7 +448,7 @@ class PowerFlowResults(ResultsTemplate):
     def get_branch_df(self) -> pd.DataFrame:
         """
         Get a DataFrame with the branches results
-        :return: DataFrame
+        :return: DataFrame, Pf in MW, Qf in MVAr, Pt in MW, Qt in MVAr, loading in %, Ploss in MW, Qloss in MVAr
         """
         return pd.DataFrame(data={'Pf': self.Sf.real,
                                   'Qf': self.Sf.imag,
@@ -462,9 +462,9 @@ class PowerFlowResults(ResultsTemplate):
 
     def mdl(self, result_type: ResultTypes) -> ResultsTable:
         """
-
-        :param result_type:
-        :return:
+        get the ResultsTable model
+        :param result_type: ResultTypes
+        :return: ResultsTable instance
         """
 
         if result_type == ResultTypes.BusVoltageModule:

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/GridCalEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # do not forget to keep a three-number version!!!
-__GridCalEngine_VERSION__ = "5.3.22"
+__GridCalEngine_VERSION__ = "5.3.23"
 
 url = 'https://github.com/SanPen/GridCal'
 

{gridcalengine-5.3.22 → gridcalengine-5.3.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCalEngine
-Version: 5.3.22
+Version: 5.3.23
 Summary: GridCal is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/GridCal
 Author: Santiago Peñate Vera et. Al.