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

power_grid_model_ds/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+from power_grid_model_ds._core.load_flow import PowerGridModelInterface
+from power_grid_model_ds._core.model.graphs.container import GraphContainer
+from power_grid_model_ds._core.model.grids.base import Grid
+
+__all__ = ["Grid", "GraphContainer", "PowerGridModelInterface"]

power_grid_model_ds/_core/data_source/generator/arrays/base.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Base generator"""
+
+import numpy as np
+
+from power_grid_model_ds._core.model.grids.base import Grid
+
+
+class BaseGenerator:
+    """Base class to build a generator for grid elements"""
+
+    def __init__(self, grid: Grid, seed: int) -> None:
+        """Initializes generator with grid and amount"""
+        self.grid = grid
+
+        self.starting_seed = seed
+        self.rng = np.random.default_rng(seed)
+
+    def reset_rng(self, seed: int):
+        """Sets the rng for a generator"""
+        rng = np.random.default_rng(seed)
+        self.rng = rng

power_grid_model_ds/_core/data_source/generator/arrays/line.py

@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Generator for LineArray"""
+
+import numpy as np
+
+from power_grid_model_ds._core import fancypy as fp
+from power_grid_model_ds._core.data_source.generator.arrays.base import BaseGenerator
+from power_grid_model_ds._core.model.arrays import LineArray, TransformerArray
+from power_grid_model_ds._core.model.grids.base import Grid
+
+AVERAGE_ROUTE_SIZE = 20
+
+
+class LineGenerator(BaseGenerator):
+    """Generator for line elements in the grid"""
+
+    def __init__(self, grid: Grid, seed: int) -> None:
+        super().__init__(grid=grid, seed=seed)
+        self.connected_nodes: list = []
+        self.unconnected_nodes: list = []
+        self.line_array: LineArray = self.grid.line.__class__()
+        self.trafo_array: TransformerArray = self.grid.transformer.__class__()
+
+    # pylint: disable=arguments-differ
+    def run(self, amount: int, number_of_routes: int | None = None) -> LineArray:
+        """Generate routes, lines and normally open points (NOPs)"""
+
+        self.trafo_array = self.grid.transformer
+        if number_of_routes is None:
+            number_of_routes = self.determine_number_of_routes()
+        if number_of_routes > 0:
+            self.create_routes(number_of_routes)
+        else:
+            self.line_array = self.grid.line
+
+        # while not all connected, add lines from a connected node to an unconnected node
+        self.set_unconnected_nodes()
+        while any(self.unconnected_nodes):
+            self.connect_nodes()
+            self.set_unconnected_nodes()
+
+        number_of_nops = amount
+        if number_of_nops > 0:
+            self.create_nop_lines(number_of_nops)
+
+        return self.line_array
+
+    def create_routes(self, number_of_routes: int):
+        """Create a number of lines from the substation to unconnected nodes"""
+        # each source should have at least one route
+        number_of_sources = len(self.grid.source)
+        from_nodes = self.rng.choice(self.grid.source.node, number_of_routes - number_of_sources, replace=True)
+        not_source_mask = ~np.isin(self.grid.node.id, self.grid.source.node)
+        to_nodes = self.rng.choice(self.grid.node.id[not_source_mask], number_of_routes, replace=False)
+        capacities = 100 + self.rng.exponential(200, number_of_routes)
+        line_array = self.grid.line.__class__.zeros(number_of_routes)
+        line_array.id = 1 + self.grid.max_id + np.arange(number_of_routes)
+        line_array.from_node = np.concatenate((self.grid.source.node, from_nodes))
+        line_array.to_node = to_nodes
+        line_array.from_status = [1] * number_of_routes
+        line_array.to_status = [1] * number_of_routes
+        line_array.r1 = self.rng.exponential(0.2, number_of_routes)
+        line_array.x1 = self.rng.exponential(0.02, number_of_routes)
+        line_array.i_n = capacities
+        self.line_array = line_array
+
+    def determine_number_of_routes(self) -> int:
+        """Decide on a number of routes based on expected route-size"""
+        expected_number_of_routes = int(np.ceil(len(self.grid.node) / AVERAGE_ROUTE_SIZE))
+        number_of_sources = len(self.grid.source)
+        # The number of routes is the max of the number of sources
+        # and the expected number based on size
+        return max(expected_number_of_routes, number_of_sources)
+
+    def connect_nodes(self):
+        """Add a new line between an active and inactive line"""
+        to_node = self.rng.choice(self.unconnected_nodes)
+        to_voltage = self.grid.node[self.grid.node.id == to_node].u_rated[0]
+        same_voltage_mask = self.grid.node.u_rated == to_voltage
+        same_voltage_nodes = self.grid.node[same_voltage_mask]
+        options_mask = np.isin(self.connected_nodes, same_voltage_nodes.id)
+        from_node = self.rng.choice(np.array(self.connected_nodes)[options_mask])
+        capacity = 100 + self.rng.exponential(200, 1)
+        new_line = self.grid.line.__class__.zeros(1)
+        new_line.id = 1 + max(max(self.line_array.id), self.grid.max_id)  # pylint: disable=nested-min-max
+        new_line.from_node = from_node
+        new_line.to_node = to_node
+        new_line.from_status = [1]
+        new_line.to_status = [1]
+        new_line.r1 = self.rng.exponential(0.2, 1)
+        new_line.x1 = self.rng.exponential(0.02, 1)
+        new_line.i_n = capacity
+        self.line_array = fp.concatenate(self.line_array, new_line)
+
+    def create_nop_lines(self, number_of_nops: int):
+        """Create the inactive lines between different routes (Normally Open Points)"""
+        nops = [self.rng.choice(self.grid.node.id, 2, replace=False) for _ in range(number_of_nops)]
+        from_nodes = [nop[0] for nop in nops]
+        to_nodes = [nop[1] for nop in nops]
+        capacities = 100 + self.rng.exponential(200, number_of_nops)
+        nop_lines = self.grid.line.__class__.zeros(number_of_nops)
+        nop_lines.id = 1 + self.line_array.id.max() + np.arange(number_of_nops)
+        nop_lines.from_node = from_nodes
+        nop_lines.to_node = to_nodes
+        nop_lines.from_status = [1] * number_of_nops
+        nop_lines.to_status = [0] * number_of_nops
+        nop_lines.r1 = self.rng.exponential(0.2, number_of_nops)
+        nop_lines.x1 = self.rng.exponential(0.02, number_of_nops)
+        nop_lines.i_n = capacities
+        self.line_array = fp.concatenate(self.line_array, nop_lines)
+
+    def set_unconnected_nodes(self) -> None:
+        """From a line array and total set of nodes determine which are not yet connected"""
+        connected_link_mask = np.logical_or(
+            np.isin(self.grid.node.id, self.line_array.from_node),
+            np.isin(self.grid.node.id, self.line_array.to_node),
+        )
+        connected_trafo_mask = np.logical_or(
+            np.isin(self.grid.node.id, self.trafo_array.from_node),
+            np.isin(self.grid.node.id, self.trafo_array.to_node),
+        )
+        connected_mask = np.logical_or(
+            connected_link_mask,
+            connected_trafo_mask,
+        )
+        connected_nodes = self.grid.node.id[connected_mask]
+        unconnected_nodes = self.grid.node.id[~connected_mask]
+
+        self.unconnected_nodes = unconnected_nodes.tolist()
+        self.connected_nodes = connected_nodes.tolist()

