feeder_network

This module manages connecting various power system components to build a network.

SimpleTwoLayerDistributionNetworkBuilder

Bases: TwoLayerDistributionNetworkBuilder

Class for creating distribution assets for developing two layer distribution network.

Attributes:

Name	Type	Description
feeder	nx.Graph	Instance of networkx graph

Source code in shift\feeder_network.py

class SimpleTwoLayerDistributionNetworkBuilder(
    TwoLayerDistributionNetworkBuilder
):
    """Class for creating distribution assets for
    developing two layer distribution network.

    Attributes:
        feeder (nx.Graph): Instance of networkx graph
    """

    def __init__(self) -> None:
        """Constructor for SimpleTwoLayerDistributionNetworkBuilder class"""

        self.feeder = nx.Graph()

    def add_load_nodes(self, loads: List[Load]) -> None:
        """Add load nodes to the network.

        Args:
            loads (List[Load]): List of `Load` objects
        """

        # Loop over all the load and add to the network
        for load in loads:

            self.feeder.add_node(
                load.name,
                pos=(load.longitude, load.latitude),
                type=NetworkAsset.LOAD,
                data=load.__dict__,
                object=load,
            )

    def add_distribution_transformers(
        self, transformers: List[Transformer]
    ) -> None:
        """Add transformer nodes to the network.

        Args:
            transformers (List[Transformer]): List of `Transformer` objects
        """
        for xfmr in transformers:

            self.feeder.add_node(
                xfmr.name,
                pos=(xfmr.longitude, xfmr.latitude),
                type=NetworkAsset.DISTXFMR,
                data=xfmr.__dict__,
                object=xfmr,
            )

    def add_low_tension_network(self, edges: List[Line]) -> None:
        """Add low tension line segments to the network.

        Args:
            edges (List[Line]): List of `Line` objects representing
                secondary line segments
        """

        for edge in edges:

            if not self.feeder.has_node(edge.fromnode):
                self.feeder.add_node(
                    edge.fromnode,
                    pos=(
                        float(edge.fromnode.split("_")[0]),
                        float(edge.fromnode.split("_")[1]),
                    ),
                    type=NetworkAsset.LTNODE,
                    data={},
                )
            if not self.feeder.has_node(edge.tonode):
                self.feeder.add_node(
                    edge.tonode,
                    pos=(
                        float(edge.tonode.split("_")[0]),
                        float(edge.tonode.split("_")[1]),
                    ),
                    type=NetworkAsset.LTNODE,
                    data={},
                )
            self.feeder.add_edge(
                edge.fromnode,
                edge.tonode,
                type=NetworkAsset.LTLINE,
                data={},
                object=edge,
            )

    def add_high_tension_network(self, edges: List[Line]) -> None:
        """Add high tension line segments to the network.

        Args:
            edges (List[Line]): List of `Line` objects representing
                primary line segments
        """
        for edge in edges:
            self.feeder.add_node(
                edge.fromnode,
                pos=(
                    float(edge.fromnode.split("_")[0]),
                    float(edge.fromnode.split("_")[1]),
                ),
                type=NetworkAsset.HTNODE,
                data={},
            )
            self.feeder.add_node(
                edge.tonode,
                pos=(
                    float(edge.tonode.split("_")[0]),
                    float(edge.tonode.split("_")[1]),
                ),
                type=NetworkAsset.HTNODE,
                data={},
            )
            self.feeder.add_edge(
                edge.fromnode,
                edge.tonode,
                type=NetworkAsset.HTLINE,
                data={},
                object=edge,
            )

        # Make correction to transformer node:
        # Pull the transformer node to network node and convert to edge

    def add_substation(self):
        """Add substation"""
        pass

__init__()

Constructor for SimpleTwoLayerDistributionNetworkBuilder class

Source code in shift\feeder_network.py

def __init__(self) -> None:
    """Constructor for SimpleTwoLayerDistributionNetworkBuilder class"""

    self.feeder = nx.Graph()

add_distribution_transformers(transformers)

Add transformer nodes to the network.

Parameters:

Name	Type	Description	Default
transformers	List[Transformer]	List of Transformer objects	required

Source code in shift\feeder_network.py

def add_distribution_transformers(
    self, transformers: List[Transformer]
) -> None:
    """Add transformer nodes to the network.

    Args:
        transformers (List[Transformer]): List of `Transformer` objects
    """
    for xfmr in transformers:

        self.feeder.add_node(
            xfmr.name,
            pos=(xfmr.longitude, xfmr.latitude),
            type=NetworkAsset.DISTXFMR,
            data=xfmr.__dict__,
            object=xfmr,
        )

add_high_tension_network(edges)

Add high tension line segments to the network.

Parameters:

Name	Type	Description	Default
edges	List[Line]	List of Line objects representing primary line segments	required

Source code in shift\feeder_network.py

