GridCalEngine 5.1.62__tar.gz → 5.2.1__tar.gz

{GridCalEngine-5.1.62 → 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.1.62 → GridCalEngine-5.2.1}/GridCalEngine/DataStructures/numerical_circuit.py

@@ -11,7 +11,7 @@ from typing import List, Tuple, Dict, Union, TYPE_CHECKING
 from GridCalEngine.Devices import RemedialAction
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
-from GridCalEngine.basic_structures import Vec, IntVec, CxVec
+from GridCalEngine.basic_structures import Vec, IntVec, CxVec, BoolVec
 from GridCalEngine.enumerations import BranchImpedanceMode, BusMode, ContingencyOperationTypes
 import GridCalEngine.Topology.topology as tp
 import GridCalEngine.Topology.simulation_indices as si
@@ -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,
@@ -43,7 +43,8 @@ ALL_STRUCTS = Union[
 ]
 
 
-def CheckArr(arr: Vec, arr_expected: Vec, tol: float, name: str, test: str, logger: Logger) -> int:
+def CheckArr(arr: Vec | IntVec | BoolVec | CxVec, arr_expected: Vec | IntVec | BoolVec | CxVec,
+             tol: float, name: str, test: str, logger: Logger) -> int:
     """
 
     :param arr:
@@ -65,12 +66,20 @@ def CheckArr(arr: Vec, arr_expected: Vec, tol: float, name: str, test: str, logg
     if np.allclose(arr, arr_expected, atol=tol):
         return 0
     else:
-        diff = arr - arr_expected
-        logger.add_error(msg="Numeric differences",
-                         device=name,
-                         device_property=test,
-                         value=f"min diff: {diff.min()}, max diff: {diff.max()}",
-                         expected_value=tol)
+        if arr.dtype == np.bool_:
+            diff = arr.astype(int) - arr_expected.astype(int)
+            logger.add_error(msg="Numeric differences",
+                             device=name,
+                             device_property=test,
+                             value=f"min diff: {diff.min()}, max diff: {diff.max()}",
+                             expected_value=tol)
+        else:
+            diff = arr - arr_expected
+            logger.add_error(msg="Numeric differences",
+                             device=name,
+                             device_property=test,
+                             value=f"min diff: {diff.min()}, max diff: {diff.max()}",
+                             expected_value=tol)
         return 1
 
 
@@ -1383,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.1.62 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Aggregation/branch_group.py

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MPL-2.0
 from typing import Union
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.enumerations import BranchGroupTypes
 
 
 class BranchGroup(EditableDevice):
@@ -11,15 +12,37 @@ class BranchGroup(EditableDevice):
     def __init__(self,
                  name='',
                  code='',
-                 idtag: Union[str, None] = None):
+                 idtag: Union[str, None] = None,
+                 group_type: BranchGroupTypes = BranchGroupTypes.GenericGroup):
         """
         BranchGroup
         :param name: name of the generator fuel
         :param code: secondary id
         :param idtag: UUID code