power_grid_model_ds/_core/data_source/generator/arrays/node.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Generator for NodeArray"""
+
+import numpy as np
+
+from power_grid_model_ds._core.data_source.generator.arrays.base import BaseGenerator
+
+
+class NodeGenerator(BaseGenerator):
+    """Generator for node elements in the grid"""
+
+    # pylint: disable=arguments-differ
+    def run(self, amount: int, voltage_level: int = 10_500):
+        """Generate nodes in a grid with two possible load scenarios"""
+        node_array = self.grid.node.__class__.zeros(amount)
+        node_array.id = 1 + self.grid.max_id + np.arange(amount)
+        node_array.u_rated = voltage_level
+
+        load_low_array = self.grid.sym_load.__class__.zeros(amount)
+        load_low_array.id = 1 + node_array.id.max() + np.arange(amount)
+        load_low_array.node = node_array.id
+        load_low_array.status = 1
+        load_high_array = self.grid.sym_load.__class__.zeros(amount)
+        load_high_array.id = 1 + load_low_array.id.max() + np.arange(amount)
+        load_high_array.node = node_array.id
+        load_high_array.status = 1
+
+        # power consumption in Watt
+        load_low_array.p_specified = np.round(self.rng.normal(200_000, 150_000, amount))
+        load_low_array.q_specified = np.round(self.rng.normal(20_000, 15_000, amount))
+        load_high_array.p_specified = np.round(self.rng.normal(-100_000, 350_000, amount))
+        load_high_array.q_specified = np.round(self.rng.normal(-5_000, 35_000, amount))
+
+        return node_array, load_low_array, load_high_array

power_grid_model_ds/_core/data_source/generator/arrays/source.py

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Generator for SourceArray"""
+
+import numpy as np
+
+from power_grid_model_ds._core.data_source.generator.arrays.base import BaseGenerator
+from power_grid_model_ds._core.model.arrays import NodeArray, SourceArray
+from power_grid_model_ds._core.model.enums.nodes import NodeType
+
+
+class SourceGenerator(BaseGenerator):
+    """Generator for source elements in the grid (substations)"""
+
+    def run(self, amount: int) -> tuple[NodeArray, SourceArray]:
+        """Generate nodes in a grid which are sources (substations)"""
+        substation_node_array = self.grid.node.__class__.empty(amount)
+        substation_node_array.id = 1 + self.grid.max_id + np.arange(amount)
+        substation_node_array.u_rated = 10_500
+        substation_node_array.node_type = NodeType.SUBSTATION_NODE.value
+
+        source_array = self.grid.source.__class__.empty(amount)
+        source_array.id = 1 + substation_node_array.id.max() + np.arange(amount)
+        source_array.node = substation_node_array.id
+        source_array.status = 1
+        source_array.u_ref = 1
+
+        return substation_node_array, source_array

