power-grid-model-ds 0.0.1a11709467271__py3-none-any.whl

power_grid_model_ds/_core/model/graphs/models/rustworkx.py

@@ -0,0 +1,119 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+import logging
+
+import rustworkx as rx
+from rustworkx import NoEdgeBetweenNodes
+from rustworkx.visit import BFSVisitor, PruneSearch
+
+from power_grid_model_ds._core.model.graphs.errors import MissingBranchError, MissingNodeError, NoPathBetweenNodes
+from power_grid_model_ds._core.model.graphs.models._rustworkx_search import find_fundamental_cycles_rustworkx
+from power_grid_model_ds._core.model.graphs.models.base import BaseGraphModel
+
+_logger = logging.getLogger(__name__)
+
+
+class RustworkxGraphModel(BaseGraphModel):
+    """A wrapper around the graph from the 'rustworkx' package"""
+
+    def __init__(self, active_only=False) -> None:
+        super().__init__(active_only=active_only)
+        self._graph: rx.PyGraph = rx.PyGraph()
+        self._internal_to_external: dict[int, int] = {}
+        self._external_to_internal: dict[int, int] = {}
+
+    @property
+    def nr_nodes(self):
+        return self._graph.num_nodes()
+
+    @property
+    def nr_branches(self):
+        return self._graph.num_edges()
+
+    @property
+    def external_ids(self) -> list[int]:
+        return list(self._external_to_internal.keys())
+
+    # pylint: disable=duplicate-code
+    def external_to_internal(self, ext_node_id: int):
+        try:
+            return self._external_to_internal[ext_node_id]
+        except KeyError as error:
+            raise MissingNodeError(f"External node id '{ext_node_id}' does NOT exist!") from error
+
+    def internal_to_external(self, int_node_id: int):
+        return self._internal_to_external[int_node_id]
+
+    def _add_node(self, ext_node_id: int):
+        graph_node_id = self._graph.add_node(ext_node_id)
+        self._external_to_internal[ext_node_id] = graph_node_id
+        self._internal_to_external[graph_node_id] = ext_node_id
+
+    def _delete_node(self, node_id: int):
+        self._graph.remove_node(node_id)
+        external_node_id = self._internal_to_external.pop(node_id)
+        self._external_to_internal.pop(external_node_id)
+
+    def _has_branch(self, from_node_id: int, to_node_id: int) -> bool:
+        return self._graph.has_edge(from_node_id, to_node_id)
+
+    def _has_node(self, node_id: int) -> bool:
+        return self._graph.has_node(node_id)
+
+    def _add_branch(self, from_node_id: int, to_node_id: int):
+        self._graph.add_edge(from_node_id, to_node_id, None)
+
+    def _delete_branch(self, from_node_id: int, to_node_id: int) -> None:
+        try:
+            self._graph.remove_edge(from_node_id, to_node_id)
+        except NoEdgeBetweenNodes as error:
+            raise MissingBranchError(f"No edge between (internal) nodes {from_node_id} and {to_node_id}") from error
+
+    def _get_shortest_path(self, source: int, target: int) -> tuple[list[int], int]:
+        path_mapping = rx.dijkstra_shortest_paths(self._graph, source, target)
+
+        if target not in path_mapping:
+            raise NoPathBetweenNodes(f"No path between internal nodes {source} and {target}")
+
+        path_nodes = list(path_mapping[target])
+        return path_nodes, len(path_nodes) - 1
+
+    def _get_all_paths(self, source: int, target: int) -> list[list[int]]:
+        return list(rx.all_simple_paths(self._graph, source, target))
+
+    def _get_components(self, substation_nodes: list[int]) -> list[list[int]]:
+        no_os_graph = self._graph.copy()
+        for os_node in substation_nodes:
+            no_os_graph.remove_node(os_node)
+        components = rx.connected_components(no_os_graph)
+        return [list(component) for component in components]
+
+    def _get_connected(self, node_id: int, nodes_to_ignore: list[int], inclusive: bool = False) -> list[int]:
+        visitor = _NodeVisitor(nodes_to_ignore)
+        rx.bfs_search(self._graph, [node_id], visitor)
+        connected_nodes = visitor.nodes
+        if not inclusive:
+            connected_nodes.remove(node_id)
+
+        return connected_nodes
+
+    def _find_fundamental_cycles(self) -> list[list[int]]:
+        """Find all fundamental cycles in the graph using Rustworkx.
+
+        Returns:
+            list[list[int]]: A list of cycles, each cycle is a list of node IDs.
+        """
+        return find_fundamental_cycles_rustworkx(self._graph)
+
+
+class _NodeVisitor(BFSVisitor):
+    def __init__(self, nodes_to_ignore: list[int]):
+        self.nodes_to_ignore = nodes_to_ignore
+        self.nodes: list[int] = []
+
+    def discover_vertex(self, v):
+        if v in self.nodes_to_ignore:
+            raise PruneSearch
+        self.nodes.append(v)

