def route_signal(sat_and_ids, route_from, route_to): G = networkx.Graph() for x, y in itertools.permutations(sat_and_ids, r=2): sat_x, sid_x = x sat_y, sid_y = y in_sight = is_in_sight(sat_x, sat_y) if in_sight is not None: G.add_edge(sid_x, sid_y, weight=in_sight) for sat, sid in sat_and_ids: in_sight = can_transmit(route_from, sat) if in_sight is not None: G.add_edge('SRC', sid, weight=in_sight) for sat, sid, in sat_and_ids: in_sight = can_transmit(route_to, sat) if in_sight is not None: G.add_edge('DST', sid, weight=in_sight) print networkx.shortest_path_length(G, 'SRC', 'DST', weight='weight') return networkx.shortest_path(G, 'SRC', 'DST', weight='weight')
def edge_update(graph, edge, cc, dd): u = edge[0] v = edge[1] change = 0 if u not in dict: dict[u] = {} dict[u][v] = 1 dict[u][u] = 0 if v not in dict: dict[v] = {} dict[v][u] = 1 dict[v][v] = 0 for s in graph.nodes(): if u not in dict[s]: try: dict[s][u] = nx.shortest_path_length(graph, s ,u) dict[u][s] = dict[s][u] if v not in dict[s]: try: dict[s][v] = nx.shortest_path_length(graph, s ,v) dict[v][s] = dict[s][v] if u in dict[s] and v in dict[s]: if math.fabs(dict[s][u] - dict[s][v]) > 1: dict[s] = {} dict[s] = nx.shortest_path_length(graph, s) change = change - cc[s] cc[s] = 0 for n in dict[s]: cc[s] = cc[s] + 1.0 / dict[s][n] change = change + cc[s] return cc, dict
def get_followers_dist(g, dg, follow): if follow == -1: return -1 no_of_paths = 0 for u in dg.nodes(): if not g.has_node(u): print "no_source" continue for v in dg.neighbors(u): if u == v: continue if g.has_node(v): try: print nx.shortest_path_length(g, source=u, target=v) no_of_paths += 1 except nx.exception.NetworkXNoPath as err: print "no_path" else: print "no_target" print >> sys.stderr, "no of paths", no_of_paths return no_of_paths
def get_followers_dist(g, dg, follow): if follow == -1: return -1 if len(dg) == 0: dg = nx.read_edgelist(sys.argv[2], create_using=dg) no_of_paths = 0 for u in dg.nodes(): if not g.has_node(u): print "no_source" continue for v in dg.successors(u): if u == v: continue if g.has_node(v): try: print nx.shortest_path_length(g, source=u, target=v) no_of_paths += 1 except nx.exception.NetworkXError as err: print "no_path" else: print "no_target" print >> sys.stderr, "no of paths", no_of_paths return no_of_paths
def verify_path_len(self): """ Make sure that the finger links are optimal in length. (That they are the shortest paths possible) """ # Iterate over all nodes: for nd in self.nodes: for f in self.dht_succ_fingers: best_succ_f = nd.get_best_succ_finger(f) # Calculate shortest path on graph: spath_len = nx.shortest_path_length(self.graph,\ self.vec_to_graph[nd.ind],\ self.vec_to_graph[best_succ_f.lindex]) # Check if the path we have to best_succ_f equals exactly # spath_len: if best_succ_f.path_len != spath_len: return False for f in self.dht_pred_fingers: best_pred_f = nd.get_best_pred_finger(f) # Calculate shortest path on graph: spath_len = nx.shortest_path_length(self.graph,\ self.vec_to_graph[nd.ind],\ self.vec_to_graph[best_pred_f.lindex]) # Check if the path we have to best_pred_f equals exactly # spath_len: if best_pred_f.path_len != spath_len: return False return True
def calc_2_lines_point_shortest_path(self, start_line, end_line): p11, p12 = self.line_dict[start_line] p21, p22 = self.line_dict[end_line] d1 = nx.shortest_path_length(self.G, source=p11, target=p21) d2 = nx.shortest_path_length(self.G, source=p11, target=p22) d3 = nx.shortest_path_length(self.G, source=p12, target=p21) d4 = nx.shortest_path_length(self.G, source=p12, target=p22) min_d = min([d1, d2, d3, d4]) if d1 == min_d: return p11, p21 pass if d2 == min_d: return p11, p22 pass if d3 == min_d: return p12, p21 pass if d4 == min_d: return p12, p22 pass pass
def heuristic(n): t = (graph.degree(n), min([nx.shortest_path_length(graph, n, s) for s in self.stations])) # geometric mean of these two # closest to orders return ( -sum([nx.shortest_path_length(graph, n, order_node) for order_node in order_nodes]), (t[0] * t[1]) ** (1 / 2), )
def get_chokes(instance, choke_candidates): #prevent writing over base space. used_set = set() start, finish = instance.level.botSpawnAreas[instance.game.enemyTeam.name] for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))): node_index = regressions2.get_node_index(instance, Vector2(i,j)) used_set.add(node_index) choke_dict = {} master_chokes = set() flag_node = regressions2.get_node_index(instance, instance.game.team.flag.position) spawn_node = regressions2.get_node_index(instance, get_enemy_base(instance)) shortest_length = nx.shortest_path_length(instance.graph, source=spawn_node, target=flag_node, weight="choke_covered") choke_count = 0 while shortest_length == 0.0: if len(choke_candidates) == 0.0: print "RAN OUT OF CANDIDATES!" break choke_count += 1 one_choke = set() choke_center = choke_candidates.pop() choke_vector = regressions2.get_node_vector(instance, choke_center) #Ignore potential chokes too far from their spawn. while (choke_vector.distance((get_enemy_base(instance))) > 5.0 or choke_center in used_set) and len(choke_candidates) > 0: choke_vector = regressions2.get_node_vector(instance, choke_center) choke_center = choke_candidates.pop() if len(choke_candidates) == 0: print "RAN OUT OF CANDIDATES!" return choke_dict, master_chokes if choke_vector.distance((get_enemy_base(instance))) > 5.0: print "RAN OUT OF CANDIDATES, LAST CANDIDATE DIDN'T WORK!" return choke_dict, master_chokes one_choke.add(choke_center) for x in range(4): neighbors = set() for node in one_choke: neighbors2 = instance.graph.neighbors(node) if neighbors2 is not None: for neighbor2 in neighbors2: if neighbor2 not in used_set: neighbors.add(neighbor2) one_choke = one_choke.union(neighbors) used_set = used_set.union(one_choke) for node in one_choke: instance.graph.node[node]["choke_covered"] = 1.0 neighbors = instance.graph.neighbors(node) for neighbor in neighbors: instance.graph.edge[node][neighbor]["choke_covered"] = 1.0 choke_dict[choke_center] = { "nodes": one_choke, "redundancy": 0} master_chokes = master_chokes.union(one_choke) shortest_length = nx.shortest_path_length(instance.graph, source=spawn_node, target=flag_node, weight="choke_covered") return choke_dict, master_chokes
def closeness_vitality(grafo,vertice, aresta=False): """Calcula closeness vitality do vértice no grafo Retorna a closeness vitality para o vértice ou aresta especificado no grafo especificado. Parâmetros ---------- grafo: grafo networkx Grafo no qual se quer calcular closeness vitality. vertice: identificador Identificador do vértice para o qual se quer a medida. aresta: tupla Identificador dos vértices que formam a aresta para o qual se quer a medida de centralidade. """ g_foo=nx.copy.deepcopy(grafo) dists=nx.shortest_path_length(g_foo, weighted=True) vertices=g_foo.nodes() pares=[] soma_dists1=0 for v1 in vertices: for v2 in vertices: if set((v1,v2)) not in pares: soma_dists1+=dists[v1][v2] pares.append(set((v1,v2))) Iwg=soma_dists1 if aresta: g_foo.remove_edge(aresta[0],aresta[1]) dists=nx.shortest_path_length(g_foo, weighted=True) vertices=g_foo.nodes() pares=[] soma_dists2=0 for v1 in vertices: for v2 in vertices: if set((v1,v2)) not in pares: soma_dists2+=dists[v1][v2] pares.append(set((v1,v2))) Iwg2=soma_dists2 return Iwg-Iwg2 g_foo.remove_node(vertice) dists=nx.shortest_path_length(g_foo, weighted=True) vertices=g_foo.nodes() pares=[] soma_dists2=0 for v1 in vertices: for v2 in vertices: if set((v1,v2)) not in pares: soma_dists2+=dists[v1][v2] pares.append(set((v1,v2))) Iwg2=soma_dists2 return Iwg-Iwg2
def _min_cycle(G, orth, weight=None): """ Computes the minimum weight cycle in G, orthogonal to the vector orth as per [p. 338, 1] """ T = nx.Graph() nodes_idx = {node: idx for idx, node in enumerate(G.nodes())} idx_nodes = {idx: node for node, idx in nodes_idx.items()} nnodes = len(nodes_idx) # Add 2 copies of each edge in G to T. If edge is in orth, add cross edge; # otherwise in-plane edge if weight is not None: for u, v in G.edges(): uidx, vidx = nodes_idx[u], nodes_idx[v] edge_w = G[u][v][weight] if frozenset((u, v)) in orth: T.add_edges_from( [(uidx, nnodes + vidx), (nnodes + uidx, vidx)], weight=edge_w) else: T.add_edges_from( [(uidx, vidx), (nnodes + uidx, nnodes + vidx)], weight=edge_w) all_shortest_pathlens = nx.shortest_path_length(T, weight='weight') else: for u, v in G.edges(): uidx, vidx = nodes_idx[u], nodes_idx[v] if frozenset((u, v)) in orth: T.add_edges_from( [(uidx, nnodes + vidx), (nnodes + uidx, vidx)]) else: T.add_edges_from( [(uidx, vidx), (nnodes + uidx, nnodes + vidx)]) all_shortest_pathlens = nx.shortest_path_length(T) cross_paths_w_lens = { n: all_shortest_pathlens[n][nnodes + n] for n in range(nnodes)} # Now compute shortest paths in T, which translates to cyles in G min_path_startpoint = min(cross_paths_w_lens, key=cross_paths_w_lens.get) min_path = nx.shortest_path( T, source=min_path_startpoint, target=nnodes + min_path_startpoint, weight='weight') # Now we obtain the actual path, re-map nodes in T to those in G min_path_nodes = [ node if node < nnodes else node - nnodes for node in min_path] # Now remove the edges that occur two times mcycle_pruned = _path_to_cycle(min_path_nodes) return {frozenset((idx_nodes[u], idx_nodes[v])) for u, v in mcycle_pruned}
def AssociatedExternal(node, Dual, External): associate = External.iterkeys().next() min_dist = nx.shortest_path_length(Dual, node, External[associate]['measure']) + 1 for candidate in External: distance = nx.shortest_path_length(Dual, node, External[candidate]['measure']) + 1 if distance < min_dist: min_dist = distance associate = candidate return associate
def get_sigma(G, s, v, predecessors): if s == v: return 1 l = nx.shortest_path_length(G,s,v) sigma_v = 0 for u in G.neighbors(v): if nx.shortest_path_length(G,s,u) < l: predecessors.add(u) sigma_v += get_sigma(G, s, u, predecessors) return sigma_v
def extract_shortestpath_subgraph(g, nodes): newg = nx.DiGraph() for beg in nodes: for end in nodes: if beg != end: newg.add_edge(beg, end, duration=nx.shortest_path_length(g,source=beg,target=end,weight='duration'), min_duration=nx.shortest_path_length(g,source=beg,target=end,weight='min_duration'), max_duration=nx.shortest_path_length(g,source=beg,target=end,weight='max_duration')) return newg
def random_pairs_dist(data1, data, el): """ Chooses random pairs of branches in the skeleton and computes the distances between them. Parameters ------------ data1 : list of pathes for the break-ups dictionaries. Used here for the estimation of the necessary number of pairs. data : list of pathes for the graphs el : list of length scales Return ------- d_ran : list of distances along the skeleton between random branches. """ d_ran = list() u=0 for b, g in zip(data1, data): br = np.load(b).item().keys() gr = nx.read_gpickle(g) edg = list(nx.edges(gr)) number = nx.get_edge_attributes(gr, 'number') num_dict = {} for k in number: for v in number[k]: num_dict.setdefault(v, []).append(k) a = len(list(br)) if a > 1500: #We cannot use here infinitly many pairs because of the computing time. a = 1500 for j in range(a): e1 = random.choice(edg) e2 = random.choice(edg) if (e1==e2): continue n1 = e1[0] n2 = e1[1] m1 = e2[0] m2 = e2[1] try: p_min = p_max = nx.shortest_path_length(gr, n1, m1, 'length') except nx.NetworkXNoPath: continue for i in itertools.product((n1,n2), (m1,m2)): p = nx.shortest_path_length(gr, i[0], i[1], 'length') if p < p_min: p_min = p if p > p_max: p_max = p d = (p_min+p_max)/(2. * el[u]) d_ran.append(d) u+=1 return d_ran
def nxShortestPath(nxGraph, nxPos, startPt, endPt, Dijk=0): if Dijk == 0: nxList = nx.shortest_path(nxGraph, source=startPt, target=endPt) score = nx.shortest_path_length(nxGraph, source=startPt, target=endPt) dist = nx.shortest_path_length(nxGraph, source=startPt, target=endPt, weight="distance") elif Dijk == 1: nxList = nx.dijkstra_path(nxGraph, source=startPt, target=endPt, weight="weight") score = nx.dijkstra_path_length(nxGraph, source=startPt, target=endPt, weight="weight") dist = nx.dijkstra_path_length(nxGraph, source=startPt, target=endPt, weight="distance") nxH = nx.subgraph(nxGraph, nxList) return nxList, nxH, score, dist
def test_single_source_shortest_path_length(self): l=nx.shortest_path_length(self.cycle,0) assert_equal(l,{0:0,1:1,2:2,3:3,4:3,5:2,6:1}) assert_equal(l,nx.single_source_shortest_path_length(self.cycle,0)) l=nx.shortest_path_length(self.grid,1) assert_equal(l[16],6) # now with weights l=nx.shortest_path_length(self.cycle,0,weighted=True) assert_equal(l,{0:0,1:1,2:2,3:3,4:3,5:2,6:1}) assert_equal(l,nx.single_source_dijkstra_path_length(self.cycle,0)) l=nx.shortest_path_length(self.grid,1,weighted=True) assert_equal(l[16],6)
def test_all_pairs_shortest_path_length(self): l=nx.shortest_path_length(self.cycle) assert_equal(l[0],{0:0,1:1,2:2,3:3,4:3,5:2,6:1}) assert_equal(l,nx.all_pairs_shortest_path_length(self.cycle)) l=nx.shortest_path_length(self.grid) assert_equal(l[1][16],6) # now with weights l=nx.shortest_path_length(self.cycle,weighted=True) assert_equal(l[0],{0:0,1:1,2:2,3:3,4:3,5:2,6:1}) assert_equal(l,nx.all_pairs_dijkstra_path_length(self.cycle)) l=nx.shortest_path_length(self.grid,weighted=True) assert_equal(l[1][16],6)
def normalize_step_weight(graph): "Changes the edge weights in the graph proportional to the longest path." longest_path_len = max(nx.shortest_path_length(graph, "ROOT").values()) # add normalized path length as weight to edges. for category in "ABCEDFGHJKLMNPQRSTUVWXZ": # for each category, find out how long the longest path is. cat_longest_path_len = max(nx.shortest_path_length(graph, category).values()) + 1 # normalize the stepsize stepsize = float(longest_path_len) / cat_longest_path_len # traverse tree for this category and assign stepsize to edges as weight attribute for a, b in nx.dfs_edges(graph, category): graph[a][b]["weight"] = stepsize
def main(): for i in range(size): for j in range(size): G.add_edge((i,j), (i+1,j), weight=mat[i,j]) G.add_edge((i,j), (i,j+1), weight=mat[i,j]) for i in range(size): G.remove_node((i,size)) G.remove_node((size,i)) print nx.shortest_path_length(G, (0,0), (size-1,size-1), weight='weight')
def distance(self, type, node1, node2): if node1 in self.Dual[type].nodes() and node2 in self.Dual[type].nodes(): return nx.shortest_path_length(self.Dual[type], node1, node2) elif node1 in self.Dual[type].nodes() and node2 not in self.Dual[type].nodes(): node2 = self.External[type][node2]['measure'] return nx.shortest_path_length(self.Dual[type], node1, node2) + 1 elif node1 not in self.Dual[type].nodes() and node2 in self.Dual[type].nodes(): node1 = self.External[type][node1]['measure'] return nx.shortest_path_length(self.Dual[type], node1, node2) + 1 else: node1 = self.External[type][node1]['measure'] node2 = self.External[type][node2]['measure'] return nx.shortest_path_length(self.Dual[type], node1, node2) + 2
def complete_mpg(g): G = propagate_constraints(g) log = log_mpg(G) complete = nx.Graph() # all track nodes of interest # ie speaker/head node not subtrack tnodes = [(n,d) for n,d in G.nodes_iter(data=True) \ if isinstance(n, TrackNode) \ and n.modality in ['speaker', 'head'] \ and not d.get(SUBTRACK, False)] # all identity nodes inodes = [(n,d) for n,d in G.nodes_iter(data=True) \ if isinstance(n, IdentityNode)] # tnode/tnode shortest path (with forbidden identity nodes) _log = nx.Graph(log) _log.remove_nodes_from(zip(*inodes)[0]) _shortest = nx.shortest_path_length(_log, weight=PROBABILITY) for i, (n, d) in enumerate(tnodes): complete.add_node(n, **d) for N, D in tnodes[i+1:]: if G.has_edge(n, N): data = dict(G[n][N]) else: data = {PROBABILITY: np.exp(-_shortest[n][N])} complete.add_edge(n, N, **data) # inode/tnodes shortest path (with forbidden other identity nodes) for i, (n, d) in enumerate(inodes): complete.add_node(n, **d) _log = nx.Graph(log) _log.remove_nodes_from([m for j,(m,_) in enumerate(inodes) if j != i]) _shortest = nx.shortest_path_length(_log, source=n, weight=PROBABILITY) for N, D in tnodes: if G.has_edge(n, N): data = dict(G[n][N]) else: data = {PROBABILITY: np.exp(-_shortest[N])} complete.add_edge(n, N, **data) # inode/inode constraint for i, (n, d) in enumerate(inodes): for m,_ in inodes[i+1:]: G.add_edge(n, m, **{PROBABILITY: 0}) return complete
def test_shortest_path_length(self): assert_equal(nx.shortest_path_length(self.cycle, 0, 3), 3) assert_equal(nx.shortest_path_length(self.grid, 1, 12), 5) assert_equal(nx.shortest_path_length(self.directed_cycle, 0, 4), 4) # now with weights assert_equal(nx.shortest_path_length(self.cycle, 0, 3, weight='weight'), 3) assert_equal(nx.shortest_path_length(self.grid, 1, 12, weight='weight'), 5) assert_equal(nx.shortest_path_length(self.directed_cycle, 0, 4, weight='weight'), 4) # weights and method specified assert_equal(nx.shortest_path_length(self.cycle, 0, 3, weight='weight', method='dijkstra'), 3) assert_equal(nx.shortest_path_length(self.cycle, 0, 3, weight='weight', method='bellman-ford'), 3) # confirm bad method rejection assert_raises(ValueError, nx.shortest_path_length, self.cycle, method='SPAM') # confirm absent source rejection assert_raises(nx.NodeNotFound, nx.shortest_path_length, self.cycle, 8)
def get_unreachable_kmers(K, source=None, sink=None): ''' Path graphs created with k > 2 can yield fragmented paths. Test for these by finding unreachable kmers from source or sink ''' if source is None: source = SOURCE if sink is None: sink = SINK allnodes = set(K) # unreachable from source a = allnodes - set(nx.shortest_path_length(K, source=source).keys()) # unreachable from sink b = allnodes - set(nx.shortest_path_length(K, target=sink).keys()) return a | b
def maketree(g,T,ww,sortedgel): for e in sortedgel: if len(T.edges())<(n-1): try: nx.shortest_path_length(T,*e) except: T.add_edge(*e) else: break if(len(T.edges())!=n-1): print "Oh no of the no no !!!"
def EndtoEndComm(graph,source,target,switch2controller): path = nx.shortest_path(graph,source,target) #domain_controller = switch2controller[graph.nodes().index(source)] domain_controller = switch2controller[graph.nodes().index(source)] l_s2c = nx.shortest_path_length(graph,source,domain_controller)#calculate the latency of the package-in package delivery, which is sent from source switch to controller. l_c2s = 0 #calculate the worst-case latency of the combinition of 2 parts:controller to controller latency and controller to switch latency. for node in path: #calculate the latency of inter-controller communication c2c = nx.shortest_path_length(graph,domain_controller,switch2controller[graph.nodes().index(node)]) #calculate the latency of the rule delivery, which is sent from controller to the switch. c2s = nx.shortest_path_length(graph,switch2controller[graph.nodes().index(node)],node) l_c2s = c2c+c2s if l_c2s < c2c+c2s else l_c2s return l_s2c+l_c2s
def test_shortest_path_length_target(self): answer = {0: 1, 1: 0, 2: 1} sp = dict(nx.shortest_path_length(nx.path_graph(3), target=1)) assert_equal(sp, answer) # with weights sp = nx.shortest_path_length(nx.path_graph(3), target=1, weight='weight') assert_equal(sp, answer) # weights and method specified sp = nx.shortest_path_length(nx.path_graph(3), target=1, weight='weight', method='dijkstra') assert_equal(sp, answer) sp = nx.shortest_path_length(nx.path_graph(3), target=1, weight='weight', method='bellman-ford') assert_equal(sp, answer)
def getDihedralsFromAtoms(atomlist,bondlist,dihedrals): """Given a list of Atoms find all the Dihedral objects in dihedrals which contains these atoms. Parameters ---------- atomlist : Atom List A list of Atoms used to search through the Dihedral List. bondlist : Bond List A List of Bond objects used to get connectivity of atoms. The connectivity is used to find the possible dihedral combinations of the Atoms in atoms. angles : Angle List A List of Angles which is searched through. Returns ------- anglelist : Angle List A list of Angles that are associated with the Atoms in atoms. """ mol_graph = molecule2graph(atomlist,bondlist) dihedral_combos=[] #Get possible angles by getting subgraphs with only 2 steps for atom1,atom2 in permutations(mol_graph.__iter__(),r=2): if(ntwkx.shortest_path_length(mol_graph,source=atom1,target=atom2)==3): dihedral_combos.append(ntwkx.shortest_path(mol_graph,source=atom1,target=atom2)) dihedral_list=[] for dihedral in dihedrals: if([dihedral.atom1,dihedral.atom2,dihedral.atom3,dihedral.atom4] in dihedral_combos): dihedral_list.append(dihedral) return dihedral_list
def is_destination_reachable_from_source(noc_rg, source_node, destination_node): """ checks if destination is reachable from the local port of the source node the search starts from the local port :param noc_rg: NoC routing graph :param source_node: source node id :param destination_node: destination node id :return: True if there is a path else, False """ # the Source port should be input port since this is input of router # (which will be connected to PE's output port) source = str(source_node)+str('L')+str('I') # the destination port should be output port since this is output of router to PE # (which will be connected to PE's input port) destination = str(destination_node)+str('L')+str('O') if has_path(noc_rg, source, destination): if Config.RotingType == 'MinimalPath': path_length = shortest_path_length(noc_rg, source, destination) minimal_hop_count = manhattan_distance(source_node, destination_node) if (path_length/2) == minimal_hop_count: return True else: return True else: return False
def twopi_layout(nx_graph, center=None): """ Render the twopi layout. Ported from C code available at https://github.com/ellson/graphviz/blob/master/lib/twopigen/circle.c :param networkx.MultiDiGraph nx_graph: the networkx graph :param str center: the centered node :return: """ if len(nx_graph.nodes()) == 0: return {} if len(nx_graph.nodes()) == 1: return {nx_graph.nodes()[0]: (0, 0)} #nx_graph = nx_graph.to_undirected() data = ExplorerScene._init_layout(nx_graph) if not center: center = networkx.center(nx_graph)[0] ExplorerScene._set_parent_nodes(nx_graph, data, center) ExplorerScene._set_subtree_size(nx_graph, data) data[center]['span'] = 2 * math.pi ExplorerScene._set_subtree_spans(nx_graph, data, center) data[center]['theta'] = 0.0 ExplorerScene._set_positions(nx_graph, data, center) distances = networkx.shortest_path_length(nx_graph.to_undirected(), center) nx_pos = {} for node in nx_graph.nodes(): hyp = distances[node] + 1 theta = data[node]['theta'] nx_pos[node] = (hyp * math.cos(theta) * 100, hyp * math.sin(theta) * 100) return nx_pos
def participation_coefficient(graph, partition): ''' Computes the participation coefficient for each node. ------ Inputs ------ graph = networkx graph partition = modularity partition of graph ------ Output ------ List of the participation coefficient for each node. ''' pc_dict = {} all_nodes = set(graph.nodes()) paths = nx.shortest_path_length(G=graph) for m in partition.keys(): mod_list = set(partition[m]) between_mod_list = list(set.difference(all_nodes, mod_list)) for source in mod_list: degree = float(nx.degree(G=graph, nbunch=source)) count = 0 for target in between_mod_list: if paths[source][target] == 1: count += 1 bm_degree = count pc = 1 - (bm_degree / degree)**2 pc_dict[source] = pc return pc_dict
def GdL_create_network(self, estim_param): ''' Creates the graph of Gare de Lausanne ''' self.G = nx.MultiDiGraph() ''' --------------------------------------------------- Defines the vertices ----------------------------------------------------''' # Dictionary used to plot the graph. Includes all the nodes of the network. self.positions = { 'NW': (-0.7, 20), 'NWM': (1, 20), 'NE': (7, 20), 'NEM': (9, 20), 'SW': (0, -3), 'SE': (8, -3), 'N': (3, 20), '1D': (-2.5, 14), '1C': (3, 14), 'BAR': (-0.8, 16.1), 'nww': (-1.4, 18), 'KIOSK': (0.9, 12), 'kioskh': (0, 12), 'SHOP': (-1.5, -3), '1h1': (-2, 14), '1h2': (-1.7, 14), '1d': (-0.9, 14), 'nwh': (0, 17), '1wh': (0, 16), '1w': (0, 14), '1wc': (0.9, 14), '1c': (1.4, 14), '1h3': (1.8, 14), '1h4': (2.4, 14), 'nh': (3, 19), 'h': (3, 18), '34B': (5.5, 9), '34C': (3, 9), '34A': (10.5, 9), '34D': (-2.5, 9), '56B': (5.5, 6), '56C': (3, 6), '56D': (-2.5, 6), '56A': (10.5, 6), '78B': (5.5, 3), '78C': (3, 3), '78A': (10.5, 3), '78D': (-2.5, 3), '9C': (3, 0), '9D': (-2.5, 0), 'nw': (-0.7, 18), 'sw': (0, -1.5), 'nwm': (1, 18), 'ne': (7, 16), 'neh1': (7, 19), 'neh2': (7, 18), 'nem': (9, 16), 'se': (8, -1.5), '1eh': (8, 15), '1e': (8, 14), '1AB': (10.5, 14), '70FE': (10.5, 16), '70fe': (9.5, 16), '1ab': (9.5, 14), '34d': (-0.9, 9), '34c': (0.9, 9), '34b': (7.1, 9), '34a': (8.9, 9), '56d': (-0.9, 6), '56c': (0.9, 6), '56b': (7.1, 6), '56a': (8.9, 6), '78d': (-0.9, 3), '78c': (0.9, 3), '78b': (7.1, 3), '78a': (8.9, 3), '9d': (-0.9, 0), '9c': (0.9, 0), '9h1': (-0.6, 0), '9h2': (-0.3, 0), '9h3': (0.3, 0), '9h4': (0, 1), '34w': (0, 9), '56w': (0, 6), '78w': (0, 3), '9w': (0, 0), '34e': (8, 9), '56e': (8, 6), '56h': (8, 4), '78e': (8, 3) } self.node_labels = { 'NW': 'NW', 'NWM': 'NWM', 'NE': 'NE', 'NEM': 'NEM', 'SW': 'SW', 'SE': 'SE', 'N': 'N', '1D': '1D', '1C': '1C', 'BAR': 'BAR', 'nww': 'nww', 'KIOSK': 'KIOSK', 'kioskh': 'kiokh', 'SHOP': 'SHOP', '1h1': '1h1', '1h2': '1h2', '1d': '1d', 'nwh': 'nwh', '1wh': '1wh', '1w': '1w', '1wc': '1wc', '1c': '1c', '1h3': '1h3', '1h4': '1h4', 'nh': 'nh', 'h': 'h', '34B': '34B', '34C': '34C', '34A': '34A', '34D': '34D', '56B': '56B', '56C': '56C', '56D': '56D', '56A': '56A', '78B': '78B', '78C': '78C', '78A': '78A', '78D': '78D', '9C': '9C', '9D': '9D', 'nw': 'nw', 'sw': 'sw', 'nwm': 'nwm', 'ne': 'ne', 'neh1': 'neh1', 'neh2': 'neh2', 'nem': 'nem', 'se': 'se', '1eh': '1eh', '1e': '1e', '1AB': '1AB', '70FE': '70FE', '70fe': '70fe', '1ab': '1ab', '34d': '34d', '34c': '34c', '34b': '34b', '34a': '34a', '56d': '56d', '56c': '56c', '56b': '56b', '56a': '56a', '78d': '78d', '78c': '78c', '78b': '78b', '78a': '78a', '9d': '9d', '9c': '9c', '9h1': '9h1', '9h2': '9h2', '9h3': '9h3', '9h4': '9h4', '34w': '34w', '56w': '56w', '78w': '78w', '9w': '9w', '34e': '34e', '56e': '56e', '56h': '56h', '78e': '78e' } self.centroids_labels = { 'NW': 'NW', 'NWM': 'NWM', 'NE': 'NE', 'NEM': 'NEM', 'SW': 'SW', 'SE': 'SE', 'N': 'N', '1D': '1D', '1C': '1C', 'BAR': 'BAR', 'KIOSK': 'KIOSK', 'SHOP': 'SHOP', '34B': '34B', '34C': '34C', '34A': '34A', '34D': '34D', '56B': '56B', '56C': '56C', '56D': '56D', '56A': '56A', '78B': '78B', '78C': '78C', '78A': '78A', '78D': '78D', '9C': '9C', '9D': '9D', '1AB': '1AB', '70FE': '70FE' } self.not_centroids_labels = { 'nww': 'nww', 'kioskh': 'kiokh', '1h1': '1h1', '1h2': '1h2', '1d': '1d', 'nwh': 'nwh', '1wh': '1wh', '1w': '1w', '1wc': '1wc', '1c': '1c', '1h3': '1h3', '1h4': '1h4', 'nh': 'nh', 'h': 'h', 'nw': 'nw', 'sw': 'sw', 'nwm': 'nwm', 'ne': 'ne', 'neh1': 'neh1', 'neh2': 'neh2', 'nem': 'nem', 'se': 'se', '1eh': '1eh', '1e': '1e', '70fe': '70fe', '1ab': '1ab', '34d': '34d', '34c': '34c', '34b': '34b', '34a': '34a', '56d': '56d', '56c': '56c', '56b': '56b', '56a': '56a', '78d': '78d', '78c': '78c', '78b': '78b', '78a': '78a', '9d': '9d', '9c': '9c', '9h1': '9h1', '9h2': '9h2', '9h3': '9h3', '9h4': '9h4', '34w': '34w', '56w': '56w', '78w': '78w', '9w': '9w', '34e': '34e', '56e': '56e', '56h': '56h', '78e': '78e' } #We define the nodes, classifying th1em as centroids (platform and not platform), ASE_measurement nodes, VS_measurement_nodes (West and East PU) and other nodes. self.centroids = [ 'NW', 'NWM', 'NE', 'NEM', 'SW', 'SE', 'N', 'KIOSK', 'BAR', 'SHOP', '1D', '1C', '70FE', '1AB', '34D', '34C', '34B', '34A', '56D', '56C', '56B', '56A', '78D', '78C', '78B', '78A', '9D', '9C' ] Centroids_Platform = [ '1D', '1C', '70FE', '1AB', '34D', '34C', '34B', '34A', '56D', '56C', '56B', '56A', '78D', '78C', '78B', '78A', '9D', '9C' ] Centroids_No_Platform = [ 'NW', 'NWM', 'NE', 'NEM', 'SW', 'SE', 'N', 'KIOSK', 'BAR', 'SHOP' ] Centroids_Entrance_Exit = ['NW', 'NWM', 'NE', 'NEM', 'SW', 'SE', 'N'] Centroids_Shop = ['KIOSK', 'BAR', 'SHOP'] Platforms = {'1', '3/4', '5/6', '7/8', '9', '70'} Centroid_Types_Detail = ['platform', 'entrance', 'shop'] Centroid_Types_RCh = ['platform', 'non-platform'] self.ASE_measurement_nodes = [ 'nw', 'nww', 'nwm', '1c', 'nh', 'neh1', 'ne', 'nem', 'sw', '9h2', '9h3', 'se' ] self.VS_measurement_nodes = [ '1h1', '1h4', '70fe', '1ab', '34d', '34c', '34b', '34a', '56d', '56c', '56b', '56a', '78d', '78c', '78b', '78a', '9d', '9c' ] # TINF nodes self.other_nodes = [ 'h', '1wc', 'kioskh', '1h2', '1d', 'nwh', '1wh', '1w', '1h3', 'neh2', '1eh', '1e', '9h1', '9h4', '34w', '56w', '78w', '9w', '34e', '56e', '56h', '78e' ] VS_west_nodes = [ '1wh', '1d', '1wc', '34d', '34c', '56d', '56c', '78d', '78c', '9h4' ] VS_east_nodes = ['1e', '34b', '34a', '56b', '56a', '56h'] VS_nodes = VS_west_nodes + VS_east_nodes #We create dictionaries for the centroids self.centroids_dict = {} self.centroids_dict_rev = {} for idx, node in enumerate(self.centroids): self.centroids_dict[idx] = node self.centroids_dict_rev[node] = idx self.centroids_p_dict = {} for idx, node in enumerate(Centroids_Platform): self.centroids_p_dict[idx] = node self.centroids_np_dict = {} for idx, node in enumerate(Centroids_No_Platform): self.centroids_np_dict[idx] = node self.centroids_ee_dict = {} for idx, node in enumerate(Centroids_Entrance_Exit): self.centroids_ee_dict[idx] = node self.shops_dict = {} for idx, node in enumerate(Centroids_Shop): self.shops_dict[idx] = node self.centroid_types_det_dict = {} self.centroid_types_det_dict_rev = {} for idx, node in enumerate(Centroid_Types_Detail): self.centroid_types_det_dict[idx] = node self.centroid_types_det_dict_rev[node] = idx self.centroid_types_RCh_dict = {} self.centroid_types_RCh_dict_rev = {} for idx, node in enumerate(Centroid_Types_RCh): self.centroid_types_RCh_dict[idx] = node self.centroid_types_RCh_dict_rev[node] = idx self.platforms_dict = {} self.platforms_dict_rev = {} for idx, node in enumerate(Platforms): self.platforms_dict[idx] = node self.platforms_dict_rev[node] = idx ''' --------------------------------------------------- Adds the vertices to the graph object ----------------------------------------------------''' self.G.add_nodes_from(Centroids_No_Platform, type='Centroids') self.G.add_nodes_from(self.ASE_measurement_nodes, type='ASE') self.G.add_nodes_from(Centroids_Platform, type='Platforms') self.G.add_nodes_from(self.VS_measurement_nodes, type='VS') self.G.add_nodes_from(self.other_nodes, type='Other') self.nodes = self.G.nodes() ''' --------------------------------------------------- Adds the edges to the graph object ----------------------------------------------------''' #We add the edges that are not ramps or escalators to the graph self.G.add_edges_from([('34d', '34w'), ('56d', '56w'), ('78d', '78w'), ('34w', '34c'), ('56w', '56c'), ('78w', '78c'), ('kioskh', 'KIOSK'), ('1w', '1d')], {'length': 3}) self.G.add_edges_from([('34b', '34e'), ('56b', '56e'), ('78b', '78e'), ('34e', '34a'), ('56e', '56a'), ('78e', '78a')], {'length': 5}) self.G.add_edges_from([('34b', '34e'), ('56b', '56e'), ('78b', '78e'), ('34e', '34a'), ('56e', '56a'), ('78e', '78a')], {'length': 5}) self.G.add_edges_from([('34w', '56w'), ('34e', '56e')], {'length': 15.5}) self.G.add_edges_from([('56w', '78w')], {'length': 14.4}) self.G.add_edges_from([('56e', '56h'), ('56h', '78e'), ('neh2', 'neh1')], {'length': 7.2}) self.G.add_edges_from([('34w', 'kioskh'), ('kioskh', '1w')], {'length': 11}) self.G.add_edges_from([('1h2', '1h1'), ('1h1', '1D'), ('1c', '1h3'), ('1h3', '1h4'), ('1h4', '1C'), ('h', 'nh'), ('neh1', 'NE')], {'length': 2}) # Check length maybe self.G.add_edges_from([('1w', 'BAR'), ('nh', 'N')], {'length': 8}) self.G.add_edges_from([('1h3', 'h')], {'length': 30}) self.G.add_edges_from([('h', 'neh2')], {'length': 75}) self.G.add_edges_from([('78C', '78B')], {'length': 82}) self.G.add_edges_from([('neh2', '70fe')], {'length': 75}) self.G.add_edges_from([('70fe', '70FE')], {'length': 10}) self.G.add_edges_from([('1ab', '1AB')], {'length': 10}) self.G.add_edges_from([('neh2', '1ab')], {'length': 40}) self.G.add_edges_from([('nww', 'NW')], {'length': 60}) self.G.add_edges_from([('nww', '1h2')], {'length': 10}) self.G.add_edges_from([('34e', '1e'), ('nem', 'NEM')], {'length': 22}) self.G.add_edges_from([('SW', 'sw'), ('sw', '9w')], {'length': 5}) self.G.add_edges_from([('9w', '9h2'), ('9h2', '9h1'), ('9h1', '9d')], {'length': 3.5}) self.G.add_edges_from([('9w', '9h3'), ('9h3', '9c')], {'length': 7}) self.G.add_edges_from([('9w', '9h4'), ('9h4', '78w')], {'length': 8.6}) self.G.add_edges_from([('9h1', 'SHOP'), ('nwm', 'NWM')], {'length': 6}) self.G.add_edges_from([('SE', 'se'), ('se', '78e')], {'length': 5.5}) self.G.add_edges_from([('1w', '1wc')], {'length': 3.0}) self.G.add_edges_from([('nw', 'nwh'), ('nwm', 'nwh'), ('nwh', '1wh'), ('ne', '1eh'), ('nem', '1eh'), ('1eh', '1e')], {'length': 1.0}) self.G.add_edges_from([('1wh', '1w')], {'length': 17.5}) self.edge_labels_simple = dict([(( u, v, ), d['length']) for u, v, d in self.G.edges(data=True)]) self.edges = self.G.edges() #We add the edges reversed for edge in self.edges: self.G.add_edges_from([edge[::-1]], self.G.get_edge_data(edge[0], edge[1])[0]) #We add the edges that are ramps or escalators and thus have a different weight in each direction self.G.add_edges_from([('34d', '34D'), ('56d', '56D'), ('78d', '78D'), ('9d', '9D'), ('34b', '34B'), ('56b', '56B'), ('78b', '78B'), ('56a', '56A'), ('1d', '1h2'), ('ne', 'neh2'), ('nw', 'NW')], {'length': 23.06}) # Stairs up self.G.add_edges_from([('34D', '34d'), ('56D', '56d'), ('78D', '78d'), ('9D', '9d'), ('34B', '34b'), ('56B', '56b'), ('78B', '78b'), ('56A', '56a'), ('1h2', '1d'), ('neh2', 'ne'), ('NW', 'nw')], {'length': 21.51}) # Stairs down self.G.add_edges_from( [('34a', '34A'), ('78a', '78A')], {'length': 25.46}) # Stairs up plus some corridor self.G.add_edges_from( [('34A', '34a'), ('78A', '78a')], {'length': 23.91}) # Stairs down plus some corridor self.G.add_edges_from([('34c', '34C'), ('56c', '56C'), ('78c', '78C'), ('9c', '9C')], {'length': 40.05}) # Ramps up self.G.add_edges_from([('34C', '34c'), ('56C', '56c'), ('78C', '78c'), ('9C', '9c')], {'length': 32.97}) # Ramps down self.G.add_edges_from([('1wc', '1c')], {'length': 33.8}) # Ramp up self.G.add_edges_from([('1c', '1wc')], {'length': 25.84}) # Ramp down self.edges = self.G.edges() self.edge_labels_duplicated = dict([(( u, v, ), d['length']) for u, v, d in self.G.edges(data=True)]) self.number_of_edges = len(self.edges) #We create a list of the edges associated to ASE sensors self.edges_ASE = [ ('nw', 'nwh'), # nwIn ('nwm', 'nwh'), # nwmIn #('1c', '1wc') , # 1cIn MALFUNCTIONING ('nh', 'h'), # nhIn ('neh1', 'neh2'), # neh1In ('ne', '1eh'), # neIn ('nem', '1eh'), # nemIn ('sw', '9w'), # swIn ('9h2', '9w'), # gh2In ('9h3', '9w'), # gh3In ('se', '78e'), # seIn #('nww', '1h2') , #nwwIn MALFUNCTIONING ('nw', 'NW'), # nwOut ('nwm', 'NWM'), # nwmOut #('1c', '1h3'), #1cOut MALFUNCTIONING ('nh', 'N'), # nhOut ('neh1', 'NE'), # neh1Out ('ne', 'neh2'), # neOut ('nem', 'NEM'), # nemOut ('sw', 'SW'), # swOut ('9h2', '9h1'), # g9h2Out ('9h3', '9c'), # 9h3Out ('se', 'SE'), # seOut #('nww', 'NW') #nwwOut MALFUNCTIONING ] self.number_of_edges_ASE = len(self.edges_ASE) #We create a list of the edges associated to TINF self.edges_TINF = [ ('1D', '1h1'), ('34d', '34w'), ('56d', '56w'), ('78d', '78w'), ('9d', '9h1'), ('1C', '1h4'), ('34c', '34w'), ('56c', '56w'), ('78c', '78w'), ('9c', '9h3'), ('1AB', '1ab'), ('70FE', '70fe'), ('34b', '34e'), ('56b', '56e'), ('78b', '78e'), ('34a', '34e'), ('56a', '56e'), ('78a', '78e'), ] self.edges_TINF_origins = [ '1D', '34D', '56D', '78D', '9D', '1C', '34C', '56C', '78C', '9C', '1AB', '70FE', '34B', '56B', '78B', '34A', '56A', '78A' ] self.number_of_edges_TINF = len(self.edges_TINF) VS_inflow_edges = [('1wh', '1w'), ('1d', '1w'), ('1wc', '1w'), ('34d', '34w'), ('34c', '34w'), ('56d', '56w'), ('56c', '56w'), ('78d', '78w'), ('78c', '78w'), ('9h4', '78w'), ('1e', '34e'), ('34b', '34e'), ('34a', '34e'), ('56b', '56e'), ('56a', '56e'), ('56h', '56e')] VS_outflow_edges = [('1wh', 'nwh'), ('1d', '1h2'), ('1wc', '1c'), ('34d', '34D'), ('34c', '34C'), ('56d', '56D'), ('56c', '56C'), ('78d', '78D'), ('78c', '78C'), ('9h4', '9w'), ('1e', '1eh'), ('34b', '34B'), ('34a', '34A'), ('56b', '56B'), ('56a', '56A'), ('56h', '78e')] # #We create a list of the edges associated to historical data # self.edges_sales_points = [ # ('KIOSK', 'kioskh'), # ('SHOP', '9h1'), # ('BAR', '1w'), # ] # self.number_of_edges_HIST = len(self.edges_sales_points) #We create dictionaries (for easier bookkeeping) self.edges_dict = {} self.edges_dict_rev = {} self.edges_reverse_dict = {} for idx, edge in enumerate(self.G.edges()): self.edges_reverse_dict[edge] = edge[::-1] self.edges_dict[idx] = edge self.edges_dict_rev[edge] = idx self.edges_ASE_dict = {} self.edges_ASE_dict_rev = {} for idx, edge in enumerate(self.edges_ASE): self.edges_ASE_dict[idx] = edge self.edges_ASE_dict_rev[edge] = idx self.edges_TINF_dict = {} self.edges_TINF_dict_rev = {} for idx, edge in enumerate(self.edges_TINF): self.edges_TINF_dict[idx] = edge self.edges_TINF_dict_rev[edge] = idx self.edges_TINF_origins_dict = {} #self.edges_TINF_origins_dict_rev = {} for idx, edge in enumerate(self.edges_TINF_origins): self.edges_TINF_origins_dict[idx] = edge #self.edges_TINF_origins_dict_rev[edge] = idx # self.edges_HIST_dict = {} # for idx, edge in enumerate(self.edges_sales_points): # self.edges_HIST_dict[idx] = edge self.VS_inflow_edges_dict = {} self.VS_inflow_edges_dict_rev = {} for idx, edge in enumerate(VS_inflow_edges): self.VS_inflow_edges_dict[idx] = edge self.VS_inflow_edges_dict_rev[edge] = idx self.VS_outflow_edges_dict = {} self.VS_outflow_edges_dict_rev = {} for idx, edge in enumerate(VS_outflow_edges): self.VS_outflow_edges_dict[idx] = edge self.VS_outflow_edges_dict_rev[edge] = idx # We define the areas. They are characterized by the nodes lying on their borders. They can overlap. areas = [[ '9h4', '78d', '56d', '34d', '1d', 'BAR', '1wh', '1wc', 'KIOSK', '34c', '56c', '78c' ], ['56h', '56b', '34b', '1e', '34a', '56a']] #We create a dictionary of the areas self.areas_dict = {} for idx, area in enumerate(areas): self.areas_dict[idx] = area ## Code to generate all routes and write them in routes.txt (postprocessing needed to select the feasible routes) if estim_param.forceGenerateRoutes: routes = [] path = nx.all_pairs_dijkstra_path(self.G, weight='length') for source in self.centroids: for target in self.centroids: if source is not target: routes.append(path[source][target]) with open(estim_param.path_routes_file, 'w') as file: for item in routes: file.write("{}\n".format(item)) #We load the routes from a precoumpted file self.routes = [] with open(estim_param.path_routes_file, 'r') as routesfile: for line in routesfile: line = line[1:-2] line = line.replace(',', '') line = line.replace("'", '') line = line.split() self.routes.append(line) self.number_of_routes = len(self.routes) # We generate all possible subroutes path = nx.all_pairs_dijkstra_path(self.G, weight='length') self.subroutes_west = [] for source in VS_west_nodes: for target in VS_west_nodes: if source is not target: self.subroutes_west.append(path[source][target]) self.subroutes_east = [] for source in VS_east_nodes: for target in VS_east_nodes: if source is not target: self.subroutes_east.append(path[source][target]) self.subroutes_VS = self.subroutes_west + self.subroutes_east #We create dictonaries for the routes and subroutes self.routes_dict = {} self.routes_dict_rev = {} for idx, route in enumerate(self.routes): self.routes_dict[idx] = route self.routes_dict_rev[str(route)] = idx self.subroutes_VS_dict = {} self.subroutes_VS_dict_rev = {} for idx, route in enumerate(self.subroutes_VS): self.subroutes_VS_dict[idx] = route self.subroutes_VS_dict_rev[str(route)] = idx self.VS_nodes_dict = {} self.VS_nodes_dict_rev = {} for idx, node in enumerate(VS_nodes): self.VS_nodes_dict[idx] = node self.VS_nodes_dict_rev[node] = idx # We compute the distances between edges and routes self.distances_edge_route = np.zeros( (len(self.edges), len(self.routes))) for e in range(len(self.edges)): for r in range(len(self.routes)): # if the edge in on the route, we compute the distance between the start of the route and the start of the edge if '( ' + str(self.edges[e][0]) + ',' + str( self.edges[e][1]) + ')' in [ '(' + str(self.routes[r][i - 1]) + ',' + str(self.routes[r][i]) + ')' for i in range(1, len(self.routes[r])) ]: self.distances_edge_route[e][r] = nx.shortest_path_length( self.G, source=self.routes[r][0], target=self.edges[e][0], weight='length') else: self.distances_edge_route[e][r] = -1 self.distances_edge_route2 = np.zeros( (len(self.edges_ASE), len(self.routes))) # Exit links self.exit_centroids_exit_edges = { 'SW': ('sw', 'SW'), 'NW': ('nw', 'NW'), 'NWM': ('nwm', 'NWM'), 'SE': ('se', 'SE'), 'NEM': ('nem', 'NEM'), 'N': ('nh', 'N'), 'NE': ('neh1', 'NE') #'NW': ('nww', 'NW'), negligibly small } # dictionaries for route choice self.route_orig_dict = {} self.route_dest_dict = {} self.routes_from_centroid = defaultdict(list) self.routes_to_centroid = defaultdict(list) for route_key in self.routes_dict.keys(): orig_centroid_key = self.centroids_dict_rev[ self.routes_dict[route_key][0]] dest_centroid_key = self.centroids_dict_rev[ self.routes_dict[route_key][-1]] self.route_orig_dict[route_key] = orig_centroid_key self.route_dest_dict[route_key] = dest_centroid_key self.routes_from_centroid[orig_centroid_key].append(route_key) self.routes_to_centroid[dest_centroid_key].append(route_key) # dictionaries for postprocessing of VisioSafe self.subroute_orig_dict = {} self.subroute_dest_dict = {} self.subroutes_from_node = defaultdict(list) self.subroutes_to_node = defaultdict(list) for subroute_key in self.subroutes_VS_dict.keys(): orig_centroid_key = self.VS_nodes_dict_rev[ self.subroutes_VS_dict[subroute_key][0]] dest_centroid_key = self.VS_nodes_dict_rev[ self.subroutes_VS_dict[subroute_key][-1]] self.subroute_orig_dict[subroute_key] = orig_centroid_key self.subroute_dest_dict[subroute_key] = dest_centroid_key self.subroutes_from_node[orig_centroid_key].append(subroute_key) self.subroutes_to_node[dest_centroid_key].append(subroute_key) # linking track numbres to platform names self.track_platform_dict = { 1: '1', 3: '3/4', 4: '3/4', 5: '5/6', 6: '5/6', 7: '7/8', 8: '7/8', 9: '9', 70: '70' } self.centroid_platform_dict = { '1D': '1', '1C': '1', '70FE': '70', '1AB': '1', '34D': '3/4', '34C': '3/4', '34B': '3/4', '34A': '3/4', '56D': '5/6', '56C': '5/6', '56B': '5/6', '56A': '5/6', '78D': '7/8', '78C': '7/8', '78B': '7/8', '78A': '7/8', '9D': '9', '9C': '9' } # Structural components of Lausanne useful for Circos and other highly aggregated plots self.structural_labels = [ 'P1', 'P34', 'P56', 'P78', 'P9', 'P70', 'Metro', 'North', 'South', 'Shops', ] #Dictionary that aggregates the centroids in these structural zones: self.structural_centroids_dict = { '1D': 0, '1C': 0, '70FE': 5, '1AB': 0, '34D': 1, '34C': 1, '34B': 1, '34A': 1, '56D': 2, '56C': 2, '56B': 2, '56A': 2, '78D': 3, '78C': 3, '78B': 3, '78A': 3, '9D': 4, '9C': 4, 'NW': 7, 'NWM': 6, 'NE': 7, 'NEM': 6, 'SW': 8, 'SE': 8, 'N': 7, 'KIOSK': 9, 'BAR': 9, 'SHOP': 9 } self.ASE_edge_names_dict = { 'ASE9ab_in': ('9h3', '9w'), 'ASE9cde_in': ('sw', '9w'), 'ASE9fgh_in': ('9h2', '9w'), 'ASE4_out': ('1c', '1wc'), 'ASE5a_in': ('nw', 'nwh'), 'ASE10_in': ('nwm', 'nwh'), 'ASE8_in': ('se', '78e'), 'ASE2_out': ('ne', '1eh'), 'ASE2de_out': ('nem', '1eh'), 'ASE3_in': ('nh', 'h'), 'ASE1_in': ('neh1', 'neh2'), 'ASE6_in': ('nww', '1h2'), 'ASE9ab_out': ('9h3', '9c'), 'ASE9cde_out': ('sw', 'SW'), 'ASE9fgh_out': ('9h2', '9h1'), 'ASE4_in': ('1c', '1h3'), 'ASE5a_out': ('nw', 'NW'), 'ASE10_out': ('nwm', 'NWM'), 'ASE8_out': ('se', 'SE'), 'ASE2_in': ('ne', 'neh2'), 'ASE2de_in': ('nem', 'NEM'), 'ASE3_out': ('nh', 'N'), 'ASE1_out': ('neh1', 'NE'), 'ASE6_out': ('nww', 'NW'), } #Reversed dictionary: self.ASE_edge_names_dict_rev = {} for key in self.ASE_edge_names_dict.keys(): self.ASE_edge_names_dict_rev[self.ASE_edge_names_dict[key]] = key self.edges_sens_correction = [ ('nw', 'nwh'), # nwIn ('nwm', 'nwh'), # nwmIn ('nh', 'h'), # nhIn ('neh1', 'neh2'), # neh1In ('nw', 'NW'), # nwOut ('nwm', 'NWM'), # nwmOut ('nh', 'N'), # nhOut ('neh1', 'NE'), # neh1Out # following links tentatively considered ('sw', '9w'), # swIn ('9h2', '9w'), # gh2In ('9h3', '9w'), # gh3In ('se', '78e'), # seIn ('sw', 'SW'), # swOut ('9h2', '9h1'), # g9h2Out ('9h3', '9c'), # 9h3Out ('se', 'SE'), # seOut ]
def shortest_path_length(self, u, v): return nx.shortest_path_length(self.G, u, v)
def min_tree(input_file_path): file_dir = os.path.dirname(input_file_path) file = os.path.basename(input_file_path) file_name, file_type = file.split('_') out_file_path = os.path.join(file_dir, file_name) test_path = os.path.join(file_dir, 'steps', 'try_') if file_type == 'pickle': G = pj.load_pickle(input_file_path) reduced_graph = remove_relay(G) # plt.figure(1) # pj.draw_graph(reduced_graph, out_file_path+"_terminals") fig = 1 pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig)) fig += 1 #terminals = reduced_graph.nodes() #print (terminals) #finding the sink (Base Station) for node in reduced_graph.nodes(data=True): if node[1]['type'] == 'BS': sink_id = node[1]['id'] break print(nx.is_biconnected(reduced_graph)) if nx.is_connected(reduced_graph): #CMST begins================================================ #initialize:---------------------------------- Tree = nx.Graph() #getting hop counts and max hop counts hop_tuples = [] for node in reduced_graph.nodes(): reduced_graph.nodes[node]['hops'] = nx.shortest_path_length( reduced_graph, sink_id, node) if reduced_graph.nodes[node]['hops'] > 1: hop_tuples += [(node, reduced_graph.nodes[node]['hops'])] hop_tuples = sorted(hop_tuples, key=lambda x: x[1]) max_hop_count = hop_tuples[-1][1] single_hop = [] #finding and connecting roots of top sub-trees for sink, branch_root in reduced_graph.edges(sink_id): single_hop += [branch_root] temprary = G.subgraph([sink] + reduced_graph.edges[sink, branch_root]['link'] + [branch_root]) Tree.add_nodes_from(temprary.nodes(data=True)) Tree.add_edges_from(temprary.edges(data=True)) # plt.figure(2) # pj.draw_graph(Tree, out_file_path+"_tree") pj.draw_graph(Tree, test_path + "tree" + str(fig)) fig += 1 #updating reduced tree - removing unrequired edges # is this needed? for i in list(combinations(single_hop, 2)): if reduced_graph.has_edge(i[0], i[1]): reduced_graph.remove_edge(i[0], i[1]) # plt.figure(1) # pj.draw_graph(reduced_graph, out_file_path+"_terminals") pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig)) fig += 1 #UPDATES #defining branches, their loads and their components branches = {} dfs_edges = list(nx.dfs_edges(Tree, source=sink_id)) for parent, child in dfs_edges: if parent == sink_id: branch = child branches[branch] = {} branches[branch]['nodes'] = set([child]) branches[branch]['load'] = 0 if Tree.nodes[child]['type'] == 'S': branches[branch]['load'] += 1 else: branches[branch]['nodes'] = set([child ]) | branches[branch]['nodes'] if Tree.nodes[child]['type'] == 'S': branches[branch]['load'] += 1 #print (dfs_edges) #print (branches) #UPDATES #making growth sets, parent sets and hop sets all_sets = {} hop_set = {} #print(hop_tuples) for node, hop in hop_tuples: if hop in hop_set: hop_set[hop] = set([node]) | hop_set[hop] else: hop_set[hop] = set([node]) all_sets[node] = {'growth': set([]), 'parents': set([])} for vertex, adj_vert in reduced_graph.edges(node): #if parent if reduced_graph.nodes[adj_vert]['hops'] < reduced_graph.nodes[ vertex]['hops']: all_sets[node]['parents'] = set( [adj_vert]) | all_sets[node]['parents'] elif reduced_graph.nodes[adj_vert][ 'hops'] > reduced_graph.nodes[vertex]['hops']: all_sets[node]['growth'] = set( [adj_vert]) | all_sets[node]['growth'] #print(all_sets) #print(hop_set) #iteration for h in range(2, max_hop_count + 1): done = [] left_tuple = [] #directly connecting nodes with single parent for node in hop_set[h]: if len(all_sets[node]['parents']) == 1: done += [node] temp = G.subgraph([node] + reduced_graph.edges[ node, all_sets[node]['parents'][0]]['link'] + all_sets[node]['parents']) Tree.add_nodes_from(temp.nodes(data=True)) Tree.add_edges_from(temp.edges(data=True)) else: left_tuple += [(node, len(all_sets[node]['growth']))] # plt.figure(2) # pj.draw_graph(Tree, out_file_path+"_tree") pj.draw_graph(Tree, test_path + "tree" + str(fig)) fig += 1 #updating reduced tree - removing unrequired edges # is this needed? for i in done: for j in hop_set[h]: if reduced_graph.has_edge(i, j): reduced_graph.remove_edge(i, j) # plt.figure(1) # pj.draw_graph(reduced_graph, out_file_path+"_terminals") pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig)) fig += 1 #updating branches, their loads and their components dfs_edges = list(nx.dfs_edges(Tree, source=sink_id)) for parent, child in dfs_edges: if parent == sink_id: branch = child branches[branch] = {} branches[branch]['nodes'] = set([child]) branches[branch]['load'] = 0 if Tree.nodes[child]['type'] == 'S': branches[branch]['load'] += 1 else: branches[branch]['nodes'] = set( [child]) | branches[branch]['nodes'] if Tree.nodes[child]['type'] == 'S': branches[branch]['load'] += 1 while len(left_tuple) > 0: left_tuple = sorted(left_tuple, key=lambda x: x[0]) left_tuple = sorted(left_tuple, key=lambda x: x[1]) node = left_tuple[0][0] left_tuple_temp = left_tuple[1:] left_tuple = [] metric_tuple = [] for branch in branches: if len(branches[branch]['nodes'] & all_sets[node]['parents']) > 0: #generate the search set if h<max_hop_count for parent in (branches[branch]['nodes'] & all_sets[node]['parents']): ss = set([]) relay_set = set([]) temp_redgraph = reduced_graph.copy() for i in done: if temp_redgraph.has_edge(node, i): temp_redgraph.remove_edge(node, i) for p in all_sets[node]['parents']: if temp_redgraph.has_edge(node, p): temp_redgraph.remove_edge(node, p) for c in all_sets[node]['growth']: flag = 0 for cp in all_sets[c]['parents']: if cp != node and flag == 0: for path in nx.all_simple_paths( temp_redgraph, source=cp, target=sink_id, cutoff=h): if len( set(path) & branches[branch]['nodes'] ) == 0: flag = 1 break if flag == 0: ss = ss | set([c]) relay_set = relay_set | set( reduced_graph.edges[node, c]['link']) #print ('ss = '+str(ss)) #TODO - replace with link weight relay_set = relay_set | set( reduced_graph.edges[node, parent]['link']) relay_count = len(relay_set - branches[branch]['nodes']) #case1 metric #metric = branches[branch]['load']+1+len(ss)+relay_count #case2 metric metric = branches[branch]['load'] + 1 + len(ss) # checking if branches are fusing relay_flag = 0 for b in branches: if b != branch: if len(relay_set & branches[b]['nodes']) > 0: relay_flag = 1 break if (relay_flag == 0): metric_tuple += [(metric, relay_count, branch, parent, ss)] #TODO - devise how to choose the best parent within a branch metric_tuple = sorted(metric_tuple, key=lambda y: y[1]) metric_tuple = sorted(metric_tuple, key=lambda y: y[0]) #TODO - add search set addition and remove them from further hop metrix and their links too temp = G.subgraph( [node] + reduced_graph.edges[node, metric_tuple[0][3]]['link'] + [metric_tuple[0][3]]) Tree.add_nodes_from(temp.nodes(data=True)) Tree.add_edges_from(temp.edges(data=True)) for n in metric_tuple[0][4]: temp = G.subgraph([n] + reduced_graph.edges[n, node]['link'] + [node]) Tree.add_nodes_from(temp.nodes(data=True)) Tree.add_edges_from(temp.edges(data=True)) # plt.figure(2) # pj.draw_graph(Tree, out_file_path+"_tree") pj.draw_graph(Tree, test_path + "tree" + str(fig)) fig += 1 #updating reduced tree - removing unrequired edges # is this needed? for i in hop_set[h]: if reduced_graph.has_edge(node, i): reduced_graph.remove_edge(node, i) for p in all_sets[node]['parents']: if p != metric_tuple[0][3]: reduced_graph.remove_edge(node, p) for n in metric_tuple[0][4]: hop_set[h + 1] = hop_set[h + 1] - set([n]) for i in hop_set[h + 1]: if reduced_graph.has_edge(n, i): reduced_graph.remove_edge(n, i) for p in all_sets[n]['parents']: if p != node: reduced_graph.remove_edge(n, p) # plt.figure(1) # pj.draw_graph(reduced_graph, out_file_path+"_terminals") pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig)) fig += 1 done += [node] #updating branches, their loads and their components dfs_edges = list(nx.dfs_edges(Tree, source=sink_id)) for parent, child in dfs_edges: if parent == sink_id: branch = child branches[branch] = {} branches[branch]['nodes'] = set([child]) branches[branch]['load'] = 0 if Tree.nodes[child]['type'] == 'S': branches[branch]['load'] += 1 else: branches[branch]['nodes'] = set( [child]) | branches[branch]['nodes'] if Tree.nodes[child]['type'] == 'S': branches[branch]['load'] += 1 #TODO - may need to change these for higher hop count nodes as well #updating growth sets and parent sets for n, a in left_tuple_temp: all_sets[n] = {'growth': set([]), 'parents': set([])} for vertex, adj_vert in reduced_graph.edges(n): #if parent if reduced_graph.nodes[adj_vert][ 'hops'] < reduced_graph.nodes[vertex]['hops']: all_sets[n]['parents'] = set( [adj_vert]) | all_sets[n]['parents'] elif reduced_graph.nodes[adj_vert][ 'hops'] > reduced_graph.nodes[vertex]['hops']: all_sets[n]['growth'] = set( [adj_vert]) | all_sets[n]['growth'] left_tuple += [(n, len(all_sets[n]['growth']))] plt.figure(fig) pj.draw_graph(reduced_graph, out_file_path + "_skeletontree") plt.figure(fig + 1) pj.draw_graph(Tree, out_file_path + "_fulltree") pj.store_pickle(Tree, out_file_path + "balancedtree_pickle") else: print( "Terminals of the given graph do not lie in a single sonnected component. Thus it cannot be processed further" )
def get_distance(self, source, target): """ Computes the shortest distance from source to target. Source is likely to be Pacman, while targets can be the ghosts for example. """ return nx.shortest_path_length(self.graph, source, target)
import networkx G = networkx.DiGraph() for a in open("06_input.txt").readlines(): G.add_edge(*[x.strip() for x in a.split(')')]) print(networkx.transitive_closure(G).size()) print(networkx.shortest_path_length(G.to_undirected(), "YOU", "SAN") - 2)
def find_shortest_length(self, start, end): return (nx.shortest_path_length(self.G, start, end, weight="weight"))
def howFarFromHome(self, node, G): return nx.shortest_path_length(G, self.location, node)
#### for ng in G2.neighbors(node): #### if ng not in lt and ng in lt2: #### newG.add_edge(i+115,j+115) #### ####print(newG.edges()) ## ##from networkx.algorithms import bipartite ##col=bipartite.color(newG) ##print(col) ## sentr={} for i in prsen: sentr[i]=True for i in prsen: for j in prsen: if i!=j: dst=nx.shortest_path_length(G2,i[0],j[0]) for lt in e.values(): if i[0] in lt: szi=len(lt) if j[0] in lt: szj=len(lt) sz=min(szi,szj) if dst<sz/3: if i[1]<j[1]: sentr[i]=False else: sentr[j]=False print(sentr)
prevalence_outcomes = [{}]*clusters for cluster in range(clusters): prevalence_outcomes[cluster] = copy.deepcopy({node: 0 for node in graphs[cluster].nodes()}) for infected_node in prevalences[cluster]: prevalence_outcomes[cluster][infected_node] = 1 IV_weights = [{node: np.random.normal(logit(IV_ps[2*cluster//clusters]), 1, 1)[0] for node in range(n)} for cluster in range(clusters)] IV_nodes = set.union(*[{((cluster, node), expit(IV_weights[cluster][node])) for node in set(range(n)).difference(infecteds[cluster])} for cluster in range(clusters)]) IV_infected = set([]) for IV_node in IV_nodes: if random.random() < IV_node[1]: IV_infected.add(IV_node[0]) mins = {node: 0 for node in range(n)} sums = {node: 0 for node in range(n)} for node in range(n): paths = [nx.shortest_path_length(graphs[cluster],node,neighbor) for neighbor in set(nx.node_connected_component(graphs[cluster], node)).intersection(prevalences[cluster]).difference(set([node]))] if len(paths) == 0: mins[node] = 0 sums[node] = 0 if len(paths) > 0: mins[node] = 1 / min(paths) sums[node] = sum([1/path for path in paths]) components = [len(C) for C in nx.connected_components(graphs[cluster])] datas[cluster] = pd.DataFrame({ # main informations relevant to basic analysis "Trt": (2*cluster//clusters), "Cluster": cluster, "Prevalences": prevalence_outcomes[cluster], # Degree-based covariates
def create_g_30000_240000_1(): graph = GraphAlgo() g_nx = nx.DiGraph() file = "../data/Graph_on_circle/G_30000_240000_1.json" graph.load_from_json(file) try: with open(file, 'r') as file: load_file = json.load(file) for vertex in load_file["Nodes"]: g_nx.add_node(vertex["id"]) for edge in load_file["Edges"]: g_nx.add_weighted_edges_from([(edge["src"], edge["dest"], edge["w"])]) except Exception as ex: print("couldn't save to jason", ex) return False finally: file.close() # graph.plot_graph() print("g_30000_240000_1 result:") shortest_path_result = [] start_time = time.perf_counter() dist, path = graph.shortest_path(2, 8) end_time = time.perf_counter() record = end_time - start_time shortest_path_result.append(record) # print("shortest_path(2, 8)=", path) # print("distance=", dist) shortest_path_networkx_result = [] start_time = time.perf_counter() path = nx.shortest_path(G=g_nx, source=2, target=8) dist = nx.shortest_path_length(G=g_nx, source=2, target=8) end_time = time.perf_counter() record = end_time - start_time # print("g_30000_240000_1 networkx result:") # print("shortest_path(2,8)", path) # print("distance=", dist) shortest_path_networkx_result.append(record) start_time = time.perf_counter() dist, path = graph.shortest_path(3, 9) end_time = time.perf_counter() record = end_time - start_time shortest_path_result.append(record) # print("shortest_path(3, 9)=", path) # print("distance=", dist) start_time = time.perf_counter() path = nx.shortest_path(G=g_nx, source=3, target=9) dist = nx.shortest_path_length(G=g_nx, source=3, target=9) end_time = time.perf_counter() record = end_time - start_time # print("g_30000_240000_1 networkx result:") # print("shortest_path(3,9)", path) # print("distance=", dist) shortest_path_networkx_result.append(record) start_time = time.perf_counter() dist, path = graph.shortest_path(4, 7) end_time = time.perf_counter() record = end_time - start_time shortest_path_result.append(record) # print("shortest_path(4, 7)=", path) # print("distance=", dist) start_time = time.perf_counter() path = nx.shortest_path(G=g_nx, source=4, target=7) dist = nx.shortest_path_length(G=g_nx, source=4, target=7) end_time = time.perf_counter() record = end_time - start_time # print("g_30000_240000_1 networkx result:") # print("shortest_path(4,7)", path) # print("distance=", dist) shortest_path_networkx_result.append(record) start_time = time.perf_counter() dist, path = graph.shortest_path(5, 4) end_time = time.perf_counter() record = end_time - start_time shortest_path_result.append(record) # print("shortest_path(5, 4)=", path) # print("distance=", dist) start_time = time.perf_counter() path = nx.shortest_path(G=g_nx, source=5, target=4) dist = nx.shortest_path_length(G=g_nx, source=5, target=4) end_time = time.perf_counter() record = end_time - start_time # print("g_30000_240000_1 networkx result:") # print("shortest_path(5,4)", path) # print("distance=", dist) shortest_path_networkx_result.append(record) start_time = time.perf_counter() dist, path = graph.shortest_path(5, 2) end_time = time.perf_counter() record = end_time - start_time shortest_path_result.append(record) # print("shortest_path(5, 2)=", path) # print("distance=", dist) result = sum(shortest_path_result) / len(shortest_path_result) print("shortest path record:", result) start_time = time.perf_counter() path = nx.shortest_path(G=g_nx, source=5, target=2) dist = nx.shortest_path_length(G=g_nx, source=5, target=2) end_time = time.perf_counter() record = end_time - start_time shortest_path_networkx_result.append(record) # print("g_30000_240000_1 networkx result:") # print("shortest_path(5,2)", path) # print("distance=", dist) result = sum(shortest_path_networkx_result) / len( shortest_path_networkx_result) print("networkx shortest path record:", result) start_time = time.perf_counter() path = graph.connected_components() end_time = time.perf_counter() record = end_time - start_time # print("connected_components=", path) print("connected components record:", record) start_time = time.perf_counter() cc = nx.strongly_connected_components(G=g_nx) end_time = time.perf_counter() record = end_time - start_time # print("g_30000_240000_1 networkx result:") # print("strongly_connected_components(G=g)", cc) print("networkx connected components record:", record) connected_component_result = [] start_time = time.perf_counter() cc = graph.connected_component(1) end_time = time.perf_counter() record = end_time - start_time # print("connected_component(1)", cc) connected_component_result.append(record) start_time = time.perf_counter() cc = graph.connected_component(2) end_time = time.perf_counter() record = end_time - start_time # print("connected_component(2)", cc) connected_component_result.append(record) start_time = time.perf_counter() cc = graph.connected_component(3) end_time = time.perf_counter() record = end_time - start_time # print("connected_component(3)", cc) connected_component_result.append(record) start_time = time.perf_counter() cc = graph.connected_component(4) end_time = time.perf_counter() record = end_time - start_time # print("connected_component(4)", cc) connected_component_result.append(record) start_time = time.perf_counter() cc = graph.connected_component(5) end_time = time.perf_counter() record = end_time - start_time connected_component_result.append(record) # print("connected_component(5)", cc) result = sum(connected_component_result) / len(connected_component_result) print("connected component record:", result)
costless_warehouse_id = None costless_warehouse_cost = INF for ii in range(len(warehouses_ids_list)): warehouse_id = warehouses_ids_list[ii] warehouse_supply = warehouse_supply_list[ii] # print(warehouse_id, " ", warehouse_supply) if warehouse_supply > 0: curr_path = nx.shortest_path(graph, source=truck_curr_node, target=warehouse_id, weight="cost") curr_path_length = nx.shortest_path_length( graph, source=truck_curr_node, target=warehouse_id, weight="cost") if _log_alg: # log or not save_path_algo.write( "--- current W id: {}\n".format(warehouse_id)) save_path_algo.write( "--- path to current W: {}\n".format(curr_path)) save_path_algo.write( "--- path cost: {}\n\n".format(curr_path_length)) if curr_path_length < costless_warehouse_cost: costless_warehouse_cost = curr_path_length costless_warehouse_id = warehouse_id path_to_go = curr_path # save_path_algo.write("--- GOTO: costless warehouse to go: {}\n".format(costless_warehouse_id)) if _log_alg:
from path_ring import make_ring_lattice def shortest_path_dijkstra(G, source): """A fast version of Dijkstra's algorithm for equal edges.""" new_dist = 0 dist = {} nextlevel = {source} while nextlevel: thislevel = nextlevel nextlevel = set() for v in thislevel: if v not in dist: dist[v] = new_dist nextlevel.update(G[v]) new_dist += 1 return dist lattice = make_ring_lattice(10, 4) d1 = shortest_path_dijkstra(lattice, 0) print(d1) # {0: 0, 8: 1, 1: 1, 2: 1, 9: 1, 6: 2, 7: 2, 3: 2, 4: 2, 5: 3} d2 = nx.shortest_path_length(lattice, 0) print(d2) # {0: 0, 8: 1, 1: 1, 2: 1, 9: 1, 6: 2, 7: 2, 3: 2, 4: 2, 5: 3} # %timeit shortest_path_dijkstra(lattice, 0) # 1.51 ms ± 9.93 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) # %timeit nx.shortest_path_length(lattice, 0) # 3.7 ms ± 49.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
def shortest_path(m, n): return nx.shortest_path_length(G, m, n)
def tooFarAway(self, G, node): if nx.shortest_path_length(G, node, self.home) > 6: return True return False
def __targets_to_source_distances(self, graph, node_index): if self.edge_type == 'unweighted': __dicts = nx.shortest_path_length(graph, target=node_index) else: __dicts = nx.shortest_path_length(graph, target=node_index, weight=self.weight_name) return __dicts
def path_length(G, u, v): return nx.shortest_path_length(G, v, u, weight='path_length')
elif text[i] == '|': current_node = start_node elif text[i] == '$': return current_node, i i += 1 return current_node, i # expr = '''^WNE$''' # expr = '''^ENWWW(NEEE|SSE(EE|N))$''' # expr = '''^ENNWSWW(NEWS|)SSSEEN(WNSE|)EE(SWEN|)NNN$''' # expr = '''^ESSWWN(E|NNENN(EESS(WNSE|)SSS|WWWSSSSE(SW|NNNE)))$''' expr = open('input.txt').read().strip() start_node = (0, 0) ROUTES.add_node(start_node) end_node, _ = parse_tree(expr[1:], start_node) import matplotlib.pyplot as plt nx.draw_networkx(ROUTES, pos={n: n for n in ROUTES.nodes()}) plt.show() shortest_paths = nx.shortest_path_length(ROUTES, start_node) print('solution 1:', max(shortest_paths.values())) print(len(list(filter(lambda k: shortest_paths[k] >= 1000, shortest_paths))))
def part2(graph, lr): return networkx.shortest_path_length(graph, (0, 0), lr, "risk")
G = nx.Graph() for x in range(NUM): G.add_node(chr(ord('0') + x)) for x in range(NUM): paths = find_paths(chr(ord('0') + x), grid) for p in paths: G.add_edge(chr(ord('0') + x), p, weight=paths[p]) tsp = 9999999999999 for path in permutations(G.nodes()): cost = 0 if path[0] != '0': continue for i in range(len(path) - 1): cost += nx.shortest_path_length(G, path[i], path[i + 1], 'weight') if cost < tsp: tsp = cost #print(tsp,path) print('part1', tsp) tsp = 9999999999999 for path in permutations(G.nodes()): cost = 0 if path[0] != '0': continue path += ('0', ) for i in range(len(path) - 1): cost += nx.shortest_path_length(G, path[i], path[i + 1], 'weight') if cost < tsp: tsp = cost
def get_path_distance(self, source: str, target: str): return nx.shortest_path_length(self._G, source=source, target=target, weight="distance")
# if os.path.exists("test.gpickle.gz"): # start_time = time.time() # G = nx.read_gpickle("test.gpickle.gz") # print time.time() - start_time # else: w = 'score' G = nx.Graph() G.add_path([0, 1], weight=1, score=100) G.add_path([1, 2], weight=2, score=200) G.add_path([1, 3], weight=1, score=100) G.add_path([2, 4], weight=3, score=300) G.add_path([3, 5], weight=1, score=100) G.add_path([5, 4], weight=1, score=100) f = 2 t = 5 print nx.shortest_path_length(G, f, t, weight=w) print[p for p in nx.all_shortest_paths(G, f, t, weight=w)] # # with open(tf_network_path) as nfh: # G = nx.DiGraph() # cnt = 0 # for line in nfh: # (a, b, score, pvalue) = line.split("\t") # G.add_path([a.lower(), b.lower()]) # cnt += 1 # if cnt % 10000 == 0: # print cnt # shorts = [p for p in nx.all_shortest_paths(G, source=key_from, target=key_to)] # with open(tf_shorts_path, 'w') as ph: # json.dump(shorts, ph)
def comprehensive_test_tasklet(): """Comprehensive test.""" successes = 0 try: yield 0 g = nx.Graph() # Construct a graph for the current topology. for c in sorted(all_cables, key=lambda x: (x.src.entity.name, x.dst.entity.name)): assert c.src, "cable {} has no source".format(c) assert c.dst, "cable {} has no destination".format(c) g.add_node(c.src.entity.name, entity=c.src.entity) g.add_node(c.dst.entity.name, entity=c.dst.entity) g.add_edge(c.src.entity.name, c.dst.entity.name, latency=c.latency) initial_wait = 5 + nx.diameter(g) api.simlog.info( "Waiting for at least %d seconds for initial routes to converge...", initial_wait) yield initial_wait * 1.1 for round in itertools.count(): api.simlog.info("=== Round %d ===", round + 1) num_actions = rand.randint(1, 3) for i in range(num_actions): yield rand.random() * 2 # Wait 0 to 2 seconds. action, u, v = pick_action(g, rand) if action == "del": api.simlog.info( "\tAction %d/%d: remove link %s -- %s" % (i + 1, num_actions, u, v)) g.remove_edge(u, v) g.nodes[u]["entity"].unlinkTo(g.nodes[v]["entity"]) elif action == "add": api.simlog.info("\tAction %d/%d: add link %s -- %s" % (i + 1, num_actions, u, v)) g.add_edge(u, v) g.nodes[u]["entity"].linkTo(g.nodes[v]["entity"]) else: assert False, "unknown action {}".format(action) # Wait for convergence. max_latency = nx.diameter(g) * 1.01 yield max_latency # Send pair-wise pings. assert nx.is_connected(g), "BUG: network partition" expected = defaultdict(dict) # dst -> src -> time deadline = defaultdict(dict) # dst -> src -> time lengths = dict(nx.shortest_path_length(g)) for s in sorted(all_hosts, key=lambda h: h.name): for d in sorted(all_hosts, key=lambda h: h.name): if s is d: continue s.ping(d, data=round) latency = lengths[s.name][d.name] deadline[d][s] = api.current_time() + latency expected[d][s] = api.current_time() + latency * 1.01 # Wait for ping to propagate. yield max_latency for dst in expected: rxed = dst.rxed_pings for src in set(expected[dst].keys()) | set(rxed.keys()): if src not in rxed: api.simlog.error( "\tFAILED: Missing ping: %s -> %s", src, dst) return assert rxed[src] rx_packets = [packet for packet, _ in rxed[src]] if src not in expected[dst]: api.simlog.error( "\tFAILED: Extraneous ping(s): %s -> %s %s", src, dst, rx_packets) return if len(rx_packets) > 1: api.simlog.error( "\tFAILED: Duplicate ping(s): %s -> %s %s", src, dst, rx_packets) return rx_packet = rx_packets[0] assert isinstance(rx_packet, Ping) if rx_packet.data != round: api.simlog.error( "\tFAILED: Ping NOT from current round %d: %s -> %s %s", round, src, dst, rx_packet) return _, actual_time = rxed[src][0] late = actual_time - expected[dst][src] if late > 0: api.simlog.error( "\tFAILED: Ping late by %g sec: %s -> %s %s", actual_time - deadline[dst][src], src, dst, rx_packet) return dst.reset() api.simlog.info("\tSUCCESS!") successes += 1 except Exception as e: api.simlog.error("Exception occurred: %s" % e) traceback.print_exc() finally: sys.exit()
def remove_Cluster(G,target_node,r): g = nx.ego_graph(G,target_node,radius = r, undirected = True, distance = "weight") # gets the subgraph within the radius node_list = list(g.nodes) # gets list of nodes around the supernode within the radius cities = [x for x in node_list if G.nodes[x]["is_city"] == True] # gets a list within the nodes that are cities target_list = [] # list of nodes that have 1 edge connecting to a node outside the radius keep_list = [] # list of nodes that we want to keep inside the radius remove_list = [] # list of nodes within the radius that will be removed check_list = [] # list of nodes inside the radius that have 2 edges connecting to 2 diff nodes outside the radius check_list2 = [] keep_list = keep_list + cities # want to keep cities if target_node not in keep_list: keep_list.append(target_node)# adds center node to the keep list check_nodes = [x for x in node_list if x not in keep_list] # gets nodes that are not city nodes or the target node for i in check_nodes: # loops through list of nodes to check e = list(G.edges(i)) num_outside_nodes = len([x[1] for x in e if x[1] not in node_list]) if num_outside_nodes > 2: keep_list.append(i) elif num_outside_nodes == 2: check_list.append(i) elif num_outside_nodes == 1: target_list.append(i) elif num_outside_nodes == 0: remove_list.append(i) for i in check_list: outside_nodes = [x for x in (list(sum(list(G.edges(i)), ()))) if x not in node_list] # returns the nodes connected to the specific node that are not in the list of nodes within the radius of the target node path = nx.shortest_path(G, source = outside_nodes[0] , target = outside_nodes[1], weight = "weight") # finds the shortest path between the two nodes outside the radius if set(path) != set([outside_nodes[0],outside_nodes[1],i]): #checks to see if the shortest path between the two outside nodes are the 2 and the specific node for n in outside_nodes: # loops through each outside node path_to_center = nx.shortest_path(G, source = i, target = target_node, weight = "weight") # finds the shortest path between the two nodes outside the radius closest_keep = [p for p in path_to_center if p in keep_list] # gets the list of nodes in the pathway that does for j in closest_keep: if not(G.has_edge(j,n)): new_dist = G[i][n]["weight"] + nx.shortest_path_length(G, source = i, target = j, weight = "weight") # finds the shortest path between the two nodes outside the radius G.add_edge(n,j,weight = new_dist, gmv = 0) break else: keep_list.append(i) check_list2.append(i) for i in target_list: node = [x for x in (list(sum(list(G.edges(i)), ()))) if x not in node_list] # returns the nodes connected to the specific node that are not in the list of nodes within the radius of the target node n = node[0] path_to_center = nx.shortest_path(G, source = i, target = target_node, weight = "weight") closest_keep = [p for p in path_to_center if p in keep_list] # gets the list of nodes in the pathway that does for j in closest_keep: if not(G.has_edge(j,n)): new_dist = G[i][n]["weight"] + nx.shortest_path_length(G, source = i, target = j, weight = "weight") # finds the shortest path between the two nodes outside the radius G.add_edge(n,j,weight = new_dist, gmv = 0) break for i in keep_list: # for nodes inside the radius but not directly connected to the center node, ensures there is a path to it path = nx.shortest_path(G, i, target_node, weight = "weight") if not(all(item in keep_list for item in path)): length = nx.shortest_path_length(G, i , target_node, weight = "weight") G.add_edge(i,target_node, weight = length, gmv = 0) for i in check_list2: check_list.remove(i) G.remove_nodes_from(target_list) G.remove_nodes_from(remove_list) G.remove_nodes_from(check_list)
def kamada_kawai_layout(G, dist=None, pos=None, weight='weight', scale=1, center=None, dim=2): """Position nodes using Kamada-Kawai path-length cost-function. Parameters ---------- G : NetworkX graph or list of nodes A position will be assigned to every node in G. dist : float (default=None) A two-level dictionary of optimal distances between nodes, indexed by source and destination node. If None, the distance is computed using shortest_path_length(). pos : dict or None optional (default=None) Initial positions for nodes as a dictionary with node as keys and values as a coordinate list or tuple. If None, then use circular_layout() for dim >= 2 and a linear layout for dim == 1. weight : string or None optional (default='weight') The edge attribute that holds the numerical value used for the edge weight. If None, then all edge weights are 1. scale : number (default: 1) Scale factor for positions. center : array-like or None Coordinate pair around which to center the layout. dim : int Dimension of layout. Returns ------- pos : dict A dictionary of positions keyed by node Examples -------- >>> G = nx.path_graph(4) >>> pos = nx.kamada_kawai_layout(G) """ import numpy as np G, center = _process_params(G, center, dim) nNodes = len(G) if dist is None: dist = dict(nx.shortest_path_length(G, weight=weight)) dist_mtx = 1e6 * np.ones((nNodes, nNodes)) for row, nr in enumerate(G): if nr not in dist: continue rdist = dist[nr] for col, nc in enumerate(G): if nc not in rdist: continue dist_mtx[row][col] = rdist[nc] if pos is None: if dim >= 2: pos = circular_layout(G, dim=dim) else: pos = {n: pt for n, pt in zip(G, np.linspace(0, 1, len(G)))} pos_arr = np.array([pos[n] for n in G]) pos = _kamada_kawai_solve(dist_mtx, pos_arr, dim) pos = rescale_layout(pos, scale=scale) + center return dict(zip(G, pos))
for i in range(N_RA): edges = [(i, t) for t in super_synapses[i]] DG.add_edges_from(edges) distances = np.zeros(N_RA, np.int32) #distances = np.empty(N_RA, np.int32) #distances.fill(np.nan) for i in range(N_RA): if i not in training_neurons: smallest_distance = 10000 for j in training_neurons: try: d = nx.shortest_path_length(DG, source=j, target=i) if d < smallest_distance: smallest_distance = d except nx.NetworkXNoPath: continue if smallest_distance == 10000: print "No path to training neurons was found for neuron", i else: distances[i] = smallest_distance indsorted = np.argsort(first_spike_times[(mature_indicators > 0) & (first_spike_times > 0)]) plt.figure() plt.plot(
def FDT2CDG(cfg: nx.DiGraph, if_id, node_infos): leafs = [] control_dep_edge = {} cdg_edges = [] idoms = nx.algorithms.immediate_dominators(cfg, "0") print("后向支配关系:", idoms) # 查询当前cfg所有叶子节点 for cfg_node in cfg.nodes: if cfg.out_degree(cfg_node) == 0: # 叶子节点列表 leafs.append(cfg_node) cfg.add_node("EXIT_POINT", label="EXIT_POINT") for leaf_node in leafs: cfg.add_edge(leaf_node, "EXIT_POINT") get_graph_png(cfg, "cfg") reverse_cfg = cfg.reverse() get_graph_png(reverse_cfg, "reverse") ifdoms = nx.algorithms.immediate_dominators(reverse_cfg, "EXIT_POINT") del ifdoms["EXIT_POINT"] print("前向支配关系:", ifdoms) # FDT fdt = nx.DiGraph(name=cfg.graph["name"]) fdt.add_nodes_from(reverse_cfg.nodes) for s in ifdoms: fdt.add_edge(ifdoms[s], s) get_graph_png(fdt, "fdt") # CDG = CFG + FDT 计算 条件语句相关控制依赖 for id in if_id: ifdom = ifdoms[str(id)] print("ifdom of {} is {}".format(id, ifdom)) cfg_paths = nx.all_simple_paths(cfg, source=str(id), target="EXIT_POINT") # Y is control dependent on X ⇔ there is a path in the CFG from X to Y that doesn’t contain the immediate # forward dominator of X for path in list(cfg_paths): for node in path[1:-1]: node_info = node_infos[node] if node_info.type != NodeType.ENDIF and node_info.type != NodeType.ENDLOOP: if node != ifdom: key = "{}-{}".format(node, str(id)) if key not in control_dep_edge: control_dep_edge[key] = 1 length = nx.shortest_path_length( cfg, str(id), node) cdg_edges.append({ 'from': node, "to": str(id), 'color': 'red', 'distance': length }) print("{} 控制依赖于 {}, 距离是: {}".format( node, id, length)) else: break control_dep_edge.clear() for cdg_edge in cdg_edges: from_node = cdg_edge["from"] to_node = cdg_edge["to"] distance = cdg_edge["distance"] if from_node not in control_dep_edge: control_dep_edge[from_node] = {"to": to_node, "distance": distance} else: old_distance = control_dep_edge[from_node]["distance"] if old_distance > distance: control_dep_edge[from_node] = { "to": to_node, "distance": distance } for from_node in control_dep_edge: cfg.add_edge(from_node, control_dep_edge[from_node]["to"], color="red") get_graph_png(cfg, "cdg")
input_lines = list(fileinput.input()) designer_number = int(input_lines[0].strip()) def wall(x, y): return (bin(x * x + 3 * x + 2 * x * y + y + y * y + designer_number)[2:].count("1") % 2 == 1) source = (1, 1) target = (31, 39) maze = networkx.Graph() diagonal = 0 distance = float("inf") while 2 * diagonal - sum(source) - sum(target) < distance: for x in range(0, diagonal + 1): y = diagonal - x if not wall(x, y): maze.add_node((x, y)) if (x - 1, y) in maze.nodes(): maze.add_edge((x, y), (x - 1, y)) if (x, y - 1) in maze.nodes(): maze.add_edge((x, y), (x, y - 1)) if diagonal >= sum(target) and networkx.has_path(maze, source, target): distance = min(networkx.shortest_path_length(maze, source, target), distance) diagonal += 1 print(distance)
def get_shortest_path_dict(self): ''' returns the dict od dict of shortest path lengths, if it does not exist, it creates it''' if self.shortest_path_dict is None: self.shortest_path_dict = nx.shortest_path_length(self) return self.shortest_path_dict
def get_nodes_from_db(graph): graph = connect_graph() matcher = NodeMatcher(graph) nodes = list(matcher.match('COORDINATE')) nodes_data = [] for node in nodes: node_json = {'longitude': node['longitude'], 'latitude': node['latitude'], 'pk': node['pk']} nodes_data.append(node_json) return nodes_data if __name__ == '__main__': neo4j_graph = connect_graph() G = nx.MultiDiGraph() add_nodes(G, get_nodes_from_db(neo4j_graph)) add_rels(G, get_rels_from_db(neo4j_graph)) site_pairs = get_sites() for site_pair in site_pairs: node_id_from = site_pair['node_id_from'] node_id_to = site_pair['node_id_to'] try: path = nx.shortest_path_length(G, node_id_from, node_id_to, weight='time') print(node_id_from, node_id_to) except Exception as e: print(e) continue
maxX = len(rows[0]) maxY = len(rows) goals = dict() distances = dict() G = networkx.generators.classic.grid_2d_graph(maxY, maxX) for y, row in enumerate(rows): for x, pos in enumerate(row): if pos == "#": G.remove_node((y,x)) if pos.isdigit(): goals[int(pos)] = (y,x) for y in range(8): for x in range(8): distances[y,x] = networkx.shortest_path_length(G, goals[y], goals[x]) distances[x,y] = distances[y,x] shortest = -1 for path in permutations(range(1,8)): l = [0] + list(path) pathDist = 0 for i in range(len(l)-1): pathDist += distances[l[i+1], l[i]] if shortest > 0: shortest = min(pathDist, shortest) else: shortest = pathDist print "Part one: " + str(shortest)