power_grid_model_ds/_core/data_source/generator/arrays/transformer.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Generator for LineArray"""
+
+import numpy as np
+
+from power_grid_model_ds._core.data_source.generator.arrays.base import BaseGenerator
+from power_grid_model_ds._core.model.arrays import TransformerArray
+
+
+class TransformerGenerator(BaseGenerator):
+    """Generator for tranformer elements in the grid"""
+
+    def run(self, amount: int) -> TransformerArray:
+        """Generate transformers"""
+
+        # Create transformers from 10kV to 3kV
+        from_mask = self.grid.node.u_rated == 10_500
+        from_nodes = self.rng.choice(self.grid.node.id[from_mask], amount, replace=True)
+        to_mask = self.grid.node.u_rated == 3_000
+        to_nodes = self.rng.choice(self.grid.node.id[to_mask], amount, replace=False)
+        transformer_array = self.grid.transformer.__class__.zeros(amount)
+        transformer_array.id = 1 + self.grid.max_id + np.arange(amount)
+        transformer_array.from_node = from_nodes
+        transformer_array.to_node = to_nodes
+        transformer_array.from_status = [1] * amount
+        transformer_array.to_status = [1] * amount
+        transformer_array.u1 = [10_500] * amount
+        transformer_array.u2 = [3_000] * amount
+        transformer_array.sn = [30e6] * amount
+        transformer_array.clock = [12] * amount
+        transformer_array.uk = [0.203] * amount
+        transformer_array.pk = [100e3] * amount
+
+        return transformer_array

power_grid_model_ds/_core/data_source/generator/grid_generators.py

@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Generators for the grid"""
+
+from typing import Type
+
+import numpy as np
+
+from power_grid_model_ds._core.data_source.generator.arrays.line import LineGenerator
+from power_grid_model_ds._core.data_source.generator.arrays.node import NodeGenerator
+from power_grid_model_ds._core.data_source.generator.arrays.source import SourceGenerator
+from power_grid_model_ds._core.data_source.generator.arrays.transformer import TransformerGenerator
+from power_grid_model_ds._core.model.graphs.models.base import BaseGraphModel
+from power_grid_model_ds._core.model.graphs.models.rustworkx import RustworkxGraphModel
+from power_grid_model_ds._core.model.grids.base import Grid
+
+# pylint: disable=too-few-public-methods,too-many-arguments,too-many-positional-arguments
+
+
+class RadialGridGenerator:
+    """Generates a random but structurally correct radial grid with the given specifications"""
+
+    def __init__(
+        self,
+        grid_class: Type[Grid],
+        nr_nodes: int = 100,
+        nr_sources: int = 2,
+        nr_nops: int = 10,
+        graph_model: type[BaseGraphModel] = RustworkxGraphModel,
+    ):
+        self.grid_class = grid_class
+        self.graph_model = graph_model
+        self.nr_nodes = nr_nodes
+        self.nr_sources = nr_sources
+        self.nr_nops = nr_nops
+
+    def run(self, seed=None, create_10_3_kv_net: bool = False):
+        """Run the generator to create a random radial grid.
+
+        if a seed is provided, this will be used to set rng.
+        """
+        grid = self.grid_class.empty(graph_model=self.graph_model)
+
+        # create nodeArray
+        node_generator = NodeGenerator(grid=grid, seed=seed)
+
+        nodes, _loads_low, loads_high = node_generator.run(amount=self.nr_nodes)
+        grid.append(nodes)
+        grid.append(loads_high)
+
+        # create sourceArray
+        source_generator = SourceGenerator(grid=grid, seed=seed)
+        nodes, sources = source_generator.run(amount=self.nr_sources)
+        grid.append(nodes)
+        grid.append(sources)
+
+        # create lineArray
+        line_generator = LineGenerator(grid=grid, seed=seed)
+        lines = line_generator.run(amount=self.nr_nops)
+        grid.append(lines)
+
+        if create_10_3_kv_net:
+            # create 3kV nodes
+            nodes, _loads_low, _loads_high = node_generator.run(amount=10, voltage_level=3_000)
+            grid.append(nodes)
+            grid.append(_loads_high)
+
+            # create transformerArray
+            transformer_generator = TransformerGenerator(grid=grid, seed=seed)
+            transformers = transformer_generator.run(amount=2)
+            grid.append(transformers)
+
+            lines = line_generator.run(amount=0, number_of_routes=0)
+            grid.append(lines[~np.isin(lines.id, grid.line.id)])
+
+        return grid

