GridCalEngine 5.3.39__tar.gz → 5.3.41__tar.gz

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/Compilers/circuit_to_gslv.py

@@ -3,28 +3,30 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
-import os.path
 import time
-import warnings
 import numpy as np
 from typing import List, Dict, Union, Tuple, TYPE_CHECKING
 
-from GridCalEngine import TapModuleControl, TapPhaseControl, BusMode
+from GridCalEngine.Utils.ThirdParty.gslv.gslv_activation import (pg, build_status_dict, tap_module_control_mode_dict,
+                                                                 tap_phase_control_mode_dict, hvdc_control_mode_dict,
+                                                                 group_type_dict, contingency_ops_type_dict,
+                                                                 contingency_method_dict, converter_control_type_dict,
+                                                                 bus_type_dict,
+                                                                 GSLV_AVAILABLE, GSLV_VERSION,
+                                                                 GSLV_RECOMMENDED_VERSION)
 from GridCalEngine.DataStructures.branch_parent_data import BranchParentData
-from GridCalEngine.basic_structures import IntVec, Vec
+from GridCalEngine.basic_structures import IntVec, Vec, ConvergenceReport
 from GridCalEngine.Devices.profile import Profile
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
-from GridCalEngine.enumerations import (HvdcControlType, SolverType, TimeGrouping,
-                                        ZonalGrouping, MIPSolvers, ContingencyMethod, ContingencyOperationTypes,
-                                        BuildStatus, BranchGroupTypes, ConverterControlType)
 import GridCalEngine.Devices as dev
 from GridCalEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions
 from GridCalEngine.Simulations.PowerFlow.power_flow_results import PowerFlowResults
-
+from GridCalEngine import TapModuleControl, TapPhaseControl
+from GridCalEngine.enumerations import SolverType
 from GridCalEngine.DataStructures.numerical_circuit import NumericalCircuit
 
-from GridCalEngine.IO.file_system import get_create_gridcal_folder
-from GridCalEngine.basic_structures import ConvergenceReport, Logger
+
+from GridCalEngine.basic_structures import Logger
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
@@ -33,97 +35,6 @@ if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
     from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
 
