GridCalEngine 5.0.14__tar.gz → 5.0.16__tar.gz

{GridCalEngine-5.0.14 → GridCalEngine-5.0.16}/GridCalEngine/Devices/multi_circuit.py

@@ -4933,6 +4933,61 @@ class MultiCircuit:
 
         return groups
 
+    def get_injection_devices_grouped_by_group_type(
+            self,
+            group_type: DeviceType) -> List[Dict[DeviceType, List[INJECTION_DEVICE_TYPES]]]:
+        """
+        Get the injection devices grouped by bus and by device type
+        :return: Dict[bus, Dict[DeviceType, List[Injection devs]]
+        """
+        result: List[Dict[DeviceType, List[INJECTION_DEVICE_TYPES]]] = list()
+
+        group_devices = self.get_elements_by_type(device_type=group_type)
+
+        for group_device in group_devices:
+
+            devices_by_type = dict()
+
+            for lst in self.get_injection_devices_lists():
+
+                for elm in lst:
+
+                    if group_type == DeviceType.AreaDevice:
+                        matches = elm.bus.area == group_device
+
+                    elif group_type == DeviceType.ZoneDevice:
+                        matches = elm.bus.zone == group_device
+
+                    elif group_type == DeviceType.SubstationDevice:
+                        matches = elm.bus.substation == group_device
+
+                    elif group_type == DeviceType.CountryDevice:
+                        matches = ((elm.bus.country == group_device) or
+                                   (elm.bus.substation.country == group_device))
+
+                    elif group_type == DeviceType.CommunityDevice:
+                        matches = (elm.bus.substation.community == group_device)
+
+                    elif group_type == DeviceType.RegionDevice:
+                        matches = elm.bus.substation.region == group_device
+
+                    elif group_type == DeviceType.MunicipalityDevice:
+                        matches = elm.bus.substation.municipality == group_device
+
+                    else:
+                        matches = False
+
+                    if matches:
+                        lst = devices_by_type.get(elm.device_type, None)
+                        if lst is None:
+                            devices_by_type[elm.device_type] = [elm]
+                        else:
+                            devices_by_type[elm.device_type].append(elm)
+
+            result.append(devices_by_type)
+
+        return result
+
     def get_batteries_by_bus(self) -> Dict[dev.Bus, List[dev.Battery]]:
         """
         Get the injection devices grouped by bus and by device type
@@ -5714,7 +5769,6 @@ class MultiCircuit:
 
         return logger
 
-
     # def split_line(self, line: dev.Line, position: float) -> Tuple["Line", "Line", Bus]:
     #     """
     #     Split a branch by a given distance
@@ -5751,4 +5805,4 @@ class MultiCircuit:
     #     for p in props_to_scale:
     #         setattr(br2, p, getattr(line, p) * (1.0 - position))
     #
-    #     return br1, br2, middle_bus
+    #     return br1, br2, middle_bus

{GridCalEngine-5.0.14 → GridCalEngine-5.0.16}/GridCalEngine/Devices/profile.py

@@ -334,15 +334,7 @@ class Profile:
 
         if isinstance(other, (int, float)):
 
-            if self._is_sparse:
-
-                # Scale the map
-                self._sparse_array._map = {key: val * other
-                                           for key, val in self._sparse_array.get_map().items()}
-            else:
-
-                # Scale the dense array
-                self._dense_array *= other
+            self.scale(value=other)
 
         else:
             raise TypeError("Unsupported type {}".format(type(other)))
@@ -399,6 +391,21 @@ class Profile:
         self._dense_array = None
         self._dtype = type(value)
 
+    def scale(self, value: Union[float, int]):
+        """
+        Scale this profile with the same value
+        :param value: any value
+        """
+        if self._is_sparse:
+
+            # Scale the map
+            self._sparse_array._map = {key: val * value
+                                       for key, val in self._sparse_array.get_map().items()}
+        else:
+
+            # Scale the dense array
+            self._dense_array *= value
+
     def size(self) -> int:
         """
         Get the size

{GridCalEngine-5.0.14 → GridCalEngine-5.0.16}/GridCalEngine/IO/cim/cgmes/base.py

@@ -65,18 +65,19 @@ def rfid2uuid(val):
     return val.replace('-', '').replace('_', '')
 
 
-def get_uuid(string: str) -> str:
+def form_rdfid(idtag: str) -> str:
     """