power_grid_model_ds/_core/fancypy.py

@@ -0,0 +1,66 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""A set of helper functions that mimic numpy functions but are specifically designed for FancyArrays."""
+
+from typing import TYPE_CHECKING, Union
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from power_grid_model_ds._core.model.arrays.base.array import FancyArray
+
+
+def concatenate(fancy_array: "FancyArray", *other_arrays: Union["FancyArray", np.ndarray]) -> "FancyArray":
+    """Concatenate arrays."""
+    np_arrays = [array if isinstance(array, np.ndarray) else array.data for array in other_arrays]
+    try:
+        concatenated = np.concatenate([fancy_array.data] + np_arrays)
+    except TypeError as error:
+        raise TypeError("Cannot append arrays: mismatching dtypes.") from error
+    return fancy_array.__class__(data=concatenated)
+
+
+def unique(array: "FancyArray", **kwargs):
+    """Return the unique elements of the array."""
+    for column in array.columns:
+        if np.issubdtype(array.dtype[column], np.floating) and np.isnan(array[column]).any():
+            raise NotImplementedError("Finding unique records in array with NaN values is not supported.")
+            # see https://github.com/numpy/numpy/issues/23286
+    unique_data = np.unique(array.data, **kwargs)
+    if isinstance(unique_data, tuple):
+        unique_data, *other = unique_data
+        return array.__class__(data=unique_data), *other
+    return array.__class__(data=unique_data)
+
+
+def sort(array: "FancyArray", axis=-1, kind=None, order=None) -> "FancyArray":
+    """Sort the array in-place and return sorted array."""
+    array.data.sort(axis=axis, kind=kind, order=order)
+    return array
+
+
+def array_equal(array1: "FancyArray", array2: "FancyArray", equal_nan: bool = True) -> bool:
+    """Return True if two arrays are equal."""
+    if equal_nan:
+        return _array_equal_with_nan(array1, array2)
+    return np.array_equal(array1.data, array2.data)
+
+
+def _array_equal_with_nan(array1: "FancyArray", array2: "FancyArray") -> bool:
+    # np.array_equal does not work with NaN values in structured arrays, so we need to compare column by column.
+    # related issue: https://github.com/numpy/numpy/issues/21539
+
+    if array1.columns != array2.columns:
+        return False
+
+    for column in array1.columns:
+        column_dtype = array1.dtype[column]
+        if np.issubdtype(column_dtype, np.str_):
+            if not np.array_equal(array1[column], array2[column]):
+                return False
+            continue
+        if not np.array_equal(array1[column], array2[column], equal_nan=True):
+            return False
+    return True

power_grid_model_ds/_core/load_flow.py

@@ -0,0 +1,140 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Load flow functions and classes"""
+
+from typing import Dict, Optional
+
+import numpy as np
+from numpy.typing import NDArray
+from power_grid_model import CalculationMethod, PowerGridModel, initialize_array
+
+from power_grid_model_ds._core.model.grids.base import Grid
+
+PGM_ARRAYS = [
+    "node",
+    "line",
+    "link",
+    "transformer",
+    "three_winding_transformer",
+    "sym_load",
+    "sym_gen",
+    "source",
+    "transformer_tap_regulator",
+    "sym_power_sensor",
+    "sym_voltage_sensor",
+    "asym_voltage_sensor",
+]
+
+
+class PGMCoreException(Exception):
+    """Raised when there is an error in running the power grid model"""
+
+
+class PowerGridModelInterface:
+    """Interface between the Grid and the PowerGridModel (pgm).
+
+    - Can convert grid data to pgm input
+    - Can calculate power flow
+    - Can do batch calculations using pgm
+    - Can update grid with output from power flow
+    """
+
+    def __init__(
+        self,
+        grid: Grid,
+        input_data: Optional[Dict] = None,
+        system_frequency: float = 50.0,
+    ):
+        self.grid = grid
+        self.system_frequency = system_frequency
+
+        self.input_data = input_data or {}
+        self.output_data: dict[str, NDArray] = {}
+        self.model: Optional[PowerGridModel] = None
+
+    def create_input_from_grid(self):
+        """
+        Create input for the PowerGridModel
+        """
+        for array_name in PGM_ARRAYS:
+            pgm_array = self._create_power_grid_array(array_name=array_name)
+            self.input_data[array_name] = pgm_array
+        return self.input_data
+
+    def calculate_power_flow(
+        self,
+        calculation_method: CalculationMethod = CalculationMethod.newton_raphson,
+        update_data: Optional[Dict] = None,
+        **kwargs,
+    ):
+        """Initialize the PowerGridModel and calculate power flow over input data.
+
+        If input data is not available, self.create_input_from_grid() will be called to create it.
+
+        Returns output of the power flow calculation (also stored in self.output_data)
+        """
+        self.model = self.model or self._setup_model()
+
+        self.output_data = self.model.calculate_power_flow(
+            calculation_method=calculation_method, update_data=update_data, **kwargs
+        )
+        return self.output_data
+
+    def _create_power_grid_array(self, array_name: str) -> np.ndarray:
+        """Create power grid model array"""
+        internal_array = getattr(self.grid, array_name)
+        pgm_array = initialize_array("input", array_name, internal_array.size)
+        fields = self._match_dtypes(pgm_array.dtype, internal_array.dtype)
+        pgm_array[fields] = internal_array.data[fields]
+        return pgm_array
+
+    def update_model(self, update_data: Dict):
+        """
+        Updates the power-grid-model using update_data, this allows for batch calculations
+
+        Example:
+            Example of update_data creation:
+
+            >>> update_sym_load = initialize_array('update', 'sym_load', 2)
+            >>> update_sym_load['id'] = [4, 7]  # same ID
+            >>> update_sym_load['p_specified'] = [30e6, 15e6]  # change active power
+            >>> # leave reactive power the same, no need to specify
+            >>>
+            >>> update_line = initialize_array('update', 'line', 1)
+            >>> update_line['id'] = [3]  # change line ID 3
+            >>> update_line['from_status'] = [0]  # switch off at from side
+            >>> # leave to-side swichint status the same, no need to specify
+            >>>
+            >>> update_data = {
+            >>>    'sym_load': update_sym_load,
+            >>>    'line': update_line
+            >>> }
+
+
+        """
+        self.model = self.model or self._setup_model()
+        self.model.update(update_data=update_data)
+
+    def update_grid(self) -> None:
+        """
+        Fills the output values in the grid for the values that are present
+        """
+        if not self.output_data:
+            raise PGMCoreException("Can not update grid without output_data")
+        for array_name in PGM_ARRAYS:
+            if array_name in self.output_data.keys():
+                internal_array = getattr(self.grid, array_name)
+                pgm_output_array = self.output_data[array_name]
+                fields = self._match_dtypes(pgm_output_array.dtype, internal_array.dtype)
+                internal_array[fields] = pgm_output_array[fields]
+
+    @staticmethod
+    def _match_dtypes(first_dtype: np.dtype, second_dtype: np.dtype):
+        return list(set(first_dtype.names).intersection(set(second_dtype.names)))  # type: ignore[arg-type]
+
+    def _setup_model(self):
+        self.input_data = self.input_data or self.create_input_from_grid()
+        self.model = PowerGridModel(self.input_data, system_frequency=self.system_frequency)
+        return self.model

power_grid_model_ds/_core/model/arrays/__init__.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Imports all the arrays, so that array can be imported as follows:
+from power_grid_model_ds._core.model.arrays import MyArray
+"""
+
+from power_grid_model_ds._core.model.arrays.pgm_arrays import (
+    AsymVoltageSensorArray,
+    Branch3Array,
+    BranchArray,
+    IdArray,
+    LineArray,
+    LinkArray,
+    NodeArray,
+    SourceArray,
+    SymGenArray,
+    SymLoadArray,
+    SymPowerSensorArray,
+    SymVoltageSensorArray,
+    ThreeWindingTransformerArray,
+    TransformerArray,
+    TransformerTapRegulatorArray,
+)
+
+__all__ = [
+    "AsymVoltageSensorArray",
+    "Branch3Array",
+    "BranchArray",
+    "IdArray",
+    "LineArray",
+    "LinkArray",
+    "NodeArray",
+    "SourceArray",
+    "SymLoadArray",
+    "SymGenArray",
+    "SymPowerSensorArray",
+    "SymVoltageSensorArray",
+    "ThreeWindingTransformerArray",
+    "TransformerArray",
+    "TransformerTapRegulatorArray",
+]