-GSLV_RECOMMENDED_VERSION = "0.2.0"
-GSLV_VERSION = ''
-GSLV_AVAILABLE = False
-try:
-    import pygslv as pg
-
-    pg.activate(os.path.join(get_create_gridcal_folder(), "license.gslv"), verbose=True)
-
-    # activate
-    if not pg.isLicensed():
-        # license not found
-        GSLV_AVAILABLE = False
-    else:
-        # already activated
-        GSLV_AVAILABLE = True
-        GSLV_VERSION = pg.get_version()
-
-    if GSLV_AVAILABLE:
-        if GSLV_VERSION < GSLV_RECOMMENDED_VERSION:
-            warnings.warn(f"Recommended version for GSLV is {GSLV_RECOMMENDED_VERSION} "
-                          f"instead of {GSLV_VERSION}")
-
-    build_status_dict = {
-        BuildStatus.Planned: pg.BuildStatus.Planned,
-        BuildStatus.Commissioned: pg.BuildStatus.Commissioned,
-        BuildStatus.Candidate: pg.BuildStatus.Candidate,
-        BuildStatus.Decommissioned: pg.BuildStatus.Decommissioned,
-        BuildStatus.PlannedDecommission: pg.BuildStatus.PlannedDecommission,
-    }
-
-    tap_module_control_mode_dict = {
-        TapModuleControl.fixed: pg.TapModuleControl.fixed,
-        TapModuleControl.Qf: pg.TapModuleControl.Qf,
-        TapModuleControl.Qt: pg.TapModuleControl.Qt,
-        TapModuleControl.Vm: pg.TapModuleControl.Vm,
-    }
-
-    tap_phase_control_mode_dict = {
-        TapPhaseControl.fixed: pg.TapPhaseControl.fixed,
-        TapPhaseControl.Pf: pg.TapPhaseControl.Pf,
-        TapPhaseControl.Pt: pg.TapPhaseControl.Pt,
-    }
-
-    hvdc_control_mode_dict = {
-        HvdcControlType.type_0_free: pg.HvdcControlType.type_0_free,
-        HvdcControlType.type_1_Pset: pg.HvdcControlType.type_1_Pset,
-    }
-
-    group_type_dict = {
-        BranchGroupTypes.GenericGroup: pg.BranchGroupTypes.GenericGroup,
-        BranchGroupTypes.TransformerGroup: pg.BranchGroupTypes.TransformerGroup,
-        BranchGroupTypes.LineSegmentsGroup: pg.BranchGroupTypes.LineSegmentsGroup,
-    }
-
-    contingency_ops_type_dict = {
-        ContingencyOperationTypes.Active: pg.ContingencyOperationTypes.Active,
-        ContingencyOperationTypes.PowerPercentage: pg.ContingencyOperationTypes.PowerPercentage,
-    }
-
-    contingency_method_dict = {
-        ContingencyMethod.PTDF: pg.ContingencyMethod.PTDF,
-        ContingencyMethod.PowerFlow: pg.ContingencyMethod.PowerFlow,
-        ContingencyMethod.HELM: pg.ContingencyMethod.HELM,
-    }
-
-    converter_control_type_dict = {
-        ConverterControlType.Vm_dc: pg.ConverterControlType.Vm_dc,
-        ConverterControlType.Vm_ac: pg.ConverterControlType.Vm_ac,
-        ConverterControlType.Va_ac: pg.ConverterControlType.Va_ac,
-        ConverterControlType.Qac: pg.ConverterControlType.Q_ac,
-        ConverterControlType.Pdc: pg.ConverterControlType.P_dc,
-        ConverterControlType.Pac: pg.ConverterControlType.P_ac,
-    }
-
-    bus_type_dict = {
-        BusMode.PQ_tpe.value: pg.BusMode.PQ,
-        BusMode.PV_tpe.value: pg.BusMode.PV,
-        BusMode.Slack_tpe.value: pg.BusMode.Slack,
-        BusMode.P_tpe.value: pg.BusMode.P,
-        BusMode.PQV_tpe.value: pg.BusMode.PQV,
-    }
-
-except ImportError as e:
-    pg = None
-    GSLV_AVAILABLE = False
-    GSLV_VERSION = ''
-    build_status_dict = dict()
-    tap_module_control_mode_dict = dict()
-    tap_phase_control_mode_dict = dict()
-    contingency_ops_type_dict = dict()
-    contingency_method_dict = dict()
 
 
 def get_gslv_mip_solvers_list() -> List[str]:
@@ -2493,10 +2404,10 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", lo
     results.loading = res.loading[0, :]
     results.losses = res.losses[0, :]
     # results.Vbranch = res.Vbranch[0, :]
-    # results.If = res.If[0, :]
-    # results.It = res.It[0, :]
-    # results.Beq = res.Beq[0, :]
-    results.m = res.tap_module[0, :]
+    results.If = res.If[0, :]
+    results.It = res.It[0, :]
+
+    results.tap_module = res.tap_module[0, :]
     results.tap_angle = res.tap_angle[0, :]
     # results.F = res.F
     # results.T = res.T
@@ -2512,10 +2423,22 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", lo
     results.loading_vsc = res.loading_vsc[0, :]
     results.losses_vsc = res.losses_vsc[0, :]
 
+    results.gen_q = res.gen_q[0, :]
+    results.battery_q = res.battery_q[0, :]
+    results.shunt_q = res.shunt_q[0, :]
+
+    report = ConvergenceReport()
+    report.add(method=SolverType.NR,
+               error=res.error_values[0],
+               elapsed=res.elapsed,
+               iterations=0,
+               converged=res.converged_values[0])
+
+    results.convergence_reports.append(report)
     # logger.add_info("gslv time", value=res.time_array[0])
 
-    # results.bus_area_indices = grid.get_bus_area_indices()
-    # results.area_names = [a.name for a in grid.areas]
+    results.bus_area_indices = grid.get_bus_area_indices()
+    results.area_names = [a.name for a in grid.areas]
     # results.bus_types = convert_bus_types(res.bus_types[0])  # this is a list of lists
 
     # for rep in res.stats[0]:

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/Devices/Branches/line.py