-    Converts a simple string (without hyphens or underscores) to a UUID format.
+    Converts a simple string, eg. idtag (without hyphens or underscores)
+    to a UUID format.
 
     Args:
-        string (str): The input string without hyphens or underscores.
+        idtag (str): The input idtag without hyphens or underscores.
 
     Returns:
-        str: The corresponding UUID string with hyphens.
+        str: The corresponding UUID idtag with hyphens.
     """
-    # Add hyphens to the simple string to create a valid UUID
-    formatted_uuid = f"{string[:8]}-{string[8:12]}-{string[12:16]}-{string[16:20]}-{string[20:]}"
+    # Add hyphens to the simple idtag to create a valid UUID
+    formatted_uuid = f"{idtag[:8]}-{idtag[8:12]}-{idtag[12:16]}-{idtag[16:20]}-{idtag[20:]}"
     try:
         # Validate and return the UUID
         UUID(formatted_uuid)

{GridCalEngine-5.0.14 → GridCalEngine-5.0.16}/GridCalEngine/IO/cim/cgmes/cgmes_to_gridcal.py

@@ -30,7 +30,7 @@ from GridCalEngine.IO.cim.cgmes.cgmes_utils import (get_nominal_voltage,
                                                     get_windings,
                                                     get_regulating_control, get_pu_values_power_transformer_end,
                                                     get_slack_id)
-from GridCalEngine.IO.cim.cgmes.gridcal_to_cgmes import gridcal_to_cgmes
+from GridCalEngine.IO.cim.cgmes.gridcal_to_cgmes import gridcal_to_cgmes    #TODO move them here
 from GridCalEngine.data_logger import DataLogger
 from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.identified_object import IdentifiedObject
 from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.terminal import Terminal
@@ -162,6 +162,24 @@ def find_connections(cgmes_elm: IdentifiedObject,
     return calc_nodes, cns
 
 
+def find_object_by_idtag(object_list, target_idtag):  #TODO mone to somewhere
+    """
+    Finds an object with the specified idtag
+     in the given object_list from a Multi Circuit.
+
+    Args:
+        object_list (list[MyObject]): List of MyObject instances.
+        target_idtag (str): The uuid to search for.
+
+    Returns:
+        MyObject or None: The found object or None if not found.
+    """
+    for obj in object_list:
+        if obj.idtag == target_idtag:
+            return obj
+    return None
+
+
 def get_gcdev_calculation_nodes(cgmes_model: CgmesCircuit,
                                 gc_model: MultiCircuit,
                                 v_dict: Dict[str, Tuple[float, float]],
@@ -885,21 +903,12 @@ def get_gcdev_switches(cgmes_model: CgmesCircuit,
 
 
 def get_gcdev_substations(cgmes_model: CgmesCircuit,
-                          gcdev_model: MultiCircuit,
-                          calc_node_dict: Dict[str, gcdev.Bus],
-                          cn_dict: Dict[str, gcdev.ConnectivityNode],
-                          device_to_terminal_dict: Dict[str, List[Terminal]],
-                          logger: DataLogger
-                          ) -> None:
+                          gcdev_model: MultiCircuit) -> None:
     """
-    Convert the CGMES substations to gcdev
+    Convert the CGMES substations to gcdev substations
 
     :param cgmes_model: CgmesCircuit
     :param gcdev_model: gcdevCircuit
