GridCalEngine 5.1.17__tar.gz → 5.1.19__tar.gz

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/Devices/Aggregation/area.py

@@ -41,10 +41,8 @@ class GenericAreaGroup(EditableDevice):
         self.latitude = latitude
         self.longitude = longitude
 
-        self.register(key='longitude', units='deg', tpe=float, definition='longitude.', profile_name='',
-                      editable=False)
-        self.register(key='latitude', units='deg', tpe=float, definition='latitude.', profile_name='',
-                      editable=False)
+        self.register(key='longitude', units='deg', tpe=float, definition='longitude.', profile_name='')
+        self.register(key='latitude', units='deg', tpe=float, definition='latitude.', profile_name='')
 
 
 class Area(GenericAreaGroup):

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/Devices/Diagrams/map_location.py

@@ -37,12 +37,63 @@ class MapLocation:
         :param draw_labels:
         """
 
-        self.latitude = latitude
-        self.longitude = longitude
-        self.altitude = altitude
+        self._latitude = latitude if latitude is not None else 0.0
+        self._longitude = longitude if longitude is not None else 0.0
+        self._altitude = altitude if altitude is not None else 0.0
         self.draw_labels = draw_labels
         self.api_object = api_object
 
+    @property
+    def latitude(self):
+        """
+
+        :return:
+        """
+        return self._latitude
+
+    @latitude.setter
+    def latitude(self, val: float):
+        """
+
+        :param val:
+        :return:
+        """
+        self._latitude = val if val is not None else 0.0
+
+    @property
+    def longitude(self):
+        """
+
+        :return:
+        """
+        return self._longitude
+
+    @longitude.setter
+    def longitude(self, val: float):
+        """
+
+        :param val:
+        :return:
+        """
+        self._longitude = val if val is not None else 0.0
+
+    @property
+    def altitude(self):
+        """
+
+        :return:
+        """
+        return self._altitude
+
+    @altitude.setter
+    def altitude(self, val: float):
+        """
+
+        :param val:
+        :return:
+        """
+        self._altitude = val if val is not None else 0.0
+
     def get_properties_dict(self) -> Dict[str, float]:
         """
         get as a dictionary point

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/Devices/Injections/generator.py

@@ -248,10 +248,10 @@ class Generator(GeneratorParent):
 
         self.register(key='enabled_dispatch', units='', tpe=bool, definition='Enabled for dispatch? Used in OPF.')
 