@@ -455,6 +455,12 @@ class Line(BranchParent):
         """
 
         if isinstance(obj, OverheadLineType):
+            if not obj.is_computed():
+                obj.compute()
+                if not obj.is_computed():
+                    return
+            else:
+                pass
 
             template_vn = obj.Vnom
             vn = self.get_max_bus_nominal_voltage()

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -247,7 +247,7 @@ class OverheadLineType(EditableDevice):
         self.wires_in_tower: ListOfWires = ListOfWires()
 
         # nominal voltage
-        self.Vnom = Vnom  # kV
+        self._Vnom = Vnom  # kV
 
         self.earth_resistivity = earth_resistivity  # ohm/m3
 
@@ -277,6 +277,14 @@ class OverheadLineType(EditableDevice):
         self.register(key='wires_in_tower', units='', tpe=SubObjectType.ListOfWires,
                       definition='List of wires', editable=False, display=False)
 
+    @property
+    def Vnom(self) -> float:
+        return self._Vnom
+
+    @Vnom.setter
+    def Vnom(self, val: float):
+        self._Vnom = float(val)
+
     @property
     def n_circuits(self) -> int:
         """
@@ -420,6 +428,28 @@ class OverheadLineType(EditableDevice):
             # there are no wires
             pass
 
+    def is_computed(self) -> bool:
+
+        """
+
+        return: Boolean that tells if the template has already been computed or not
+
+        """
+
+        ok = True
+        ok = ok and self.z_abc is not None
+        ok = ok and self.z_seq is not None
+        ok = ok and self.z_abcn is not None
+        ok = ok and self.z_phases_abc is not None
+        ok = ok and self.z_phases_abcn is not None
+        ok = ok and self.y_abc is not None
+        ok = ok and self.y_seq is not None
+        ok = ok and self.y_abcn is not None
+        ok = ok and self.y_phases_abc is not None
+        ok = ok and self.y_phases_abcn is not None
+
+        return ok
+
     def check(self, logger=Logger()):
         """
         Check that the wires configuration make sense

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/Devices/Injections/load.py

@@ -65,6 +65,9 @@ class Load(LoadParent):
         self._Ir_prof = Profile(default_value=self.Ir, data_type=float)
         self._Ii_prof = Profile(default_value=self.Ii, data_type=float)
 
+        self._n_customers: int = 1
+        self._n_customers_prof = Profile(default_value=self._n_customers, data_type=int)
+
         self.register(key='Ir', units='MW', tpe=float,
                       definition='Active power of the current component at V=1.0 p.u.', profile_name='Ir_prof')
         self.register(key='Ii', units='MVAr', tpe=float,
@@ -73,6 +76,8 @@ class Load(LoadParent):
                       definition='Active power of the impedance component at V=1.0 p.u.', profile_name='G_prof')
         self.register(key='B', units='MVAr', tpe=float,
                       definition='Reactive power of the impedance component at V=1.0 p.u.', profile_name='B_prof')
+        self.register(key='n_customers', units='unit', tpe=int,
+                      definition='Number of customers represented by this load', profile_name='n_customers_prof')
 
     @property
     def Ir_prof(self) -> Profile:
@@ -142,6 +147,45 @@ class Load(LoadParent):
         else:
             raise Exception(str(type(val)) + 'not supported to be set into a B_prof')
 
+    @property
+    def n_customers(self) -> int:
+        """
+        Return the number of customers
+        """
+        return self._n_customers
+
+    @n_customers.setter
+    def n_customers(self, val: int):
+        """
+        Set the number of customers
+        :param val: value greater than 0
+        """
+        try:
+            val2 = int(val)
+            if val2 > 0:
+                self._n_customers = val2
+            else:
+                print("There must be at least one customer right?")
+        except ValueError as e:
+            print(e)
+
+    @property
+    def n_customers_prof(self) -> Profile:
+        """
+        Cost profile
+        :return: Profile
+        """
+        return self._n_customers_prof
+
+    @n_customers_prof.setter
+    def n_customers_prof(self, val: Union[Profile, np.ndarray]):
+        if isinstance(val, Profile):
+            self._n_customers_prof = val
+        elif isinstance(val, np.ndarray):
+            self._n_customers_prof.set(arr=val)
+        else:
+            raise Exception(str(type(val)) + 'not supported to be set into n_customers_prof')
+
     def plot_profiles(self, time=None, show_fig=True):
         """
         Plot the time series results of this object

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/Devices/multi_circuit.py

