Is there a way to query all pipes between two nodes - network analysis

[hawklorry]

We have a list of upgrades (~400) list in a Excel file. Each upgrade has a from node and to node. We want to get select the pipes in between and get their size. Please let me know if it's possible to do this.

[gedaskir]

I hope I understood your request correctly, but I think this could be done with a script like this:

import mikeio1d
from mikeio1d.res1d import Res1D


def get_diameter(reach):
    try:
        grid_points = list(reach.GridPoints)
        h_point = grid_points[0]
        diameter = h_point.CrossSection.Diameter
    except:
        diameter = None

    return diameter


def create_node_ids_to_reach_map(res1d):
    reaches = list(res1d.data.Reaches)
    nodes = list(res1d.data.Nodes)

    node_ids_to_reach_map = dict()

    for reach in reaches:
        node_from_index = reach.StartNodeIndex
        node_to_index = reach.EndNodeIndex

        node_from = nodes[node_from_index]
        node_to = nodes[node_to_index]

        node_reach_label = (node_from.ID, node_to.ID)

        node_ids_to_reach_map[node_reach_label] = reach

    return node_ids_to_reach_map


def print_link_geometries(upgrades, node_ids_to_reach_map):
    for upgrade in upgrades:
        node_from_id, node_to_id = upgrade
        reach = node_ids_to_reach_map[upgrade]

        diameter = get_diameter(reach)

        print("Link ID:", reach.Name)
        print("  From Node ID:", node_from_id)
        print("  To Node ID:", node_to_id)
        print("  Diameter:", diameter)
        print("  Length:", reach.Length)


filepath = "Network.res1d"
res1d = Res1D(filepath)

node_ids_to_reach_map = create_node_ids_to_reach_map(res1d)

# List of tuples with ids of from node and to node
upgrades = [('105', '38'), ('112', '101'), ('52', '51')]

print_link_geometries(upgrades, node_ids_to_reach_map)

[gedaskir]

Also I have converted the issue to a discussion, because I think this is more proper place for things like that.

[hawklorry]

Thanks @gedaskir. This is very close to what I need. As shown in the diagram below, there may be more than one reaches between the from node and to node. I think we will need a function to get a list of reaches with given from and to node.

[rolffank]

You could do it with help of networkX:

import networkx as nx

G = nx.DiGraph()
for reach in reaches:
    node_from_index = reach.StartNodeIndex
    node_from = nodes[node_from_index]
    node_to_index = reach.EndNodeIndex
    node_to = nodes[node_to_index]
    G.add_edge(node_from.ID, node_to.ID, name=reach.Name)

# just for control
print('Number of edges:', G.number_of_edges())
print('Number of nodes:', G.number_of_nodes())

def return_edge_path(graph, fromN, toN):
    p = []
    for path in nx.all_simple_edge_paths(graph, fromN, toN):
        p = path
    edge_names = nx.get_edge_attributes(graph, "name")
    for edge in p:
        print(edge_names[edge])

# use
from_node = '30.1'
to_node = '76.2'
return_edge_path(G, from_node, to_node)
# printing edges between from_node and to_node

[hawklorry]

Perfect. I will give it a try.

[rolffank]

If you have only such simple cases as the drawn one, then it is probably enough to use the following function:

def get_reach_and_to_node(reaches, from_node, result):
    for reach in reaches:
        node_from_index = reach.StartNodeIndex
        node_from = nodes[node_from_index]
        if node_from.ID == from_node:
            node_to_index = reach.EndNodeIndex
            node_to = nodes[node_to_index]
            result.append(reach.Name)
            return node_to.ID    
    return ''

# use function
links = []
from_node = '30.1'
to_node = '30.7' 
get_node = from_node

while get_node != to_node:
    get_node = get_reach_and_to_node(reaches, get_node, links)
    if get_node == '':
        links.append('not found!')
        break
print(links)

That is what I tried first but it possibly doesn't work if you have cases where divider nodes (one inflow reach, two outflow reaches) are in the path. Then there are two reaches with the same start node (from_node) but the function only uses the first reach it finds and that's possibly the wrong one!