zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/services/network/tracing/feeder/assign_to_lv_feeders.py

@@ -0,0 +1,202 @@
+#  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__ = ["AssignToLvFeeders"]
+
+from functools import singledispatchmethod
+from typing import Collection, List, Generator, TypeVar, Dict, Set, Type, TYPE_CHECKING
+
+from zepben.ewb import Switch, ProtectedSwitch, PowerElectronicsConnection, Terminal, ConductingEquipment, AuxiliaryEquipment, LvFeeder
+from zepben.ewb.services.network.network_service import NetworkService
+from zepben.ewb.services.network.tracing.feeder.assign_to_feeders import BaseFeedersInternal
+from zepben.ewb.services.network.tracing.networktrace.conditions.conditions import stop_at_open
+from zepben.ewb.services.network.tracing.networktrace.network_trace import NetworkTrace
+from zepben.ewb.services.network.tracing.networktrace.network_trace_action_type import NetworkTraceActionType
+from zepben.ewb.services.network.tracing.networktrace.network_trace_step import NetworkTraceStep
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+from zepben.ewb.services.network.tracing.networktrace.tracing import Tracing
+from zepben.ewb.services.network.tracing.traversal.step_context import StepContext
+
+if TYPE_CHECKING:
+    from logging import Logger
+
+T = TypeVar("T")
+
+
+class AssignToLvFeeders:
+    """
+    Convenience class that provides methods for assigning LV feeders on a `NetworkService`.
+    Requires that a Feeder have a normalHeadTerminal with associated ConductingEquipment.
+    This class is backed by a `BasicTraversal`.
+    """
+
+    def __init__(self, debug_logger: Logger = None):
+        self._debug_logger = debug_logger
+
+    @singledispatchmethod
+    async def run(
+        self,
+        network: NetworkService,
+        network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL,
+        start_terminal: Terminal = None
+    ):
+        """
+        Assign equipment to each feeder in the specified network.
+
+        :param network: The network containing the feeders to process.
+        :param network_state_operators: `NetworkStateOperators` to use for stateful operations.
+        :param start_terminal: get the lv feeders for this `Terminal`s `ConductingEquipment`.
+        """
+
+        await AssignToLvFeedersInternal(
+            network_state_operators,
+            self._debug_logger
+        ).run(network, start_terminal)
+
+    @run.register
+    async def _(
+        self,
+        terminal: Terminal,
+        lv_feeder_start_points: Set[ConductingEquipment],
+        terminal_to_aux_equipment: Dict[Terminal, List[AuxiliaryEquipment]],
+        lv_feeders_to_assign: List[LvFeeder],
+        network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL
+    ):
+        await AssignToLvFeedersInternal(
+            network_state_operators,
+            self._debug_logger
+        ).run_with_feeders(
+            terminal,
+            lv_feeder_start_points,
+            terminal_to_aux_equipment,
+            lv_feeders_to_assign
+        )
+
+
+class AssignToLvFeedersInternal(BaseFeedersInternal):
+
+    async def run(
+        self,
+        network: NetworkService,
+        start_terminal: Terminal = None
+    ):
+        lv_feeder_start_points = network.lv_feeder_start_points
+        terminal_to_aux_equipment = network.aux_equipment_by_terminal
+
+        if start_terminal is None:
+            for lv_feeder in network.objects(LvFeeder):
+
+                head_terminal = lv_feeder.normal_head_terminal
+                if head_terminal is not None:
+
+                    head_equipment = head_terminal.conducting_equipment
+                    if head_equipment is not None:
+
+                        for feeder in head_equipment.feeders(self.network_state_operators):
+                            self.network_state_operators.associate_energizing_feeder(feeder, lv_feeder)
+
+                #  We can run from each LV feeder as we process them, as being associated with their energizing feeders is not a requirement of the trace.
+                await self.run_with_feeders(lv_feeder.normal_head_terminal,
+                                            lv_feeder_start_points,
+                                            terminal_to_aux_equipment,
+                                            [lv_feeder])
+
+        else:
+            await self.run_with_feeders(start_terminal,
+                                        lv_feeder_start_points,
+                                        terminal_to_aux_equipment,
+                                        self._lv_feeders_from_terminal(start_terminal))
+
+    async def run_with_feeders(
+        self,
+        terminal: Terminal,
+        lv_feeder_start_points: Set[ConductingEquipment],
+        terminal_to_aux_equipment: Dict[Terminal, List[AuxiliaryEquipment]],
+        lv_feeders_to_assign: List[LvFeeder]
+    ):
+        if terminal is None or len(lv_feeders_to_assign) == 0:
+            return
+
+        if isinstance(start_ce := terminal.conducting_equipment, Switch) and self.network_state_operators.is_open(start_ce):
+            self._associate_equipment_with_containers(lv_feeders_to_assign, [start_ce])
+        else:
+            traversal = self._create_trace(terminal_to_aux_equipment, lv_feeder_start_points, lv_feeders_to_assign)
+            await traversal.run(terminal, False)
+
+    def _create_trace(
+        self,
+        terminal_to_aux_equipment: Dict[Terminal, List[AuxiliaryEquipment]],
+        lv_feeder_start_points: Set[ConductingEquipment],
+        lv_feeders_to_assign: List[LvFeeder]
+    ) -> NetworkTrace[T]:
+        def _reached_hv(ce: ConductingEquipment):
+            return True if ce.base_voltage and ce.base_voltage.nominal_voltage >= 1000 else False
+
+        async def step_action(nts: NetworkTraceStep, context):
+            await self._process(nts.path, nts.data, context, terminal_to_aux_equipment, lv_feeder_start_points, lv_feeders_to_assign)
+
+        return (
+            Tracing.network_trace(
+                network_state_operators=self.network_state_operators,
+                action_step_type=NetworkTraceActionType.ALL_STEPS,
+                debug_logger=self._debug_logger,
+                name=f'AssignToLvFeeders({self.network_state_operators.description})',
+                compute_data=(lambda x, y, next_path: next_path.to_equipment in lv_feeder_start_points)
+            )
+            .add_condition(stop_at_open())
+            .add_stop_condition(lambda step, ctx: step.data)
+            .add_queue_condition(
+                lambda next_step, *args: next_step.data or not _reached_hv(next_step.path.to_equipment)
+            )
+            .add_step_action(step_action)
+        )
+
+    async def _process(
+        self,
+        step_path: NetworkTraceStep.Path,
+        found_lv_feeder: bool,
+        step_context: StepContext,
+        terminal_to_aux_equipment: Dict[Terminal, Collection[AuxiliaryEquipment]],
+        lv_feeder_start_points: Set[ConductingEquipment],
+        lv_feeders_to_assign: List[LvFeeder]
+    ):
+        if step_path.traced_internally and not step_context.is_start_item:
+            return
+
+        # It might be tempting to check `stepContext.isStopping`, but that would also pick up open points between LV feeders which is not good.
+        if found_lv_feeder:
+
+            for it in (found_lv_feeders := list(self._find_lv_feeders(step_path.to_equipment, lv_feeder_start_points))):
+                # Energize the LV feeders that we are processing by the energizing feeders of what we found
+                self._feeder_energizes(self.network_state_operators.get_energizing_feeders(it), lv_feeders_to_assign)
+
+            for it in lv_feeders_to_assign:
+                # Energize the LV feeders we found by the energizing feeders we are processing
+                self._feeder_energizes(self.network_state_operators.get_energizing_feeders(it), found_lv_feeders)
+
+        aux_equip_for_this_terminal = terminal_to_aux_equipment.get(step_path.to_terminal, {})
+
+        self._associate_equipment_with_containers(lv_feeders_to_assign, [step_path.to_equipment])
+        self._associate_equipment_with_containers(lv_feeders_to_assign, aux_equip_for_this_terminal)
+
+        to_equip = step_path.to_equipment
+        if isinstance(to_equip, ProtectedSwitch):
+            self._associate_relay_systems_with_containers(lv_feeders_to_assign, to_equip)
+        elif isinstance(to_equip, PowerElectronicsConnection):
+            self._associate_power_electronic_units(lv_feeders_to_assign, to_equip)
+
+    def _find_lv_feeders(self, ce: ConductingEquipment, lv_feeder_start_points: Set[ConductingEquipment]) -> Generator[LvFeeder, None, None]:
+        if sites := list(ce.sites):
+            for site in sites:
+                for feeder in site.find_lv_feeders(lv_feeder_start_points, self.network_state_operators):
+                    yield feeder
+        else:
+            for feeder in ce.lv_feeders(self.network_state_operators):
+                yield feeder
+
+    def _lv_feeders_from_terminal(self, terminal: Terminal) -> List[LvFeeder]:
+        return list(terminal.conducting_equipment.lv_feeders(self.network_state_operators))