power_grid_model_ds/_core/model/grids/_text_sources.py

@@ -0,0 +1,119 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Create a grid from text a text file"""
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from power_grid_model_ds._core.model.enums.nodes import NodeType
+
+if TYPE_CHECKING:
+    from power_grid_model_ds._core.model.grids.base import Grid
+
+_logger = logging.getLogger(__name__)
+
+
+class TextSource:
+    """Class for handling text sources.
+
+    Text sources are only intended for test purposes so that a grid can quickly be designed from a text file.
+    Moreover, these text sources are compatible with the grid editor at https://csacademy.com/app/graph_editor/
+
+    Example of a text file:
+        S1 2
+        2 3
+        3 4 transformer
+        4 5
+        S1 7
+
+    See docs/examples/3_drawing_a_grid.md for more information.
+    """
+
+    def __init__(self, grid_class: type["Grid"]):
+        self.grid = grid_class.empty()
+
+    def load_grid_from_path(self, path: Path):
+        """Load assets from text file & sort them by id so that
+        they are ready to be appended to the grid"""
+
+        txt_nodes, txt_branches = self.read_txt(path)
+        self.add_nodes(txt_nodes)
+        self.add_branches(txt_branches)
+        self.grid.set_feeder_ids()
+        return self.grid
+
+    @staticmethod
+    def read_txt(path: Path) -> tuple[set, dict]:
+        """Extract assets from text"""
+        with open(path, "r", encoding="utf-8") as f:
+            txt_rows = f.readlines()
+
+        txt_nodes = set()
+        txt_branches = {}
+        for text_line in txt_rows:
+            if not text_line.strip() or text_line.startswith("#"):
+                continue  # skip empty lines and comments
+            try:
+                from_node_str, to_node_str, *comments = text_line.strip().split(" ")
+            except ValueError as err:
+                raise ValueError(f"Text line '{text_line}' is invalid. Skipping...") from err
+            comments = comments[0].split(",") if comments else []
+
+            txt_nodes |= {from_node_str, to_node_str}
+            txt_branches[(from_node_str, to_node_str)] = comments
+        return txt_nodes, txt_branches
+
+    def add_nodes(self, nodes: set[str]):
+        """Add nodes to the grid"""
+        source_nodes = {int(node[1:]) for node in nodes if node.startswith("S")}
+        regular_nodes = {int(node) for node in nodes if not node.startswith("S")}
+
+        if source_nodes.intersection(regular_nodes):
+            raise ValueError("Source nodes and regular nodes have overlapping ids")
+
+        for node_id in source_nodes:
+            new_node = self.grid.node.empty(1)
+            new_node.id = node_id
+            new_node.node_type = NodeType.SUBSTATION_NODE
+            self.grid.append(new_node, check_max_id=False)
+
+        for node_id in regular_nodes:
+            new_node = self.grid.node.empty(1)
+            new_node.id = node_id
+            self.grid.append(new_node, check_max_id=False)
+
+    def add_branches(self, branches: dict[tuple[str, str], list[str]]):
+        """Add branches to the grid"""
+        for branch, comments in branches.items():
+            self.add_branch(branch, comments)
+
+    def add_branch(self, branch: tuple[str, str], comments: list[str]):
+        """Add a branch to the grid"""
+        from_node_str, to_node_str = branch
+        from_node = int(from_node_str.replace("S", ""))
+        to_node = int(to_node_str.replace("S", ""))
+
+        if "transformer" in comments:
+            new_branch = self.grid.transformer.empty(1)
+        elif "link" in comments:
+            new_branch = self.grid.link.empty(1)
+        else:  # assume it is a line
+            new_branch = self.grid.line.empty(1)
+
+        branch_ids = [branch_id for branch_id in comments if branch_id.isdigit()]
+        if branch_ids:
+            if len(branch_ids) > 1:
+                raise ValueError(f"Multiple branch ids found in row {branch} {','.join(comments)}")
+            new_branch.id = int(branch_ids[0])
+
+        new_branch.from_node = from_node
+        new_branch.to_node = to_node
+        new_branch.from_status = 1
+        if "open" in comments:
+            new_branch.to_status = 0
+        else:
+            new_branch.to_status = 1
+        self.grid.append(new_branch)

power_grid_model_ds/_core/model/grids/base.py

@@ -0,0 +1,434 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Base grid classes"""
+
+import dataclasses
+import itertools
+import logging
+from copy import copy
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Type, TypeVar
+
+import numpy as np
+import numpy.typing as npt
+
+from power_grid_model_ds._core import fancypy as fp
+from power_grid_model_ds._core.model.arrays import (
+    AsymVoltageSensorArray,
+    Branch3Array,
+    BranchArray,
+    LineArray,
+    LinkArray,
+    NodeArray,
+    SourceArray,
+    SymGenArray,
+    SymLoadArray,
+    SymPowerSensorArray,
+    SymVoltageSensorArray,
+    ThreeWindingTransformerArray,
+    TransformerArray,
+    TransformerTapRegulatorArray,
+)
+from power_grid_model_ds._core.model.arrays.base.array import FancyArray
+from power_grid_model_ds._core.model.arrays.base.errors import RecordDoesNotExist
+from power_grid_model_ds._core.model.containers.base import FancyArrayContainer
+from power_grid_model_ds._core.model.enums.nodes import NodeType
+from power_grid_model_ds._core.model.graphs.container import GraphContainer
+from power_grid_model_ds._core.model.graphs.models import RustworkxGraphModel
+from power_grid_model_ds._core.model.graphs.models.base import BaseGraphModel
+from power_grid_model_ds._core.model.grids._text_sources import TextSource
+from power_grid_model_ds._core.model.grids.helpers import set_feeder_ids, set_is_feeder
+from power_grid_model_ds._core.utils.pickle import get_pickle_path, load_from_pickle, save_to_pickle
+from power_grid_model_ds._core.utils.zip import file2gzip
+
+Self = TypeVar("Self", bound="Grid")
+
+# pylint: disable=too-many-instance-attributes
+# pylint: disable=too-many-public-methods
+
+
+@dataclass
+class Grid(FancyArrayContainer):
+    """Grid object containing the entire network and interface to interact with it.
+
+    Examples:
+
+        >>> from power_grid_model_ds import Grid
+        >>> grid = Grid.empty()
+        >>> grid
+    """
+
+    graphs: GraphContainer
+    """The graph representations of the grid."""
+
+    # nodes
+    node: NodeArray
+
+    # branches
+    transformer: TransformerArray
+    three_winding_transformer: ThreeWindingTransformerArray
+    line: LineArray
+    link: LinkArray
+
+    source: SourceArray
+    sym_load: SymLoadArray
+    sym_gen: SymGenArray
+
+    # regulators
+    transformer_tap_regulator: TransformerTapRegulatorArray
+
+    # sensors
+    sym_power_sensor: SymPowerSensorArray
+    sym_voltage_sensor: SymVoltageSensorArray
+    asym_voltage_sensor: AsymVoltageSensorArray
+
+    def __str__(self) -> str:
+        """String representation of the grid.
+
+        Compatible with https://csacademy.com/app/graph_editor/
+        """
+        grid_str = ""
+
+        for transformer3 in self.three_winding_transformer:
+            nodes = [transformer3.node_1.item(), transformer3.node_2.item(), transformer3.node_3.item()]
+            for combo in itertools.combinations(nodes, 2):
+                grid_str += f"S{combo[0]} S{combo[1]} {transformer3.id.item()},3-transformer\n"
+
+        for branch in self.branches:
+            from_node = self.node.get(id=branch.from_node).record
+            to_node = self.node.get(id=branch.to_node).record
+
+            from_node_str = f"S{from_node.id}" if from_node.node_type == NodeType.SUBSTATION_NODE else str(from_node.id)
+            to_node_str = f"S{to_node.id}" if to_node.node_type == NodeType.SUBSTATION_NODE else str(to_node.id)
+
+            suffix_str = str(branch.id.item())
+            if branch.from_status.item() == 0 or branch.to_status.item() == 0:
+                suffix_str = f"{suffix_str},open"
+
+            if branch.id in self.transformer.id:
+                suffix_str = f"{suffix_str},transformer"
+            elif branch.id in self.link.id:
+                suffix_str = f"{suffix_str},link"
+            elif branch.id in self.line.id:
+                pass  # no suffix needed
+            else:
+                raise ValueError(f"Branch {branch.id} is not a transformer, link or line")
+
+            grid_str += f"{from_node_str} {to_node_str} {suffix_str}\n"
+        return grid_str
+
+    @property
+    def branches(self) -> BranchArray:
+        """Converts all branch arrays into a single BranchArray."""
+        branch_dtype = BranchArray.get_dtype()
+        branches = BranchArray()
+        for array in self.branch_arrays:
+            new_branch = BranchArray(data=array.data[list(branch_dtype.names)])
+            branches = fp.concatenate(branches, new_branch)
+        return branches
+
+    @property
+    def branch_arrays(self) -> list[BranchArray]:
+        """Returns all branch arrays"""
+        branch_arrays = []
+        for field in dataclasses.fields(self):
+            array = getattr(self, field.name)
+            if isinstance(array, BranchArray):
+                branch_arrays.append(array)
+        return branch_arrays
+
+    def get_typed_branches(self, branch_ids: list[int] | npt.NDArray[np.int32]) -> BranchArray:
+        """Find a matching LineArray, LinkArray or TransformerArray for the given branch_ids
+
+        Raises:
+            ValueError:
+                - If no branch_ids are provided.
+                - If not all branch_ids are of the same type.
+        """
+        if not np.any(branch_ids):
+            raise ValueError("No branch_ids provided.")
+        for branch_array in self.branch_arrays:
+            array = branch_array.filter(branch_ids)
+            if 0 < array.size != len(branch_ids):
+                raise ValueError("Branches are not of the same type.")
+            if array.size:
+                return array
+        raise RecordDoesNotExist(f"Branches {branch_ids} not found in grid.")
+
+    def reverse_branches(self, branches: BranchArray):
+        """Reverse the direction of the branches."""
+        if not branches.size:
+            return
+        if not isinstance(branches, (LineArray, LinkArray, TransformerArray)):
+            try:
+                branches = self.get_typed_branches(branches.id)
+            except ValueError:
+                # If the branches are not of the same type, reverse them per type (though this is slower)
+                for array in self.branch_arrays:
+                    self.reverse_branches(array.filter(branches.id))
+                return
+
+        from_nodes = branches.from_node
+        to_nodes = branches.to_node
+
+        array_field = self.find_array_field(branches.__class__)
+        array = getattr(self, array_field.name)
+        array.update_by_id(branches.id, from_node=to_nodes, to_node=from_nodes)
+
+    @classmethod
+    def empty(cls: Type[Self], graph_model: type[BaseGraphModel] = RustworkxGraphModel) -> Self:
+        """Create an empty grid
+
+        Args:
+            graph_model (type[BaseGraphModel], optional): The graph model to use. Defaults to RustworkxGraphModel.
+
+        Returns:
+            Grid: An empty grid
+        """
+        empty_fields = cls._get_empty_fields()
+        empty_fields["graphs"] = GraphContainer.empty(graph_model=graph_model)
+        return cls(**empty_fields)
+
+    def append(self, array: FancyArray, check_max_id: bool = True):
+        """Append an array to the grid. Both 'grid arrays' and 'grid.graphs' will be updated.
+
+        Args:
+            array (FancyArray): The array to append.
+            check_max_id (bool, optional): Whether to check if the array id is the maximum id. Defaults to True.
+        """
+        self._append(array, check_max_id=check_max_id)  # noqa
+        for row in array:
+            # pylint: disable=protected-access
+            self.graphs._append(row)
+
+    def add_branch(self, branch: BranchArray) -> None:
+        """Add a branch to the grid
+
+        Args:
+            branch (BranchArray): The branch to add
+        """
+        self._append(array=branch)
+        self.graphs.add_branch(branch=branch)
+
+        logging.debug(f"added branch {branch.id} from {branch.from_node} to {branch.to_node}")
+
+    def delete_branch(self, branch: BranchArray) -> None:
+        """Remove a branch from the grid
+
+        Args:
+            branch (BranchArray): The branch to remove
+        """
+        _add_branch_array(branch=branch, grid=self)
+        self.graphs.delete_branch(branch=branch)
+        logging.debug(
+            f"""deleted branch {branch.id.item()} from {branch.from_node.item()} to {branch.to_node.item()}"""
+        )
+
+    def delete_branch3(self, branch: Branch3Array) -> None:
+        """Remove a branch3 from the grid
+
+        Args:
+            branch (Branch3Array): The branch3 to remove
+        """
+        _add_branch_array(branch=branch, grid=self)
+        self.graphs.delete_branch3(branch=branch)
+
+    def add_node(self, node: NodeArray) -> None:
+        """Add a new node to the grid
+
+        Args:
+            node (NodeArray): The node to add
+        """
+        self._append(array=node)
+        self.graphs.add_node(node=node)
+        logging.debug(f"added rail {node.id}")
+
+    def delete_node(self, node: NodeArray) -> None:
+        """Remove a node from the grid
+
+        Args:
+            node (NodeArray): The node to remove
+        """
+        self.node = self.node.exclude(id=node.id)
+        self.sym_load = self.sym_load.exclude(node=node.id)
+        self.source = self.source.exclude(node=node.id)
+
+        for branch_array in self.branch_arrays:
+            matching_branches = branch_array.filter(from_node=node.id, to_node=node.id, mode_="OR")
+            for branch in matching_branches:
+                self.delete_branch(branch)
+
+        self.graphs.delete_node(node=node)
+        logging.debug(f"deleted rail {node.id}")
+
+    def make_active(self, branch: BranchArray) -> None:
+        """Make a branch active
+
+        Args:
+            branch (BranchArray): The branch to make active
+        """
+        array_field = self.find_array_field(branch.__class__)
+        array_attr = getattr(self, array_field.name)
+        branch_mask = array_attr.id == branch.id
+        array_attr.from_status[branch_mask] = 1
+        array_attr.to_status[branch_mask] = 1
+        setattr(self, array_field.name, array_attr)
+
+        self.graphs.make_active(branch=branch)
+        logging.debug(f"activated branch {branch.id}")
+
+    def make_inactive(self, branch: BranchArray, at_to_side: bool = True) -> None:
+        """Make a branch inactive. This is done by setting from or to status to 0.
+
+        Args:
+            branch (BranchArray): The branch to make inactive
+            at_to_side (bool, optional): Whether to deactivate the to_status instead of the from_status.
+            Defaults to True.
+        """
+        array_field = self.find_array_field(branch.__class__)
+        array_attr = getattr(self, array_field.name)
+        branch_mask = array_attr.id == branch.id
+        status_side = "to_status" if at_to_side else "from_status"
+        array_attr[status_side][branch_mask] = 0
+        setattr(self, array_field.name, array_attr)
+
+        self.graphs.make_inactive(branch=branch)
+        logging.debug(f"deactivated branch {branch.id}")
+
+    def get_branches_in_path(self, nodes_in_path: list[int]) -> BranchArray:
+        """Returns all branches within a path of nodes
+
+        Args:
+            nodes_in_path (list[int]): The nodes in the path
+
+        Returns:
+            BranchArray: The branches in the path
+        """
+        return self.branches.filter(from_node=nodes_in_path, to_node=nodes_in_path, from_status=1, to_status=1)
+
+    def get_nearest_substation_node(self, node_id: int):
+        """Find the nearest substation node.
+
+        Args:
+            node_id(int): The id of the node to find the nearest substation node for.
+
+        Returns:
+            NodeArray: The nearest substation node.
+
+        Raises:
+            RecordDoesNotExist: If no substation node is connected to the input node.
+        """
+        connected_nodes = self.graphs.active_graph.get_connected(node_id=node_id, inclusive=True)
+        substation_nodes = self.node.filter(node_type=NodeType.SUBSTATION_NODE.value)
+
+        for node in connected_nodes:
+            if node in substation_nodes.id:
+                return substation_nodes.get(node)
+        raise RecordDoesNotExist(f"No {NodeType.SUBSTATION_NODE.name} connected to node {node_id}")
+
+    def get_downstream_nodes(self, node_id: int, inclusive: bool = False):
+        """Get the downstream nodes from a node.
+
+        Example:
+            given this graph: [1] - [2] - [3] - [4], with 1 being a substation node
+
+            >>> graph.get_downstream_nodes(2) == [3, 4]
+            >>> graph.get_downstream_nodes(3) == [4]
+            >>> graph.get_downstream_nodes(3, inclusive=True) == [3, 4]
+
+        Args:
+            node_id(int): The id of the node to get the downstream nodes from.
+            inclusive(bool): Whether to include the input node in the result.
+
+        Raises:
+            NotImplementedError: If the input node is a substation node.
+
+        Returns:
+            list[int]: The downstream nodes.
+        """
+        substation_node_id = self.get_nearest_substation_node(node_id).id.item()
+
+        if node_id == substation_node_id:
+            raise NotImplementedError("get_downstream_nodes is not implemented for substation nodes!")
+
+        path_to_substation, _ = self.graphs.active_graph.get_shortest_path(node_id, substation_node_id)
+        upstream_node = path_to_substation[1]
+
+        return self.graphs.active_graph.get_connected(node_id, nodes_to_ignore=[upstream_node], inclusive=inclusive)
+
+    def cache(self, cache_dir: Path, cache_name: str, compress: bool = True):
+        """Cache Grid to a folder
+
+        Args:
+            cache_dir (Path): The directory to save the cache to.
+            cache_name (str): The name of the cache.
+            compress (bool, optional): Whether to compress the cache. Defaults to True.
+        """
+        tmp_graphs = copy(self.graphs)
+        self.graphs = None  # noqa
+        cache_dir.mkdir(parents=True, exist_ok=True)
+
+        pickle_path = cache_dir / f"{cache_name}.pickle"
+        save_to_pickle(path=pickle_path, python_object=self)
+
+        if compress:
+            gzip_path = file2gzip(pickle_path)
+            pickle_path.unlink()
+            return gzip_path
+
+        self.graphs = tmp_graphs
+        return pickle_path
+
+    @classmethod
+    # pylint: disable=arguments-differ
+    def from_cache(cls: Type[Self], cache_path: Path, load_graphs: bool = True) -> Self:
+        """Read from cache and build .graphs from arrays
+
+        Args:
+            cache_path (Path): The path to the cache
+            load_graphs (bool, optional): Whether to load the graphs. Defaults to True.
+
+        Returns:
+            Self: The grid loaded from cache
+        """
+        pickle_path = get_pickle_path(cache_path)
+
+        grid = cls._from_pickle(pickle_path=pickle_path)
+        if load_graphs:
+            grid.graphs = GraphContainer.from_arrays(grid)
+        return grid
+
+    @classmethod
+    def _from_pickle(cls, pickle_path: Path):
+        grid = load_from_pickle(path=pickle_path)
+        if not isinstance(grid, Grid):
+            raise TypeError(f"{pickle_path.name} is not a valid {cls.__name__} cache.")
+        return grid
+
+    @classmethod
+    # pylint: disable=arguments-differ
+    def from_txt_file(cls, txt_file_path: Path):
+        """Load grid from txt file
+
+        Args:
+            txt_file_path (Path): The path to the txt file
+        """
+        text_source = TextSource(grid_class=cls)
+        return text_source.load_grid_from_path(txt_file_path)
+
+    def set_feeder_ids(self):
+        """Sets feeder and substation id properties in the grids arrays"""
+        set_is_feeder(grid=self)
+        set_feeder_ids(grid=self)
+
+
+def _add_branch_array(branch: BranchArray | Branch3Array, grid: Grid):
+    """Add a branch array to the grid"""
+    array_field = grid.find_array_field(branch.__class__)
+    array_attr = getattr(grid, array_field.name)
+    setattr(grid, array_field.name, array_attr.exclude(id=branch.id))
+
+    grid.transformer_tap_regulator = grid.transformer_tap_regulator.exclude(regulated_object=branch.id)