zepben.ewb 1.0.0__py3-none-any.whl

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

@@ -0,0 +1,168 @@
+#  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__ = ["SynchronousMachine"]
+
+from typing import Optional, List, Generator, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.wires.rotating_machine import RotatingMachine
+from zepben.ewb.model.cim.iec61970.base.wires.synchronous_machine_kind import SynchronousMachineKind
+from zepben.ewb.util import ngen, nlen, get_by_mrid, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.reactive_capability_curve import ReactiveCapabilityCurve
+
+
+class SynchronousMachine(RotatingMachine):
+    """
+    An electromechanical device that operates with shaft rotating synchronously with the network. It is a single machine operating either as a generator or
+    synchronous condenser or pump.
+    """
+
+    _reactive_capability_curves: Optional[List['ReactiveCapabilityCurve']] = None
+
+    base_q: Optional[float] = None
+    """Default base reactive power value in VAr. This value represents the initial reactive power that can be used by any application function."""
+
+    condenser_p: Optional[int] = None
+    """Active power consumed (watts) when in condenser mode operation."""
+
+    earthing: Optional[bool] = None
+    """Indicates whether the generator is earthed. Used for short circuit data exchange according to IEC 60909."""
+
+    earthing_star_point_r: Optional[float] = None
+    """Generator star point earthing resistance in Ohms (Re). Used for short circuit data exchange according to IEC 60909."""
+
+    earthing_star_point_x: Optional[float] = None
+    """Generator star point earthing reactance in Ohms (Xe). Used for short circuit data exchange according to IEC 60909."""
+
+    ikk: Optional[float] = None
+    """
+    Steady-state short-circuit current (in A for the profile) of generator with compound excitation during 3-phase short circuit.
+    - Ikk=0: Generator with no compound excitation.
+    - Ikk<>0: Generator with compound excitation.
+    Ikk is used to calculate the minimum steady-state short-circuit current for generators with compound excitation. (4.6.1.2 in IEC 60909-0:2001).
+    Used only for single fed short circuit on a generator. (4.3.4.2. in IEC 60909-0:2001).
+    """
+
+    max_q: Optional[float] = None
+    """Maximum reactive power limit in VAr. This is the maximum (nameplate) limit for the unit."""
+
+    max_u: Optional[int] = None
+    """Maximum voltage limit for the unit in volts."""
+
+    min_q: Optional[float] = None
+    """Minimum reactive power limit for the unit in VAr."""
+
+    min_u: Optional[int] = None
+    """Minimum voltage limit for the unit in volts."""
+
+    mu: Optional[float] = None
+    """
+    Factor to calculate the breaking current (Section 4.5.2.1 in IEC 60909-0).
+    Used only for single fed short circuit on a generator (Section 4.3.4.2. in IEC 60909-0).
+    """
+
+    r: Optional[float] = None
+    """
+    Equivalent resistance (RG) of generator as a percentage. RG is considered for the calculation of all currents,
+    except for the calculation of the peak current ip. Used for short circuit data exchange according to IEC 60909.
+    """
+
+    r0: Optional[float] = None
+    """Zero sequence resistance of the synchronous machine as a percentage."""
+
+    r2: Optional[float] = None
+    """Negative sequence resistance as a percentage."""
+
+    sat_direct_subtrans_x: Optional[float] = None
+    """Direct-axis subtransient reactance saturated as a percentage, also known as Xd"sat."""
+
+    sat_direct_sync_x: Optional[float] = None
+    """
+    Direct-axes saturated synchronous reactance (xdsat); reciprocal of short-circuit ration, as a percentage.
+    Used for short circuit data exchange, only for single fed short circuit on a generator. (4.3.4.2. in IEC 60909-0:2001).
+    """
+
+    sat_direct_trans_x: Optional[float] = None
+    """
+    Saturated Direct-axis transient reactance as a percentage.
+    The attribute is primarily used for short circuit calculations according to ANSI.
+    """
+
+    x0: Optional[float] = None
+    """Zero sequence reactance of the synchronous machine as a percentage."""
+
+    x2: Optional[float] = None
+    """Negative sequence reactance as a percentage."""
+
+    type: SynchronousMachineKind = SynchronousMachineKind.UNKNOWN
+    """Modes that this synchronous machine can operate in."""
+
+    operating_mode: SynchronousMachineKind = SynchronousMachineKind.UNKNOWN
+    """Current mode of operation."""
+
+    def __init__(self, curves: List['ReactiveCapabilityCurve'] = None, **kwargs):
+        """
+        `reactive_capability_curves` A list of `ReactiveCapabilityCurve`s to associate with this `SynchronousMachine`.
+        """
+        super(SynchronousMachine, self).__init__(**kwargs)
+        if curves:
+            for rcc in curves:
+                self.add_curve(rcc)
+
+    @property
+    def curves(self) -> Generator['ReactiveCapabilityCurve', None, None]:
+        """
+        The available reactive capability curves for this synchronous machine. The first shall be the default for this :class:`SynchronousMachine`.
+        """
+        return ngen(self._reactive_capability_curves)
+
+    def num_curves(self):
+        """Return the number of :class:`ReactiveCapabilityCurve`s associated with this :class:`SynchronousMachine`."""
+        return nlen(self._reactive_capability_curves)
+
+    def get_curve(self, mrid: str) -> 'ReactiveCapabilityCurve':
+        """
+        Get the :class:`ReactiveCapabilityCurve` for this :class:`SynchronousMachine` identified by `mrid`
+
+        :param mrid: The mRID of the required :class:`ReactiveCapabilityCurve`.
+        :returns: The :class:`ReactiveCapabilityCurve` with the specified `mrid` if it exists.
+        :raises KeyError: If `mrid` wasn't present.
+        """
+        return get_by_mrid(self._reactive_capability_curves, mrid)
+
+    def add_curve(self, curve: 'ReactiveCapabilityCurve') -> 'SynchronousMachine':
+        """
+        Associate a :class:`ReactiveCapabilityCurve` with this :class:`SynchronousMachine`.
+
+        :param curve: The :class:`ReactiveCapabilityCurve` to associate with this :class:`SynchronousMachine`.
+        :returns: A reference to this :class:`SynchronousMachine` to allow fluent use.
+        :raises ValueError: If another :class:`ReactiveCapabilityCurve` with the same `mrid` already exists for this :class:`SynchronousMachine`.
+        """
+        if self._validate_reference(curve, self.get_curve, "A ReactiveCapabilityCurve"):
+            return self
+        self._reactive_capability_curves = self._reactive_capability_curves or []
+        self._reactive_capability_curves.append(curve)
+        return self
+
+    def remove_curve(self, curve: 'ReactiveCapabilityCurve') -> 'SynchronousMachine':
+        """
+        Disassociate a :class:`ReactiveCapabilityCurve` from this :class:`SynchronousMachine`.
+
+        :param curve: The :class:`ReactiveCapabilityCurve` to disassociate from this :class:`SynchronousMachine`.
+        :returns: A reference to this :class:`SynchronousMachine` to allow fluent use.
+        :raises ValueError: If `curve` was not associated with this :class:`SynchronousMachine`.
+        """
+        self._reactive_capability_curves = safe_remove(self._reactive_capability_curves, curve)
+        return self
+
+    def clear_curves(self) -> 'SynchronousMachine':
+        """
+        Clear all :class:`ReactiveCapabilityCurve` associated with this :class:`SynchronousMachine`.
+        :returns: A reference to this :class:`SynchronousMachine` to allow fluent use.
+        """
+        self._reactive_capability_curves = None
+        return self

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

