zepben.ewb 1.0.0__py3-none-any.whl

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

@@ -0,0 +1,214 @@
+#  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__ = ["AcLineSegment"]
+
+from typing import Optional, List, Generator, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.wires.conductor import Conductor
+from zepben.ewb.util import nlen, ngen, get_by_mrid, safe_remove, require
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.clamp import Clamp
+    from zepben.ewb.model.cim.iec61970.base.wires.cut import Cut
+    from zepben.ewb.model.cim.iec61970.base.wires.per_length_impedance import PerLengthImpedance
+    from zepben.ewb.model.cim.iec61970.base.wires.per_length_phase_impedance import PerLengthPhaseImpedance
+    from zepben.ewb.model.cim.iec61970.base.wires.per_length_sequence_impedance import PerLengthSequenceImpedance
+
+
+class AcLineSegment(Conductor):
+    """
+    A wire or combination of wires, with consistent electrical characteristics, building a single electrical system,
+    used to carry alternating current between points in the power system.
+
+    For symmetrical, transposed 3ph lines, it is sufficient to use attributes of the line segment, which describe
+    impedances and admittances for the entire length of the segment. Additionally impedances can be computed by
+    using length and associated per length impedances.
+
+    The BaseVoltage at the two ends of ACLineSegments in a Line shall have the same BaseVoltage.nominalVoltage.
+    However, boundary lines  may have slightly different BaseVoltage.nominalVoltages and variation is allowed.
+    Larger voltage difference in general requires use of an equivalent branch.
+    """
+    max_terminals = 2
+
+    per_length_impedance: Optional['PerLengthImpedance'] = None
+    """A `zepben.ewb.model.cim.iec61970.base.wires.PerLengthImpedance` describing this AcLineSegment"""
+
+    _cuts: Optional[List['Cut']] = None
+    _clamps: Optional[List['Clamp']] = None
+
+    @property
+    def per_length_sequence_impedance(self) -> Optional['PerLengthSequenceImpedance']:
+        """
+        Per-length sequence impedance of this line segment.
+        :return: A PerLengthSequenceImpedance if one is set, otherwise None.
+        """
+        if self.per_length_impedance:
+            from zepben.ewb.model.cim.iec61970.base.wires.per_length_sequence_impedance import PerLengthSequenceImpedance
+            if isinstance(self.per_length_impedance, PerLengthSequenceImpedance):
+                return self.per_length_impedance
+        return None
+
+    @per_length_sequence_impedance.setter
+    def per_length_sequence_impedance(self, value: Optional['PerLengthSequenceImpedance']):
+        self.per_length_impedance = value
+
+    @property
+    def per_length_phase_impedance(self) -> Optional['PerLengthPhaseImpedance']:
+        """
+        Per-length phase impedance of this line segment.
+        :return: A PerLengthPhaseImpedance if one is set, otherwise None.
+        """
+        if self.per_length_impedance:
+            from zepben.ewb.model.cim.iec61970.base.wires.per_length_phase_impedance import PerLengthPhaseImpedance
+            if isinstance(self.per_length_impedance, PerLengthPhaseImpedance):
+                return self.per_length_impedance
+        return None
+
+    @per_length_phase_impedance.setter
+    def per_length_phase_impedance(self, value: Optional['PerLengthPhaseImpedance']):
+        self.per_length_impedance = value
+
+    @property
+    def cuts(self) -> Generator['Cut', None, None]:
+        """The `Cut`s for this `AcLineSegment`."""
+        return ngen(self._cuts)
+
+    def num_cuts(self):
+        """
+        Get the number of `Cut`s for this `AcLineSegment`.
+        """
+        return nlen(self._cuts)
+
+    def get_cut(self, mrid: str) -> 'Cut':
+        """
+        Get the `Cut` for this `AcLineSegment` identified by `mrid`
+
+        :param mrid: The mRID of the required `Cut`
+        :return: The `Cut` with the specified `mrid` if it exists
+        :raise KeyError: If the `mrid` wasn't present.
+        """
+        return get_by_mrid(self._cuts, mrid)
+
+    def add_cut(self, cut: 'Cut') -> 'AcLineSegment':
+        """
+        Associate a `Cut` with this `AcLineSegment`.
+
+        :param cut: the `Cut` to associate with this `AcLineSegment`.
+        :return: A reference to this `AcLineSegment` to allow fluent use.
+        :raise ValueError: If another `Cut` with the same `mrid` already exists for this `AcLineSegment`.
+        """
+        if self._validate_cut(cut):
+            return self
+
+        self._cuts = list() if self._cuts is None else self._cuts
+        self._cuts.append(cut)
+        return self
+
+    def remove_cut(self, cut: 'Cut') -> 'AcLineSegment':
+        """
+        :param cut: The `Cut` to disassociate from this `AcLineSegment`.
+        :raise ValueError: If `cut` was not associated with this `AcLineSegment`.
+        :return: A reference to this `AcLineSegment` to allow fluent use.
+        """
+        self._cuts = safe_remove(self._cuts, cut)
+        return self
+
+    def clear_cuts(self) -> 'AcLineSegment':
+        """
+        Clear all `Cut`s.
+        :return: A reference to this `AcLineSegment` to allow fluent use.
+        """
+        self._cuts.clear()
+        return self
+
+    @property
+    def clamps(self) -> Generator['Clamp', None, None]:
+        """The `Clamp`s for this `AcLineSegment`."""
+        return ngen(self._clamps)
+
+    def num_clamps(self):
+        """
+        Get the number of `Clamp`s for this `AcLineSegment`.
+        """
+        return nlen(self._clamps)
+
+    def get_clamp(self, mrid: str) -> 'Clamp':
+        """
+        Get the `Clamp` for this `AcLineSegment` identified by `mrid`
+
+        :param mrid: The mRID of the required `Clamp`
+        :return: The `Clamp` with the specified `mrid` if it exists
+        :raise KeyError: If the `mrid` wasn't present.
+        """
+        return get_by_mrid(self._clamps, mrid)
+
+    def add_clamp(self, clamp: 'Clamp') -> 'AcLineSegment':
+        """
+        Associate a `Clamp` with this `AcLineSegment`.
+
+        :param clamp: the `Clamp` to associate with this `AcLineSegment`.
+        :return: A reference to this `AcLineSegment` to allow fluent use.
+        :raise ValueError: If another `Clamp` with the same `mrid` already exists for this `AcLineSegment`.
+        """
+        if self._validate_clamp(clamp):
+            return self
+
+        self._clamps = list() if self._clamps is None else self._clamps
+        self._clamps.append(clamp)
+        return self
+
+    def remove_clamp(self, clamp: 'Clamp') -> 'AcLineSegment':
+        """
+        :param clamp: The `Clamp` to disassociate from this `AcLineSegment`.
+        :raise ValueError: If `clamp` was not associated with this `AcLineSegment`.
+        :return: A reference to this `AcLineSegment` to allow fluent use.
+        """
+        self._clamps = safe_remove(self._clamps, clamp)
+        return self
+
+    def clear_clamps(self) -> 'AcLineSegment':
+        """
+        Clear all `Clamp`s.
+        :return: A reference to this `AcLineSegment` to allow fluent use.
+        """
+        self._clamps.clear()
+        return self
+
+    def _validate_cut(self, cut: 'Cut') -> bool:
+        """
+        Validate a cut against this `AcLineSegment`'s `Cut`s.
+
+        :param cut: The `Cut` to validate.
+        :return: True if `cut` is already associated with this `AcLineSegment`, otherwise False.
+        :raise ValueError: If `cut.ac_line_segment` is not this `AcLineSegment`, or if this `AcLineSegment` has a different `Cut` with the same mRID.
+        """
+        if self._validate_reference(cut, self.get_cut, "A Cut"):
+            return True
+
+        if not cut.ac_line_segment:
+            cut.ac_line_segment = self
+
+        require(cut.ac_line_segment is self,
+                lambda: f"Cut {cut} references another AcLineSegment {cut.ac_line_segment}, expected {str(self)}.")
+        return False
+
+    def _validate_clamp(self, clamp: 'Clamp') -> bool:
+        """
+        Validate a clamp against this `AcLineSegment`'s `Clamp`s.
+
+        :param clamp: The `Clamp` to validate.
+        :return: True if `clamp` is already associated with this `AcLineSegment`, otherwise False.
+        :raise ValueError: If `clamp.ac_line_segment` is not this `AcLineSegment`, or if this `AcLineSegment` has a different `Clamp` with the same mRID.
+        """
+        if self._validate_reference(clamp, self.get_clamp, "A Clamp"):
+            return True
+
+        if not clamp.ac_line_segment:
+            clamp.ac_line_segment = self
+
+        require(clamp.ac_line_segment is self,
+                lambda: f"Clamp {clamp} references another AcLineSegment {clamp.ac_line_segment}, expected {str(self)}.")
+        return False

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