+        :param group_type: type of branch group
         """
+
         EditableDevice.__init__(self,
                                 name=name,
                                 code=code,
                                 idtag=idtag,
                                 device_type=DeviceType.BranchGroupDevice)
+
+        self._group_type: BranchGroupTypes = group_type
+
+        self.register(key='group_type', units='', tpe=BranchGroupTypes, definition=f'Type of branch group')
+
+    @property
+    def group_type(self) -> BranchGroupTypes:
+        """
+        Type of branch group
+        :return: BranchGroupTypes
+        """
+        return self._group_type
+
+    @group_type.setter
+    def group_type(self, value: BranchGroupTypes):
+        if isinstance(value, BranchGroupTypes):
+            self._group_type = value
+        else:
+            raise TypeError("Invalid group_type data type")

{GridCalEngine-5.1.62 → 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.1.62 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Branches/hvdc_line.py

@@ -130,32 +130,51 @@ class HvdcLine(BranchParent):
                  cn_from: ConnectivityNode = None,
                  cn_to: ConnectivityNode = None,
                  name='HVDC Line', idtag=None, active=True, code='',
-                 rate=1.0, Pset=0.0, r=1e-20, loss_factor=0.0, Vset_f=1.0, Vset_t=1.0, length=1.0, mttf=0.0, mttr=0.0,
-                 overload_cost=1000.0, min_firing_angle_f=-1.0, max_firing_angle_f=1.0, min_firing_angle_t=-1.0,
-                 max_firing_angle_t=1.0, contingency_factor=1.0, protection_rating_factor: float = 1.4,
-                 control_mode: HvdcControlType = HvdcControlType.type_1_Pset, dispatchable=True, angle_droop=0,
-                 capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned,
-                 dc_link_voltage: float = 200):
+                 rate=1.0, Pset=0.0,
+                 r=1e-20, loss_factor=0.0,
+                 Vset_f=1.0, Vset_t=1.0, length=1.0, mttf=0.0, mttr=0.0,
+                 overload_cost=1000.0,
+                 min_firing_angle_f=-1.0, max_firing_angle_f=1.0,
+                 min_firing_angle_t=-1.0, max_firing_angle_t=1.0,
+                 contingency_factor=1.0, protection_rating_factor: float = 1.4,
+                 control_mode: HvdcControlType = HvdcControlType.type_1_Pset,
+                 dispatchable=True, angle_droop=0,
+                 capex=0, opex=0,
+                 build_status: BuildStatus = BuildStatus.Commissioned,
+                 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.1.62 → 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.1.62 → 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.1.62 → 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.1.62 → 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.1.62 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Parents/branch_parent.py

@@ -125,7 +125,7 @@ class BranchParent(PhysicalDevice):
         self._protection_rating_factor = float(protection_rating_factor)
         self._protection_rating_factor_prof = Profile(default_value=protection_rating_factor, data_type=float)
 
-        # List of measurements
+        # group of this branch
         self.group: Union[BranchGroup, None] = None
 
         self.register('bus_from', units="", tpe=DeviceType.BusDevice,

{GridCalEngine-5.1.62 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Parents/editable_device.py

@@ -12,7 +12,7 @@ from GridCalEngine.enumerations import (DeviceType, TimeFrame, BuildStatus, Wind
                                         HvdcControlType, ActionType, AvailableTransferMode, ContingencyMethod,
                                         CpfParametrization, CpfStopAt, InvestmentEvaluationMethod, SolverType,
                                         InvestmentsEvaluationObjectives, NodalCapacityMethod, TimeGrouping,
-                                        ZonalGrouping, MIPSolvers, AcOpfMode, SubstationTypes,
+                                        ZonalGrouping, MIPSolvers, AcOpfMode, SubstationTypes, BranchGroupTypes,
                                         BranchImpedanceMode, FaultType, TapChangerTypes, ContingencyOperationTypes)
 
 # types that can be assigned to a GridCal property
@@ -45,7 +45,8 @@ GCPROP_TYPES = Union[
     Type[FaultType],
     Type[TapChangerTypes],
     Type[SubstationTypes],
-    Type[ContingencyOperationTypes]
+    Type[ContingencyOperationTypes],
+    Type[BranchGroupTypes]
 ]
 
 

{GridCalEngine-5.1.62 → 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.1.62 → 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
 
@@ -292,7 +304,7 @@ class Bus(PhysicalDevice):
             p_load[p_load > 0] = 0
             p_gen = p.copy()
             p_gen[p_gen < 0] = 0
-            P_data = {"Load":  p_load, "Gen": p_gen}
+            P_data = {"Load": p_load, "Gen": p_gen}
             t = time_series_driver.results.time_array
             pd.DataFrame(data=v, index=t, columns=['Voltage (p.u.)']).plot(ax=ax_voltage)
             pd.DataFrame(data=P_data, index=t).plot(ax=ax_load)
@@ -321,3 +333,19 @@ class Bus(PhysicalDevice):
         Get tuple of the bus coordinates (longitude, latitude)
         """
         return self.longitude, self.latitude
+
+    def try_to_find_coordinates(self):
+        """
+        Try to find the bus coordinates
+        """
+        lon, lat = self.longitude, self.latitude
+
+        if self.substation is not None:
+            if lon == 0.0:
+                lon = self.substation.longitude
+
+        if self.substation is not None:
+            if lat == 0.0:
+                lat = self.substation.latitude
+
+        return lon, lat

{GridCalEngine-5.1.62 → GridCalEngine-5.2.1}/GridCalEngine/Devices/Substation/voltage_level.py

@@ -11,8 +11,11 @@ from GridCalEngine.Devices.Substation.substation import Substation
 
 class VoltageLevel(PhysicalDevice):
 
-    def __init__(self, name='VoltageLevel', idtag: Union[str, None] = None, code: str = '',
-                 Vnom: float = 1.0, substation: Union[None, Substation] = None):
+    def __init__(self, name='VoltageLevel',
+                 idtag: Union[str, None] = None,
+                 code: str = '',
+                 Vnom: float = 1.0,
+                 substation: Union[None, Substation] = None):
         """
         Constructor
         :param name: Name

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

@@ -24,7 +24,7 @@ from GridCalEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, F
 from GridCalEngine.basic_structures import Logger
 import GridCalEngine.Topology.topology as tp
 from GridCalEngine.Topology.topology_processor import TopologyProcessorInfo, process_grid_topology_at
-from GridCalEngine.enumerations import DeviceType, ActionType
+from GridCalEngine.enumerations import DeviceType, ActionType, SubObjectType
 
 
 def get_system_user() -> str:
@@ -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
@@ -1898,6 +1908,22 @@ class MultiCircuit(Assets):
                                     device_property=prop.name,
                                     value=v2,
                                     expected_value=v1)
+                        elif prop.tpe == SubObjectType.Array:
+                            if len(v1) != len(v2):
+                                logger.add_error(
+                                    msg="Different array length",
+                                    device_class=template_elm.device_type.value,
+                                    device_property=prop.name,
+                                    value=v2,
+                                    expected_value=v1)
+                            else:
+                                if not np.isclose(v1, v2, atol=tolerance):
+                                    logger.add_error(
+                                        msg="Different snapshot values",
+                                        device_class=template_elm.device_type.value,
+                                        device_property=prop.name,
+                                        value=v2,
+                                        expected_value=v1)
                         else:
                             if v1 != v2:
                                 logger.add_error(msg="Different snapshot values",
@@ -1905,7 +1931,6 @@ class MultiCircuit(Assets):
                                                  device_property=prop.name,
                                                  value=v2,
                                                  expected_value=v1)
-
                         if prop.has_profile():
                             p1 = elm1.get_profile_by_prop(prop=prop)
                             p2 = elm1.get_profile_by_prop(prop=prop)