zepben/ewb/services/network/tracing/feeder/clear_direction.py

@@ -0,0 +1,80 @@
+#  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__ = ['ClearDirection']
+
+from logging import Logger
+from typing import TYPE_CHECKING, Any, Type
+
+from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+from zepben.ewb.services.network.tracing.feeder.feeder_direction import FeederDirection
+from zepben.ewb.services.network.tracing.networktrace.conditions.conditions import stop_at_open
+from zepben.ewb.services.network.tracing.networktrace.network_trace import NetworkTrace
+from zepben.ewb.services.network.tracing.networktrace.network_trace_action_type import NetworkTraceActionType
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+from zepben.ewb.services.network.tracing.networktrace.tracing import Tracing
+from zepben.ewb.services.network.tracing.traversal.weighted_priority_queue import WeightedPriorityQueue
+
+if TYPE_CHECKING:
+    from zepben.ewb import StepContext, NetworkTraceStep
+
+
+class ClearDirection:
+    """Convenience class that provides methods for clearing feeder direction on a `NetworkService`"""
+
+    def __init__(self, debug_logger: Logger = None):
+        self._debug_logger = debug_logger
+
+    # NOTE: We used to try and remove directions in a single pass rather than clearing (and the reapplying where needed) to be more efficient.
+    #       However, this caused all sorts of pain when trying to determine which directions to remove from dual fed equipment that contains inner loops.
+    #       We decided it is so much simpler to just clear the directions and reapply from other feeder heads even if its a bit more computationally expensive.
+    #
+
+    async def run(
+        self,
+        terminal: Terminal,
+        network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL
+    ) -> list[Terminal]:
+        """
+        Clears the feeder direction from a terminal and the connected equipment chain.
+        This clears directions even if equipment is dual fed. A set of feeder head terminals encountered while running will be returned and directions
+        can be reapplied if required using `set_direction`. Note that if you start on a feeder head terminal, this will be returned in the encountered
+        feeder heads set.
+
+        :param terminal: The `Terminal` from which to start the direction removal.
+        :param network_state_operators: The `NetworkStateOperators` to be used when removing directions.
+        :return : A set of feeder head `Terminal`s encountered when clearing directions
+        """
+
+        trace = self._create_trace(network_state_operators, feeder_head_terminals := [])
+        await trace.run(terminal, can_stop_on_start_item=False)
+        return feeder_head_terminals
+
+    def _create_trace(
+        self,
+        state_operators: Type[NetworkStateOperators],
+        visited_feeder_head_terminals: list[Terminal]
+    ) -> NetworkTrace[Any]:
+        def step_action(item: NetworkTraceStep, context: StepContext):
+            state_operators.set_direction(item.path.to_terminal, FeederDirection.NONE)
+            visited_feeder_head_terminals.append(item.path.to_terminal) if item.path.to_terminal.is_feeder_head_terminal() else None
+
+        return (
+            Tracing.network_trace(
+                network_state_operators=state_operators,
+                action_step_type=NetworkTraceActionType.ALL_STEPS,
+                debug_logger=self._debug_logger,
+                name=f'ClearDirection({state_operators.description})',
+                queue=WeightedPriorityQueue.process_queue(
+                    lambda it: it.path.to_terminal.phases.num_phases),
+            )
+            .add_condition(stop_at_open())
+            .add_queue_condition(
+                lambda step, *args: state_operators.get_direction(step.path.to_terminal) != FeederDirection.NONE
+            )
+            .add_step_action(step_action)
+        )