@@ -0,0 +1,46 @@
+#  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__ = ["SynchronousMachineKind"]
+
+from enum import Enum
+
+from zepben.ewb import unique
+
+
+@unique
+class SynchronousMachineKind(Enum):
+    """
+    Synchronous machine type.
+    """
+
+    UNKNOWN = 0
+    """UNKNOWN"""
+
+    generator = 1
+    """Indicates the synchronous machine can operate as a generator."""
+
+    condenser = 2
+    """Indicates the synchronous machine can operate as a condenser."""
+
+    generatorOrCondenser = 3
+    """Indicates the synchronous machine can operate as a generator or as a condenser."""
+
+    motor = 4
+    """Indicates the synchronous machine can operate as a motor."""
+
+    generatorOrMotor = 5
+    """Indicates the synchronous machine can operate as a generator or as a motor."""
+
+    motorOrCondenser = 6
+    """Indicates the synchronous machine can operate as a motor or as a condenser."""
+
+    generatorOrCondenserOrMotor = 7
+    """Indicates the synchronous machine can operate as a generator or as a condenser or as a motor."""
+
+    @property
+    def short_name(self) -> str:
+        """Get the name of this `SynchronousMachineKind` without the class qualifier"""
+        return str(self)[23:]

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

@@ -0,0 +1,150 @@
+#  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/.
+
+__all__ = ["TapChanger"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
+from zepben.ewb.util import require
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.tap_changer_control import TapChangerControl
+
+
+class TapChanger(PowerSystemResource):
+    """
+    Mechanism for changing transformer winding tap positions.
+    """
+
+    control_enabled: Optional[bool] = None
+    """Specifies the regulation status of the equipment.  True is regulating, false is not regulating."""
+
+    neutral_u: Optional[int] = None
+    """Voltage at which the winding operates at the neutral tap setting."""
+
+    tap_changer_control: Optional['TapChangerControl'] = None
+    """The regulating control scheme in which this tap changer participates."""
+
+    _high_step: Optional[int] = None
+    _low_step: Optional[int] = None
+    _neutral_step: Optional[int] = None
+    _normal_step: Optional[int] = None
+    _step: Optional[float] = None
+
+    def __init__(self, high_step: int = None, low_step: int = None, neutral_step: int = None, normal_step: int = None, step: float = None, **kwargs):
+        super(TapChanger, self).__init__(**kwargs)
+        if high_step is not None:
+            self._high_step = high_step
+        if low_step is not None:
+            self._low_step = low_step
+        if neutral_step is not None:
+            self._neutral_step = neutral_step
+        if normal_step is not None:
+            self._normal_step = normal_step
+        if step is not None:
+            self._step = step
+        self._validate_steps()
+
+    @property
+    def high_step(self):
+        """
+        Highest possible tap step position, advance from neutral. The attribute shall be greater than lowStep. This tap position results in the
+        maximum voltage boost on secondary winding(s).
+        """
+        return self._high_step
+
+    @high_step.setter
+    def high_step(self, val):
+        require((val is None) or (self._low_step is None) or (val > self._low_step),
+                lambda: f"High step [{val}] must be greater than low step [{self._low_step}]")
+        self._check_steps(self.low_step, val)
+        self._high_step = val
+
+    @property
+    def low_step(self):
+        """Lowest possible tap step position, retard from neutral. This tap position results in the maximum voltage buck on secondary winding(s)."""
+        return self._low_step
+
+    @low_step.setter
+    def low_step(self, val):
+        require((val is None) or (self._high_step is None) or (val < self._high_step),
+                lambda: f"Low step [{val}] must be less than high step [{self._high_step}]")
+        self._check_steps(val, self.high_step)
+        self._low_step = val
+
+    @property
+    def neutral_step(self):
+        """The neutral tap step position for this winding. The attribute shall be equal or greater than lowStep and equal or less than highStep."""
+        return self._neutral_step
+
+    @neutral_step.setter
+    def neutral_step(self, val):
+        require(self._is_in_range(val), lambda: f"Neutral step [{val}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
+        self._neutral_step = val
+
+    @property
+    def normal_step(self):
+        """
+        The tap step position used in "normal" network operation for this winding. For a "Fixed" tap changer indicates the current physical tap setting.
+        The attribute shall be equal or greater than lowStep and equal or less than highStep.
+        """
+        return self._normal_step
+
+    @normal_step.setter
+    def normal_step(self, val):
+        require(self._is_in_range(val), lambda: f"Normal step [{val}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
+        self._normal_step = val
+
+    @property
+    def step(self):
+        """
+        Tap changer position. Starting step for a steady state solution. Non integer values are allowed to support continuous tap variables.
+        The reasons for continuous value are to support study cases where no discrete tap changers has yet been designed, a solutions where a narrow voltage
+        band force the tap step to oscillate or accommodate for a continuous solution as input.
+        The attribute shall be equal or greater than lowStep and equal or less than highStep.
+        """
+        return self._step
+
+    @step.setter
+    def step(self, val):
+        require(self._is_in_range(val), lambda: f"Step [{val}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
+        self._step = val
+
+    def _check_steps(self, low, high):
+        if low is not None:
+            require((self.step is None) or (low <= self.step), lambda: f"New value would invalidate current step of [{self.step}]")
+            require((self.normal_step is None) or (low <= self.normal_step), lambda: f"New value would invalidate current normal_step of [{self.normal_step}]")
+            require((self.neutral_step is None) or (low <= self.neutral_step),
+                    lambda: f"New value would invalidate current neutral_step of [{self.neutral_step}]")
+
+        if high is not None:
+            require((self.step is None) or (self.step <= high), lambda: f"New value would invalidate current step of [{self.step}]")
+            require((self.normal_step is None) or (self.normal_step <= high), lambda: f"New value would invalidate current normal_step of [{self.normal_step}]")
+            require((self.neutral_step is None) or (self.neutral_step <= high),
+                    lambda: f"New value would invalidate current neutral_step of [{self.neutral_step}]")
+
+    def _validate_steps(self):
+        require((self._high_step is None) or (self._low_step is None) or (self._high_step > self._low_step),
+                lambda: f"High step [{self._high_step}] must be greater than low step [{self._low_step}]")
+        require(self._is_in_range(self._neutral_step),
+                lambda: f"Neutral step [{self.neutral_step}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
+        require(self._is_in_range(self._normal_step),
+                lambda: f"Normal step [{self.normal_step}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
+        require(self._is_in_range(self._step), lambda: f"Step [{self._step}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
+
+    def _is_in_range(self, val) -> bool:
+        if val is None:
+            return True
+
+        if self._low_step is not None:
+            if val < self._low_step:
+                return False
+
+        if self._high_step is not None:
+            if val > self._high_step:
+                return False
+
+        return True

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

@@ -0,0 +1,49 @@
+#  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__ = ["TapChangerControl"]
+
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.wires.regulating_control import RegulatingControl
+
+
+class TapChangerControl(RegulatingControl):
+    """
+    Describes behaviour specific to tap changers, e.g. how the voltage at the end of a line varies with the load level and compensation of the voltage drop by
+    tap adjustment.
+    """
+    limit_voltage: Optional[int] = None
+    """Maximum allowed regulated voltage on the PT secondary, regardless of line drop compensation. Sometimes referred to as first-house protection."""
+
+    line_drop_compensation: Optional[bool] = None
+    """If true, then line drop compensation is to be applied. """
+
+    line_drop_r: Optional[float] = None
+    """Line drop compensator resistance setting for normal (forward) power flow in Ohms."""
+
+    line_drop_x: Optional[float] = None
+    """Line drop compensator reactance setting for normal (forward) power flow in Ohms."""
+
+    reverse_line_drop_r: Optional[float] = None
+    """Line drop compensator resistance setting for reverse power flow in Ohms."""
+
+    reverse_line_drop_x: Optional[float] = None
+    """Line drop compensator reactance setting for reverse power flow in Ohms."""
+
+    forward_ldc_blocking: Optional[bool] = None
+    """
+    True implies this tap changer turns off/ignores reverse current flows for line drop compensation when power flow is reversed and no reverse line drop 
+    is set.
+    """
+
+    time_delay: Optional[float] = None
+    """The time delay for the tap changer in seconds."""
+
+    co_generation_enabled: Optional[bool] = None
+    """
+    True implies cogeneration mode is enabled and that the control will regulate to the new source bushing (downline bushing), keeping locations downline 
+    from experiencing overvoltage situations.
+    """

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

@@ -0,0 +1,73 @@
+#  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/.
+
+__all__ = ["TransformerEnd"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+from zepben.ewb.util import require
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.base_voltage import BaseVoltage
+    from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+    from zepben.ewb.model.cim.iec61970.base.wires.power_transformer import PowerTransformer
+    from zepben.ewb.model.cim.iec61970.base.wires.ratio_tap_changer import RatioTapChanger
+    from zepben.ewb.model.cim.iec61970.base.wires.transformer_star_impedance import TransformerStarImpedance
+
+
+class TransformerEnd(IdentifiedObject):
+    """
+    A conducting connection point of a power transformer. It corresponds to a physical transformer winding terminal.
+    In earlier CIM versions, the TransformerWinding class served a similar purpose, but this class is more flexible
+    because it associates to terminal but is not a specialization of ConductingEquipment.
+    """
+    grounded: Optional[bool] = None
+    """(for Yn and Zn connections) True if the neutral is solidly grounded."""
+
+    r_ground: Optional[float] = None
+    """(for Yn and Zn connections) Resistance part of neutral impedance where 'grounded' is true"""
+
+    x_ground: Optional[float] = None
+    """(for Yn and Zn connections) Reactive part of neutral impedance where 'grounded' is true"""
+
+    ratio_tap_changer: Optional['RatioTapChanger'] = None
+    """Ratio tap changer associated with this transformer end."""
+
+    _terminal: Optional['Terminal'] = None
+    """The terminal of the transformer that this end is associated with"""
+
+    base_voltage: Optional['BaseVoltage'] = None
+    """Base voltage of the transformer end.  This is essential for PU calculation."""
+
+    end_number: int = 0
+    """Number for this transformer end, corresponding to the end’s order in the power transformer vector group or phase angle clock number. 
+    Highest voltage winding should be 1. Each end within a power transformer should have a unique subsequent end number. 
+    Note the transformer end number need not match the terminal sequence number."""
+
+    star_impedance: Optional['TransformerStarImpedance'] = None
+    """(accurate for 2- or 3-winding transformers only) Pi-model impedances of this transformer end. By convention, for a two winding transformer, the full
+     values of the transformer should be entered on the high voltage end (endNumber=1)."""
+
+    def __init__(self, terminal: Optional['Terminal'] = None, **kwargs):
+        super(TransformerEnd, self).__init__(**kwargs)
+        if terminal is not None:
+            self.terminal = terminal
+
+    @property
+    def terminal(self) -> Optional['Terminal']:
+        """
+        The terminal of the transformer that this end is associated with
+        """
+        return self._terminal
+
+    @terminal.setter
+    def terminal(self, value: Optional['Terminal']):
+        if value is not None:
+            from zepben.ewb.model.cim.iec61970.base.wires.power_transformer import PowerTransformer
+            require(value.conducting_equipment is None or isinstance(value.conducting_equipment, PowerTransformer),
+                    lambda: f"Cannot assign {self.__class__.__name__}[{self.mrid}] to {value.__class__.__name__}[{value.mrid}], which is connected to a " +
+                            f"{value.conducting_equipment.__class__.__name__}[{value.conducting_equipment.mrid}] rather than a PowerTransformer.")
+            self._terminal = value

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

@@ -0,0 +1,48 @@
+#  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__ = ["TransformerStarImpedance"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+from zepben.ewb.model.resistance_reactance import ResistanceReactance
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.assetinfo.transformer_end_info import TransformerEndInfo
+
+
+class TransformerStarImpedance(IdentifiedObject):
+    """
+    Transformer star impedance (Pi-model) that accurately reflects impedance for transformers with 2 or 3 windings. For transformers with 4 or more windings,
+    TransformerMeshImpedance class shall be used.
+    For transmission networks use PowerTransformerEnd impedances (r, r0, x, x0, b, b0, g and g0).
+    """
+
+    r: Optional[float] = None
+    """ r : Resistance of the transformer end. Unit: Ohms  """
+
+    r0: Optional[float] = None
+    """ r0 : Zero sequence series resistance of the transformer end. Unit: Ohms"""
+
+    x: Optional[float] = None
+    """ x : Positive sequence series reactance  of the transformer end. Unit: Ohms"""
+
+    x0: Optional[float] = None
+    """ x0 : Zero sequence series reactance of the transformer end. Unit: Ohms"""
+
+    transformer_end_info: Optional['TransformerEndInfo'] = None
+    """Transformer end datasheet used to calculate this transformer star impedance."""
+
+    def resistance_reactance(self) -> ResistanceReactance:
+        """
+        Get the `ResistanceReactance` for this `TransformerStarImpedance`. If any values are missing
+        attempt to calculate them from the `TransformerEndInfo` tests.
+        Returns the `ResistanceReactance` for this `TransformerStarImpedance`
+        """
+        # noinspection PyArgumentList
+        return ResistanceReactance(self.r, self.x, self.r0, self.x0).merge_if_incomplete(
+            lambda: self.transformer_end_info.calculate_resistance_reactance_from_tests() if self.transformer_end_info is not None else None
+        )

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

@@ -0,0 +1,45 @@
+#  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__ = ["WindingConnection"]
+
+from enum import Enum
+
+from zepben.ewb import unique
+
+
+@unique
+class WindingConnection(Enum):
+    """
+    Winding connection type.
+    """
+
+    UNKNOWN = 0
+    """Default"""
+
+    D = 1
+    """Delta"""
+
+    Y = 2
+    """Wye"""
+
+    Z = 3
+    """ZigZag"""
+
+    Yn = 4
+    """Wye, with neutral brought out for grounding"""
+
+    Zn = 5
+    """ZigZag, with neutral brought out for grounding"""
+
+    A = 6
+    """Autotransformer common winding"""
+
+    I = 7
+    """Independent winding, for single-phase connections"""
+
+    @property
+    def short_name(self):
+        return str(self)[18:]

zepben/ewb/model/cim/iec61970/infiec61970/__init__.py

@@ -0,0 +1,4 @@
+#  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/.

zepben/ewb/model/cim/iec61970/infiec61970/feeder/__init__.py

@@ -0,0 +1,4 @@
+#  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/.