zepben.ewb 1.0.0__py3-none-any.whl

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

@@ -0,0 +1,172 @@
+#  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__ = ["EnergySource"]
+
+from typing import List, Optional, Generator, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.wires.energy_connection import EnergyConnection
+from zepben.ewb.util import nlen, get_by_mrid, ngen, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.energy_source_phase import EnergySourcePhase
+
+
+class EnergySource(EnergyConnection):
+    """
+    A generic equivalent for an energy supplier on a transmission or distribution voltage level.
+    """
+
+    _energy_source_phases: Optional[List[EnergySourcePhase]] = None
+
+    active_power: Optional[float] = None
+    """
+    High voltage source active injection. Load sign convention is used, i.e. positive sign means flow out from a node. Starting value
+    for steady state solutions
+    """
+
+    reactive_power: Optional[float] = None
+    """High voltage source reactive injection. Load sign convention is used, i.e. positive sign means flow out from a node. 
+    Starting value for steady state solutions."""
+
+    voltage_angle: Optional[float] = None
+    """Phase angle of a-phase open circuit."""
+
+    voltage_magnitude: Optional[float] = None
+    """Phase-to-phase open circuit voltage magnitude."""
+
+    p_max: Optional[float] = None
+    """
+    This is the maximum active power that can be produced by the source. Load sign convention is used, i.e. positive sign means flow out from a
+    TopologicalNode (bus) into the conducting equipment.
+    """
+
+    p_min: Optional[float] = None
+    """
+    This is the minimum active power that can be produced by the source. Load sign convention is used, i.e. positive sign means flow out from a
+    TopologicalNode (bus) into the conducting equipment.
+    """
+
+    r: Optional[float] = None
+    """Positive sequence Thevenin resistance."""
+
+    r0: Optional[float] = None
+    """Zero sequence Thevenin resistance."""
+
+    rn: Optional[float] = None
+    """Negative sequence Thevenin resistance."""
+
+    x: Optional[float] = None
+    """Positive sequence Thevenin reactance."""
+
+    x0: Optional[float] = None
+    """Zero sequence Thevenin reactance."""
+
+    xn: Optional[float] = None
+    """Negative sequence Thevenin reactance."""
+
+    is_external_grid: Optional[bool] = None
+    """
+    True if this energy source represents the higher-level power grid connection to an external grid
+    that normally is modelled as the slack bus for power flow calculations.
+    """
+
+    r_min: Optional[float] = None
+    """Minimum positive sequence Thevenin resistance."""
+
+    rn_min: Optional[float] = None
+    """Minimum negative sequence Thevenin resistance."""
+
+    r0_min: Optional[float] = None
+    """Minimum zero sequence Thevenin resistance."""
+
+    x_min: Optional[float] = None
+    """Minimum positive sequence Thevenin reactance."""
+
+    xn_min: Optional[float] = None
+    """Minimum negative sequence Thevenin reactance."""
+
+    x0_min: Optional[float] = None
+    """Minimum zero sequence Thevenin reactance."""
+
+    r_max: Optional[float] = None
+    """Maximum positive sequence Thevenin resistance."""
+
+    rn_max: Optional[float] = None
+    """Maximum negative sequence Thevenin resistance."""
+
+    r0_max: Optional[float] = None
+    """Maximum zero sequence Thevenin resistance."""
+
+    x_max: Optional[float] = None
+    """Maximum positive sequence Thevenin reactance."""
+
+    xn_max: Optional[float] = None
+    """Maximum negative sequence Thevenin reactance."""
+
+    x0_max: Optional[float] = None
+    """Maximum zero sequence Thevenin reactance."""
+
+    def __init__(self, energy_source_phases: List[EnergySourcePhase] = None, **kwargs):
+        super(EnergySource, self).__init__(**kwargs)
+        if energy_source_phases:
+            for phase in energy_source_phases:
+                self.add_phase(phase)
+
+    @property
+    def phases(self) -> Generator[EnergySourcePhase, None, None]:
+        """
+        The `EnergySourcePhase`s for this `EnergySource`.
+        """
+        return ngen(self._energy_source_phases)
+
+    def num_phases(self):
+        """Return the number of `EnergySourcePhase`s associated with this `EnergySource`"""
+        return nlen(self._energy_source_phases)
+
+    def get_phase(self, mrid: str) -> EnergySourcePhase:
+        """
+        Get the `EnergySourcePhase` for this `EnergySource` identified by `mrid`
+
+        `mrid` the mRID of the required `EnergySourcePhase`
+        Returns The `EnergySourcePhase` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._energy_source_phases, mrid)
+
+    def add_phase(self, phase: EnergySourcePhase) -> EnergySource:
+        """
+        Associate an `EnergySourcePhase` with this `EnergySource`
+
+        `phase` the `EnergySourcePhase` to associate with this `EnergySource`.
+        Returns A reference to this `EnergySource` to allow fluent use.
+        Raises `ValueError` if another `EnergySourcePhase` with the same `mrid` already exists for this `EnergySource`.
+        """
+        if self._validate_reference(phase, self.get_phase, "An EnergySourcePhase"):
+            return self
+        self._energy_source_phases = list() if self._energy_source_phases is None else self._energy_source_phases
+        self._energy_source_phases.append(phase)
+        return self
+
+    def remove_phase(self, phase: EnergySourcePhase) -> EnergySource:
+        """
+        Disassociate an `phase` from this `EnergySource`
+
+        `phase` the `EnergySourcePhase` to disassociate from this `EnergySource`.
+        Returns A reference to this `EnergySource` to allow fluent use.
+        Raises `ValueError` if `phase` was not associated with this `EnergySource`.
+        """
+        self._energy_source_phases = safe_remove(self._energy_source_phases, phase)
+        return self
+
+    def clear_phases(self) -> EnergySource:
+        """
+        Clear all phases.
+        Returns A reference to this `EnergySource` to allow fluent use.
+        """
+        self._energy_source_phases = None
+        return self

zepben/ewb/model/cim/iec61970/base/wires/energy_source_phase.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__ = ["EnergySourcePhase"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
+from zepben.ewb.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.energy_source import EnergySource
+
+
+class EnergySourcePhase(PowerSystemResource):
+    """
+    A single phase of an energy source.
+    """
+
+    _energy_source: Optional['EnergySource'] = None
+    """The `zepben.ewb.model.cim.iec61970.wires.EnergySource` with this `EnergySourcePhase`"""
+
+    phase: SinglePhaseKind = SinglePhaseKind.NONE
+    """A `zepben.ewb.model.cim.iec61970.base.wires.single_phase_kind.SinglePhaseKind` Phase of this energy source component. If the energy source is wye connected, 
+    the connection is from the indicated phase to the central ground or neutral point. If the energy source is delta connected, the phase indicates an energy 
+    source connected from the indicated phase to the next logical non-neutral phase."""
+
+    def __init__(self, energy_source: 'EnergySource' = None, **kwargs):
+        super(EnergySourcePhase, self).__init__(**kwargs)
+        if energy_source:
+            self.energy_source = energy_source
+
+    @property
+    def energy_source(self):
+        """The `EnergySource` with this `EnergySourcePhase`"""
+        return self._energy_source
+
+    @energy_source.setter
+    def energy_source(self, es):
+        if self._energy_source is None or self._energy_source is es:
+            self._energy_source = es
+        else:
+            raise ValueError(f"energy_source for {str(self)} has already been set to {self._energy_source}, cannot reset this field to {es}")

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

@@ -0,0 +1,23 @@
+#  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__ = ["Fuse"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.wires.switch import Switch
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.extensions.iec61970.base.protection.protection_relay_function import ProtectionRelayFunction
+
+
+class Fuse(Switch):
+    """
+    An overcurrent protective device with a circuit opening fusible part that is heated and severed by the passage of
+    overcurrent through it. A fuse is considered a switching device because it breaks current.
+    """
+
+    function: Optional['ProtectionRelayFunction'] = None
+    """The function implemented by this Fuse"""

zepben/ewb/model/cim/iec61970/base/wires/ground.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__ = ["Ground"]
+
+from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+
+
+class Ground(ConductingEquipment):
+    """
+    A point where the system is grounded used for connecting conducting equipment to ground. The power system model can have any number of grounds.
+    """
+    pass

zepben/ewb/model/cim/iec61970/base/wires/ground_disconnector.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__ = ["GroundDisconnector"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.switch import Switch
+
+
+class GroundDisconnector(Switch):
+    """
+    A manually operated or motor operated mechanical switching device used for isolating a circuit or equipment from ground.
+    """
+    pass

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

@@ -0,0 +1,19 @@
+#  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__ = ["GroundingImpedance"]
+
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.wires.earth_fault_compensator import EarthFaultCompensator
+
+
+class GroundingImpedance(EarthFaultCompensator):
+    """
+    A fixed impedance device used for grounding.
+    """
+
+    x: Optional[float] = None
+    """Reactance of device in ohms."""

zepben/ewb/model/cim/iec61970/base/wires/jumper.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__ = ["Jumper"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.switch import Switch
+
+
+class Jumper(Switch):
+    """
+    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.
+    """
+    pass

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

@@ -0,0 +1,15 @@
+#  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__ = ["Junction"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.connector import Connector
+
+
+class Junction(Connector):
+    """
+    A point where one or more conducting equipments are connected with zero resistance.
+    """
+    pass

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

@@ -0,0 +1,13 @@
+#  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__ = ["Line"]
+
+from zepben.ewb.model.cim.iec61970.base.core.equipment_container import EquipmentContainer
+
+
+class Line(EquipmentContainer):
+    """Contains equipment beyond a substation belonging to a power transmission line."""
+    pass

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

@@ -0,0 +1,26 @@
+#  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__ = ["LinearShuntCompensator"]
+
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.wires.shunt_compensator import ShuntCompensator
+
+
+class LinearShuntCompensator(ShuntCompensator):
+    """A linear shunt compensator has banks or sections with equal admittance values."""
+
+    b0_per_section: Optional[float] = None
+    """Zero sequence shunt (charging) susceptance per section"""
+
+    b_per_section: Optional[float] = None
+    """Positive sequence shunt (charging) susceptance per section"""
+
+    g0_per_section: Optional[float] = None
+    """Zero sequence shunt (charging) conductance per section"""
+
+    g_per_section: Optional[float] = None
+    """Positive sequence shunt (charging) conductance per section"""

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

@@ -0,0 +1,14 @@
+#  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__ = ["LoadBreakSwitch"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.protected_switch import ProtectedSwitch
+
+
+class LoadBreakSwitch(ProtectedSwitch):
+    """A mechanical switching device capable of making, carrying, and breaking currents under normal operating
+    conditions. """
+    pass

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

@@ -0,0 +1,13 @@
+#  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__ = ["PerLengthImpedance"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.per_length_line_parameter import PerLengthLineParameter
+
+
+class PerLengthImpedance(PerLengthLineParameter):
+    """Common type for per-length impedance electrical catalogues."""
+    pass

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

@@ -0,0 +1,13 @@
+#  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__ = ["PerLengthLineParameter"]
+
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+
+
+class PerLengthLineParameter(IdentifiedObject):
+    """Common type for per-length electrical catalogues describing line parameters."""
+    pass

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

@@ -0,0 +1,99 @@
+#  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__ = ["PerLengthPhaseImpedance"]
+
+from typing import Optional, List, Generator
+
+from zepben.ewb.model.cim.iec61970.base.wires.per_length_impedance import PerLengthImpedance
+from zepben.ewb.model.cim.iec61970.base.wires.phase_impedance_data import PhaseImpedanceData
+from zepben.ewb.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
+from zepben.ewb.util import require, ngen, nlen, safe_remove, none
+
+
+class PerLengthPhaseImpedance(PerLengthImpedance):
+    """
+    Impedance and admittance parameters per unit length for n-wire unbalanced lines, in matrix form.
+    """
+
+    _data: Optional[List[PhaseImpedanceData]] = None
+
+    def __init__(self, data: List[PhaseImpedanceData] = None, **kwargs):
+        """
+        `data` A list of `PhaseImpedanceData`s to associate with this `PerLengthPhaseImpedance`.
+        """
+        super(PerLengthPhaseImpedance, self).__init__(**kwargs)
+        if data:
+            for phase_data in data:
+                self.add_data(phase_data)
+
+    @property
+    def data(self) -> Generator[PhaseImpedanceData, None, None]:
+        """
+        The point data values that define this phase_impedance, sorted by `x_value` in ascending order.
+        """
+        return ngen(self._data)
+
+    @property
+    def diagonal(self) -> Generator[PhaseImpedanceData, None, None]:
+        """
+        Get only the diagonal elements of the matrix, i.e toPhase == fromPhase.
+        """
+        return ngen(pid for pid in self._data if pid.from_phase == pid.to_phase)
+
+    def num_data(self):
+        """Return the number of :class:`PhaseImpedanceData` associated with this :class:`PerLengthPhaseImpedance`."""
+        return nlen(self._data)
+
+    def get_data(self, from_phase: SinglePhaseKind, to_phase: SinglePhaseKind) -> PhaseImpedanceData:
+        """
+        Get the matrix entry for the corresponding to and from phases.
+
+        :param from_phase: The from_phase to lookup.
+        :param to_phase: The to_phase to lookup.
+        :returns: The :class:`PhaseImpedanceData` with the specified `from_phase` and `to_phase` if it exists.
+        :raises KeyError: When no `PhaseImpedanceData` was found with a matching `from_phase` and `to_phase`.
+        """
+        if self._data:
+            phase_impedance_data = next((it for it in self._data if it.from_phase == from_phase and it.to_phase == to_phase), None)
+            if phase_impedance_data:
+                return phase_impedance_data
+        raise KeyError((from_phase, to_phase))
+
+    def add_data(self, phase_impedance_data: PhaseImpedanceData) -> 'PerLengthPhaseImpedance':
+        """
+        Add a :class:`PhaseImpedanceData` to this :class:`PerLengthPhaseImpedance`.
+
+        :param phase_impedance_data: The :class:`PhaseImpedanceData` to add.
+        :returns: A reference to this :class:`PerLengthPhaseImpedance` to allow fluent use.
+        :raises ValueError: If another :class:`PhaseImpedanceData` with the same `from_phase` and `to_phase` already exists for this :class:`PerLengthPhaseImpedance`.
+        """
+
+        require(none([it.from_phase == phase_impedance_data.from_phase and it.to_phase == phase_impedance_data.to_phase for it in self.data]),
+                lambda: f"""Unable to add PhaseImpedanceData to {self}. A PhaseImpedanceData with from_phase {phase_impedance_data.from_phase} and to_phase {phase_impedance_data.to_phase} already exists in this PerLengthPhaseImpedance.""")
+
+        self._data = self._data or []
+        self._data.append(phase_impedance_data)
+
+        return self
+
+    def remove_data(self, phase_impedance_data: PhaseImpedanceData) -> 'PerLengthPhaseImpedance':
+        """
+        Remove a :class:`PhaseImpedanceData` from this :class:`PerLengthPhaseImpedance`.
+
+        :param phase_impedance_data: The :class:`PhaseImpedanceData` to remove from this :class:`PerLengthPhaseImpedance`.
+        :returns: A reference to this :class:`PerLengthPhaseImpedance` to allow fluent use.
+        :raises ValueError: If `phase_impedance_data` was not associated with this :class:`PerLengthPhaseImpedance`.
+        """
+        self._data = safe_remove(self._data, phase_impedance_data)
+        return self
+
+    def clear_data(self) -> 'PerLengthPhaseImpedance':
+        """
+        Clear all :class:`PhaseImpedanceData` associated with this :class:`PerLengthPhaseImpedance`.
+        :returns: A reference to this :class:`PerLengthPhaseImpedance` to allow fluent use.
+        """
+        self._data = None
+        return self

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

@@ -0,0 +1,43 @@
+#  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__ = ["PerLengthSequenceImpedance"]
+
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.wires.per_length_impedance import PerLengthImpedance
+
+
+class PerLengthSequenceImpedance(PerLengthImpedance):
+    """
+    Sequence impedance and admittance parameters per unit length, for transposed lines of 1, 2, or 3 phases.
+    For 1-phase lines, define x=x0=xself. For 2-phase lines, define x=xs-xm and x0=xs+xm.
+
+    Typically, one PerLengthSequenceImpedance is used for many ACLineSegments.
+    """
+
+    r: Optional[float] = None
+    """Positive sequence series resistance, per unit of length."""
+
+    x: Optional[float] = None
+    """Positive sequence series reactance, per unit of length."""
+
+    bch: Optional[float] = None
+    """Positive sequence shunt (charging) susceptance, per unit of length."""
+
+    gch: Optional[float] = None
+    """Positive sequence shunt (charging) conductance, per unit of length."""
+
+    r0: Optional[float] = None
+    """Zero sequence series resistance, per unit of length."""
+
+    x0: Optional[float] = None
+    """Zero sequence series reactance, per unit of length."""
+
+    b0ch: Optional[float] = None
+    """Zero sequence shunt (charging) susceptance, per unit of length."""
+
+    g0ch: Optional[float] = None
+    """Zero sequence shunt (charging) conductance, per unit of length."""

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

@@ -0,0 +1,22 @@
+#  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__ = ["PetersenCoil"]
+
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.wires.earth_fault_compensator import EarthFaultCompensator
+
+
+class PetersenCoil(EarthFaultCompensator):
+    """
+    A variable impedance device normally used to offset line charging during single line faults in an ungrounded section of network.
+    """
+
+    x_ground_nominal: Optional[float] = None
+    """
+    The nominal reactance. This is the operating point (normally over compensation) that is defined based on the resonance point in the
+    healthy network condition. The impedance is calculated based on nominal voltage divided by position current.
+    """

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

@@ -0,0 +1,37 @@
+#  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__ = ["PhaseImpedanceData"]
+
+from dataclasses import dataclass
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
+
+
+@dataclass(frozen=True)
+class PhaseImpedanceData(object):
+    """
+    Impedance and conductance matrix element values. The diagonal elements are described by the elements having the same toPhase and fromPhase value and the
+    off diagonal elements have different to_phase and from_phase values.
+    """
+
+    from_phase: SinglePhaseKind
+    """Refer to the class description."""
+
+    to_phase: SinglePhaseKind
+    """Refer to the class description."""
+
+    b: Optional[float] = None
+    """Susceptance matrix element value, per length of unit."""
+
+    g: Optional[float] = None
+    """Conductance matrix element value, per length of unit."""
+
+    r: Optional[float] = None
+    """Resistance matrix element value, per length of unit."""
+
+    x: Optional[float] = None
+    """Reactance matrix element value, per length of unit."""

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

@@ -0,0 +1,40 @@
+#  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__ = ["PhaseShuntConnectionKind"]
+
+from enum import Enum
+
+from zepben.ewb.util import unique
+
+
+@unique
+class PhaseShuntConnectionKind(Enum):
+    """
+    The configuration of phase connections for a single terminal device such as a load or capacitor.
+    """
+
+    UNKNOWN = 0
+    """Unknown `PhaseShuntConnectionKind`"""
+
+    D = 1
+    """Delta Connection"""
+
+    Y = 2
+    """Wye connection"""
+
+    Yn = 3
+    """Wye, with neutral brought out for grounding."""
+
+    I = 4
+    """Independent winding, for single-phase connections."""
+
+    G = 5
+    """Ground connection; use when explicit connection to ground needs to be expressed in combination with the phase code,
+    such as for electrical wire/cable or for meters."""
+
+    @property
+    def short_name(self):
+        return str(self)[25:]