zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/model/cim/iec61970/base/wires/power_transformer.py

@@ -0,0 +1,217 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["PowerTransformer"]
+
+from typing import List, Optional, Generator, TYPE_CHECKING
+
+from zepben.ewb.model.cim.extensions.iec61970.base.wires.vector_group import VectorGroup
+from zepben.ewb.model.cim.iec61968.infiec61968.infassetinfo.transformer_construction_kind import TransformerConstructionKind
+from zepben.ewb.model.cim.iec61968.infiec61968.infassetinfo.transformer_function_kind import TransformerFunctionKind
+from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+from zepben.ewb.util import require, nlen, get_by_mrid, ngen, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.assetinfo.power_transformer_info import PowerTransformerInfo
+    from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+    from zepben.ewb.model.cim.iec61970.base.wires.power_transformer_end import PowerTransformerEnd
+
+
+class PowerTransformer(ConductingEquipment):
+    """
+    An electrical device consisting of  two or more coupled windings, with or without a magnetic core, for introducing
+    mutual coupling between electric circuits.
+
+    Transformers can be used to control voltage and phase shift (active power flow). A power transformer may be composed of separate transformer tanks that
+    need not be identical. A power transformer can be modeled with or without tanks and is intended for use in both balanced and unbalanced representations.
+
+    A power transformer typically has two terminals, but may have one (grounding), three or more terminals.
+
+    The inherited association ConductingEquipment.BaseVoltage should not be used.
+    The association from TransformerEnd to BaseVoltage should be used instead.
+
+    Attributes -
+        vector_group : `zepben.protobuf.cim.iec61970.base.wires.VectorGroup` of the transformer for protective relaying.
+        power_transformer_ends : 
+                                 
+                                 
+    """
+    vector_group: VectorGroup = VectorGroup.UNKNOWN
+    """
+    Vector group of the transformer for protective relaying, e.g., Dyn1. For unbalanced transformers, this may not be simply
+    determined from the constituent winding connections and phase angle displacements.
+                                                                                                                            
+    The vectorGroup string consists of the following components in the order listed: high voltage winding connection, mid
+    voltage winding connection(for three winding transformers), phase displacement clock number from 0 to 11,  low voltage
+    winding connection phase displacement clock number from 0 to 11.   The winding connections are D(delta), Y(wye),
+    YN(wye with neutral), Z(zigzag), ZN(zigzag with neutral), A(auto transformer). Upper case means the high voltage,
+    lower case mid or low.The high voltage winding always has clock position 0 and is not included in the vector group
+    string.  Some examples: YNy0(two winding wye to wye with no phase displacement), YNd11(two winding wye to delta with
+    330 degrees phase displacement), YNyn0d5(three winding transformer wye with neutral high voltage, wye with neutral mid
+    voltage and no phase displacement, delta low voltage with 150 degrees displacement).
+                                                                                                                            
+    Phase displacement is defined as the angular difference between the phasors representing the voltages between the
+    neutral point(real or imaginary) and the corresponding terminals of two windings, a positive sequence voltage system
+    being applied to the high-voltage terminals, following each other in alphabetical sequence if they are lettered, or in
+    numerical sequence if they are numbered: the phasors are assumed to rotate in a counter-clockwise sense.
+    """
+
+    _power_transformer_ends: Optional[List[PowerTransformerEnd]] = None
+
+    transformer_utilisation: Optional[float] = None
+    """
+    The fraction of the transformer’s normal capacity (nameplate rating) that is in use. It may be expressed as the
+    result of the calculation S/Sn, where S = Load on Transformer (in VA), Sn = Transformer Nameplate Rating (in VA).
+    """
+
+    construction_kind: TransformerConstructionKind = TransformerConstructionKind.unknown
+    """
+    The construction kind of this transformer.
+    """
+
+    function: TransformerFunctionKind = TransformerFunctionKind.other
+    """
+    The function of this transformer.
+    """
+
+    def __init__(self, power_transformer_ends: List[PowerTransformerEnd] = None, **kwargs):
+        super(PowerTransformer, self).__init__(**kwargs)
+        if power_transformer_ends:
+            for end in power_transformer_ends:
+                if end.power_transformer is None:
+                    end.power_transformer = self
+                self.add_end(end)
+
+    def num_ends(self):
+        """
+        Get the number of `PowerTransformerEnd`s for this `PowerTransformer`.
+        """
+        return nlen(self._power_transformer_ends)
+
+    @property
+    def ends(self) -> Generator[PowerTransformerEnd, None, None]:
+        """The `PowerTransformerEnd`s for this `PowerTransformer`."""
+        return ngen(self._power_transformer_ends)
+
+    @property
+    def power_transformer_info(self) -> Optional[PowerTransformerInfo]:
+        """The `PowerTransformerInfo` for this `PowerTransformer`"""
+        return self.asset_info
+
+    @power_transformer_info.setter
+    def power_transformer_info(self, pti: Optional[PowerTransformerInfo]):
+        """
+        Set the `PowerTransformerInfo` for this `PowerTransformer`
+        `pti` The `PowerTransformerInfo` to associate with this `PowerTransformer`
+        """
+        self.asset_info = pti
+
+    def get_base_voltage(self, terminal: Terminal = None):
+        if terminal is None:
+            return self.base_voltage
+        for end in self.ends:
+            if end.terminal is terminal:
+                return end.base_voltage
+        else:
+            return None
+
+    def get_end_by_mrid(self, mrid: str) -> PowerTransformerEnd:
+        """
+        Get the `PowerTransformerEnd` for this `PowerTransformer` identified by `mrid`
+
+        `mrid` the mRID of the required `PowerTransformerEnd`
+        Returns The `PowerTransformerEnd` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._power_transformer_ends, mrid)
+
+    def get_end_by_num(self, end_number: int) -> PowerTransformerEnd:
+        """
+        Get the `PowerTransformerEnd` on this `PowerTransformer` by its `end_number`.
+
+        `end_number` The `end_number` of the `PowerTransformerEnd` in relation to this `PowerTransformer`s VectorGroup.
+        Returns The `PowerTransformerEnd` referred to by `end_number`
+        Raises IndexError if no `PowerTransformerEnd` was found with end_number `end_number`.
+        """
+        if self._power_transformer_ends:
+            for end in self._power_transformer_ends:
+                if end.end_number == end_number:
+                    return end
+        raise IndexError(f"No TransformerEnd with end_number {end_number} was found in PowerTransformer {str(self)}")
+
+    def get_end_by_terminal(self, terminal: Terminal) -> PowerTransformerEnd:
+        """
+        Get the `PowerTransformerEnd` on this `PowerTransformer` by its `terminal`.
+
+        `terminal` The `terminal` to find a `PowerTransformerEnd` for.
+        Returns The `PowerTransformerEnd` connected to the specified `terminal`
+        Raises IndexError if no `PowerTransformerEnd` connected to `terminal` was found on this `PowerTransformer`.
+        """
+        if self._power_transformer_ends:
+            for end in self._power_transformer_ends:
+                if end.terminal is terminal:
+                    return end
+        raise IndexError(f"No TransformerEnd with terminal {terminal} was found in PowerTransformer {str(self)}")
+
+    def add_end(self, end: PowerTransformerEnd) -> PowerTransformer:
+        """
+        Associate a `PowerTransformerEnd` with this `PowerTransformer`. If `end.end_number` == 0, the end will be assigned an end_number of
+        `self.num_ends() + 1`.
+
+        `end` the `PowerTransformerEnd` to associate with this `PowerTransformer`.
+        Returns A reference to this `PowerTransformer` to allow fluent use.
+        Raises `ValueError` if another `PowerTransformerEnd` with the same `mrid` already exists for this `PowerTransformer`.
+        """
+        if self._validate_end(end):
+            return self
+
+        if end.end_number == 0:
+            end.end_number = self.num_ends() + 1
+
+        self._power_transformer_ends = list() if self._power_transformer_ends is None else self._power_transformer_ends
+        self._power_transformer_ends.append(end)
+        self._power_transformer_ends.sort(key=lambda t: t.end_number)
+        return self
+
+    def remove_end(self, end: PowerTransformerEnd) -> PowerTransformer:
+        """
+        `end` the `PowerTransformerEnd` to disassociate from this `PowerTransformer`.
+        Raises `ValueError` if `end` was not associated with this `PowerTransformer`.
+        Returns A reference to this `PowerTransformer` to allow fluent use.
+        """
+        self._power_transformer_ends = safe_remove(self._power_transformer_ends, end)
+        return self
+
+    def clear_ends(self) -> PowerTransformer:
+        """
+        Clear all `PowerTransformerEnd`s.
+        Returns A reference to this `PowerTransformer` to allow fluent use.
+        """
+        self._power_transformer_ends.clear()
+        return self
+
+    def _validate_end(self, end: PowerTransformerEnd) -> bool:
+        """
+        Validate an end against this `PowerTransformer`'s `PowerTransformerEnd`s.
+
+        `end` The `PowerTransformerEnd` to validate.
+        Returns True if `end` is already associated with this `PowerTransformer`, otherwise False.
+        Raises `ValueError` if `end.power_transformer` is not this `PowerTransformer`, or if this `PowerTransformer` has a different `PowerTransformerEnd`
+        with the same mRID.
+        """
+        if self._validate_reference(end, self.get_end_by_mrid, "A PowerTransformerEnd"):
+            return True
+
+        if self._validate_reference_by_field(end, end.end_number, self.get_end_by_num, "end_number"):
+            return True
+
+        if not end.power_transformer:
+            end.power_transformer = self
+
+        require(end.power_transformer is self,
+                lambda: f"PowerTransformerEnd {end} references another PowerTransformer {end.power_transformer}, expected {str(self)}.")
+        return False

zepben/ewb/model/cim/iec61970/base/wires/power_transformer_end.py

@@ -0,0 +1,208 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["PowerTransformerEnd"]
+
+import warnings
+from typing import Optional, List, Generator, TYPE_CHECKING
+
+from zepben.ewb.model.cim.extensions.iec61970.base.wires.transformer_cooling_type import TransformerCoolingType
+from zepben.ewb.model.cim.extensions.iec61970.base.wires.transformer_end_rated_s import TransformerEndRatedS
+from zepben.ewb.model.cim.iec61970.base.wires.transformer_end import TransformerEnd
+from zepben.ewb.model.cim.iec61970.base.wires.winding_connection import WindingConnection
+from zepben.ewb.model.resistance_reactance import ResistanceReactance
+from zepben.ewb.util import ngen, nlen, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.power_transformer import PowerTransformer
+
+
+class PowerTransformerEnd(TransformerEnd):
+    """
+    A PowerTransformerEnd is associated with each Terminal of a PowerTransformer.
+
+    The impedance values r, r0, x, and x0 of a PowerTransformerEnd represents a star equivalent as follows
+
+    1) for a two Terminal PowerTransformer the high voltage PowerTransformerEnd has non-zero values on r, r0, x, and x0
+    while the low voltage PowerTransformerEnd has zero values for r, r0, x, and x0.
+    2) for a three Terminal PowerTransformer the three PowerTransformerEnds represents a star equivalent with each leg
+    in the star represented by r, r0, x, and x0 values.
+    3) For a three Terminal transformer each PowerTransformerEnd shall have g, g0, b and b0 values corresponding the no load losses
+    distributed on the three PowerTransformerEnds. The total no load loss shunt impedances may also be placed at one of the
+    PowerTransformerEnds, preferably the end numbered 1, having the shunt values on end 1 is the preferred way.
+    4) for a PowerTransformer with more than three Terminals the PowerTransformerEnd impedance values cannot be used.
+    Instead use the TransformerMeshImpedance or split the transformer into multiple PowerTransformers.
+    """
+
+    _power_transformer: Optional[PowerTransformer] = None
+    """The power transformer of this power transformer end."""
+    _rated_s: Optional[int] = None
+
+    rated_u: Optional[int] = None
+    """Rated voltage: phase-phase for three-phase windings, and either phase-phase or phase-neutral for single-phase windings. A high voltage side, as given by 
+    TransformerEnd.endNumber, shall have a ratedU that is greater or equal than ratedU for the lower voltage sides."""
+
+    r: Optional[float] = None
+    """Resistance (star-phases) of the transformer end. The attribute shall be equal or greater than zero for non-equivalent transformers."""
+
+    x: Optional[float] = None
+    """Positive sequence series reactance (star-phases) of the transformer end."""
+
+    r0: Optional[float] = None
+    """Zero sequence series resistance (star-phases) of the transformer end."""
+
+    x0: Optional[float] = None
+    """Zero sequence series reactance of the transformer end."""
+
+    g: Optional[float] = None
+    """Magnetizing branch conductance."""
+
+    g0: Optional[float] = None
+    """Zero sequence magnetizing branch conductance (star-phases)."""
+
+    b: Optional[float] = None
+    """Magnetizing branch susceptance (B mag).  The value can be positive or negative."""
+
+    b0: Optional[float] = None
+    """Zero sequence magnetizing branch susceptance."""
+
+    connection_kind: WindingConnection = WindingConnection.UNKNOWN
+    """Kind of `zepben.protobuf.cim.iec61970.base.wires.winding_connection.WindingConnection` for this end."""
+
+    phase_angle_clock: Optional[int] = None
+    """Terminal voltage phase angle displacement where 360 degrees are represented with clock hours. The valid values are 0 to 11. For example, for the 
+    secondary side end of a transformer with vector group code of 'Dyn11', specify the connection kind as wye with neutral and specify the phase angle of the 
+    clock as 11. The clock value of the transformer end number specified as 1, is assumed to be zero."""
+
+    _s_ratings: Optional[List[TransformerEndRatedS]] = None
+    """
+    Backing list for storing transformer ratings. Placed here to not mess with __init__ param order. Must always be placed at the end.
+    Should not be used directly, instead use add_rating and get_rating functions. 
+    """
+
+    def __init__(self, power_transformer: PowerTransformer = None, rated_s: int = None, **kwargs):
+        super(PowerTransformerEnd, self).__init__(**kwargs)
+        if power_transformer:
+            self.power_transformer = power_transformer
+        if self._s_ratings:
+            raise ValueError("Do not directly set s_ratings through the constructor. You have one more constructor parameter than expected.")
+        if rated_s and self._rated_s:
+            raise ValueError(f"Cannot specify both rated_s and _rated_s properties when constructing {self}. Check your constructor parameters.")
+        if rated_s is not None:
+            warnings.warn(
+                "`rated_s` has been replaced by `s_ratings`. Please use `add_rating()` to add one of more ratings and their related [TransformerCoolingType].",
+                DeprecationWarning,
+                stacklevel=3
+            )
+            self.rated_s = rated_s
+        if self._rated_s is not None:
+            self.rated_s = self._rated_s
+            self._rated_s = None
+
+    @property
+    def power_transformer(self):
+        """The power transformer of this power transformer end."""
+        return self._power_transformer
+
+    @power_transformer.setter
+    def power_transformer(self, pt):
+        if self._power_transformer is None or self._power_transformer is pt:
+            self._power_transformer = pt
+        else:
+            raise ValueError(f"power_transformer for {str(self)} has already been set to {self._power_transformer}, cannot reset this field to {pt}")
+
+    @property
+    def nominal_voltage(self):
+        return self.base_voltage.nominal_voltage if self.base_voltage else self.rated_u
+
+    @property
+    def rated_s(self) -> Optional[int]:
+        """
+        Normal apparent power rating. The attribute shall be a positive value. For a two-winding transformer the values for the high and low voltage sides
+        shall be identical.
+        """
+        if self._s_ratings:
+            return self._s_ratings[0].rated_s if len(self._s_ratings) > 0 else None
+        return None
+
+    @rated_s.setter
+    def rated_s(self, rated_s: Optional[int]):
+        warnings.warn(
+            "`rated_s` has been replaced by `s_ratings` and is only for backward compatibility. Setting `rated_s`, will clear any other ratings.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        self.clear_ratings()
+        if rated_s is not None:
+            self.add_transformer_end_rated_s(TransformerEndRatedS(TransformerCoolingType.UNKNOWN, rated_s))
+
+    @property
+    def s_ratings(self) -> Generator[TransformerEndRatedS, None, None]:
+        return ngen(self._s_ratings)
+
+    def num_ratings(self) -> int:
+        return nlen(self._s_ratings)
+
+    def get_rating(self, cooling_type: TransformerCoolingType) -> TransformerEndRatedS:
+        if self._s_ratings:
+            for s_rating in self._s_ratings:
+                if s_rating.cooling_type == cooling_type:
+                    return s_rating
+        raise KeyError(cooling_type)
+
+    def add_rating(self, rated_s: int, cooling_type: TransformerCoolingType = TransformerCoolingType.UNKNOWN) -> PowerTransformerEnd:
+        self._s_ratings = self._s_ratings if self._s_ratings else list()
+
+        for s_rating in self._s_ratings:
+            if s_rating.cooling_type == cooling_type:
+                raise ValueError(f"A rating for coolingType {cooling_type.name} already exists, please remove it first.")
+
+        self._s_ratings.append(TransformerEndRatedS(cooling_type, rated_s))
+
+        def sort_by_rated_s(t: TransformerEndRatedS) -> int:
+            return t.rated_s
+
+        self._s_ratings.sort(key=sort_by_rated_s, reverse=True)
+
+        return self
+
+    def add_transformer_end_rated_s(self, transformer_end_rated_s: TransformerEndRatedS) -> PowerTransformerEnd:
+        return self.add_rating(transformer_end_rated_s.rated_s, transformer_end_rated_s.cooling_type)
+
+    def remove_rating(self, transformer_end_rated_s: TransformerEndRatedS) -> PowerTransformerEnd:
+        self._s_ratings = safe_remove(self._s_ratings, transformer_end_rated_s)
+        return self
+
+    def remove_rating_by_cooling_type(self, cooling_type: TransformerCoolingType) -> TransformerEndRatedS:
+        if self._s_ratings:
+            for transformer_end_rated_s in self._s_ratings:
+                if transformer_end_rated_s.cooling_type == cooling_type:
+                    self._s_ratings.remove(transformer_end_rated_s)
+                    self._s_ratings = self._s_ratings if self._s_ratings else None
+                    return transformer_end_rated_s
+        raise IndexError(cooling_type)
+
+    def clear_ratings(self) -> PowerTransformerEnd:
+        self._s_ratings = None
+        return self
+
+    def resistance_reactance(self):
+        """
+        Get the `ResistanceReactance` for this `PowerTransformerEnd` from either:
+        1. directly assigned values or
+        2. the pre-calculated `starImpedance` or
+        3. from the datasheet information of the associated `powerTransformer`
+
+        If the data is not complete in any of the above it will merge in the missing values from the subsequent sources.
+        :return:
+        """
+        ResistanceReactance(self.r, self.x, self.r0, self.x0).merge_if_incomplete(
+            lambda: self.star_impedance.resistance_reactance() if self.star_impedance is not None else None
+        ).merge_if_incomplete(
+            lambda: self.power_transformer.power_transformer_info.resistance_reactance(self.end_number) if self.power_transformer.asset_info is not None
+            else None
+        )

zepben/ewb/model/cim/iec61970/base/wires/protected_switch.py

@@ -0,0 +1,96 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["ProtectedSwitch"]
+
+from typing import Optional, List, Generator, TYPE_CHECKING, Iterable
+
+from zepben.ewb.model.cim.iec61970.base.wires.switch import Switch
+from zepben.ewb.util import get_by_mrid, ngen, nlen, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.extensions.iec61970.base.protection.protection_relay_function import ProtectionRelayFunction
+
+
+class ProtectedSwitch(Switch):
+    """
+    A ProtectedSwitch is a switching device that can be operated by :class:`ProtectionRelayFunction`.
+    """
+
+    breaking_capacity: Optional[int] = None
+    """The maximum fault current in amps a breaking device can break safely under prescribed conditions of use."""
+
+    _relay_functions: Optional[List[ProtectionRelayFunction]] = None
+
+    def __init__(
+        self,
+        relay_functions: Iterable[ProtectionRelayFunction] = None,
+        **kwargs
+    ):
+        super(ProtectedSwitch, self).__init__(**kwargs)
+
+        # breaking_capacity is handled via dataclassy.
+        if relay_functions is not None:
+            for relay_function in relay_functions:
+                self.add_relay_function(relay_function)
+
+    @property
+    def relay_functions(self) -> Generator[ProtectionRelayFunction, None, None]:
+        """
+        Yields all :class:`ProtectionRelayFunctions<ProtectionRelayFunction>` operating this :class:`ProtectedSwitch`.
+
+        :return: A generator that iterates over all :class:`ProtectionRelayFunctions<ProtectionRelayFunction>` operating this :class:`ProtectedSwitch`.
+        """
+        return ngen(self._relay_functions)
+
+    def num_relay_functions(self) -> int:
+        """
+        Get the number of :class:`ProtectionRelayFunctions<ProtectionRelayFunction>` operating this :class:`ProtectedSwitch`.
+
+        :return: The number of :class:`ProtectionRelayFunctions<ProtectionRelayFunction>` operating this :class:`ProtectedSwitch`.
+        """
+        return nlen(self._relay_functions)
+
+    def get_relay_function(self, mrid: str) -> ProtectionRelayFunction:
+        """
+        Get a :class:`ProtectionRelayFunction` operating this :class:`ProtectedSwitch` with the specified `mrid`.
+
+        :param mrid: The mRID of the desired :class:`ProtectionRelayFunction`
+        :return: The :class:`ProtectionRelayFunction` with the specified mRID if it exists, otherwise None.
+        :raises KeyError: If `mrid` wasn't present.
+        """
+        return get_by_mrid(self._relay_functions, mrid)
+
+    def add_relay_function(self, relay_function: ProtectionRelayFunction) -> ProtectedSwitch:
+        """
+        Associate this :class:`ProtectedSwitch` with a :class:`ProtectionRelayFunction` operating it.
+        :param relay_function: The :class:`ProtectionRelayFunction` to associate with this :class:`ProtectedSwitch`.
+        :return: A reference to this :class:`ProtectedSwitch` for fluent use.
+        """
+        if self._validate_reference(relay_function, self.get_relay_function, "A ProtectionRelayFunction"):
+            return self
+
+        self._relay_functions = list() if self._relay_functions is None else self._relay_functions
+        self._relay_functions.append(relay_function)
+        return self
+
+    def remove_relay_function(self, relay_function: Optional[ProtectionRelayFunction]) -> ProtectedSwitch:
+        """
+        Disassociate this :class:`ProtectedSwitch` from a :class:`ProtectionRelayFunction`.
+        :param relay_function: The :class:`ProtectionRelayFunction` to disassociate from this :class:`ProtectedSwitch`.
+        :return: A reference to this :class:`ProtectedSwitch` for fluent use.
+        """
+        self._relay_functions = safe_remove(self._relay_functions, relay_function)
+        return self
+
+    def clear_relay_functions(self) -> ProtectedSwitch:
+        """
+        Disassociate all :class:`ProtectionRelayFunction` from this :class:`ProtectedSwitch`.
+        :return: A reference to this :class:`ProtectedSwitch` for fluent use.
+        """
+        self._relay_functions = None
+        return self

zepben/ewb/model/cim/iec61970/base/wires/ratio_tap_changer.py

@@ -0,0 +1,30 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["RatioTapChanger"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.wires.tap_changer import TapChanger
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.transformer_end import TransformerEnd
+
+
+class RatioTapChanger(TapChanger):
+    """
+    A tap changer that changes the voltage ratio impacting the voltage magnitude but not the phase angle across the transformer.
+
+    Angle sign convention (general): Positive value indicates a positive phase shift from the winding where the tap is located to the other winding
+    (for a two-winding transformer).
+    """
+
+    transformer_end: Optional[TransformerEnd] = None
+    """`TransformerEnd` to which this ratio tap changer belongs."""
+
+    step_voltage_increment: Optional[float] = None
+    """Tap step increment, in per cent of neutral voltage, per step position."""

zepben/ewb/model/cim/iec61970/base/wires/reactive_capability_curve.py

@@ -0,0 +1,16 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["ReactiveCapabilityCurve"]
+
+from zepben.ewb.model.cim.iec61970.base.core.curve import Curve
+
+
+class ReactiveCapabilityCurve(Curve):
+    """
+    Reactive power rating envelope versus the synchronous machine's active power, in both the generating and motoring modes. For each active power value there
+    is a corresponding high and low reactive power limit value. Typically, there will be a separate curve for each coolant condition, such as hydrogen pressure.
+    The Y1 axis values represent reactive minimum and the Y2 axis values represent reactive maximum.
+    """

zepben/ewb/model/cim/iec61970/base/wires/recloser.py

@@ -0,0 +1,15 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["Recloser"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.protected_switch import ProtectedSwitch
+
+
+class Recloser(ProtectedSwitch):
+    """
+    Pole-mounted fault interrupter with built-in phase and ground relays, current transformer (CT), and supplemental controls.
+    """
+    pass

zepben/ewb/model/cim/iec61970/base/wires/regulating_cond_eq.py

@@ -0,0 +1,45 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["RegulatingCondEq"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.wires.energy_connection import EnergyConnection
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.regulating_control import RegulatingControl
+
+
+class RegulatingCondEq(EnergyConnection):
+    """
+    A short section of conductor with negligible impedance which can be manually removed and replaced if the circuit is
+    de-energized. Note that zero-impedance branches can potentially be modeled by other equipment types.
+    """
+
+    control_enabled: Optional[bool] = None
+    """Specifies the regulation status of the equipment.  True is regulating, false is not regulating."""
+
+    _regulating_control: Optional[RegulatingControl] = None
+
+    def __init__(self, regulating_control: Optional[RegulatingControl] = None, **kwargs):
+        super(RegulatingCondEq, self).__init__(**kwargs)
+        self.regulating_control = regulating_control
+
+    @property
+    def regulating_control(self):
+        """
+        The `RegulatingControl` associated with this `RegulatingCondEq`
+        """
+        return self._regulating_control
+
+    @regulating_control.setter
+    def regulating_control(self, rc):
+        if self._regulating_control is None or rc is self._regulating_control:
+            self._regulating_control = rc
+        else:
+            raise ValueError(f"regulating_control for {str(self)} has already been set to {self._regulating_control}, cannot set this field again")