zepben/ewb/services/network/tracing/feeder/direction_status.py

@@ -0,0 +1,133 @@
+#  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__ = ["normal_direction", "current_direction", "DirectionStatus", "NormalDirection", "CurrentDirection"]
+
+from abc import ABC, abstractmethod
+
+from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+from zepben.ewb.services.network.tracing.feeder.feeder_direction import FeederDirection
+
+
+def normal_direction(terminal: Terminal):
+    return NormalDirection(terminal)
+
+
+def current_direction(terminal: Terminal):
+    return CurrentDirection(terminal)
+
+
+class DirectionStatus(ABC):
+    """
+    Interface to query or set the `FeederDirection` for a `Terminal`.
+    """
+
+    @abstractmethod
+    def value(self) -> FeederDirection:
+        """
+        Returns The direction added to this status.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def set(self, direction: FeederDirection) -> bool:
+        """
+        Clears the existing direction and sets it to the specified direction.
+
+        `direction` The direction of the `Terminal`.
+
+        Returns True if the direction has been updated, otherwise False.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def add(self, direction: FeederDirection) -> bool:
+        """
+        Adds the given direction to the `Terminal`.
+
+        `direction` The direction to add to the `Terminal`.
+
+        Returns True if the direction has been updated, otherwise False.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def remove(self, direction: FeederDirection) -> bool:
+        """
+        Removes the given direction from the `Terminal`.
+
+        `direction` The direction to remove from the `Terminal`.
+
+        Returns True if the direction has been updated, otherwise False.
+        """
+        raise NotImplementedError
+
+
+class NormalDirection(DirectionStatus):
+
+    def __init__(self, terminal: Terminal):
+        self.terminal = terminal
+
+    def value(self) -> FeederDirection:
+        return self.terminal.normal_feeder_direction
+
+    def set(self, direction: FeederDirection) -> bool:
+        if self.terminal.normal_feeder_direction == direction:
+            return False
+
+        self.terminal.normal_feeder_direction = direction
+        return True
+
+    def add(self, direction: FeederDirection) -> bool:
+        previous = self.terminal.normal_feeder_direction
+        new = previous + direction
+        if new == previous:
+            return False
+
+        self.terminal.normal_feeder_direction = new
+        return True
+
+    def remove(self, direction: FeederDirection) -> bool:
+        previous = self.terminal.normal_feeder_direction
+        new = previous - direction
+        if new == previous:
+            return False
+
+        self.terminal.normal_feeder_direction = new
+        return True
+
+
+class CurrentDirection(DirectionStatus):
+
+    def __init__(self, terminal: Terminal):
+        self.terminal = terminal
+
+    def value(self) -> FeederDirection:
+        return self.terminal.current_feeder_direction
+
+    def set(self, direction: FeederDirection) -> bool:
+        if self.terminal.current_feeder_direction == direction:
+            return False
+
+        self.terminal.current_feeder_direction = direction
+        return True
+
+    def add(self, direction: FeederDirection) -> bool:
+        previous = self.terminal.current_feeder_direction
+        new = previous + direction
+        if new == previous:
+            return False
+
+        self.terminal.current_feeder_direction = new
+        return True
+
+    def remove(self, direction: FeederDirection) -> bool:
+        previous = self.terminal.current_feeder_direction
+        new = previous - direction
+        if new == previous:
+            return False
+
+        self.terminal.current_feeder_direction = new
+        return True

zepben/ewb/services/network/tracing/feeder/feeder_direction.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/.
+
+__all__ = ["FeederDirection"]
+
+from enum import Enum
+
+
+class FeederDirection(Enum):
+    """
+    Enumeration of directions along a feeder at a terminal.
+    """
+
+    NONE = 0
+    """
+    The terminal is not on a feeder.
+    """
+
+    UPSTREAM = 1
+    """
+    The terminal can be used to trace upstream towards the feeder head.
+    """
+
+    DOWNSTREAM = 2
+    """
+    The terminal can be used to trace downstream away from the feeder head.
+    """
+
+    BOTH = 3
+    """
+    The terminal is part of a loop on the feeder and tracing in either direction will allow you
+    to trace upstream towards the feeder head, or downstream away from the feeder head.
+    """
+
+    CONNECTOR = 4
+    """
+    The terminal belongs to a Connector that is modelled with only a single terminal.
+    CONNECTOR will match direction UPSTREAM, DOWNSTREAM, and BOTH, however it exists
+    to differentiate it from BOTH which is used to indicate loops on the feeder. This
+    however means you connected tell if a terminal with CONNECTOR is part of a loop
+    directly, you need to check its connected terminals and check for BOTH to determine
+    if it is in a loop.
+    """
+
+    def __contains__(self, other):
+        """
+        Check whether this `FeederDirection`` contains another `FeederDirection`.
+
+        :param other: The `FeederDirection` to check.
+        :return: `True` if this is `BOTH` and other is not `NONE`, or if the directions are the same, otherwise `False`
+        """
+        if self in (FeederDirection.BOTH, FeederDirection.CONNECTOR):
+            return other is not FeederDirection.NONE
+        else:
+            return self is other
+
+    def __add__(self, other):
+        """
+        Add a `FeederDirection` to this `FeederDirection`
+
+        :param other: The `FeederDirection` to add.
+        :return: The resulting `FeederDirection` with `other` added.
+        """
+        if self == FeederDirection.CONNECTOR:
+            return FeederDirection.CONNECTOR
+
+        return FeederDirection(self.value | other.value)
+
+    def __sub__(self, other):
+        """
+        Remove a `FeederDirection` from this `FeederDirection`
+
+        :param other: The `FeederDirection` to remove.
+        :return: The resulting `FeederDirection` with `other` removed.
+        """
+        if self == FeederDirection.CONNECTOR:
+            return FeederDirection.CONNECTOR
+
+        return FeederDirection(self.value - (self.value & other.value))
+
+    def __invert__(self):
+        if self == FeederDirection.UPSTREAM:
+            return FeederDirection.DOWNSTREAM
+        elif self == FeederDirection.DOWNSTREAM:
+            return FeederDirection.UPSTREAM
+        elif self in (FeederDirection.BOTH, FeederDirection.CONNECTOR):
+            return FeederDirection.NONE
+        else:  # lif self == FeederDirection.NONE:
+            return FeederDirection.BOTH
+
+    @property
+    def complementary_external_direction(self):
+        if self == FeederDirection.UPSTREAM:
+            return FeederDirection.DOWNSTREAM
+        elif self == FeederDirection.DOWNSTREAM:
+            return FeederDirection.UPSTREAM
+        else:
+            return self
+
+    @property
+    def short_name(self) -> str:
+        """
+        :return: The name of the enum without the class name.
+        """
+        return str(self)[16:]

zepben/ewb/services/network/tracing/feeder/set_direction.py

@@ -0,0 +1,143 @@
+#  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__ = ["SetDirection"]
+
+from functools import singledispatchmethod
+from logging import Logger
+from typing import Optional, TYPE_CHECKING, Type
+
+from zepben.ewb.model.cim.iec61970.base.core.feeder import Feeder
+from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+from zepben.ewb.model.cim.iec61970.base.wires.busbar_section import BusbarSection
+from zepben.ewb.model.cim.iec61970.base.wires.cut import Cut
+from zepben.ewb.model.cim.iec61970.base.wires.power_transformer import PowerTransformer
+from zepben.ewb.services.network.tracing.feeder.feeder_direction import FeederDirection
+from zepben.ewb.services.network.tracing.networktrace.conditions.conditions import stop_at_open
+from zepben.ewb.services.network.tracing.networktrace.network_trace import NetworkTrace
+from zepben.ewb.services.network.tracing.networktrace.network_trace_action_type import NetworkTraceActionType
+from zepben.ewb.services.network.tracing.networktrace.network_trace_step import NetworkTraceStep
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+from zepben.ewb.services.network.tracing.networktrace.tracing import Tracing
+from zepben.ewb.services.network.tracing.traversal.weighted_priority_queue import WeightedPriorityQueue
+
+if TYPE_CHECKING:
+    from zepben.ewb import NetworkService, Switch, ConductingEquipment
+
+
+class SetDirection:
+    """
+    Convenience class that provides methods for setting feeder direction on a [NetworkService]
+    This class is backed by a [BranchRecursiveTraversal].
+    """
+
+    def __init__(self, debug_logger: Logger = None):
+        self._debug_logger = debug_logger
+
+    @staticmethod
+    def _compute_data(
+        reprocessed_loop_terminals: list[Terminal],
+        state_operators: Type[NetworkStateOperators],
+        step: NetworkTraceStep[FeederDirection],
+        next_path: NetworkTraceStep.Path
+    ) -> FeederDirection:
+
+        if next_path.to_equipment is BusbarSection:
+            return FeederDirection.CONNECTOR
+
+        def next_direction_func():
+            if step.data == FeederDirection.NONE:
+                return FeederDirection.NONE
+            elif next_path.traced_internally:
+                return FeederDirection.DOWNSTREAM
+            elif isinstance(next_path.to_equipment, Cut):
+                return FeederDirection.UPSTREAM
+            elif next_path.did_traverse_ac_line_segment:
+                return FeederDirection.DOWNSTREAM
+            else:
+                return FeederDirection.UPSTREAM
+
+        next_direction = next_direction_func()
+
+        # NOTE: Stopping / short-circuiting by checking that the next direction is already present in the toTerminal,
+        #       causes certain looping network configurations not to be reprocessed. This means that some parts of
+        #       loops do not end up with BOTH directions. This is done to stop massive computational blowout on
+        #       large networks with weird looping connectivity that rarely happens in reality.
+        #
+        #       To allow these parts of the loop to be correctly processed without the computational blowout, we allow
+        #       a single re-pass over the loop, controlled by the `reprocessedLoopTerminals` set.
+
+        next_terminal_direction = state_operators.get_direction(next_path.to_terminal)
+
+        if next_direction == FeederDirection.NONE:
+            return FeederDirection.NONE
+        elif next_direction not in next_terminal_direction:
+            return next_direction
+        elif next_terminal_direction == FeederDirection.BOTH:
+            reprocessed_loop_terminals.append(next_path.to_terminal)
+            return next_direction
+        return FeederDirection.NONE
+
+    def _create_traversal(self, state_operators: Type[NetworkStateOperators]) -> NetworkTrace[FeederDirection]:
+        reprocessed_loop_terminals: list[Terminal] = []
+
+        return (
+            Tracing.network_trace_branching(
+                network_state_operators=state_operators,
+                action_step_type=NetworkTraceActionType.ALL_STEPS,
+                debug_logger=self._debug_logger,
+                name=f'SetDirection({state_operators.description})',
+                queue_factory=lambda: WeightedPriorityQueue.process_queue(lambda it: it.path.to_terminal.phases.num_phases),
+                branch_queue_factory=lambda: WeightedPriorityQueue.branch_queue(lambda it: it.path.to_terminal.phases.num_phases),
+                compute_data=lambda step, _, next_path: self._compute_data(reprocessed_loop_terminals, state_operators, step, next_path)
+            )
+            .add_condition(stop_at_open())
+            .add_stop_condition(
+                lambda nts, ctx: nts.path.to_terminal.is_feeder_head_terminal() or
+                                 self._reached_substation_transformer(nts.path.to_terminal)
+            )
+            .add_queue_condition(lambda nts, *args: nts.data != FeederDirection.NONE)
+            .add_step_action(
+                lambda nts, ctx: state_operators.add_direction(nts.path.to_terminal, nts.data)
+            )
+        )
+
+    @staticmethod
+    def _reached_substation_transformer(terminal: Terminal) -> bool:
+        if ce := terminal.conducting_equipment:
+            return isinstance(ce, PowerTransformer) and ce.num_substations() > 0
+        return False
+
+    @staticmethod
+    def _is_normally_open_switch(conducting_equipment: Optional[ConductingEquipment]):
+        return isinstance(conducting_equipment, Switch) and conducting_equipment.is_normally_open()
+
+    @singledispatchmethod
+    async def run(self, network: NetworkService, network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL):
+        """
+         Apply feeder directions from all feeder head terminals in the network.
+
+         :param network: The network in which to apply feeder directions.
+         :param network_state_operators: The `NetworkStateOperators` to be used when setting feeder direction
+         """
+
+        for terminal in (f.normal_head_terminal for f in network.objects(Feeder) if f.normal_head_terminal):
+            if (head_terminal := terminal.conducting_equipment) is not None:
+                if not network_state_operators.is_open(head_terminal, None):
+                    await self.run_terminal(terminal, network_state_operators)
+
+    @run.register
+    async def run_terminal(self, terminal: Terminal, network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL):
+        """
+         Apply [FeederDirection.DOWNSTREAM] from the [terminal].
+
+         :param terminal: The terminal to start applying feeder direction from.
+         :param network_state_operators: The `NetworkStateOperators` to be used when setting feeder direction
+         """
+
+        return await (self._create_traversal(network_state_operators)
+                      .run(terminal, FeederDirection.DOWNSTREAM, can_stop_on_start_item=False))