def add_high_tension_network(self, edges: List[Line]) -> None:
    """Add high tension line segments to the network.

    Args:
        edges (List[Line]): List of `Line` objects representing
            primary line segments
    """
    for edge in edges:
        self.feeder.add_node(
            edge.fromnode,
            pos=(
                float(edge.fromnode.split("_")[0]),
                float(edge.fromnode.split("_")[1]),
            ),
            type=NetworkAsset.HTNODE,
            data={},
        )
        self.feeder.add_node(
            edge.tonode,
            pos=(
                float(edge.tonode.split("_")[0]),
                float(edge.tonode.split("_")[1]),
            ),
            type=NetworkAsset.HTNODE,
            data={},
        )
        self.feeder.add_edge(
            edge.fromnode,
            edge.tonode,
            type=NetworkAsset.HTLINE,
            data={},
            object=edge,
        )

add_load_nodes(loads)

Add load nodes to the network.

Parameters:

Name	Type	Description	Default
loads	List[Load]	List of Load objects	required

Source code in shift\feeder_network.py

def add_load_nodes(self, loads: List[Load]) -> None:
    """Add load nodes to the network.

    Args:
        loads (List[Load]): List of `Load` objects
    """

    # Loop over all the load and add to the network
    for load in loads:

        self.feeder.add_node(
            load.name,
            pos=(load.longitude, load.latitude),
            type=NetworkAsset.LOAD,
            data=load.__dict__,
            object=load,
        )

add_low_tension_network(edges)

Add low tension line segments to the network.

Parameters:

Name	Type	Description	Default
edges	List[Line]	List of Line objects representing secondary line segments	required

Source code in shift\feeder_network.py

def add_low_tension_network(self, edges: List[Line]) -> None:
    """Add low tension line segments to the network.

    Args:
        edges (List[Line]): List of `Line` objects representing
            secondary line segments
    """

    for edge in edges:

        if not self.feeder.has_node(edge.fromnode):
            self.feeder.add_node(
                edge.fromnode,
                pos=(
                    float(edge.fromnode.split("_")[0]),
                    float(edge.fromnode.split("_")[1]),
                ),
                type=NetworkAsset.LTNODE,
                data={},
            )
        if not self.feeder.has_node(edge.tonode):
            self.feeder.add_node(
                edge.tonode,
                pos=(
                    float(edge.tonode.split("_")[0]),
                    float(edge.tonode.split("_")[1]),
                ),
                type=NetworkAsset.LTNODE,
                data={},
            )
        self.feeder.add_edge(
            edge.fromnode,
            edge.tonode,
            type=NetworkAsset.LTLINE,
            data={},
            object=edge,
        )

add_substation()

Add substation

Source code in shift\feeder_network.py

def add_substation(self):
    """Add substation"""
    pass

TwoLayerDistributionNetworkBuilder

Bases: ABC

Interface to build two layer (low tension + high tension) distribution network

Source code in shift\feeder_network.py

class TwoLayerDistributionNetworkBuilder(ABC):
    """Interface to build two layer (low tension +
    high tension) distribution network"""

    @abstractmethod
    def add_load_nodes(self, loads: List[Load]) -> None:
        """Abstract method to add customer nodes
        to the distribution network"""
        pass

    @abstractmethod
    def add_distribution_transformers(
        self, transformers: List[Transformer]
    ) -> None:
        """Abstract method to add distribution transformer nodes"""
        pass

    @abstractmethod
    def add_low_tension_network(self, edges: List[Line]) -> None:
        """Abstract method to add low tension network"""
        pass

    @abstractmethod
    def add_high_tension_network(self, edges: List[Line]) -> None:
        """Abstract method to add high tension network"""
        pass

    @abstractmethod
    def add_substation(self):
        """Abstract method to add substation"""
        pass

add_distribution_transformers(transformers) abstractmethod

Abstract method to add distribution transformer nodes

Source code in shift\feeder_network.py

@abstractmethod
def add_distribution_transformers(
    self, transformers: List[Transformer]
) -> None:
    """Abstract method to add distribution transformer nodes"""
    pass

add_high_tension_network(edges) abstractmethod

Abstract method to add high tension network

Source code in shift\feeder_network.py

@abstractmethod
def add_high_tension_network(self, edges: List[Line]) -> None:
    """Abstract method to add high tension network"""
    pass

add_load_nodes(loads) abstractmethod

Abstract method to add customer nodes to the distribution network

Source code in shift\feeder_network.py

@abstractmethod
def add_load_nodes(self, loads: List[Load]) -> None:
    """Abstract method to add customer nodes
    to the distribution network"""
    pass

add_low_tension_network(edges) abstractmethod

Abstract method to add low tension network

Source code in shift\feeder_network.py

@abstractmethod
def add_low_tension_network(self, edges: List[Line]) -> None:
    """Abstract method to add low tension network"""
    pass

add_substation() abstractmethod

Abstract method to add substation

Source code in shift\feeder_network.py

@abstractmethod
def add_substation(self):
    """Abstract method to add substation"""
    pass

TwoLayerNetworkBuilderDirector

Builder for creating two layer distribution network.

Attributes:

Name	Type	Description
builder	TwoLayerDistributionNetworkBuilder	Instance of TwoLayerDistributionNetworkBuilder class

Source code in shift\feeder_network.py