@@ -0,0 +1,32 @@
+#  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__ = ["Breaker"]
+
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.wires.protected_switch import ProtectedSwitch
+
+
+class Breaker(ProtectedSwitch):
+    """
+    A mechanical switching device capable of making, carrying, and breaking currents under normal circuit conditions
+    and also making, carrying for a specified time, and breaking currents under specified abnormal circuit conditions
+    e.g. those of short circuit.
+    """
+
+    in_transit_time: Optional[float] = None
+    """The transition time from open to close in seconds."""
+
+    @property
+    def is_substation_breaker(self) -> bool:
+        """Convenience function for detecting if this breaker is part of a substation. Returns true if this Breaker is associated with a Substation."""
+        return self.num_substations() > 0
+
+    @property
+    def is_feeder_head_breaker(self) -> bool:
+        """Convenience function for detecting if this breaker is at the head of a feeder."""
+        terminals = list(self.terminals)
+        return any(fdr.normal_head_terminal in terminals for fdr in self.normal_feeders)

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

@@ -0,0 +1,19 @@
+#  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__ = ["BusbarSection"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.connector import Connector
+
+
+class BusbarSection(Connector):
+    """
+    A conductor, or group of conductors, with negligible impedance, that serve to connect other conducting equipment within a single substation.
+
+    Voltage measurements are typically obtained from voltage transformers that are connected to busbar sections. A bus bar section may have many
+    physical terminals but for analysis is modelled with exactly one logical terminal.
+    """
+    max_terminals = 1
+    pass

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