@@ -1112,7 +1112,7 @@ class MultiCircuit(Assets):
 
     def get_inter_buses_branches(self, a1: Set[dev.Bus], a2: Set[dev.Bus]) -> List[Tuple[int, object, float]]:
         """
-        Get the inter-buese Branches. HVDC Branches are not considered
+        Get the inter-buses Branches. HVDC Branches are not considered
         :param a1: Group of Buses 1
         :param a2: Group of Buses 1
         :return: List of (branch index, branch object, flow sense w.r.t the area exchange)

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/IO/cim/cgmes/cgmes_data_parser.py

@@ -167,10 +167,11 @@ def merge(A: Dict[str, Dict[str, Dict[str, str]]],
                                 pass
 
 
-def read_cgmes_files(cim_files: Union[List[str], str]) -> Dict[str, List[str]]:
+def read_cgmes_files(cim_files: Union[List[str], str], logger: DataLogger) -> Dict[str, List[str]]:
     """
     Reads a list of .zip or xml into a dictionary of file name -> list of text lines
     :param cim_files: list of file names
+    :param logger: DataLogger instance
     :return: dictionary of file name -> list of text lines
     """
     # read files and sort them in the preferred reading order
@@ -189,21 +190,28 @@ def read_cgmes_files(cim_files: Union[List[str], str]) -> Dict[str, List[str]]:
             elif file_extension == '.zip':
                 # read the content of a zip file
                 d = get_xml_from_zip(file_name_zip=f)
-                for key, value in d.items():
-                    data[key] = value
+                if d is not None:
+                    for key, value in d.items():
+                        data[key] = value
+                else:
+                    logger.add_error("BadZipFile", value=f)
+                    print(f"BadZipFile {f}")
     else:
         name, file_extension = os.path.splitext(cim_files)
 
         if file_extension == '.xml':
-            file_ptr = open(cim_files, 'rb')
-            data[name] = get_xml_content(file_ptr)
-            file_ptr.close()
+            with open(cim_files, 'rb') as file_ptr:
+                data[name] = get_xml_content(file_ptr=file_ptr)
 
         elif file_extension == '.zip':
             # read the content of a zip file
             d = get_xml_from_zip(file_name_zip=cim_files)
-            for key, value in d.items():
-                data[key] = value
+            if d is not None:
+                for key, value in d.items():
+                    data[key] = value
+            else:
+                logger.add_error("BadZipFile", value=cim_files)
+                print(f"BadZipFile {cim_files}")
 
     return data
 
@@ -324,7 +332,7 @@ class CgmesDataParser(BaseCircuit):
                           "http://iec.ch/TC57/ns/CIM/StateVariables-EU/3.0",
                           "http://iec.ch/TC57/ns/CIM/Topology-EU/3.0"]
         # import the cim files' content into a dictionary
-        data = read_cgmes_files(files)
+        data = read_cgmes_files(cim_files=files, logger=self.logger)
         # Parse the files
         i = 0
         for file_name, file_data in data.items():

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/IO/cim/cgmes/cgmes_export.py

@@ -21,6 +21,32 @@ import xml.etree.ElementTree as Et
 import xml.dom.minidom
 
 
+def get_available_cgmes_profiles(cgmes_version: CGMESVersions):
+    if cgmes_version == CGMESVersions.v2_4_15:
+        return {
+            "EQ": ["http://entsoe.eu/CIM/EquipmentCore/3/1",
+                   "http://entsoe.eu/CIM/EquipmentShortCircuit/3/1",
+                   "http://entsoe.eu/CIM/EquipmentOperation/3/1"],
+            "SSH": ["http://entsoe.eu/CIM/SteadyStateHypothesis/1/1"],
+            "TP": ["http://entsoe.eu/CIM/Topology/4/1"],
+            "SV": ["http://entsoe.eu/CIM/StateVariables/4/1"],
+            "GL": ["http://entsoe.eu/CIM/GeographicalLocation/2/1"]
+        }
+    elif cgmes_version == CGMESVersions.v3_0_0:
+        return {
+            "EQ": ["http://iec.ch/TC57/ns/CIM/CoreEquipment-EU/3.0"],
+            "OP": ["http://iec.ch/TC57/ns/CIM/Operation-EU/3.0"],
+            "SC": ["http://iec.ch/TC57/ns/CIM/ShortCircuit-EU/3.0"],
+            "SSH": ["http://iec.ch/TC57/ns/CIM/SteadyStateHypothesis-EU/3.0"],
+            "TP": ["http://iec.ch/TC57/ns/CIM/Topology-EU/3.0"],
+            "SV": ["http://iec.ch/TC57/ns/CIM/StateVariables-EU/3.0"],
+            "GL": ["http://iec.ch/TC57/ns/CIM/GeographicalLocation-EU/3.0"]
+        }
+    else:
+        print(f"CGMES Version not suported {cgmes_version.value}")
+        return dict()
+
+
 class CimExporter:
     def __init__(self, cgmes_circuit: CgmesCircuit, profiles_to_export: List[cgmesProfile], one_file_per_profile: bool):
         self.cgmes_circuit = cgmes_circuit
@@ -48,15 +74,7 @@ class CimExporter:
                 "xmlns:entsoe": "http://entsoe.eu/CIM/SchemaExtension/3/1#",
                 "xmlns:rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
             }
-            self.profile_uris = {
-                "EQ": ["http://entsoe.eu/CIM/EquipmentCore/3/1",
-                       "http://entsoe.eu/CIM/EquipmentShortCircuit/3/1",
-                       "http://entsoe.eu/CIM/EquipmentOperation/3/1"],
-                "SSH": ["http://entsoe.eu/CIM/SteadyStateHypothesis/1/1"],
-                "TP": ["http://entsoe.eu/CIM/Topology/4/1"],
-                "SV": ["http://entsoe.eu/CIM/StateVariables/4/1"],
-                "GL": ["http://entsoe.eu/CIM/GeographicalLocation/2/1"]
-            }
+            self.profile_uris = get_available_cgmes_profiles(cgmes_version=cgmes_circuit.cgmes_version)
 
             self.enum_dict = dict()
             self.about_dict = dict()
@@ -101,15 +119,8 @@ class CimExporter:
                 "xmlns:eu": "http://iec.ch/TC57/CIM100-European#",
                 "xmlns:rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
             }
-            self.profile_uris = {
-                "EQ": ["http://iec.ch/TC57/ns/CIM/CoreEquipment-EU/3.0"],
-                "OP": ["http://iec.ch/TC57/ns/CIM/Operation-EU/3.0"],
-                "SC": ["http://iec.ch/TC57/ns/CIM/ShortCircuit-EU/3.0"],
-                "SSH": ["http://iec.ch/TC57/ns/CIM/SteadyStateHypothesis-EU/3.0"],
-                "TP": ["http://iec.ch/TC57/ns/CIM/Topology-EU/3.0"],
-                "SV": ["http://iec.ch/TC57/ns/CIM/StateVariables-EU/3.0"],
-                "GL": ["http://iec.ch/TC57/ns/CIM/GeographicalLocation-EU/3.0"]
-            }
+            self.profile_uris = get_available_cgmes_profiles(cgmes_version=cgmes_circuit.cgmes_version)
+
             self.enum_dict = dict()
             self.about_dict = dict()
             for s_i, p_i, o_i in rdf_serialization.triples((None, RDF.type, RDFS.Class)):

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/IO/cim/cgmes/cgmes_to_gridcal.py

@@ -279,7 +279,7 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
                     gc_model: MultiCircuit,
                     v_dict: Dict[str, Tuple[float, float]],
                     cn_look_up: CnLookup,
-                    logger: DataLogger) -> Dict[str, gcdev.Bus]:
+                    logger: DataLogger) -> Tuple[Dict[str, gcdev.Bus], bool]:
     """
     Convert the TopologicalNodes to Buses (CalculationNodes)
 