-        self.register(key='emissions', units='', tpe=SubObjectType.Associations,
+        self.register(key='emissions', units='t/MWh', tpe=SubObjectType.Associations,
                       definition='List of emissions', display=False)
 
-        self.register(key='fuels', units='', tpe=SubObjectType.Associations,
+        self.register(key='fuels', units='t/MWh', tpe=SubObjectType.Associations,
                       definition='List of fuels', display=False)
 
     @property

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/Devices/Parents/injection_parent.py

@@ -114,7 +114,7 @@ class InjectionParent(EditableDevice):
         self.register(key='Cost', units='e/MWh', tpe=float, definition='Cost of not served energy. Used in OPF.',
                       profile_name='Cost_prof')
 
-        self.register(key='technologies', units='', tpe=SubObjectType.Associations,
+        self.register(key='technologies', units='p.u.', tpe=SubObjectType.Associations,
                       definition='List of technologies', display=False)
 
     @property

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/Devices/multi_circuit.py

@@ -34,6 +34,7 @@ import GridCalEngine.Devices as dev
 from GridCalEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, FLUID_TYPES
 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
 
 
@@ -1355,6 +1356,20 @@ class MultiCircuit(Assets):
 
         return groups
 
+    def get_substation_buses(self, substation: dev.Substation) -> List[dev.Bus]:
+        """
+        Get the list of buses of this substation
+        :param substation:
+        :return:
+        """
+        lst: List[dev.Bus] = list()
+
+        for bus in self.buses:
+            if bus.substation == substation:
+                lst.append(bus)
+
+        return lst
+
     def fuse_devices(self) -> List[INJECTION_DEVICE_TYPES]:
         """
         Fuse all the different devices in a node to a single device per node
@@ -2222,7 +2237,7 @@ class MultiCircuit(Assets):
     def process_topology_at(self,
                             t_idx: Union[int, None] = None,
                             logger: Union[Logger, None] = None,
-                            debug: int = 0) -> tp.TopologyProcessorInfo:
+                            debug: int = 0) -> TopologyProcessorInfo:
         """
         Topology processor finding the Buses that calculate a certain node-breaker topology
         This function fill the bus pointers into the grid object, and adds any new bus required for simulation
@@ -2232,131 +2247,10 @@ class MultiCircuit(Assets):
         :return: TopologyProcessorInfo
         """
 
-        if logger is None:
-            logger = Logger()
-
-        # --------------------------------------------------------------------------------------------------------------
-        # Compose the candidate nodes (buses)
-        # --------------------------------------------------------------------------------------------------------------
-        process_info = tp.TopologyProcessorInfo()
-
-        # traverse connectivity nodes
-        for cn in self.get_connectivity_nodes():
-
-            if cn.default_bus is None:  # connectivity nodes can be linked to a previously existing Bus
-                # create a new candidate
-                candidate_bus = dev.Bus(name=f"Candidate from {cn.name}",
-                                        code=cn.code,  # for soft checking
-                                        Vnom=cn.Vnom  # we must keep the voltage level for the virtual taps
-                                        )
-
-                cn.default_bus = candidate_bus  # to avoid adding extra buses upon consecutive runs
-                process_info.add_new_candidate(candidate_bus)
-            else:
-                # pick the default candidate
-                candidate_bus = cn.default_bus
-                # candidate_bus.code = cn.code  # for soft checking
-
-            # register
-            process_info.add_candidate(candidate_bus)
-            process_info.cn_to_candidate[cn] = candidate_bus
-
-        nbus_candidate = process_info.candidate_number()
-        bus_active = process_info.get_candidate_active(t_idx=t_idx)
-
-        # get a list of all branches
-        all_branches = self.get_switches() + self.get_branches()
-
-        # --------------------------------------------------------------------------------------------------------------
-        # Create the connectivity matrices
-        # --------------------------------------------------------------------------------------------------------------
-        nbr = len(all_branches)
-
-        # declare the matrices
-        Cf = lil_matrix((nbr, nbus_candidate))
-        Ct = lil_matrix((nbr, nbus_candidate))
-        br_active = np.empty(nbr, dtype=int)
-
-        # fill matrices approprietly
-        for i, elm in enumerate(all_branches):
-
-            if elm.device_type == DeviceType.SwitchDevice:
-                br_active[i] = int(elm.active) if t_idx is None else int(elm.active_prof[t_idx])
-            else:
-                # non switches form islands, because we want islands to be
-                # the set of candidates to fuse into one
-                br_active[i] = 0
-
-            # if elm.cn_from is not None and elm.cn_to is not None:
-            #     f = process_info.get_candidate_pos_from_cn(elm.cn_from)
-            #     t = process_info.get_candidate_pos_from_cn(elm.cn_to)
-            if br_active[i]:  # avoid adding zeros
-                f, t, is_ok = process_info.get_connection_indices(elm=elm, logger=logger)
-                Cf[i, f] = br_active[i]
-                Ct[i, t] = br_active[i]
-
-        # --------------------------------------------------------------------------------------------------------------
-        # Compose the adjacency matrix from the connectivity information
-        # --------------------------------------------------------------------------------------------------------------
-        A = tp.get_adjacency_matrix(C_branch_bus_f=Cf.tocsc(),
-                                    C_branch_bus_t=Ct.tocsc(),
-                                    branch_active=br_active,
-                                    bus_active=bus_active)
-
-        if debug >= 2:
-            candidate_names = process_info.get_candidate_names()
-            br_names = [br.name for br in all_branches]
-            C = Cf + Ct
-            df = pd.DataFrame(data=C.toarray(), columns=candidate_names, index=br_names)
-            print(df.replace(to_replace=0.0, value="-"))
-
-            print("A:")
-
-            df = pd.DataFrame(data=A.toarray(), columns=candidate_names, index=candidate_names)
-            print(df.replace(to_replace=0.0, value="-"))
-            print()
-
-        # --------------------------------------------------------------------------------------------------------------
-        # Perform the topology search, this will find candidate buses that reduce to be the same bus
-        # --------------------------------------------------------------------------------------------------------------
-        islands = tp.find_islands(adj=A, active=bus_active)  # each island is finally a single calculation element
-
-        if debug >= 1:
-            for i, island in enumerate(islands):
-                print(f"island {i}:", island)
-
-        # --------------------------------------------------------------------------------------------------------------
-        # Generate auxiliary structures that derive from the topology results
-        # --------------------------------------------------------------------------------------------------------------
-        final_buses = process_info.apply_results(islands=islands)
-
-        # --------------------------------------------------------------------------------------------------------------
-        # Apply the results to the grid object
-        # --------------------------------------------------------------------------------------------------------------
-
-        # Add any extra bus that may arise from the calculation
-        grid_buses_set = {b for b in self.get_buses()}
-        for bus_device in final_buses:
-            if bus_device not in grid_buses_set:
-                self.add_bus(bus_device)
-                if logger:
-                    logger.add_info("Bus added to grid", device=bus_device.name)
-
-        # map the buses to the branches from their connectivity nodes
-        for i, elm in enumerate(all_branches):
-            if elm.cn_from is not None:
-                elm.set_bus_from_at(t_idx=t_idx, val=process_info.get_final_bus(elm.cn_from))
-
-            if elm.cn_to is not None:
-                elm.set_bus_to_at(t_idx=t_idx, val=process_info.get_final_bus(elm.cn_to))
-
-        for dev_lst in self.get_injection_devices_lists():
-            for elm in dev_lst:
-                if elm.cn is not None:
-                    elm.set_bus_at(t_idx=t_idx, val=process_info.get_final_bus(elm.cn))
-
-        # return the TopologyProcessorInfo
-        return process_info
+        return process_grid_topology_at(grid=self,
+                                        t_idx=t_idx,
+                                        logger=logger,
+                                        debug=debug)
 
     def split_line(self,
                    original_line: Union[dev.Line],

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/IO/cim/cgmes/cgmes_to_gridcal.py

@@ -50,6 +50,11 @@ class CnLookup:
         self.fill(cgmes_model=cgmes_model)
 
     def fill(self, cgmes_model: CgmesCircuit):
+        """
+
+        :param cgmes_model:
+        :return:
+        """
         bb_tpe = cgmes_model.cgmes_assets.class_dict.get("BusbarSection", None)
 
         if bb_tpe is not None:
@@ -163,9 +168,6 @@ def get_gcdev_device_to_terminal_dict(cgmes_model: CgmesCircuit,
     return device_to_terminal_dict
 
 
-
-
-
 def find_connections(cgmes_elm: Base,
                      device_to_terminal_dict: Dict[str, List[Base]],
                      calc_node_dict: Dict[str, gcdev.Bus],
@@ -454,7 +456,6 @@ def get_gcdev_generators(cgmes_model: CgmesCircuit,
     :param calc_node_dict: Dict[str, gcdev.Bus]
     :param cn_dict: Dict[str, gcdev.ConnectivityNode]
     :param device_to_terminal_dict: Dict[str, Terminal]
-    :param cn_look_up: CnLookup
     :param logger: Logger object
     """
     # add generation technologies
@@ -1056,7 +1057,8 @@ def get_gcdev_switches(cgmes_model: CgmesCircuit,
                 else:
                     op_rate = 9999  # Corrected
 
-                if (cgmes_elm.ratedCurrent is not None and cgmes_elm.ratedCurrent != 0.0
+                if (cgmes_elm.ratedCurrent is not None
+                        and cgmes_elm.ratedCurrent != 0.0
                         and cgmes_elm.BaseVoltage is not None):  # TODO
                     rated_current = np.round(
                         (cgmes_elm.ratedCurrent / 1000.0) * cgmes_elm.BaseVoltage.nominalVoltage * 1.73205080756888,
@@ -1123,7 +1125,7 @@ def get_gcdev_substations(cgmes_model: CgmesCircuit,
                 name=cgmes_elm.name,
                 idtag=cgmes_elm.uuid,
                 code=cgmes_elm.description,
-                latitude=latitude,     # later from GL profile/Location class
+                latitude=latitude,  # later from GL profile/Location class
                 longitude=longitude
             )
 
@@ -1218,8 +1220,8 @@ def get_gcdev_busbars(cgmes_model: CgmesCircuit,
                 cn = cn_look_up.get_busbar_cn(bb_id=cgmes_elm.uuid)
                 bus = cn_look_up.get_busbar_bus(bb_id=cgmes_elm.uuid)
 
-                # if bus and cn:
-                #     cn.default_bus = bus
+                if bus and cn:
+                    cn.default_bus = bus
 
                 gcdev_elm = gcdev.BusBar(
                     name=cgmes_elm.name,

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/IO/gridcal/pack_unpack.py

@@ -1166,7 +1166,7 @@ def handle_legacy_jsons(model_data: Dict[str, List],
             if generator is not None and fuel is not None:
                 generator.fuels.add_object(api_object=fuel, val=rate)
                 logger.add_info("Converted legacy generator fuel association",
-                                device_class="Generator_technology",
+                                device_class="generator_fuel",
                                 value=f"{generator.name} -> {fuel.name} at {rate}")
 
     ge_data_list = model_data.get("generator_emission", None)
@@ -1176,11 +1176,11 @@ def handle_legacy_jsons(model_data: Dict[str, List],
             emision_idtag = entry.get('emission', None)
             rate = entry.get('rate', 1.0)
             generator = elements_dict_by_type[DeviceType.GeneratorDevice].get(gen_idtag, None)
-            emission = elements_dict_by_type[DeviceType.Technology].get(emision_idtag, None)
+            emission = elements_dict_by_type[DeviceType.EmissionGasDevice].get(emision_idtag, None)
             if generator is not None and emission is not None:
                 generator.emissions.add_object(api_object=emission, val=rate)
-                logger.add_info("Converted legacy generator fuel association",
-                                device_class="Generator_technology",
+                logger.add_info("Converted legacy generator emission association",
+                                device_class="generator_emission",
                                 value=f"{generator.name} -> {emission.name} at {rate}")
 
 

{GridCalEngine-5.1.17 → GridCalEngine-5.1.19}/GridCalEngine/Topology/topology.py

@@ -342,264 +342,7 @@ def compute_connectivity_with_hvdc(branch_active: IntVec,
     return ConnectivityMatrices(Cf=Cf.tocsc(), Ct=Ct.tocsc())
 
 
-class TopologyProcessorInfo:
-    """
-    TopologyProcessorInfo
-    """
-
-    def __init__(self) -> None:
-
-        # list of buses that appear because of connectivity nodes
-        self.new_candidates: List[Bus] = list()
-
-        # list of final candidate buses for reduction
-        self.candidates: List[Bus] = list()
-
-        # map of ConnectivityNodes to candidate Buses
-        self.cn_to_candidate: dict[ConnectivityNode, Bus] = dict()
-
-        # integer position of the candidate bus matching a connectivity node
-        self.candidate_to_int_dict = dict()
-
-        # map of ConnectivityNodes to final Buses
-        self.cn_to_final_bus: dict[ConnectivityNode, Bus] = dict()
-
-    def get_connection_indices(self, elm: BRANCH_TYPES, logger: Logger) -> Tuple[int, int, bool]:
-        """
-        Get connection indices
-        :param elm:
-        :param logger:
-        :return: f, t, ok
-        """
-        # if elm.cn_from is not None and elm.cn_to is not None and elm.bus_from is not None and elm.bus_to is not None:
-        #     # All properties are not None
-        #     f = self.get_candidate_pos_from_cn(elm.cn_from)
-        #     t = self.get_candidate_pos_from_cn(elm.cn_to)
-        #
-        # elif elm.cn_from is not None and elm.cn_to is not None and elm.bus_from is not None and elm.bus_to is None:
-        #     # bus_to is None
-        #     f = self.get_candidate_pos_from_cn(elm.cn_from)
-        #     t = self.get_candidate_pos_from_cn(elm.cn_to)
-        #
-        # elif elm.cn_from is not None and elm.cn_to is not None and elm.bus_from is None and elm.bus_to is not None:
-        #     # bus_from is None
-        #     f = self.get_candidate_pos_from_cn(elm.cn_from)
-        #     t = self.get_candidate_pos_from_cn(elm.cn_to)
-        #
-        # elif elm.cn_from is not None and elm.cn_to is not None and elm.bus_from is None and elm.bus_to is None:
-        #     # bus_from and bus_to are None
-        #     f = self.get_candidate_pos_from_cn(elm.cn_from)
-        #     t = self.get_candidate_pos_from_cn(elm.cn_to)
-        #
-        # elif elm.cn_from is not None and elm.cn_to is None and elm.bus_from is not None and elm.bus_to is not None:
-        #     # cn_to is None
-        #     f = self.get_candidate_pos_from_cn(elm.cn_from)
-        #     t = self.get_candidate_pos_from_bus(elm.bus_to)
-        #
-        # elif elm.cn_from is not None and elm.cn_to is None and elm.bus_from is not None and elm.bus_to is None:
-        #     # cn_to and bus_to are None
-        #     # raise ValueError("No to connection provided!")
-        #     logger.add_error(msg="No to connection provided!", device=elm.name)
-        #     return -1, -1, False
-        #
-        # elif elm.cn_from is not None and elm.cn_to is None and elm.bus_from is None and elm.bus_to is not None:
-        #     # cn_to and bus_from are None
-        #     f = self.get_candidate_pos_from_cn(elm.cn_from)
-        #     t = self.get_candidate_pos_from_bus(elm.bus_to)
-        #
-        # elif elm.cn_from is not None and elm.cn_to is None and elm.bus_from is None and elm.bus_to is None:
-        #     # cn_to, bus_from, and bus_to are None
-        #     # raise ValueError("No to connection provided!")
-        #     logger.add_error(msg="No to connection provided!", device=elm.name)
-        #     return -1, -1, False
-        #
-        # elif elm.cn_from is None and elm.cn_to is not None and elm.bus_from is not None and elm.bus_to is not None:
-        #     # cn_from is None
-        #     f = self.get_candidate_pos_from_bus(elm.bus_from)
-        #     t = self.get_candidate_pos_from_cn(elm.cn_to)
-        #
-        # elif elm.cn_from is None and elm.cn_to is not None and elm.bus_from is not None and elm.bus_to is None:
-        #     # cn_from and bus_to are None
-        #     f = self.get_candidate_pos_from_bus(elm.bus_from)
-        #     t = self.get_candidate_pos_from_cn(elm.cn_to)
-        #
-        # elif elm.cn_from is None and elm.cn_to is not None and elm.bus_from is None and elm.bus_to is not None:
-        #     # cn_from and bus_from are None
-        #     # raise ValueError("No from connection provided!")
-        #     logger.add_error(msg="No to connection provided!", device=elm.name)
-        #     return -1, -1, False
-        #
-        # elif elm.cn_from is None and elm.cn_to is not None and elm.bus_from is None and elm.bus_to is None:
-        #     # cn_from, bus_from, and bus_to are None
-        #     # raise ValueError("No from connection provided!")
-        #     logger.add_error(msg="No to connection provided!", device=elm.name)
-        #     return -1, -1, False
-        #
-        # elif elm.cn_from is None and elm.cn_to is None and elm.bus_from is not None and elm.bus_to is not None:
-        #     # cn_from and cn_to are None
-        #     f = self.get_candidate_pos_from_bus(elm.bus_from)
-        #     t = self.get_candidate_pos_from_bus(elm.bus_to)
-        #
-        # elif elm.cn_from is None and elm.cn_to is None and elm.bus_from is not None and elm.bus_to is None:
-        #     # cn_from, cn_to, and bus_to are None
-        #     # raise ValueError("No to connection provided!")
-        #     logger.add_error(msg="No to connection provided!", device=elm.name)
-        #     return -1, -1, False
-        #
-        # elif elm.cn_from is None and elm.cn_to is None and elm.bus_from is None and elm.bus_to is not None:
-        #     # cn_from, cn_to, and bus_from are None
-        #     # raise ValueError("No from connection provided!")
-        #     logger.add_error(msg="No to connection provided!", device=elm.name)
-        #     return -1, -1, False
-        #
-        # elif elm.cn_from is None and elm.cn_to is None and elm.bus_from is None and elm.bus_to is None:
-        #     # All properties are None
-        #     # raise ValueError("isolated branch!")
-        #     logger.add_error(msg="Isolated branch!", device=elm.name)
-        #     return -1, -1, False
-        #
-        # else:
-        #     # All properties are None
-        #     # raise ValueError("isolated branch!")
-        #     logger.add_error(msg="Isolated branch!", device=elm.name)
-        #     return -1, -1, False
-
-        fr_obj, to_obj, ok = elm.get_from_and_to_objects(logger=logger)
-
-        if ok:
-            if isinstance(fr_obj, ConnectivityNode):
-                f = self.get_candidate_pos_from_cn(fr_obj)
-            elif isinstance(fr_obj, Bus):
-                f = self.get_candidate_pos_from_bus(fr_obj)
-            else:
-                f = -1
-
-            if isinstance(to_obj, ConnectivityNode):
-                t = self.get_candidate_pos_from_cn(to_obj)
-            elif isinstance(to_obj, Bus):
-                t = self.get_candidate_pos_from_bus(to_obj)
-            else:
-                t = -1
-
-            if f == t:
-                logger.add_error(msg="Loop connected branch!", device=elm.name)
-                return -1, -1, False
-
-            return f, t, True
-
-        else:
-            logger.add_error(msg="No to connection provided!", device=elm.name)
-            return -1, -1, False
-
-    def add_new_candidate(self, new_candidate: Bus):
-        """
-
-        :param new_candidate:
-        :return:
-        """
-        self.new_candidates.append(new_candidate)
-
-    def add_candidate(self, new_candidate: Bus):
-        """
-
-        :param new_candidate:
-        :return:
-        """
-        self.candidate_to_int_dict[new_candidate] = len(self.candidates)
-        self.candidates.append(new_candidate)
-
-    def candidate_number(self) -> int:
-        """
-        Number of candidates
-        :return: integer
-        """
-        return len(self.candidates)
-
-    def get_candidate_pos_from_cn(self, cn: ConnectivityNode) -> int:
-        """
-        Get the integer position of the candidate bus matching a connectivity node
-        :param cn: ConnectivityNode
-        :return: integer
-        """
-        candidate = self.cn_to_candidate[cn]
-        return self.candidate_to_int_dict[candidate]
-
-    def get_candidate_pos_from_bus(self, bus: Bus) -> int:
-        """
-        Get the integer position of the candidate bus matching
-        :param bus: Bus
-        :return: integer
-        """
-        return self.candidate_to_int_dict[bus]
-
-    def get_candidate_active(self, t_idx: Union[None, int]) -> IntVec:
-        """
-        Get the active array of candidate buses at a time index
-        :param t_idx: time index
-        :return: Array of bus active
-        """
-        bus_active = np.ones(self.candidate_number(), dtype=int)
-
-        for i, elm in enumerate(self.candidates):
-            bus_active[i] = int(elm.active) if t_idx is None else int(elm.active_prof[t_idx])
-
-        return bus_active
-
-    def apply_results(self, islands: List[List[int]]) -> List[Bus]:
-        """
-        Apply the topology results
-        :param islands: rsults from the topology search
-        :return: list of final buses
-        """
-        final_buses = list()
-        # print("Islands:")
-        for island in islands:
-            # print(",".join([self.candidates[i].name for i in island]))
-
-            island_bus = self.candidates[island[0]]
-
-            # pick the first bus from each island
-            final_buses.append(island_bus)
-
-            for cn, candidate_bus in self.cn_to_candidate.items():
-                for i in island:
-                    if candidate_bus == self.candidates[i]:
-                        self.cn_to_final_bus[cn] = island_bus
-
-        return final_buses
 
-    def get_final_bus(self, cn: ConnectivityNode) -> Bus:
-        """
-        Get the final Bus that should map to a connectivity node
-        :param cn: ConnectivityNode
-        :return: Final calculation Bus
-        """
-        return self.cn_to_final_bus[cn]
-
-    def get_cn_lists_per_bus(self) -> Dict[Bus, List[ConnectivityNode]]:
-        """
-        Invert cn_to_final_bus
-        :return: Dict[Bus, List[ConnectivityNode]]
-        """
-        data = dict()
-
-        for cn, bus in self.cn_to_final_bus.items():
-
-            lst = data.get(bus, None)
-
-            if lst is None:
-                data[bus] = [cn]
-            else:
-                lst.append(cn)
-
-        return data
-
-    def get_candidate_names(self) -> List[str]:
-        """
-
-        :return:
-        """
-        return [c.name for c in self.candidates]
 
 
 def compute_connectivity_acdc_isolated(branch_active: IntVec,