@@ -0,0 +1,32 @@
+#  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__ = ["Clamp"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.ac_line_segment import AcLineSegment
+
+
+class Clamp(ConductingEquipment):
+    """
+    A Clamp is a galvanic connection at a line segment where other equipment is connected. A Clamp does not cut the line segment. A Clamp is ConductingEquipment
+    and has one Terminal with an associated ConnectivityNode. Any other ConductingEquipment can be connected to the Clamp ConnectivityNode.
+    """
+
+    length_from_terminal_1: Optional[float] = None
+    """The length to the place where the clamp is located starting from side one of the line segment, i.e. the line segment terminal with sequence number equal to 1."""
+
+    ac_line_segment: Optional['AcLineSegment'] = None
+    """The line segment to which the clamp is connected."""
+
+    max_terminals = 1
+
+    @property
+    def length_from_t1_or_0(self) -> float:
+        return self.length_from_terminal_1 or 0.0

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

@@ -0,0 +1,49 @@
+#  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__ = ["Conductor"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.assetinfo.cable_info import CableInfo
+    from zepben.ewb.model.cim.iec61968.assetinfo.wire_info import WireInfo
+
+
+class Conductor(ConductingEquipment):
+    """
+    Combination of conducting material with consistent electrical characteristics, building a single electrical
+    system, used to carry current between points in the power system.
+    """
+
+    length: Optional[float] = None
+    """Segment length for calculating line section capabilities."""
+
+    design_temperature: Optional[int] = None
+    """[ZBEX] The temperature in degrees Celsius for the network design of this conductor."""
+
+    design_rating: Optional[float] = None
+    """[ZBEX] The current rating in Amperes at the specified design temperature that can be used without the conductor breaching physical network"""
+
+    @property
+    def wire_info(self):
+        """The `WireInfo` for this `Conductor`"""
+        return self.asset_info
+
+    @wire_info.setter
+    def wire_info(self, wi: Optional['WireInfo']):
+        """
+        Set the `WireInfo` for this `Conductor`
+        :param wi: The `WireInfo` for this `Conductor`
+        """
+        self.asset_info = wi
+
+    def is_underground(self):
+        """
+        :return: True if this `Conductor` is underground.
+        """
+        return isinstance(self.wire_info, CableInfo)

zepben/ewb/model/cim/iec61970/base/wires/connector.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__ = ["Connector"]
+
+from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+
+
+class Connector(ConductingEquipment):
+    """
+    A conductor, or group of conductors, with negligible impedance, that serve to connect other conducting equipment
+    within a single substation and are modelled with a single logical terminal.
+    """
+    pass

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