@@ -289,7 +289,7 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
     :param cn_look_up: CnLookup
     :param logger: DataLogger
     :return: dictionary relating the TopologicalNode uuid to the gcdev CalculationNode
-             Dict[str, gcdev.Bus]
+             Dict[str, gcdev.Bus], fatal error?
     """
 
     slack_id = get_slack_id(cgmes_model.cgmes_assets.SynchronousMachine_list)
@@ -310,11 +310,12 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
                              device_class=tp_node.tpe,
                              device_property="nominalVoltage")
         elif nominal_voltage is None:
-            logger.add_error(msg='Nominal voltage is None. :(',
+            logger.add_error(msg='Nominal voltage is None. Maybe boundary was not attached for import :(',
                              device=tp_node.rdfid,
                              device_class=tp_node.tpe,
                              device_property="nominalVoltage")
-            raise Exception("Nominal voltage is missing for Bus (Maybe boundary was not attached for import) !")
+            # raise Exception("Nominal voltage is missing for Bus (Maybe boundary was not attached for import) !")
+            return calc_node_dict, True
 
 
         if voltage is not None and nominal_voltage is not None:
@@ -392,7 +393,7 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
         cn_look_up.add_bus(bus=gcdev_elm)
         calc_node_dict[gcdev_elm.idtag] = gcdev_elm
 
-    return calc_node_dict
+    return calc_node_dict, False
 
 
 def get_gcdev_dc_buses(cgmes_model: CgmesCircuit,
@@ -2339,11 +2340,14 @@ def cgmes_to_gridcal(cgmes_model: CgmesCircuit,
     device_to_terminal_dict = get_gcdev_device_to_terminal_dict(cgmes_model=cgmes_model,
                                                                 logger=logger)
 
-    calc_node_dict: Dict[str, gcdev.Bus] = get_gcdev_buses(cgmes_model=cgmes_model,
-                                                           gc_model=gc_model,
-                                                           v_dict=sv_volt_dict,
-                                                           cn_look_up=cn_look_up,
-                                                           logger=logger)
+    calc_node_dict, fatal_error = get_gcdev_buses(cgmes_model=cgmes_model,
+                                                   gc_model=gc_model,
+                                                   v_dict=sv_volt_dict,
+                                                   cn_look_up=cn_look_up,
+                                                   logger=logger)
+
+    if fatal_error:
+        return gc_model
 
     cn_dict = get_gcdev_connectivity_nodes(cgmes_model=cgmes_model,
                                            gcdev_model=gc_model,

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/IO/cim/cim16/cim_parser.py

@@ -14,7 +14,7 @@ from GridCalEngine.IO.cim.cim16.cim_circuit import CIMCircuit
 from GridCalEngine.data_logger import DataLogger
 
 
-def read_cim_files(cim_files):
+def read_cim_files(cim_files, logger: DataLogger):
     """
     Reads a list of .zip or xml into a dictionary of file name -> list of text lines
     :param cim_files: list of file names