-    :param calc_node_dict: Dict[str, gcdev.Bus]
-    :param cn_dict: Dict[str, gcdev.ConnectivityNode]
-    :param device_to_terminal_dict: Dict[str, Terminal]
-    :param logger:
     """
     # convert substations
     for device_list in [cgmes_model.Substation_list]:
@@ -916,7 +925,53 @@ def get_gcdev_substations(cgmes_model: CgmesCircuit,
 
             gcdev_model.add_substation(gcdev_elm)
 
-    # convert Busbars
+
+def get_gcdev_voltage_levels(cgmes_model: CgmesCircuit,
+                             gcdev_model: MultiCircuit,
+                             logger: DataLogger) -> None:
+    """
+    Convert the CGMES voltage levels to gcdev voltage levels
+
+    :param cgmes_model: CgmesCircuit
+    :param gcdev_model: gcdevCircuit
+    :param logger:
+    """
+    for cgmes_elm in cgmes_model.VoltageLevel_list:
+
+        gcdev_elm = gcdev.VoltageLevel(
+            idtag=cgmes_elm.uuid,
+            name=cgmes_elm.name,
+            Vnom=cgmes_elm.BaseVoltage.nominalVoltage
+        )
+
+        subs = find_object_by_idtag(
+            object_list=gcdev_model.substations,
+            target_idtag=cgmes_elm.Substation.uuid  # gcdev_elm.idtag
+        )
+        if subs:
+            gcdev_elm.substation = subs
+
+        gcdev_model.add_voltage_level(gcdev_elm)
+
+
+def get_gcdev_busbars(cgmes_model: CgmesCircuit,
+                      gcdev_model: MultiCircuit,
+                      calc_node_dict: Dict[str, gcdev.Bus],
+                      cn_dict: Dict[str, gcdev.ConnectivityNode],
+                      device_to_terminal_dict: Dict[str, List[Terminal]],
+                      logger: DataLogger
+                      ) -> None:
+    """
+    Convert the CGMES busbars to gcdev busbars
+
+    :param cgmes_model: CgmesCircuit
+    :param gcdev_model: gcdevCircuit
+    :param calc_node_dict: Dict[str, gcdev.Bus]
+    :param cn_dict: Dict[str, gcdev.ConnectivityNode]
+    :param device_to_terminal_dict: Dict[str, Terminal]
+    :param logger:
+    """
+    # convert busbars
     for device_list in [cgmes_model.BusbarSection_list]:
 
         for cgmes_elm in device_list:
@@ -943,7 +998,7 @@ def get_gcdev_substations(cgmes_model: CgmesCircuit,
                     name=cgmes_elm.name,
                     idtag=cgmes_elm.uuid,
                     code=cgmes_elm.description,
-                    substation=substation,
+                    # substation=substation,  #TODO fix it with VoltageLevel
                     cn=cn
                 )
                 gcdev_model.add_bus_bar(gcdev_elm)
@@ -993,17 +1048,19 @@ def cgmes_to_gridcal(cgmes_model: CgmesCircuit,
     get_gcdev_shunts(cgmes_model, gc_model, calc_node_dict, cn_dict, device_to_terminal_dict, logger, Sbase)
     get_gcdev_switches(cgmes_model, gc_model, calc_node_dict, cn_dict, device_to_terminal_dict, logger, Sbase)
 
-    get_gcdev_substations(cgmes_model, gc_model, calc_node_dict, cn_dict, device_to_terminal_dict, logger)
+    get_gcdev_substations(cgmes_model, gc_model)
+    get_gcdev_voltage_levels(cgmes_model, gc_model, logger)
+    get_gcdev_busbars(cgmes_model, gc_model, calc_node_dict, cn_dict, device_to_terminal_dict, logger)
     print('debug')
 
     # Export with ET
-    start = time.time()
-    serializer = CimExporter(cgmes_model)
-    serializer.export()
-    end = time.time()
-    print("ET export time: ", end - start, "sec")
+    # start = time.time()
+    # serializer = CimExporter(cgmes_model)
+    # serializer.export()
+    # end = time.time()
+    # print("ET export time: ", end - start, "sec")
 
     # Gridcal to cgmes
-    # exported_cgmes = gridcal_to_cgmes(gc_model, logger)
+    cgmes_model_export = gridcal_to_cgmes(gc_model, logger)
 
     return gc_model

GridCalEngine-5.0.16/GridCalEngine/IO/cim/cgmes/gridcal_to_cgmes.py

@@ -0,0 +1,228 @@
+from GridCalEngine.Devices import MultiCircuit
+from GridCalEngine.IO.cim.cgmes.base import get_new_rfid, form_rdfid
+from GridCalEngine.IO.cim.cgmes.cgmes_circuit import CgmesCircuit
+# import GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices as cgmes
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.base_voltage import BaseVoltage
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.substation import Substation
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.voltage_level import VoltageLevel
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.connectivity_node import ConnectivityNode
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.topological_node import TopologicalNode
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.sv_voltage import SvVoltage
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.conform_load import ConformLoad
+from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.load_response_characteristic import LoadResponseCharacteristic
+from GridCalEngine.data_logger import DataLogger
+from typing import Dict, List, Tuple
+
+
+# region UTILS
+def find_terms_connections():
+    pass # TODO
+
+
+def find_object_by_uuid(object_list, target_uuid):  #TODO mone to CGMES utils
+    """
+    Finds an object with the specified uuid
+     in the given object_list from a CGMES Circuit.
+
+    Args:
+        object_list (list[MyObject]): List of MyObject instances.
+        target_uuid (str): The uuid to search for.
+
+    Returns:
+        MyObject or None: The found object or None if not found.
+    """
+    for obj in object_list:
+        if obj.uuid == target_uuid:
+            return obj
+    return None
+
+
+def find_object_by_vnom(object_list: List[BaseVoltage], target_vnom):
+    for obj in object_list:
+        if obj.nominalVoltage == target_vnom:
+            return obj
+    return None
+
+# endregion
+
+# region Convert functions from MC to CC
+def get_cgmes_geograpical_regions(multi_circuit_model: MultiCircuit,
+                            cgmes_model: CgmesCircuit,
+                            logger: DataLogger):
+    pass
+
+
+def get_cgmes_subgeograpical_regions(multi_circuit_model: MultiCircuit,
+                            cgmes_model: CgmesCircuit,
+                            logger: DataLogger):
+    pass
+
+
+def get_cgmes_base_voltages(multi_circuit_model: MultiCircuit,
+                            cgmes_model: CgmesCircuit,
+                            logger: DataLogger):
+    base_volt_set = set()
+    for bus in multi_circuit_model.buses:
+
+        if bus.Vnom not in base_volt_set:
+            base_volt_set.add(bus.Vnom)
+
+            new_rdfid = get_new_rfid()
+            base_volt = BaseVoltage(rdfid=new_rdfid)
+            base_volt.name = f'_BV_{int(bus.Vnom)}'
+            base_volt.nominalVoltage = bus.Vnom
+
+            cgmes_model.BaseVoltage_list.append(base_volt)
+    return
+
+
+def get_cgmes_substations(multi_circuit_model: MultiCircuit,
+                          cgmes_model: CgmesCircuit,
+                          logger: DataLogger):
+
+    for mc_elm in multi_circuit_model.substations:
+
+        substation = Substation(rdfid=form_rdfid(mc_elm.idtag))
+        substation.name = mc_elm.name
+        substation.Region = find_object_by_uuid(
+            object_list=cgmes_model.SubGeographicalRegion_list,
+            target_uuid=mc_elm.idtag  #TODO Community.idtag!
+        )
+
+        cgmes_model.Substation_list.append(substation)
+
+
+def get_cgmes_voltage_levels(multi_circuit_model: MultiCircuit,
+                             cgmes_model: CgmesCircuit,
+                             logger: DataLogger):
+
+    for mc_elm in multi_circuit_model.voltage_levels:
+
+        vl = VoltageLevel(rdfid=form_rdfid(mc_elm.idtag))
+        vl.name = mc_elm.name
+        vl.BaseVoltage = find_object_by_vnom(
+            object_list=cgmes_model.BaseVoltage_list,
+            target_vnom=mc_elm.Vnom
+        )
+        # vl.Bays = later
+
+        if mc_elm.substation is not None:
+            substation: Substation = find_object_by_uuid(
+                object_list=cgmes_model.Substation_list,
+                target_uuid=mc_elm.substation.idtag
+            )
+            if substation:
+                vl.Substation = substation
+
+                # link back
+                if substation.VoltageLevels is None:
+                    substation.VoltageLevels = set()
+                substation.VoltageLevels.add(vl)
+
+        cgmes_model.VoltageLevel_list.append(vl)
+
+
+def get_cgmes_cn_tn_nodes(multi_circuit_model: MultiCircuit,
+                          cgmes_model: CgmesCircuit,
+                          logger: DataLogger):
+
+    for bus in multi_circuit_model.buses:
+
+        new_rdfid = get_new_rfid()
+        tn = TopologicalNode(new_rdfid)
+        tn.name = bus.name
+        tn.BaseVoltage = find_object_by_vnom(
+            object_list=cgmes_model.BaseVoltage_list,
+            target_vnom=bus.Vnom
+        )
+        # tn.ConnectivityNodeContainer = VoltageLevel
+        #TODO bus should have association for VoltageLevel first
+        # and the voltagelevel to the substation
+
+        cn = ConnectivityNode(rdfid=form_rdfid(bus.idtag))
+        cn.name = bus.name
+        cn.TopologicalNode = tn
+        # cn.ConnectivityNodeContainer = VoltageLevel same as for tn
+
+        cgmes_model.ConnectivityNode_list.append(cn)
+        cgmes_model.TopologicalNode_list.append(tn)
+
+    return
+
+
+def get_cgmes_svvoltages(v_dict: Dict[str, Tuple[float, float]],
+                         cgmes_model: CgmesCircuit,
+                         logger: DataLogger) -> CgmesCircuit:
+    """
+    Creates a CgmesCircuit SvVoltage_list.
+
+    Args:
+        v_dict (Dict[str, Tuple[float, float]]): The voltage dictionary.
+        logger (DataLogger): The data logger for error handling.
+
+    Returns:
+        CgmesCircuit: A CgmesCircuit object with SvVoltage_list populated.
+    """
+    #TODO should it come from the results?
+    for uuid, (v, angle) in v_dict.items():
+        # Create an SvVoltage instance for each entry in v_dict
+        sv_voltage = SvVoltage(
+            rdfid=uuid, tpe='SvVoltage'
+        )
+        sv_voltage.v = v
+        sv_voltage.angle = angle
+
+        # Add the SvVoltage instance to the SvVoltage_list
+        cgmes_model.SvVoltage_list.append(sv_voltage)
+
+    return cgmes_model
+
+
+def get_cgmes_loads(multicircuit_model: MultiCircuit,
+                    cgmes_model: CgmesCircuit,
+                    logger: DataLogger):
+
+    # TODO find connections
+    find_terms_connections()
+    for mc_elm in multicircuit_model.loads:
+        # TODO How do we determine what the MultiCircuit mc_elm corresponds to in the Cgmes object? Is it EnergyConsumer, Conformmc_elm, NonConformmc_elm
+        # mc_elm.bus contains the Terminal connections ?
+        # all can be Conformmc_elm! and mc_elmResponseChar
+        cl = ConformLoad(rdfid=form_rdfid(mc_elm.idtag))
+        cl.description = mc_elm.code
+        cl.name = mc_elm.name
+        cl.p = mc_elm.P
+        cl.q = mc_elm.Q
+        cgmes_model.ConformLoad_list.append(cl)
+
+# endregion
+
+
+def gridcal_to_cgmes(gc_model: MultiCircuit, logger: DataLogger) -> CgmesCircuit:
+    """
+    Converts the input Multi circuit to a new CGMES Circuit.
+
+    :param gc_model: Multi circuit object
+    :param logger: Logger object
+    :return: CGMES circuit (as a new object)
+    """
+
+    cgmes_circuit = CgmesCircuit()
+    
+    get_cgmes_geograpical_regions(gc_model, cgmes_circuit, logger)
+    get_cgmes_subgeograpical_regions(gc_model, cgmes_circuit, logger)
+    
+    get_cgmes_base_voltages(gc_model, cgmes_circuit, logger)
+
+    get_cgmes_substations(gc_model, cgmes_circuit, logger)
+    get_cgmes_voltage_levels(gc_model, cgmes_circuit, logger)
+
+    get_cgmes_cn_tn_nodes(gc_model, cgmes_circuit, logger)
+
+    #TODO How to determine the device_to_terminal_dict, calc_node_dict, and cn_dict dictionaries?
+    # What are the appropriate data types in MultiCircuit that provide the connectivity?
+
+    #TODO Determine multicircuit terminals here to be able to define connections
+    get_cgmes_loads(gc_model, cgmes_circuit, logger)
+
+    return cgmes_circuit