GridCalEngine 5.2.0__tar.gz → 5.2.1__tar.gz

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/DataStructures/branch_data.py

@@ -200,7 +200,7 @@ class BranchData:
 
             if data.F[k] == -1:
                 if logger is not None:
-                    logger.add_error(f"Branch {k}, {self.names[k]} if connected to a disconnected node",
+                    logger.add_error(f"Branch {k}, {self.names[k]} is connected to a disconnected node",
                                      value=data.F[k])
                 data.active[k] = 0
 
@@ -208,7 +208,7 @@ class BranchData:
 
             if data.T[k] == -1:
                 if logger is not None:
-                    logger.add_error(f"Branch {k}, {self.names[k]} if connected to a disconnected node",
+                    logger.add_error(f"Branch {k}, {self.names[k]} is connected to a disconnected node",
                                      value=data.T[k])
                 data.active[k] = 0
 
@@ -307,7 +307,7 @@ class BranchData:
         Get the series admittance of the branches
         :return: complex vector
         """
-        return 1.0 / (self.R + 1j * self.X)
+        return 1.0 / (self.R + 1.0j * self.X + 1e-20)
 
     def get_island(self, bus_idx: Vec) -> IntVec:
         """
@@ -336,13 +336,6 @@ class BranchData:
         """
         return np.where(self.dc != 0)[0]
 
-    def get_series_admittance(self) -> CxVec:
-        """
-
-        :return:
-        """
-        return 1.0 / (self.R + 1.0j * self.X + 1e-20)
-
     def get_linear_series_admittance(self) -> Vec:
         """
         Get the linear version of the series admittance for ACDC systems

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/DataStructures/numerical_circuit.py

@@ -25,7 +25,7 @@ from GridCalEngine.Devices.Aggregation.investment import Investment
 from GridCalEngine.Devices.Aggregation.contingency import Contingency
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
-    from GridCalEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
+    pass
 
 ALL_STRUCTS = Union[
     ds.BusData,
@@ -66,7 +66,7 @@ def CheckArr(arr: Vec | IntVec | BoolVec | CxVec, arr_expected: Vec | IntVec | B
     if np.allclose(arr, arr_expected, atol=tol):
         return 0
     else:
-        if arr.dtype == np.bool:
+        if arr.dtype == np.bool_:
             diff = arr.astype(int) - arr_expected.astype(int)
             logger.add_error(msg="Numeric differences",
                              device=name,
@@ -1392,7 +1392,7 @@ class NumericalCircuit:
         # idx_dPt = self.simulation_indices_.k_pt_tau
         # idx_dQt = self.simulation_indices_.k_qt_m
 
-        from GridCalEngine.Simulations.PowerFlow.NumericalMethods.pf_advanced_formulation import (
+        from GridCalEngine.Simulations.PowerFlow.Formulations.pf_advanced_formulation import (
             PfAdvancedFormulation)
         from GridCalEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions
 

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Aggregation/facility.py

@@ -5,10 +5,10 @@
 
 
 from typing import Union
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.Devices.Aggregation.area import GenericAreaGroup, DeviceType
 
 
-class Facility(EditableDevice):
+class Facility(GenericAreaGroup):
     """
     This is an aggregation of Injection devices
     """
@@ -22,14 +22,10 @@ class Facility(EditableDevice):
         :param latitude: latitude (deg)
         :param longitude: longitude (deg)
         """
-        EditableDevice.__init__(self,
-                                name=name,
-                                code=code,
-                                idtag=idtag,
-                                device_type=DeviceType.FacilityDevice)
-
-        self.latitude = float(latitude)
-        self.longitude = float(longitude)
-
-        self.register(key='longitude', units='deg', tpe=float, definition='longitude.')
-        self.register(key='latitude', units='deg', tpe=float, definition='latitude.')
+        GenericAreaGroup.__init__(self,
+                                  name=name,
+                                  idtag=idtag,
+                                  code=code,
+                                  device_type=DeviceType.FacilityDevice,
+                                  latitude=latitude,
+                                  longitude=longitude)

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Branches/hvdc_line.py

@@ -141,27 +141,40 @@ class HvdcLine(BranchParent):
                  dispatchable=True, angle_droop=0,
                  capex=0, opex=0,
                  build_status: BuildStatus = BuildStatus.Commissioned,
-                 dc_link_voltage: float = 200):
+                 dc_link_voltage: float = 200.0):
         """
         HVDC Line model
         :param bus_from: Bus from
-        :param bus_to: Bus to
-        :param idtag: id tag of the line
+        :param bus_to:  Bus to
+        :param cn_from: Connectivity node from
+        :param cn_to: Connectivity node to
         :param name: name of the line
-        :param active: Is the line active?
-        :param rate: Line rate in MVA
-        :param Pset: Active power set point
-        :param loss_factor: Losses factor (p.u.)
+        :param idtag:  id tag of the line
+        :param active:  Is the line active?
+        :param code: Secondary code for compatibilty
+        :param rate:  Line rate in MVA
+        :param Pset:  Active power set point
+        :param r: Line resistance (Ohm)
+        :param loss_factor:  Losses factor (p.u.)
         :param Vset_f: Voltage set point at the "from" side
         :param Vset_t: Voltage set point at the "to" side
+        :param length: line length in km
+        :param mttf: Mean time to failure in hours
+        :param mttr: Mean time to recovery in hours
+        :param overload_cost: cost of a line overload in EUR/MW
         :param min_firing_angle_f: minimum firing angle at the "from" side
         :param max_firing_angle_f: maximum firing angle at the "from" side
         :param min_firing_angle_t: minimum firing angle at the "to" side
         :param max_firing_angle_t: maximum firing angle at the "to" side
-        :param overload_cost: cost of a line overload in EUR/MW
-        :param mttf: Mean time to failure in hours
-        :param mttr: Mean time to recovery in hours
-        :param length: line length in km
+        :param contingency_factor: factor used for contingency studies
+        :param protection_rating_factor: Rating used for protection tripping limit
+        :param control_mode: HvdcControlType
+        :param dispatchable: is this line dispatchable?
+        :param angle_droop: INELFE angle-droop constant
+        :param capex: Capital expenditures (€)
+        :param opex: Operational expenditures (€)
+        :param build_status: BuildStatus
+        :param dc_link_voltage: line voltage (only for compatibility, not used in calcs.) (kV)
         """
 
         BranchParent.__init__(self,

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -241,11 +241,11 @@ class OverheadLineType(EditableDevice):
     def compute_rating(self):
         """
         Compute the sum of the wires max current in A
-        :return: max current iof the tower in A
+        :return: max current (I) of the tower in A
         """
         r = 0
-        for wire in self.wires_in_tower:
-            r += wire.wire.max_current
+        for wit in self.wires_in_tower:
+            r += wit.wire.max_current
 
         return r
 

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Branches/tap_changer.py

@@ -388,7 +388,7 @@ class TapChanger:
         self._negative_low = low < 0
 
         if self._negative_low:
-            self.asymmetry_angle = float(asymmetry_angle)  # assymetry angle (Theta)
+            self.asymmetry_angle = float(asymmetry_angle)  # asymmetry angle (Theta)
             self._total_positions = int(high - low + 1)  # total number of positions
             self.dV = float(stepVoltageIncrement / 100)  # voltage increment in p.u.
             self.neutral_position = int(neutral - low + 1)  # neutral position
@@ -397,7 +397,7 @@ class TapChanger:
             self.tc_type = tc_type  # tap changer mode
 
         else:
-            self.asymmetry_angle = float(asymmetry_angle)  # assymetry angle (Theta)
+            self.asymmetry_angle = float(asymmetry_angle)  # asymmetry angle (Theta)
             self._total_positions = int(high - low + 1)  # total number of positions
             self.dV = float(stepVoltageIncrement / 100)  # voltage increment in p.u.
             self.neutral_position = int(neutral)  # neutral position

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Injections/battery.py

@@ -10,68 +10,7 @@ from GridCalEngine.Devices.Injections.generator import Generator, BuildStatus
 
 class Battery(Generator):
     """
-    :ref:`Battery<battery>` (voltage controlled and dispatchable).
-
-    Arguments:
-
-        **name** (str, "batt"): Name of the battery
-
-        **active_power** (float, 0.0): Active power in MW
-
-        **power_factor** (float, 0.8): Power factor
-
-        **voltage_module** (float, 1.0): Voltage setpoint in per unit
-
-        **is_controlled** (bool, True): Is the unit voltage controlled (if so, the
-        connection bus becomes a PV bus)
-
-        **Qmin** (float, -9999): Minimum reactive power in MVAr
-
-        **Qmax** (float, 9999): Maximum reactive power in MVAr
-
-        **Snom** (float, 9999): Nominal apparent power in MVA
-
-        **Enom** (float, 9999): Nominal energy capacity in MWh
-
-        **p_min** (float, -9999): Minimum dispatchable power in MW
-
-        **p_max** (float, 9999): Maximum dispatchable power in MW
-
-        **op_cost** (float, 1.0): Operational cost in Eur (or other e) per MW
-
-        **power_prof** (DataFrame, None): Pandas DataFrame with the active power
-        profile in MW
-
-        **power_factor_prof** (DataFrame, None): Pandas DataFrame with the power factor profile
-
-        **vset_prof** (DataFrame, None): Pandas DataFrame with the voltage setpoint
-        profile in per unit
-
-        **active** (bool, True): Is the battery active?
-
-        **Sbase** (float, 100): Base apparent power in MVA
-
-        **enabled_dispatch** (bool, True): Is the battery enabled for OPF?
-
-        **mttf** (float, 0.0): Mean time to failure in hours
-
-        **mttr** (float, 0.0): Mean time to recovery in hours
-
-        **charge_efficiency** (float, 0.9): Efficiency when charging
-
-        **discharge_efficiency** (float, 0.9): Efficiency when discharging
-
-        **max_soc** (float, 0.99): Maximum state of charge
-
-        **min_soc** (float, 0.3): Minimum state of charge
-
-        **soc** (float, 0.8): Current state of charge
-
-        **charge_per_cycle** (float, 0.1): Per unit of power to take per cycle when charging
-
-        **discharge_per_cycle** (float, 0.1): Per unit of power to deliver per cycle
-        when discharging
-
+    Battery
     """
 
     def __init__(self, name='batt', idtag=None, P=0.0, power_factor=0.8, vset=1.0,
@@ -84,32 +23,32 @@ class Battery(Generator):
                  srap_enabled: bool = True,
                  build_status: BuildStatus = BuildStatus.Commissioned):
         """
-
-        :param name:
+        :ref:`Battery<battery>` (voltage controlled and dispatchable).
+        :param name: Name of the battery
         :param idtag:
-        :param P:
-        :param power_factor:
-        :param vset:
-        :param is_controlled:
-        :param Qmin:
-        :param Qmax:
-        :param Snom:
-        :param Enom:
-        :param Pmin:
-        :param Pmax:
-        :param Cost:
-        :param active:
-        :param Sbase:
-        :param enabled_dispatch:
-        :param mttf:
-        :param mttr:
-        :param charge_efficiency:
-        :param discharge_efficiency:
-        :param max_soc:
-        :param min_soc:
-        :param soc:
-        :param charge_per_cycle:
-        :param discharge_per_cycle:
+        :param P: Active power in MW
+        :param power_factor: Power factor
+        :param vset: Voltage setpoint in per unit
+        :param is_controlled: Is the unit voltage controlled (if so, the connection bus becomes a PV bus)
+        :param Qmin: Minimum reactive power in MVAr
+        :param Qmax: Maximum reactive power in MVAr
+        :param Snom: Nominal apparent power in MVA
+        :param Enom: Nominal energy capacity in MWh
+        :param Pmin: Minimum dispatchable power in MW
+        :param Pmax: Maximum dispatchable power in MW
+        :param Cost: Operational cost in Eur (or other e) per MW
+        :param active: Is the battery active?
+        :param Sbase: Base apparent power in MVA
+        :param enabled_dispatch: Is the battery enabled for OPF?
+        :param mttf: Mean time to failure in hours
+        :param mttr: Mean time to recovery in hours
+        :param charge_efficiency: Efficiency when charging
+        :param discharge_efficiency: Efficiency when discharging
+        :param max_soc: Maximum state of charge
+        :param min_soc: Minimum state of charge
+        :param soc: Current state of charge
+        :param charge_per_cycle: Per unit of power to take per cycle when charging
+        :param discharge_per_cycle: Per unit of power to deliver per cycle when discharging
         :param r1:
         :param x1:
         :param r0:
@@ -169,10 +108,6 @@ class Battery(Generator):
 
         self.energy = self.Enom * self.soc
 
-        self.energy_array = None
-
-        self.power_array = None
-
         self.register(key='Enom', units='MWh', tpe=float, definition='Nominal energy capacity.')
         self.register(key='max_soc', units='p.u.', tpe=float, definition='Minimum state of charge.')
         self.register(key='min_soc', units='p.u.', tpe=float, definition='Maximum state of charge.')

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Injections/generator_q_curve.py

@@ -155,18 +155,6 @@ class GeneratorQCurve:
         """
         return json.dumps(self.to_list())
 
-    # def parse(self, data: List[float]) -> None:
-    #     """
-    #     Parse json curve data
-    #     :param data: string value: [[P1, Qmin1, Qmax1], [P2, Qmin2, Qmax2], ...]
-    #     """
-    #     n = len(data)
-    #     self._q_points = np.zeros((n, 3))
-    #     for i, row in enumerate(data):
-    #         self._q_points[i, 0] = row[0]
-    #         self._q_points[i, 1] = row[1]
-    #         self._q_points[i, 2] = row[2]
-
     def parse(self, data: List[Tuple[float, float, float]]):
         """
         Parse Json data
@@ -181,7 +169,7 @@ class GeneratorQCurve:
     def set(self, data: np.ndarray):
         """
         Parse Json data
-        :param data: List of lists with (latitude, longitude, altitude)
+        :param data: List of [(P1, Qmin1, Qmax1), (P2, Qmin2, Qmax2), ...]
         """
         if data.ndim == 2:
             if data.shape[1] == 3:

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Parents/load_parent.py

@@ -118,14 +118,14 @@ class LoadParent(InjectionParent):
 
         :return:
         """
-        return complex(self.P, self.Q)
+        return complex(-self.P, -self.Q)
 
     def get_Sprof(self) -> CxVec:
         """
 
         :return:
         """
-        return self.P_prof.toarray() + 1j * self.Q_prof.toarray()
+        return -self.P_prof.toarray() - 1j * self.Q_prof.toarray()
 
     def plot_profiles(self, time=None, show_fig=True):
         """

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Substation/bus.py

@@ -126,6 +126,18 @@ class Bus(PhysicalDevice):
 
         self._voltage_level: VoltageLevel = voltage_level
 
+        if voltage_level is not None:
+
+            if voltage_level.Vnom != Vnom:
+                print(f"{self.idtag} {self.name} The nominal voltage of the voltage level is different from bus nominal voltage!")
+
+            if voltage_level.substation is not None:
+                if substation is None:
+                    self.substation = voltage_level.substation
+                else:
+                    if substation != voltage_level.substation:
+                        print(f"{self.idtag} {self.name} The substation from the voltage level is different from bus substation!")
+
         # Bus type
         self.type = BusMode.PQ_tpe
 

{GridCalEngine-5.2.0 → GridCalEngine-5.2.1}/GridCalEngine/Devices/multi_circuit.py

@@ -685,7 +685,6 @@ class MultiCircuit(Assets):
             B = list()
             P_gen = list()
             V_gen = list()
-            E_batt = list()
 
             load_names = list()
             gen_names = list()
@@ -713,7 +712,6 @@ class MultiCircuit(Assets):
                 gen_names.append(elm.name)
                 P_gen.append(elm.P_prof)
                 V_gen.append(elm.Vset_prof)
-                E_batt.append(elm.energy_array)
 
             # form DataFrames
             P = pd.DataFrame(data=np.array(P).transpose(), index=self.time_profile, columns=load_names)
@@ -724,7 +722,6 @@ class MultiCircuit(Assets):
             B = pd.DataFrame(data=np.array(B).transpose(), index=self.time_profile, columns=load_names)
             P_gen = pd.DataFrame(data=np.array(P_gen).transpose(), index=self.time_profile, columns=gen_names)
             V_gen = pd.DataFrame(data=np.array(V_gen).transpose(), index=self.time_profile, columns=gen_names)
-            E_batt = pd.DataFrame(data=np.array(E_batt).transpose(), index=self.time_profile, columns=bat_names)
 
             with pd.ExcelWriter(file_name) as writer:  # pylint: disable=abstract-class-instantiated
                 P.to_excel(writer, 'P loads')
@@ -739,8 +736,6 @@ class MultiCircuit(Assets):
                 P_gen.to_excel(writer, 'P generators')
                 V_gen.to_excel(writer, 'V generators')
 
-                E_batt.to_excel(writer, 'Energy batteries')
-
         else:
             raise Exception('There are no time series!')
 
@@ -1680,6 +1675,21 @@ class MultiCircuit(Assets):
         """
         return self.get_Sbus_prof().real
 
+    def get_imbalance(self) -> float:
+        """
+        Get the system imbalance in per unit
+        :return:
+        """
+        P = self.get_Pbus()
+        Pg = P[P > 0].sum()
+        Pl = -P[P < 0].sum()
+        if Pl > 0:
+            ratio = (Pg - Pl) / Pl
+        else:
+            ratio = 1.0
+
+        return ratio
+
     def get_branch_rates_prof_wo_hvdc(self) -> Mat:
         """
         Get the complex bus power Injections