@@ -49,8 +49,13 @@ def read_cim_files(cim_files):
         elif file_extension == '.zip':
             # read the content of a zip file
             d = get_xml_from_zip(file_name_zip=cim_files)
-            for key, value in d.items():
-                data[key] = value
+
+            if d is not None:
+                for key, value in d.items():
+                    data[key] = value
+            else:
+                logger.add_error("BadZipFile", value=cim_files)
+                print(f"BadZipFile {cim_files}")
 
     return data
 
@@ -968,7 +973,7 @@ class CIMImport:
         self.cim = CIMCircuit(text_func=self.text_func, progress_func=self.progress_func, logger=self.logger)
 
         # import the cim files' content into a dictionary
-        data = read_cim_files(cim_files)
+        data = read_cim_files(cim_files=cim_files, logger=self.logger)
 
         lst2 = sort_cim_files(list(data.keys()))
         # Parse the files

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/IO/file_handler.py

@@ -417,6 +417,10 @@ class FileOpen:
                         self.circuit = cgmes_to_gridcal(cgmes_model=self.cgmes_circuit,
                                                         map_dc_to_hvdc_line=self.options.try_to_map_dc_to_hvdc_line,
                                                         logger=self.cgmes_logger)
+
+                        if self.cgmes_logger.has_logs():
+                            self.logger += self.cgmes_logger.get_logger()
+
                     else:
                         # try CIM
                         parser = CIMImport(text_func=text_func, progress_func=progress_func)