class TwoLayerNetworkBuilderDirector:
    """Builder for creating two layer distribution network.

    Attributes:
        builder (TwoLayerDistributionNetworkBuilder): Instance
            of `TwoLayerDistributionNetworkBuilder` class
    """

    def __init__(
        self,
        loads: List[Load],
        transformers: List[Transformer],
        primary_edges: List[Line],
        secondary_edges: List[Line],
        builder: TwoLayerDistributionNetworkBuilder,
    ) -> None:
        """Constructor method for TwoLayerNetworkBuilderDirector class.

        Args:
            loads (List[Load]): List of `Load` objects
            transformers (List[Transformer]): List of `Transformer` objects
            primary_edges (List[Line]): List of `Line` objects
                representing primary sections
            secondary_edges (List[Line]): List of `Line` objects representing
                secondary sections
            builder (TwoLayerDistributionNetworkBuilder): Instance of builder
                type `TwoLayerDistributionNetworkBuilder`
        """

        self.builder = builder
        self.builder.add_load_nodes(loads)
        self.builder.add_distribution_transformers(transformers)
        self.builder.add_high_tension_network(primary_edges)
        self.builder.add_low_tension_network(secondary_edges)

    def get_network(self):
        """Returns a distribution network"""
        return self.builder.feeder

__init__(loads, transformers, primary_edges, secondary_edges, builder)

Constructor method for TwoLayerNetworkBuilderDirector class.

Parameters:

Name	Type	Description	Default
loads	List[Load]	List of Load objects	required
transformers	List[Transformer]	List of Transformer objects	required
primary_edges	List[Line]	List of Line objects representing primary sections	required
secondary_edges	List[Line]	List of Line objects representing secondary sections	required
builder	TwoLayerDistributionNetworkBuilder	Instance of builder type TwoLayerDistributionNetworkBuilder	required

Source code in shift\feeder_network.py

def __init__(
    self,
    loads: List[Load],
    transformers: List[Transformer],
    primary_edges: List[Line],
    secondary_edges: List[Line],
    builder: TwoLayerDistributionNetworkBuilder,
) -> None:
    """Constructor method for TwoLayerNetworkBuilderDirector class.

    Args:
        loads (List[Load]): List of `Load` objects
        transformers (List[Transformer]): List of `Transformer` objects
        primary_edges (List[Line]): List of `Line` objects
            representing primary sections
        secondary_edges (List[Line]): List of `Line` objects representing
            secondary sections
        builder (TwoLayerDistributionNetworkBuilder): Instance of builder
            type `TwoLayerDistributionNetworkBuilder`
    """

    self.builder = builder
    self.builder.add_load_nodes(loads)
    self.builder.add_distribution_transformers(transformers)
    self.builder.add_high_tension_network(primary_edges)
    self.builder.add_low_tension_network(secondary_edges)

get_network()

Returns a distribution network

Source code in shift\feeder_network.py

def get_network(self):
    """Returns a distribution network"""
    return self.builder.feeder

update_transformer_locations(retain_nodes, transformers_cust_mapper, primary_lines)

Updated the location of transformers by connecting it to nearest primary node.

Parameters:

Name	Type	Description	Default
retain_nodes	List[str]	list of nodes to be retained	required
transformers_cust_mapper	dict	A dictionary with key r epresenting Transformer object values list of Load objects	required
primary_lines	List[Line]	List of line objects representing primary line sections.	required

Returns:

Name	Type	Description
dict	dict	New transformer to customer or loads mapping

Source code in shift\feeder_network.py

def update_transformer_locations(
    retain_nodes: List[str],
    transformers_cust_mapper: dict,
    primary_lines: List[Line],
) -> dict:
    """Updated the location of transformers by connecting it
    to nearest primary node.

    Args:
        retain_nodes (List[str]): list of nodes to be retained
        transformers_cust_mapper (dict): A dictionary with key r
            epresenting `Transformer` object values
            list of `Load` objects
        primary_lines (List[Line]): List of line objects
            representing primary line sections.

    Returns:
        dict: New transformer to customer or loads mapping
    """
    rnode_to_trans_mapping = {}
    for rnode, rdict in retain_nodes.items():
        for trans, cust_list in transformers_cust_mapper.items():
            if rdict["centre"] == (trans.longitude, trans.latitude):
                rnode_to_trans_mapping[rnode] = {
                    "trans": trans,
                    "longitude": rdict["longitude"],
                    "latitude": rdict["latitude"],
                    "cust_list": cust_list,
                }
    new_transformers_cust_mapper = {}
    for edge in primary_lines:
        for node in [edge.fromnode, edge.tonode]:
            if node in rnode_to_trans_mapping:
                trans_obj = rnode_to_trans_mapping[node]["trans"]
                trans_obj.longitude = rnode_to_trans_mapping[node]["longitude"]
                trans_obj.latitude = rnode_to_trans_mapping[node]["latitude"]
                new_transformers_cust_mapper[
                    trans_obj
                ] = rnode_to_trans_mapping[node]["cust_list"]

    return new_transformers_cust_mapper