@@ -0,0 +1,36 @@
+#  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__ = ["Cut"]
+
+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.iec61970.base.wires.ac_line_segment import AcLineSegment
+
+
+class Cut(Switch):
+    """
+    A cut separates a line segment into two parts. The cut appears as a switch inserted between these two parts and connects them together. As the cut is
+    normally open there is no galvanic connection between the two line segment parts. But it is possible to close the cut to get galvanic connection. The cut
+    terminals are oriented towards the line segment terminals with the same sequence number. Hence the cut terminal with sequence number equal to 1 is oriented
+    to the line segment's terminal with sequence number equal to 1. The cut terminals also act as connection points for jumpers and other equipment, e.g. a
+    mobile generator. To enable this, connectivity nodes are placed at the cut terminals. Once the connectivity nodes are in place any conducting equipment can
+    be connected at them.
+    """
+
+    max_terminals = 2
+
+    length_from_terminal_1: Optional[float] = None
+    """The length to the place where the cut is located starting from side one of the cut line segment, i.e. the line segment Terminal with sequenceNumber equal to 1."""
+
+    ac_line_segment: Optional['AcLineSegment'] = None
+    """The line segment to which the cut is applied."""
+
+    @property
+    def length_from_t1_or_0(self) -> float:
+        return self.length_from_terminal_1 or 0.0

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

@@ -0,0 +1,17 @@
+#  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__ = ["Disconnector"]
+
+from zepben.ewb.model.cim.iec61970.base.wires.switch import Switch
+
+
+class Disconnector(Switch):
+    """
+    A manually operated or motor operated mechanical switching device used for changing the connections in a circuit,
+    or for isolating a circuit or equipment from a source of power. It is required to open or close circuits when
+    negligible current is broken or made.
+    """
+    pass

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

@@ -0,0 +1,21 @@
+#  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__ = ["EarthFaultCompensator"]
+
+from typing import Optional
+
+from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+
+
+class EarthFaultCompensator(ConductingEquipment):
+    """
+    A conducting equipment used to represent a connection to ground which is typically used to compensate earth faults. An earth fault compensator device
+    modelled with a single terminal implies a second terminal solidly connected to ground. If two terminals are modelled, the ground is not assumed and
+    normal connection rules apply.
+    """
+
+    r: Optional[float] = None
+    """Nominal resistance of device in ohms."""

zepben/ewb/model/cim/iec61970/base/wires/energy_connection.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__ = ["EnergyConnection"]
+
+from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+
+
+class EnergyConnection(ConductingEquipment):
+    """
+    A connection of energy generation or consumption on the power system phases.
+    """
+    pass

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