{gridcalengine-5.3.39 → gridcalengine-5.3.41}/GridCalEngine/IO/gridcal/zip_interface.py

@@ -3,7 +3,7 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 import json
-from io import StringIO, TextIOWrapper, BytesIO
+from io import StringIO, TextIOWrapper, BytesIO, BufferedReader
 import os
 import numpy as np
 import chardet
@@ -435,7 +435,7 @@ def load_session_driver_objects(file_name_zip: str,
     return data
 
 
-def get_xml_content(file_ptr: zipfile.ZipExtFile) -> List[str]:
+def get_xml_content(file_ptr: zipfile.ZipExtFile | BufferedReader) -> List[str]:
     """
     Reads the content of a file
     :param file_ptr: File pointer (from file or zip file)

gridcalengine-5.3.41/GridCalEngine/IO/iidm/devices/bus.py

@@ -0,0 +1,13 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from GridCalEngine.IO.iidm.devices.rte_object import RteObject
+
+
+class Bus(RteObject):
+    def __init__(self, id):
+        super().__init__("Bus")
+        self.id = id
+
+        self.register_property("id", "bus:id", str, description="Bus ID")

gridcalengine-5.3.41/GridCalEngine/IO/iidm/devices/busbar_section.py

@@ -0,0 +1,13 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from GridCalEngine.IO.iidm.devices.rte_object import RteObject
+
+
+class BusbarSection(RteObject):
+    def __init__(self, id: str):
+        super().__init__("BusbarSection")
+        self.id = id
+
+        self.register_property("id", "busbarSection:id", str, description="Busbar section ID")

gridcalengine-5.3.41/GridCalEngine/IO/iidm/devices/dangling_line.py

@@ -0,0 +1,29 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from GridCalEngine.IO.iidm.devices.rte_object import RteObject, Unit
+
+
+class DanglingLine(RteObject):
+    def __init__(self, id: str, bus: str, p0: float, q0: float, u0: float, r: float, x: float, g: float, b: float):
+        super().__init__("DanglingLine")
+        self.id = id
+        self.bus = bus
+        self.p0 = p0
+        self.q0 = q0
+        self.u0 = u0
+        self.r = r
+        self.x = x
+        self.g = g
+        self.b = b
+
+        self.register_property("id", "danglingLine:id", str, description="Dangling line ID")
+        self.register_property("bus", "danglingLine:bus", str, description="Connected bus")
+        self.register_property("p0", "danglingLine:p0", float, Unit("MW"), description="Active power")
+        self.register_property("q0", "danglingLine:q0", float, Unit("MVAr"), description="Reactive power")
+        self.register_property("u0", "danglingLine:u0", float, Unit("kV"), description="Voltage at terminal")
+        self.register_property("r", "danglingLine:r", float, Unit("Ohm"), description="Resistance")
+        self.register_property("x", "danglingLine:x", float, Unit("Ohm"), description="Reactance")
+        self.register_property("g", "danglingLine:g", float, Unit("S"), description="Conductance")
+        self.register_property("b", "danglingLine:b", float, Unit("S"), description="Susceptance")

gridcalengine-5.3.41/GridCalEngine/IO/iidm/devices/discrete_measurement.py

@@ -0,0 +1,17 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from GridCalEngine.IO.iidm.devices.rte_object import RteObject
+
+
+class DiscreteMeasurement(RteObject):
+    def __init__(self, id: str, equipmentId: str, value: bool):
+        super().__init__("DiscreteMeasurement")
+        self.id = id
+        self.equipmentId = equipmentId
+        self.value = value
+
+        self.register_property("id", "discreteMeasurement:id", str, description="Measurement ID")
+        self.register_property("equipmentId", "discreteMeasurement:equipmentId", str, description="Referenced equipment ID")
+        self.register_property("value", "discreteMeasurement:value", bool, description="Boolean value of the measurement")