GridCalEngine 5.2.0__tar.gz → 5.2.2__tar.gz

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/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.2}/GridCalEngine/DataStructures/hvdc_data.py

@@ -299,7 +299,7 @@ class HvdcData:
                 else:
                     Losses[i] = 0
                     Pf[i] = 0
-                    Pt[0] = 0
+                    Pt[i] = 0
 
                 # compute loading
                 loading[i] = Pf[i] / (self.rate[i] + 1e-20)

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/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.2}/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.2}/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,
@@ -197,8 +210,6 @@ class HvdcLine(BranchParent):
 
         self.dc_link_voltage = float(dc_link_voltage)
 
-        # self.n_lines = int(n_lines)
-
         self.angle_droop = float(angle_droop)
 
         self.loss_factor = float(loss_factor)
@@ -232,11 +243,11 @@ class HvdcLine(BranchParent):
 
         self.control_mode: HvdcControlType = control_mode
 
-        self._Pset_prof: Vec = Profile(default_value=Pset, data_type=float)
-        self._active_prof: IntVec = Profile(default_value=active, data_type=bool)
-        self._Vset_f_prof: Vec = Profile(default_value=Vset_f, data_type=float)
-        self._Vset_t_prof: Vec = Profile(default_value=Vset_t, data_type=float)
-        self._angle_droop_prof: Vec = Profile(default_value=angle_droop, data_type=float)
+        self._Pset_prof: Profile = Profile(default_value=Pset, data_type=float)
+        self._active_prof: Profile = Profile(default_value=active, data_type=bool)
+        self._Vset_f_prof: Profile = Profile(default_value=Vset_f, data_type=float)
+        self._Vset_t_prof: Profile = Profile(default_value=Vset_t, data_type=float)
+        self._angle_droop_prof: Profile = Profile(default_value=angle_droop, data_type=float)
 
         # Line locations
         self._locations: LineLocations = LineLocations()

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Branches/line.py

@@ -103,17 +103,17 @@ class Line(BranchParent):
         self.fault_pos = float(fault_pos)
 
         # total impedance and admittance in p.u.
-        self.R = float(r)
-        self.X = float(x)
-        self.B = float(b)
+        self._R = float(r)
+        self._X = float(x)
+        self._B = float(b)
 
-        self.R0 = float(r0)
-        self.X0 = float(x0)
-        self.B0 = float(b0)
+        self._R0 = float(r0)
+        self._X0 = float(x0)
+        self._B0 = float(b0)
 
-        self.R2 = float(r2)
-        self.X2 = float(x2)
-        self.B2 = float(b2)
+        self._R2 = float(r2)
+        self._X2 = float(x2)
+        self._B2 = float(b2)
 
         # Conductor base and operating temperatures in ºC
         self.temp_base = float(temp_base)
@@ -146,7 +146,6 @@ class Line(BranchParent):
         self.register(key='tolerance', units='%', tpe=float,
                       definition='Tolerance expected for the impedance values % is expected '
                                  'for transformers0% for lines.')
-
         self.register(key='length', units='km', tpe=float, definition='Length of the line (not used for calculation)')
         self.register(key='temp_base', units='ºC', tpe=float, definition='Base temperature at which R was measured.')
         self.register(key='temp_oper', units='ºC', tpe=float, definition='Operation temperature to modify R.',
@@ -179,6 +178,78 @@ class Line(BranchParent):
                       definition='Possible sequence line types (>1 to denote association), - to denote no association',
                       display=False)
 
+    @property
+    def R(self):
+        return self._R
+
+    @R.setter
+    def R(self, value):
+        self._R = float(value)
+
+    @property
+    def X(self):
+        return self._X
+
+    @X.setter
+    def X(self, value):
+        self._X = float(value)
+
+    @property
+    def B(self):
+        return self._B
+
+    @B.setter
+    def B(self, value):
+        self._B = float(value)
+
+    @property
+    def R0(self):
+        return self._R0
+
+    @R0.setter
+    def R0(self, value):
+        self._R0 = float(value)
+
+    @property
+    def X0(self):
+        return self._X0
+
+    @X0.setter
+    def X0(self, value):
+        self._X0 = float(value)
+
+    @property
+    def B0(self):
+        return self._B0
+
+    @B0.setter
+    def B0(self, value):
+        self._B0 = float(value)
+
+    @property
+    def R2(self):
+        return self._R2
+
+    @R2.setter
+    def R2(self, value):
+        self._R2 = float(value)
+
+    @property
+    def X2(self):
+        return self._X2
+
+    @X2.setter
+    def X2(self, value):
+        self._X2 = float(value)
+
+    @property
+    def B2(self):
+        return self._B2
+
+    @B2.setter
+    def B2(self, value):
+        self._B2 = float(value)
+
     @property
     def length(self) -> float:
         """
@@ -194,18 +265,17 @@ class Line(BranchParent):
         :param val:
         :return:
         """
-        self.set_length(val, update_electrical_values=True)
+        self.set_length(val)
 
-    def set_length(self, val: float, update_electrical_values: bool = True):
+    def set_length(self, val: float):
         """
 
         :param val:
-        :param update_electrical_values:
         :return:
         """
         if isinstance(val, float):
             if val > 0.0:
-                if self._length != 0 and update_electrical_values:
+                if self._length != 0 and self.auto_update_enabled:
                     factor = np.round(val / self._length, 6)  # new length / old length
 
                     self.R *= factor
@@ -218,6 +288,7 @@ class Line(BranchParent):
                     self.X2 *= factor
                     self.B2 *= factor
 
+                # set the value
                 self._length = val
             else:
                 print('The length cannot be zero, ignoring value')
@@ -408,7 +479,7 @@ class Line(BranchParent):
         elm.temperature_prof = self.temp_oper_prof
         return elm
 
-    def fill_design_properties(self, r_ohm, x_ohm, c_nf, length, Imax, freq, Sbase, apply_to_profile: bool = True,):
+    def fill_design_properties(self, r_ohm, x_ohm, c_nf, length, Imax, freq, Sbase, apply_to_profile: bool = True, ):
         """
         Fill R, X, B from not-in-per-unit parameters
         :param r_ohm: Resistance per km in OHM/km

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/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.2}/GridCalEngine/Devices/Branches/series_reactance.py

@@ -20,7 +20,7 @@ class SeriesReactance(BranchParent):
                  r=1e-20, x=1e-20, rate=1.0, active=True, tolerance=0, cost=100.0,
                  mttf=0, mttr=0, r_fault=0.0, x_fault=0.0, fault_pos=0.5,
                  temp_base=20, temp_oper=20, alpha=0.00330,
-                 template=None, contingency_factor=1.0, protection_rating_factor: float = 1.4,
+                 contingency_factor=1.0, protection_rating_factor: float = 1.4,
                  contingency_enabled=True, monitor_loading=True,
                  r0=1e-20, x0=1e-20,  r2=1e-20, x2=1e-20,
                  capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned):
@@ -45,7 +45,6 @@ class SeriesReactance(BranchParent):
         :param temp_base: Base temperature at which `r` is measured in °C
         :param temp_oper: Operating temperature in °C
         :param alpha: Thermal constant of the material in °C
-        :param template: Basic branch template
         :param contingency_factor: Rating factor in case of contingency
         :param protection_rating_factor: Rating factor before the protections tripping
         :param contingency_enabled: enabled for contingencies (Legacy)

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Branches/switch.py

@@ -13,7 +13,7 @@ from GridCalEngine.Devices.Parents.editable_device import DeviceType
 class Switch(BranchParent):
     """
     The **Switch** class represents the connections between nodes (i.e.
-    :ref:`buses<bus>`) in **GridCal**. A Switch is an devices that cuts or allows the flow.
+    :ref:`buses<bus>`) in **GridCal**. A Switch is a devices that cuts or allows the flow.
     """
 
     def __init__(self, bus_from: Bus = None, bus_to: Bus = None,
@@ -22,7 +22,6 @@ class Switch(BranchParent):
                  rate=1.0,
                  active=True,
                  contingency_factor=1.0, protection_rating_factor: float = 1.4,
-                 # is_open=False,
                  retained=True,
                  normal_open=False,
                  rated_current=0.0):
@@ -81,7 +80,7 @@ class Switch(BranchParent):
 
         self.register(key='normal_open', units="", tpe=bool,
                       definition='Normal position of the switch')
-        self.register(key='rated_current', units="KA", tpe=float,
+        self.register(key='rated_current', units="kA", tpe=float,
                       definition='Rated current of the switch device.')
 
     def copy(self, bus_dict=None):

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/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.2}/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.2}/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.2}/GridCalEngine/Devices/Parents/branch_parent.py

@@ -403,7 +403,7 @@ class BranchParent(PhysicalDevice):
 
     def get_virtual_taps(self) -> Tuple[float, float]:
         """
-        Always unit vitual taps (unless proven otherwise)
+        Always unit virtual taps (unless proven otherwise)
         :return: tap_f, tap_t
         """
         return 1.0, 1.0

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Parents/editable_device.py

@@ -228,6 +228,10 @@ class EditableDevice:
         # dictionary with property name -> profile name
         self.properties_with_profile: Dict[str, str] = dict()
 
+        # some devices have an auto update of a property when another property changes
+        # (i.e. Line's R, X, B when the length changes) this controls that behaviour and disables it during loading
+        self.__auto_update_enabled = False
+
         self.register(key='idtag', units='', tpe=str, definition='Unique ID', editable=False)
         self.register(key='name', units='', tpe=str, definition='Name of the device.')
         self.register(key='code', units='', tpe=str, definition='Secondary ID')
@@ -236,6 +240,28 @@ class EditableDevice:
                       display=False)
         self.register(key='comment', units='', tpe=str, definition='User comment')
 
+    @property
+    def auto_update_enabled(self):
+        """
+
+        :return:
+        """
+        return self.__auto_update_enabled
+
+    def enable_auto_updates(self):
+        """
+
+        :return:
+        """
+        self.__auto_update_enabled = True
+
+    def disable_auto_updates(self):
+        """
+
+        :return:
+        """
+        self.__auto_update_enabled = False
+
     def get_uuid(self) -> str:
         """
         If the idtag property looks like a UUID, it adds the dashes

{GridCalEngine-5.2.0 → GridCalEngine-5.2.2}/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):
         """