network_planning.py

import networkx as nx
import pylab

from collections import namedtuple

K_d = 1.1  # коефициент неучтенных работ
K_vn = 1.1  # коефициент производительности труда



# t_P_j = max(t_p_i + T_ij)

T_ij_values = {
    (0,1): 3,
    (1,2): 7,
    (1,3): 4,
    (2,5): 4,
    (3,5): 3,
    (5,12): 4,
    (12,15): 6,
    (12,14): 2,
    (1,4): 6,
    (9,11): 4,
    (15,16): 3,
    (3,13): (48,2),
    (13,14): (80,2),
    (14,15): (160,4),
    (11,15): (48,3),
    (4,6): (144,6),
    (4,7): (16,2),
    (6,8): (32,2),
    (6,9): (64,4),
    (8,9): (192,4),
    (4,7): (64,2),
    (7,10): (160,2),
    (10,11): (64,2),

    (3,6): 0,
    (9, 10): 0
}

def process_laboriousness(items):
    T_ij = lambda t_ij, n_ij: int((t_ij*K_d)/(n_ij*K_vn))  # продолжительность работы в раб днях

    tmp = []
    for key in items:
        if key==-1: break
        current_val = T_ij_values[key]
        if isinstance(current_val, tuple):
            tmp.append((*key, T_ij(*current_val)))
        else:
            tmp.append((*key, current_val))
    return tmp


def generate_nodes(DG):
    Node = namedtuple('Node', 't_p R_i t_n i')

    nodes = []
    for key, pred in DG.pred.items():
        if not pred:
            nodes.append(Node(t_p=0, R_i=0, t_n=0, i=0))
            continue

        t_p = max(p['weight']+nodes[k].t_p for k,p in pred.items())  # t_p_j + t_p_i

        node = Node(t_p=t_p, R_i=0, t_n=0,i=key,)
        nodes.append(node)

    for key, pred in sorted(DG.adj.items(), reverse=True):
        if not pred:
            node = nodes[key]
            nodes[key] = Node(t_p=node.t_p, R_i=0, t_n=node.t_p, i=key)
            continue

        t_n = min(nodes[k].t_n-p['weight'] for k,p in pred.items())  # t_n_j - t_n_i

        node = nodes[key]
        nodes[key] = Node(t_p=node.t_p, R_i=t_n - node.t_p, t_n=t_n,i=key,)
    return nodes


if __name__=='__main__':
    weighted_edges = process_laboriousness(T_ij_values)
    DG=nx.DiGraph(t_p=0, R_i=0, t_n=0, i=0)
    DG.add_weighted_edges_from(weighted_edges)

    elarge=[(u,v) for (u,v,d) in DG.edges(data=True) if d['weight'] >= 1]
    esmall=[(u,v) for (u,v,d) in DG.edges(data=True) if d['weight'] ==0]

    pos=nx.pygraphviz_layout(DG)

    pylab.figure(1,figsize=(30,30))
    # nodes
    nx.draw_networkx_nodes(DG,pos,node_size=2300)

    # edges
    nx.draw_networkx_edges(DG,pos,edgelist=elarge,
                    width=2)
    nx.draw_networkx_edges(DG,pos,edgelist=esmall,
                    width=2,alpha=0.5,edge_color='b',style='dashed')

    # labels
    nodes = generate_nodes(DG)
    pattern = ''' {R_i}\n{t_p} X {t_n}\n   {i}  '''
    labels = {n.i: pattern.format(R_i=n.t_n-n.t_p, t_n=n.t_n, i=n.i, t_p=n.t_p) for n in nodes}
    nx.draw_networkx_labels(DG,pos,labels,font_size=14,font_family='sans-serif', font_color='blue')

    # edge labels
    pattern = '{weight} \n ({R_p},{R_1},{R_2},{R_free_ij})'
    edge_labels = {}
    for i,j,d in DG.edges(data=True):
        # R_p = t_n_j - t_p_i - T_ij
        # R_1 = t_n_j - t_n_i - T_ij
        # R_2 = t_p_j - t_p_i - T_ij
        # R_free_ij = t_p_j - t_n_i - T_ij
        R_p = nodes[j].t_n - nodes[i].t_p - d['weight']
        R_1 = nodes[j].t_n - nodes[i].t_n - d['weight']
        R_2 = nodes[j].t_p - nodes[i].t_p - d['weight']
        R_free_ij = nodes[j].t_p - nodes[i].t_n - d['weight']

        edge_labels[(i,j)] = pattern.format(weight=d['weight'], R_p=R_p,R_1=R_1,R_2=R_2,R_free_ij=R_free_ij)

    nx.draw_networkx_edge_labels(DG,pos,edge_labels=edge_labels)
    pylab.axis('off')
    pylab.show()