GridCalEngine 5.3.38__tar.gz → 5.3.40__tar.gz

{gridcalengine-5.3.38 → gridcalengine-5.3.40}/GridCalEngine/Compilers/circuit_to_gslv.py

@@ -3,27 +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 warnings
+import time
 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.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
+
+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
@@ -32,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]:
@@ -188,8 +100,6 @@ def fill_profile(gslv_profile: "pg.Profiledouble|pg.Profilebool|pg.Profileint|pg
     :param default_val: Default value
     """
 
-
-
     if use_time_series:
         if gc_profile.is_sparse:
             if time_indices is None:
@@ -2418,7 +2328,8 @@ def gslv_pf(circuit: MultiCircuit,
             pf_opt: PowerFlowOptions,
             time_series: bool = False,
             time_indices: Union[IntVec, None] = None,
-            opf_results: Union[None, OptimalPowerFlowResults] = None) -> "pg.PowerFlowResults":
+            opf_results: Union[None, OptimalPowerFlowResults] = None,
+            logger: Logger = Logger()) -> "pg.PowerFlowResults":
     """
     GSLV power flow
     :param circuit: MultiCircuit instance
@@ -2449,19 +2360,23 @@ def gslv_pf(circuit: MultiCircuit,
         time_indices = [0]
         n_threads = 1
 
+    t0 = time.time()
     pf_res = pg.multi_island_pf(grid=gslv_grid,
                                 options=pf_options,
                                 time_indices=time_indices,
                                 n_threads=n_threads)
 
+    logger.add_info("gslv time", value=f"{(time.time() - t0)} s")
+
     return pf_res
 
 
-def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults") -> PowerFlowResults:
+def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", logger: Logger) -> PowerFlowResults:
     """
     Translate the GSLV Power Analytics results back to GridCal
     :param grid: MultiCircuit instance
     :param res: GSLV's PowerFlowResults instance
+    :param logger: Logger
     :return: PowerFlowResults instance
     """
     results = PowerFlowResults(
@@ -2489,10 +2404,10 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults") ->
     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
@@ -2502,6 +2417,18 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults") ->
     results.Pt_hvdc = res.Pt_hvdc[0, :]
     results.loading_hvdc = res.loading_hvdc[0, :]
     results.losses_hvdc = res.losses_hvdc[0, :]
+
+    results.Pf_vsc = res.Pf_vsc[0, :]
+    results.St_vsc = res.St_vsc[0, :]
+    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, :]
+
+    # 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_types = convert_bus_types(res.bus_types[0])  # this is a list of lists
@@ -2657,8 +2584,8 @@ def compare_branch_parent_data(gslv_branch_data: pg.BranchParentData,
     # branch data
     errors += CheckArrEq(np.array(gslv_branch_data.idtag), np.array(gc_branch_data.idtag), parent_name, 'idtag')
     errors += CheckArrEq(gslv_branch_data.F, gc_branch_data.F, parent_name, 'F')
-    errors += CheckArrEq(gslv_branch_data.T, gc_branch_data.T,  parent_name, 'T')
-    errors += CheckArrEq(gslv_branch_data.active, gc_branch_data.active,  parent_name, 'active')
+    errors += CheckArrEq(gslv_branch_data.T, gc_branch_data.T, parent_name, 'T')
+    errors += CheckArrEq(gslv_branch_data.active, gc_branch_data.active, parent_name, 'active')
     errors += CheckArr(gslv_branch_data.rates, gc_branch_data.rates, tol, parent_name, 'rates')
 
     errors += CheckArr(gslv_branch_data.contingency_rates, gc_branch_data.contingency_rates, tol,
@@ -2671,14 +2598,14 @@ def compare_branch_parent_data(gslv_branch_data: pg.BranchParentData,
     errors += CheckArr(gslv_branch_data.mttr, gc_branch_data.mttr, tol, parent_name, 'mttr')
 
     errors += CheckArrEq(gslv_branch_data.contingency_enabled, gc_branch_data.contingency_enabled,
-                       parent_name, 'contingency_enabled')
+                         parent_name, 'contingency_enabled')
     errors += CheckArrEq(gslv_branch_data.monitor_loading, gc_branch_data.monitor_loading,
-                       parent_name, 'monitor_loading')
+                         parent_name, 'monitor_loading')
 
     errors += CheckArr(gslv_branch_data.overload_cost, gc_branch_data.overload_cost, tol,
                        parent_name, 'overload_cost')
     errors += CheckArrEq(gslv_branch_data.original_idx, gc_branch_data.original_idx,
-                       parent_name, 'original_idx')
+                         parent_name, 'original_idx')
     # errors += CheckArr(gslv_branch_data.reducible, gc_branch_data.reducible, tol, parent_name, 'reducible')
 
     return errors
@@ -2695,7 +2622,7 @@ def compare_nc(nc_gslv: "pg.NumericalCircuit", nc_gc: NumericalCircuit, tol: flo
     errors = 0
 
     # bus data
-    errors += CheckArrEq(nc_gslv.bus_data.active, nc_gc.bus_data.active,  'BusData', 'active')
+    errors += CheckArrEq(nc_gslv.bus_data.active, nc_gc.bus_data.active, 'BusData', 'active')
     errors += CheckArr(nc_gslv.bus_data.Vbus.real, nc_gc.bus_data.Vbus.real, tol, 'BusData', 'V0')
     errors += CheckArr(nc_gslv.bus_data.installed_power, nc_gc.bus_data.installed_power, tol,
                        'BusData', 'installed power')
@@ -2736,14 +2663,14 @@ def compare_nc(nc_gslv: "pg.NumericalCircuit", nc_gc: NumericalCircuit, tol: flo
     errors += CheckArr(nc_gslv.vsc_data.control1_val, nc_gc.vsc_data.control1_val, tol, 'VscData', 'control1_val')
     errors += CheckArr(nc_gslv.vsc_data.control2_val, nc_gc.vsc_data.control2_val, tol, 'VscData', 'control2_val')
 
-    errors += CheckArrEq(nc_gslv.vsc_data.control1_bus_idx, nc_gc.vsc_data.control1_bus_idx,  'VscData',
-                       'control1_bus_idx')
-    errors += CheckArrEq(nc_gslv.vsc_data.control2_bus_idx, nc_gc.vsc_data.control2_bus_idx,  'VscData',
-                       'control2_bus_idx')
-    errors += CheckArrEq(nc_gslv.vsc_data.control1_branch_idx, nc_gc.vsc_data.control1_branch_idx,  'VscData',
-                       'control1_branch_idx')
-    errors += CheckArrEq(nc_gslv.vsc_data.control2_branch_idx, nc_gc.vsc_data.control2_branch_idx,  'VscData',
-                       'control2_branch_idx')
+    errors += CheckArrEq(nc_gslv.vsc_data.control1_bus_idx, nc_gc.vsc_data.control1_bus_idx, 'VscData',
+                         'control1_bus_idx')
+    errors += CheckArrEq(nc_gslv.vsc_data.control2_bus_idx, nc_gc.vsc_data.control2_bus_idx, 'VscData',
+                         'control2_bus_idx')
+    errors += CheckArrEq(nc_gslv.vsc_data.control1_branch_idx, nc_gc.vsc_data.control1_branch_idx, 'VscData',
+                         'control1_branch_idx')
+    errors += CheckArrEq(nc_gslv.vsc_data.control2_branch_idx, nc_gc.vsc_data.control2_branch_idx, 'VscData',
+                         'control2_branch_idx')
 
     # HVDC data
     errors += compare_branch_parent_data(nc_gslv.hvdc_data, nc_gc.hvdc_data, tol, "HvdcData")
@@ -2768,8 +2695,8 @@ def compare_nc(nc_gslv: "pg.NumericalCircuit", nc_gc: NumericalCircuit, tol: flo
     errors += CheckArr(nc_gslv.hvdc_data.Qmax_t, nc_gc.hvdc_data.Qmax_t, tol, 'HvdcData', 'Qmax_t')
 
     # generator data
-    errors += CheckArrEq(nc_gslv.generator_data.bus_idx, nc_gc.generator_data.bus_idx,  'GenData', 'bus_idx')
-    errors += CheckArrEq(nc_gslv.generator_data.active, nc_gc.generator_data.active,  'GenData', 'active')
+    errors += CheckArrEq(nc_gslv.generator_data.bus_idx, nc_gc.generator_data.bus_idx, 'GenData', 'bus_idx')
+    errors += CheckArrEq(nc_gslv.generator_data.active, nc_gc.generator_data.active, 'GenData', 'active')
     errors += CheckArr(nc_gslv.generator_data.p, nc_gc.generator_data.p, tol, 'GenData', 'P')
     errors += CheckArr(nc_gslv.generator_data.pf, nc_gc.generator_data.pf, tol, 'GenData', 'Pf')
     errors += CheckArr(nc_gslv.generator_data.v, nc_gc.generator_data.v, tol, 'GenData', 'v')

{gridcalengine-5.3.38 → gridcalengine-5.3.40}/GridCalEngine/Devices/Branches/line.py

@@ -325,8 +325,9 @@ class Line(BranchParent):
             raise Exception("Template must be set before changing the circuit index.")
         if not isinstance(obj, (OverheadLineType, UndergroundLineType, SequenceLineType)):
             raise Exception("Invalid template type. Must be OverheadLineType, UndergroundLineType, or SequenceLineType.")
-        if val > obj.n_circuits and isinstance(obj, OverheadLineType):
-            raise Exception("Circuit index exceeds the number of circuits in the template.")
+        if isinstance(obj, OverheadLineType):
+            if val > obj.n_circuits:
+                raise Exception("Circuit index exceeds the number of circuits in the template.")
         if val <= 0:
             raise Exception("Circuit index must be greater than 0.")
         else:

{gridcalengine-5.3.38 → gridcalengine-5.3.40}/GridCalEngine/Devices/Branches/wire.py

@@ -13,7 +13,8 @@ class Wire(EditableDevice):
     to compose towers
     """
 
-    def __init__(self, name='', idtag: Union[str, None] = None,
+    def __init__(self, name='',
+                 idtag: Union[str, None] = None,
                  r: float = 0.01,
                  max_current: float = 1.0,
                  stranding: str = "",

{gridcalengine-5.3.38 → gridcalengine-5.3.40}/GridCalEngine/Devices/Parents/editable_device.py

@@ -83,6 +83,23 @@ def parse_idtag(val: Union[str, None]) -> str:
         return str(val)
 
 
+def smart_compare(a, b, atol = 1.e-10):
+    """
+    Compares two Python objects with tolerance for numerical values.
+
+    If both inputs are numeric (int, float, complex, or NumPy numbers),
+    the function uses `np.isclose()` to compare them. For all other types, it falls back to
+    standard equality comparison (`==`).
+
+    a :First object to compare.
+    b :Second object to compare.
+    :return: bool
+    """
+    if isinstance(a, float) and isinstance(b, float):
+        return np.isclose(a, b, atol=atol)
+    return a == b
+
+
 class GCProp:
     """
     GridCal property
@@ -879,7 +896,7 @@ class EditableDevice:
             v1 = self.get_property_value(prop=prop, t_idx=None)
             v2 = other.get_property_value(prop=prop, t_idx=None)
 
-            if v1 != v2:
+            if not smart_compare(v1, v2):
                 logger.add_info(msg="Different snapshot values",
                                 device_class=self.device_type.value,
                                 device_property=prop.name,
@@ -907,7 +924,7 @@ class EditableDevice:
                         v1 = p1[t_idx]
                         v2 = p2[t_idx]
 
-                        if v1 != v2:
+                        if not smart_compare(v1, v2):
                             logger.add_info(msg="Different time series values",
                                             device_class=self.device_type.value,
                                             device_property=prop.name,
@@ -919,7 +936,7 @@ class EditableDevice:
                         v1b = self.get_property_value(prop=prop, t_idx=t_idx)
                         v2b = other.get_property_value(prop=prop, t_idx=t_idx)
 
-                        if v1 != v1b:
+                        if not smart_compare(v1, v1b):
                             logger.add_info(
                                 msg="Profile values differ with different getter methods!",
                                 device_class=self.device_type.value,
@@ -929,7 +946,7 @@ class EditableDevice:
                                 expected_value=v1)
                             action = ActionType.Modify
 
-                        if v2 != v2b:
+                        if not smart_compare(v2, v2b):
                             logger.add_info(
                                 msg="Profile getting values differ with different getter methods!",
                                 device_class=self.device_type.value,

{gridcalengine-5.3.38 → gridcalengine-5.3.40}/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.38 → gridcalengine-5.3.40}/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.38 → gridcalengine-5.3.40}/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.38 → gridcalengine-5.3.40}/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.38 → gridcalengine-5.3.40}/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.38 → gridcalengine-5.3.40}/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.38 → gridcalengine-5.3.40}/GridCalEngine/Simulations/ContingencyAnalysis/contingency_analysis_driver.py

@@ -167,14 +167,25 @@ class ContingencyAnalysisDriver(DriverTemplate):
 
         elif self.engine == EngineType.GSLV:
 
-            self.report_text("Running contingencies in newton...")
+            self.report_text("Running contingencies in gslv...")
             con_res = gslv_contingencies(circuit=self.grid,
                                          con_opt=self.options,
                                          time_series=False,
                                          time_indices=None)
 
-            self.results = translate_newton_pa_contingencies(grid=self.grid,
-                                                             con_res=con_res)
+            self.results = ContingencyAnalysisResults(
+                ncon=self.grid.get_contingency_groups_number(),
+                nbus=self.grid.get_bus_number(),
+                nbr=self.grid.get_branch_number_wo_hvdc(),
+                bus_names=self.grid.get_bus_names(),
+                branch_names=self.grid.get_branch_names_wo_hvdc(),
+                bus_types=np.ones(self.grid.get_bus_number(), dtype=int),
+                con_names=np.array(self.grid.get_contingency_group_names())
+            )
+
+            # results.S[t, :] = res_t.S.real.max(axis=0)
+            self.results.max_flows = con_res.max_values.Sf[0, :]
+            self.results.max_loading = con_res.max_values.loading[0, :]
 
         return self.results