@@ -0,0 +1,107 @@
+#  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__ = ["EnergyConsumer"]
+
+from typing import Optional, Generator, List, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.wires.energy_connection import EnergyConnection
+from zepben.ewb.model.cim.iec61970.base.wires.phase_shunt_connection_kind import PhaseShuntConnectionKind
+from zepben.ewb.util import nlen, get_by_mrid, ngen, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.energy_consumer_phase import EnergyConsumerPhase
+
+
+class EnergyConsumer(EnergyConnection):
+    """Generic user of energy - a point of consumption on the power system phases. May also represent a pro-sumer with negative p/q values. """
+
+    _energy_consumer_phases: Optional[List[EnergyConsumerPhase]] = None
+    """The individual phase models for this energy consumer."""
+
+    customer_count: Optional[int] = None
+    """Number of individual customers represented by this demand."""
+
+    grounded: Optional[bool] = None
+    """Used for Yn and Zn connections. True if the neutral is solidly grounded."""
+
+    phase_connection: PhaseShuntConnectionKind = PhaseShuntConnectionKind.D
+    """`zepben.protobuf.cim.iec61970.base.wires.phase_shunt_connection_kind.PhaseShuntConnectionKind` - The type of phase connection, 
+    such as wye, delta, I (single phase)."""
+
+    p: Optional[float] = None
+    """Active power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at 
+    rated voltage. Starting value for a steady state solution."""
+
+    p_fixed: Optional[float] = None
+    """Active power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
+
+    q: Optional[float] = None
+    """Reactive power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at 
+    rated voltage. Starting value for a steady state solution."""
+
+    q_fixed: Optional[float] = None
+    """Power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
+
+    def __init__(self, energy_consumer_phases: List[EnergyConsumerPhase] = None, **kwargs):
+        super(EnergyConsumer, self).__init__(**kwargs)
+        if energy_consumer_phases:
+            for phase in energy_consumer_phases:
+                self.add_phase(phase)
+
+    def num_phases(self):
+        """Get the number of `EnergySourcePhase`s for this `EnergyConsumer`."""
+        return nlen(self._energy_consumer_phases)
+
+    @property
+    def phases(self) -> Generator[EnergyConsumerPhase, None, None]:
+        """The individual phase models for this energy consumer."""
+        return ngen(self._energy_consumer_phases)
+
+    def get_phase(self, mrid: str) -> EnergyConsumerPhase:
+        """
+        Get the `EnergyConsumerPhase` for this `EnergyConsumer` identified by `mrid`
+
+        `mrid` The mRID of the required `EnergyConsumerPhase`
+        Returns The `EnergyConsumerPhase` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._energy_consumer_phases, mrid)
+
+    def add_phase(self, phase: EnergyConsumerPhase) -> EnergyConsumer:
+        """
+        Associate an `EnergyConsumerPhase` with this `EnergyConsumer`
+
+        `phase` the `EnergyConsumerPhase` to associate with this `EnergyConsumer`.
+        Returns A reference to this `EnergyConsumer` to allow fluent use.
+        Raises `ValueError` if another `EnergyConsumerPhase` with the same `mrid` already exists for this `EnergyConsumer`.
+        """
+        if self._validate_reference(phase, self.get_phase, "An EnergyConsumerPhase"):
+            return self
+        self._energy_consumer_phases = list() if self._energy_consumer_phases is None else self._energy_consumer_phases
+        self._energy_consumer_phases.append(phase)
+        return self
+
+    def remove_phase(self, phase: EnergyConsumerPhase) -> EnergyConsumer:
+        """
+        Disassociate `phase` from this `OperationalRestriction`.
+
+        `phase` the `EnergyConsumerPhase` to disassociate with this `EnergyConsumer`.
+        Raises `KeyError` if `phase` was not associated with this `EnergyConsumer`.
+        Returns A reference to this `EnergyConsumer` to allow fluent use.
+        Raises `ValueError` if `phase` was not associated with this `EnergyConsumer`.
+        """
+        self._energy_consumer_phases = safe_remove(self._energy_consumer_phases, phase)
+        return self
+
+    def clear_phases(self) -> EnergyConsumer:
+        """
+        Clear all phases.
+        Returns A reference to this `EnergyConsumer` to allow fluent use.
+        """
+        self._energy_consumer_phases = None
+        return self

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

@@ -0,0 +1,56 @@
+#  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__ = ["EnergyConsumerPhase"]
+
+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_consumer import EnergyConsumer
+
+
+class EnergyConsumerPhase(PowerSystemResource):
+    """A single phase of an energy consumer."""
+
+    _energy_consumer: Optional['EnergyConsumer'] = None
+
+    phase: SinglePhaseKind = SinglePhaseKind.X
+    """Phase of this energy consumer component. If the energy consumer is wye connected, the connection is from the indicated phase to the central ground or 
+    neutral point. If the energy consumer is delta connected, the phase indicates an energy consumer connected from the indicated phase to the next
+    logical non-neutral phase. """
+
+    p: Optional[float] = None
+    """Active power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at 
+    rated voltage. Starting value for a steady state solution."""
+
+    q: Optional[float] = None
+    """Reactive power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at 
+    rated voltage. Starting value for a steady state solution."""
+
+    p_fixed: Optional[float] = None
+    """Active power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
+
+    q_fixed: Optional[float] = None
+    """Reactive power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
+
+    def __init__(self, energy_consumer: 'EnergyConsumer' = None, **kwargs):
+        super(EnergyConsumerPhase, self).__init__(**kwargs)
+        if energy_consumer:
+            self.energy_consumer = energy_consumer
+
+    @property
+    def energy_consumer(self):
+        """The `EnergyConsumer` that has this phase."""
+        return self._energy_consumer
+
+    @energy_consumer.setter
+    def energy_consumer(self, ec):
+        if self._energy_consumer is None or self._energy_consumer is ec:
+            self._energy_consumer = ec
+        else:
+            raise ValueError(f"energy_consumer for {str(self)} has already been set to {self._energy_consumer}, cannot reset this field to {ec}")