def test_articulation_points_resnet(): """Make sure articulation points are found correctly in resnet.""" tf.reset_default_graph() nodes = util.make_resnet(3) all_ops = ge.get_forward_walk_ops(seed_ops=nodes[0].op) graph = nx.Graph(util.tf_ops_to_graph(all_ops)) assert util.set_equal(util.format_ops(nx.articulation_points(graph)), ['a01_add']) tf.reset_default_graph() nodes = util.make_resnet(4) all_ops = ge.get_forward_walk_ops(seed_ops=nodes[0].op) graph = nx.Graph(util.tf_ops_to_graph(all_ops)) assert util.set_equal(util.format_ops(nx.articulation_points(graph)), ['a01_add', 'a02_add'])
def test_articulation_points(): Ggen = _generate_no_biconnected() for i in range(5): G = next(Ggen) cut = nx.minimum_node_cut(G) assert_true(len(cut) == 1) assert_true(cut.pop() in set(nx.articulation_points(G)))
def test_articulation_points(): Ggen = _generate_no_biconnected() for i in range(2): G = next(Ggen) articulation_points = list({a} for a in nx.articulation_points(G)) for cut in nx.all_node_cuts(G): assert_true(cut in articulation_points)
def get_randomdeletion_graph(network, filename, count): while len(network) > count: toRemove = numpy.random.choice(network.nodes()) if toRemove not in nx.articulation_points(network): network.remove_node(toRemove) fh.write_edge_list("%s-RD.txt" % filename, network)
def test_articulation_points(): Ggen = _generate_no_biconnected() for i in range(1): # change 1 to 3 or more for more realizations. G = next(Ggen) articulation_points = list({a} for a in nx.articulation_points(G)) for cut in nx.all_node_cuts(G): assert_true(cut in articulation_points)
def block_cutpoint_tree(G, projected=False, verbose=False): input_graph = Graph(G) top_nodes = [] bottom_nodes = [] articulation_points = set(nx.articulation_points(input_graph)) if verbose: print "Articulation points:", articulation_points for biconnected_component in nx.biconnected_components(input_graph): inter = biconnected_component.intersection(articulation_points) if verbose: print "Inter:", inter top_nodes.extend( [json.dumps(sorted(biconnected_component)) for _ in inter] ) #top_nodes.extend([G.subgraph(bcc) for _ in inter]) bottom_nodes.extend([x for x in inter]) #bottom_nodes.extend([G.subgraph(x) for x in inter]) if verbose: print "Top nodes:", top_nodes print "Bottom nodes:", bottom_nodes edges = zip(top_nodes, bottom_nodes) if verbose: print "Edges:", edges bc_tree = Graph() bc_tree.add_edges_from(edges) if projected: return Graph(bipartite.projected_graph(bc_tree, top_nodes)) else: return bc_tree
def _singleSegment(self, nodes): # disjoint line or a bent line at 45 degrees appearing as dichtonomous tree but an error due to # improper binarization, so remove them and do not account for statistics listOfPerms = list(itertools.combinations(nodes, 2)) if type(nodes[0]) == int: modulus = [[start - end] for start, end in listOfPerms] dists = [abs(i[0]) for i in modulus] else: dims = len(nodes[0]) modulus = [[start[dim] - end[dim] for dim in range(0, dims)] for start, end in listOfPerms] dists = [sum(modulus[i][dim] * modulus[i][dim] for dim in range(0, dims)) for i in range(0, len(modulus))] if len(list(nx.articulation_points(self._subGraphSkeleton))) == 1 and set(dists) != 1: # each node is connected to one or two other nodes which are not a distance of 1 implies there is a # one branch point with two end points in a single dichotomous tree""" for sourceOnTree, item in listOfPerms: if nx.has_path(self._subGraphSkeleton, sourceOnTree, item) and sourceOnTree != item: simplePaths = list(nx.all_simple_paths(self._subGraphSkeleton, source=sourceOnTree, target=item)) simplePath = simplePaths[0] countBranchNodesOnPath = sum([1 for point in simplePath if point in nodes]) if countBranchNodesOnPath == 2: curveLength = self._getLengthAndRemoveTracedPath(simplePath) self.isolatedEdgeInfoDict[sourceOnTree, item] = curveLength else: # each node is connected to one or two other nodes implies it is a line, endPoints = [k for (k, v) in self._nodeDegreeDict.items() if v == 1] sourceOnLine = endPoints[0] targetOnLine = endPoints[1] simplePath = nx.shortest_path(self._subGraphSkeleton, source=sourceOnLine, target=targetOnLine) curveLength = self._getLengthAndRemoveTracedPath(simplePath) self.isolatedEdgeInfoDict[sourceOnLine, targetOnLine] = curveLength
def test_articulation_points(): Ggen = _generate_no_biconnected() for flow_func in flow_funcs: for i in range(3): G = next(Ggen) cut = nx.minimum_node_cut(G, flow_func=flow_func) assert_true(len(cut) == 1, msg=msg.format(flow_func.__name__)) assert_true(cut.pop() in set(nx.articulation_points(G)), msg=msg.format(flow_func.__name__))
def graph_stats(self, n): stats = {} stats['Top'] = self.top_nodes(n+1) stats['Pagerank'] = nx.pagerank_scipy(self.G) stats['Pagerank'] = sorted(stats['Pagerank'].iteritems(), key=itemgetter(1),reverse=True)[0:n+1] stats['Articulation Points'] = list(nx.articulation_points(self.G.to_undirected())) stats['Histogram'] = self.degree_histogram()[1:26] return stats
def test_biconnected_karate(): K = nx.karate_club_graph() answer = [{0, 1, 2, 3, 7, 8, 9, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33}, {0, 4, 5, 6, 10, 16}, {0, 11}] bcc = list(nx.biconnected_components(K)) assert_components_equal(bcc, answer) assert_equal(set(nx.articulation_points(K)), {0})
def sorted_articulation_points(targets): """Returns list of articulation points (cut vertices) sorted in according to the execution order provided by linearize.""" graph, targets = _process_targets(targets) sorted_list = list(obtain_linear_order(targets)) nx_graph = nx.Graph(graph) points = _sort(nx.articulation_points(nx_graph), total_order=sorted_list, dedup=True) return points
def articulationpoints(args): """Compute articulation points in subgraphs of the graph. Parameters ---------- graphname : str Refers to pre-computed graphs stored in folder, with the name being the first element. edgefilter : str (default="families") Refers to second component of filename, thus, the component managing how edges are created and defined (here: language families as a default). subgraph : str (default="infomap") Determines the name of the subgraph that is used to pre-filter the search for articulation points. Defaults to the infomap-algorithms. threshold : int (default=1) The threshold which was used to calculate the community detection analaysis. Note ---- Method searches for articulation points inside partitions of the graph, usually the partitions as provided by the infomap algorithm. The repository stores graph data in different forms, as binary graph and as gml, and the paramters are used to identify a given analysis by its filename and make sure the correct graph is loaded. """ args.api._log = args.log threshold = args.threshold or 1 graph = args.api.load_graph('infomap', threshold, args.edgefilter) coms = defaultdict(list) for node, data in graph.nodes(data=True): coms[data['infomap']].append(node) for com, nodes in sorted(coms.items(), key=lambda x: len(x), reverse=True): if len(nodes) > 5: subgraph = graph.subgraph(nodes) degrees = subgraph.degree(list(subgraph.nodes())) cnode = [a for a, b in sorted(degrees, key=lambda x: x[1], reverse=True)][0] graph.node[cnode]['DegreeCentrality'] = 1 for artip in nx.articulation_points(subgraph): graph.node[artip]['ArticulationPoint'] = \ graph.node[artip].get('ArticulationPoint', 0) + 1 if bool(args.verbosity): print('{0}\t{1}\t{2}'.format( com, graph.node[cnode]['Gloss'], graph.node[artip]['Gloss'])) for node, data in graph.nodes(data=True): data.setdefault('ArticulationPoint', 0) data.setdefault('DegreeCentrality', 0) args.api.save_graph(graph, 'articulationpoints', threshold, args.edgefilter)
def test_biconnected_components1(): # graph example from # http://www.ibluemojo.com/school/articul_algorithm.html edges=[ (0, 1), (0, 5), (0, 6), (0, 14), (1, 5), (1, 6), (1, 14), (2, 4), (2, 10), (3, 4), (3, 15), (4, 6), (4, 7), (4, 10), (5, 14), (6, 14), (7, 9), (8, 9), (8, 12), (8, 13), (10, 15), (11, 12), (11, 13), (12, 13) ] G=nx.Graph(edges) pts = set(nx.articulation_points(G)) assert_equal(pts, {4, 6, 7, 8, 9}) comps = list(nx.biconnected_component_edges(G)) answer = [ [(3, 4), (15, 3), (10, 15), (10, 4), (2, 10), (4, 2)], [(13, 12), (13, 8), (11, 13), (12, 11), (8, 12)], [(9, 8)], [(7, 9)], [(4, 7)], [(6, 4)], [(14, 0), (5, 1), (5, 0), (14, 5), (14, 1), (6, 14), (6, 0), (1, 6), (0, 1)], ] assert_components_edges_equal(comps, answer)
def cut_control(seed_num, graph_json_filename=None, graph_json_str=None): """ Randomly choose 'seed_num' number of cut-vertices from the given graph. If there are fewer cut vertices than 'seed_num' then choose the vertices adjacent to cut vertices . Parameters: seed_num: Number of nodes to choose. graph_json_filename: Filename where the adjacency list lives as JSON. graph_json_str: Graph as an adjacency list string in JSON. Return: List of the chosen nodes. """ if graph_json_filename is None and graph_json_str is None: return [] G = None if graph_json_str is None: G = util.load_graph(graph_json_filename=graph_json_filename) else: G = util.load_graph(graph_json_str=graph_json_str) iters_since_change = 0 cut_vertices = list(set(nx.articulation_points(G))) while (len(cut_vertices) < seed_num): rand_node = cut_vertices[rand.randint(0, len(cut_vertices) - 1)] adj_node_lst = G.neighbors(rand_node) rand_adj_node = adj_node_lst[rand.randint(0, len(adj_node_lst) - 1)] if (rand_adj_node not in cut_vertices): iters_since_change = 0 cut_vertices.append(rand_adj_node) else: iters_since_change = iters_since_change + 1 if (iters_since_change > 10): break return cut_vertices[0:seed_num]
def spofs(gr): """Identifies the SPOF nodes (single points of failure) in a topology, and the downstream nodes that will be isolated from the majority of the network when any of the SPOFs fail. Takes a NetworkX Graph or DiGraph as input, returns a dictionary of two lists: 1. a list of SPOF nodes (single points of failure) 2. a list of downstream nodes that will become isolated when SPOFs fail.""" if type(gr) != type(nx.Graph()): gr = gr.to_undirected(gr) # structure: # {'spofs':[node1, node2,...,nodeN], 'isolated':[node1, node2,...,nodeN]} impacts = {} impacts['spofs'] = list(nx.articulation_points(gr)) impacts['isolated'] = [] for spof in impacts['spofs']: gr_tmp = gr.copy() gr_tmp.remove_node(spof) ccomp = nx.connected_components(gr_tmp) ccomp.sort(key=len) for sublist in range(len(ccomp)-1): for node in ccomp[sublist]: if not node in impacts['isolated']: impacts['isolated'].append(node) return impacts
def articulation_points(graph): return graph, nx.articulation_points(graph)
def test_articulation_points_cycle(): G = nx.cycle_graph(3) nx.add_cycle(G, [1, 3, 4]) pts = set(nx.articulation_points(G)) assert pts == {1}
cpterr+=1 except ValueError: cpterr+=1 links = [] # NetworkX graph G=nx.Graph() for sensor in sensorlist: G.add_node(sensor) for edge in linklist: G.add_edge(edge[0], edge[1], weight=edge[2]) # We remove articulation points if int(MODIF) == -1: for H in list(nx.connected_component_subgraphs(G)): for sensor in list(nx.articulation_points(H)): pos[sensor] = (-1,-1) if os.path.isfile(SENSORS_DATA): os.remove(SENSORS_DATA) det_file = open(SENSORS_DATA, "a+") for i in set(pos.keys()): posx = float(pos[i][0]) posy = float(pos[i][1]) if posx != -1 and posy != -1: print >> det_file, str(posx) + ',' + str(posy) det_file.close()
for stridx in strategies: start_graph_path = expdir + '/nuc0-' + str(masteridx) + '_' + expname +\ '/' + str(stridx) + '/olsrd2_vanilla/start_graph.graphml' strategy_path = expdir + '/nuc0-' + str(masteridx) + '_' + expname +\ '/' + str(stridx) + '/prince/strategies' deadnode_id = '' deadnode_name = '' with open(strategy_path, 'r') as df: line = df.read() deadnode_id = line.split('@')[0] sg = nx.read_graphml(start_graph_path) ap = [x for x in nx.articulation_points(sg)] no_leaves_nodes = nx.k_core(sg, 2).nodes() cn = [x for x in sg.nodes() if x not in ap and x in no_leaves_nodes] node_ip_to_name = {} node_name_to_ip = {} for i in range(1, 100): node_ip_to_name['10.1.0.' + str(i)] = 'nuc0-' + str(i) node_name_to_ip['nuc0-' + str(i)] = '10.1.0.' + str(i) deadnode_name = node_ip_to_name[deadnode_id] bcn = nx.betweenness_centrality(sg, weight='weight', endpoints=True) bcns = [(node_ip_to_name[n], bcn[n]) for ( n, bcn[n]) in sorted(bcn.items(), key=lambda x: x[1], reverse=True) ]
def topographic_metrics(wn): # Get a copy of the graph G = wn.get_graph() # Print general topographic information print(nx.info(G)) # Plot node and edge attributes. junction_attr = wn.query_node_attribute('elevation', node_type=wntr.network.Junction) pipe_attr = wn.query_link_attribute('length', link_type=wntr.network.Pipe) wntr.graphics.plot_network(wn, node_attribute=junction_attr, link_attribute=pipe_attr, title='Node elevation and pipe length', node_size=40, link_width=2) # Compute link density print("Link density: " + str(nx.density(G))) # Compute node degree node_degree = dict(G.degree()) wntr.graphics.plot_network(wn, node_attribute=node_degree, title='Node Degree', node_size=40, node_range=[1, 5]) # Compute number of terminal nodes terminal_nodes = G.terminal_nodes() wntr.graphics.plot_network(wn, node_attribute=terminal_nodes, title='Terminal nodes', node_size=40, node_range=[0, 1]) print("Number of terminal nodes: " + str(len(terminal_nodes))) print(" " + str(terminal_nodes)) # Compute pipes with diameter > threshold diameter = 0.508 # m (20 inches) pipes = wn.query_link_attribute('diameter', np.greater, diameter) wntr.graphics.plot_network(wn, link_attribute=list(pipes.keys()), title='Pipes > 20 inches', link_width=2, link_range=[0, 1]) print("Number of pipes > 20 inches: " + str(len(pipes))) print(" " + str(pipes)) # Compute nodes with elevation <= treshold elevation = 1.524 # m (5 feet) nodes = wn.query_node_attribute('elevation', np.less_equal, elevation) wntr.graphics.plot_network(wn, node_attribute=list(nodes.keys()), title='Nodes <= 5 ft elevation', node_size=40, node_range=[0, 1]) print("Number of nodes <= 5 ft elevation: " + str(len(nodes))) print(" " + str(nodes)) # Compute eccentricity, diameter, and average shortest path length # These all use an undirected graph uG = G.to_undirected() # undirected graph if nx.is_connected(uG): ecc = nx.eccentricity(uG) wntr.graphics.plot_network(wn, node_attribute=ecc, title='Eccentricity', node_size=40, node_range=[15, 30]) print("Diameter: " + str(nx.diameter(uG))) ASPL = nx.average_shortest_path_length(uG) print("Average shortest path length: " + str(ASPL)) # Compute cluster coefficient clust_coefficients = nx.clustering(nx.Graph(G)) wntr.graphics.plot_network(wn, node_attribute=clust_coefficients, title='Clustering Coefficient', node_size=40) # Compute betweenness centrality bet_cen = nx.betweenness_centrality(G) wntr.graphics.plot_network(wn, node_attribute=bet_cen, title='Betweenness Centrality', node_size=40, node_range=[0, 0.4]) central_pt_dom = G.central_point_dominance() print("Central point dominance: " + str(central_pt_dom)) # Compute articulation points Nap = list(nx.articulation_points(uG)) Nap = list(set(Nap)) # get the unique nodes in Nap Nap_density = float(len(Nap)) / uG.number_of_nodes() print("Density of articulation points: " + str(Nap_density)) wntr.graphics.plot_network(wn, node_attribute=Nap, title='Articulation Point', node_size=40, node_range=[0, 1]) # Compute bridges bridges = G.bridges() wntr.graphics.plot_network(wn, link_attribute=bridges, title='Bridges', link_width=2, link_range=[0, 1]) Nbr_density = float(len(bridges)) / G.number_of_edges() print("Density of bridges: " + str(Nbr_density)) # Compute spectal gap spectral_gap = G.spectral_gap() print("Spectal gap: " + str(spectral_gap)) # Compute algebraic connectivity alg_con = G.algebraic_connectivity() print("Algebraic connectivity: " + str(alg_con)) # Critical ratio of defragmentation fc = G.critical_ratio_defrag() print("Critical ratio of defragmentation: " + str(fc)) # Compute closeness centrality clo_cen = nx.closeness_centrality(G) wntr.graphics.plot_network(wn, node_attribute=clo_cen, title='Closeness Centrality', node_size=40)
def test_biconnected_davis(): D = nx.davis_southern_women_graph() bcc = list(nx.biconnected_components(D))[0] assert_true(set(D) == bcc) # All nodes in a giant bicomponent # So no articulation points assert_equal(len(list(nx.articulation_points(D))), 0)
def articulation_avoidance(segmentation_graph, segment_counts): # This implementation of Articulation Avoidance is different from the one proposed in the paper # It uses additional heuristics to reduce the number of questions further by ~3% # The data provided, however, is for bins generated without using these additional heuristics n = segmentation_graph.number_of_nodes() m = segmentation_graph.number_of_edges() groups = [] # list of all final groups count_groups = [] remaining_nodes = G.nodes() H = segmentation_graph.copy() cutpoints = list(nx.articulation_points(H)) # picking group starting nodes in sequence for now while len(remaining_nodes) > 0: new_center = -1 # first node in new group new_group = [] for i in remaining_nodes: if i not in cutpoints: new_center = i remaining_nodes.remove(i) H.remove_node(i) cutpoints = list(nx.articulation_points(H)) break # if no remaining non-cutpoints if new_center == -1: new_center = remaining_nodes.pop() H.remove_node(new_center) cutpoints = list(nx.articulation_points(H)) # form new group new_group.append(new_center) current_size = segment_counts[new_center] regular_neighbors = [] # non Articulation Points cutpoint_neighbors = [] # Articulation Points for node in segmentation_graph.neighbors(new_center): if node in remaining_nodes: if node in cutpoints: cutpoint_neighbors.append(node) else: regular_neighbors.append(node) max_segment_size = int(math.floor(WORKER_COUNT_THRESHOLD * 1.0 / max(segment_counts.values()))) * max( segment_counts.values() ) while current_size < max_segment_size and len(regular_neighbors) + len(cutpoint_neighbors) > 0: if regular_neighbors: add_next = regular_neighbors.pop() else: add_next = cutpoint_neighbors.pop() if (add_next in remaining_nodes) and (segment_counts[add_next] + current_size <= max_segment_size): H.remove_node(add_next) cutpoints = list(nx.articulation_points(H)) # Recompute cutpoint_neighbors and regular_neighbors for vertex in cutpoint_neighbors: if vertex not in cutpoints: cutpoint_neighbors.remove(vertex) regular_neighbors.append(vertex) for vertex in regular_neighbors: if vertex in cutpoints: cutpoint_neighbors.append(vertex) regular_neighbors.remove(vertex) new_group.append(add_next) current_size += segment_counts[add_next] remaining_nodes.remove(add_next) for node in segmentation_graph.neighbors(add_next): if node in remaining_nodes: if node in cutpoints: cutpoint_neighbors.append(node) else: regular_neighbors.append(node) groups.append(new_group) count_groups.append(current_size) return groups, count_groups
yfit = lambda x: np.exp(poly(np.log(x))) plt.loglog(x,yfit(x)) plt.legend(['degree-distribution','Fit-line']) plt.xlabel('Degree') plt.ylabel('Number of nodes') plt.title('deg distribution') plt.savefig('deg distribution.pdf') plt.show() plt.close() print "Exponents are b", a,"loga",b #Find the number of bridges in the graph #print list(nx.articulation_points(G)) nbr = len(list(nx.articulation_points(G))) print "No of bridges are ",nbr #Count the number of 3-cycles. In directed graphs, ignore the direction cycls_3 = [c for c in nx.cycle_basis(G) if len(c)==3] print "no of 3 cycles are ",len(cycls_3) #Measure the graph’s diameter. In directed graphs, ignore the direction. print "Diameter of graph is",nx.diameter(G) #Remove x% of edges randomly then: #Compute the size |S| of the largest connected component #Do for x from 1 to 100. Plot x versus |S|. #If you have a directed graph, make it undirected i=0
def GTCannon(self, Graph): """Turn graph into canonical form Note: Relies on NetworkX articulation_points which is restricted to undirected graphs""" # Handle case where graph is empty. if len(Graph.nodes()) == 0: return Graph lex_labeling = self.utility.lexicographicallyLargestLabeling(Graph) Graph = networkx.relabel_nodes(Graph, lex_labeling,copy=True) retGraph = Graph.copy() last_degree = Graph.degree() original_degree = Graph.degree() canon_label = {} label = len(Graph.nodes()) while len(Graph.nodes()) > 0: articulations = list(networkx.articulation_points(Graph.to_undirected())) \ if networkx.is_directed(Graph) else list(networkx.articulation_points(Graph)) current_degrees = temp_degrees = Graph.degree() #Remove articulation points from consideration for nodes in articulations: if nodes in temp_degrees: temp_degrees.pop(nodes) #Sort by degree sorted_degrees = sorted(temp_degrees.iteritems(), key=itemgetter(1)) #Capture min degree candidates = [] u_min = sorted_degrees.pop(0) candidates.append(u_min) #Collect candidates with same degree while len(sorted_degrees) > 0 and sorted_degrees[0][1] == u_min[1]: candidates.append(sorted_degrees.pop(0)) #Are there ties? if len(candidates) > 1: first_tie_candidates = [] sorted_last_degrees = [] for pair in candidates: sorted_last_degrees.append((pair[0],last_degree[pair[0]])) sorted_last_degrees = sorted(sorted_last_degrees, key=itemgetter(1)) u_min = sorted_last_degrees.pop(0) first_tie_candidates.append(u_min) while len(sorted_last_degrees) > 0 and sorted_last_degrees[0][1] == u_min[1]: first_tie_candidates.append(sorted_last_degrees.pop()) #Still ties? if len(first_tie_candidates) > 1: sorted_original_degree = [] for pair in first_tie_candidates: sorted_original_degree.append((pair[0],original_degree[pair[0]])) sorted_original_degree = sorted(sorted_original_degree, key=itemgetter(1)) u_min = sorted_original_degree.pop(0) Graph.remove_node(u_min[0]) canon_label[u_min[0]] = label label -= 1 retGraph = networkx.relabel_nodes(retGraph, canon_label, copy=True) return retGraph
def test_null_graph(): G = nx.Graph() assert not nx.is_biconnected(G) assert list(nx.biconnected_components(G)) == [] assert list(nx.biconnected_component_edges(G)) == [] assert list(nx.articulation_points(G)) == []
def test_biconnected_davis(): D = nx.davis_southern_women_graph() bcc = list(nx.biconnected_components(D))[0] assert set(D) == bcc # All nodes in a giant bicomponent # So no articulation points assert len(list(nx.articulation_points(D))) == 0
def cut_vertices(self): """Return list of cut vertices. Each cut vertex is a node that if removed, with its edges, disconnects the graph.""" return list(nx.articulation_points(self.G))
def compute_2_connected_k_dominating_set(G, DA): graphDA = G.subgraph(DA) DB = DA genB = nx.biconnected_components(graphDA) B = [] for item in genB: B.append(list(item)) # print "B" # print B art_points = list(nx.articulation_points(graphDA)) # print "Articulation Points" # print art_points P = [] while len(B) > 1: for block in B: inducedL = list(set(block) - set(art_points)) L = block # print "L" # print L # print "inducedL" # print inducedL if inducedL: break for v in inducedL: tempDB = list(DB) tempDB.remove(v) # Now for nodes in DA, may need DB for u in list(set(graphDA.nodes()) - set(L)): tempDB.remove(u) newG = G.copy() newG.remove_nodes_from(tempDB) # This part can make the algorithm fail if nx.has_path(newG, v, u): tempP = nx.shortest_path(newG, v, u) P.append(tempP) # print "P" # print P minPath = min(P, key=len) # Keep intermediate nodes of path interPath = list(minPath) interPath.pop(0) interPath.pop(-1) for node in interPath: DB.append(node) # Compute new CDS graph and recalculate B tempGraph = G.subgraph(DB) B = [] for item in genB: B.append(list(item)) genB = nx.biconnected_components(tempGraph) # print "B" # print B art_points = list(nx.articulation_points(tempGraph)) # print "Articulation Points" # print art_points return DB
def new_vertex_selector(local_g, v_pol_local, v_pro_local, list_thr, v_s, agg=max): # --- Define local subgraph with v_pro removed local_vertices = [] local_vertices = list(local_g.nodes()) for v_pro in list(v_pro_local.nodes): local_vertices.remove(v_pro) deleted_subgraph = local_g.subgraph(local_vertices) search_subgraph_list = [] subgraph_list = [] subgraph_list.extend(list_thr) subgraph_list.extend(list(v_pol_local.nodes())) # --- Find subgraph for searching use for v_thr in list_thr: for v_nbr in deleted_subgraph.neighbors(v_thr): if v_nbr in subgraph_list: continue else: subgraph_list.append(v_nbr) search_subgraph_list.append(v_nbr) for rng in range(2): search_list_temp = [] search_list_temp.extend(search_subgraph_list) search_subgraph_list = [] for v_srch in search_list_temp: for v_nbr in deleted_subgraph.neighbors(v_srch): if v_nbr in subgraph_list: continue else: subgraph_list.append(v_nbr) search_subgraph_list.append(v_nbr) # find out which vertex will increase the average distance the most local_vertices_deleted = [] local_vertices_deleted.extend(subgraph_list) local_vertices_deleted.append(v_s) # --- Find Articulation Points that are threatened art_pts = [ x for x in list_thr if x in nx.articulation_points(deleted_subgraph) ] if len(art_pts) > 0: infinity_num_dict = {} # --- First pass through articulation points for art in art_pts: # print('2') # Remove articulation point from graph local_vertices_deleted.remove(art) deleted_subgraph = local_g.subgraph(local_vertices_deleted) # Find connected component containing source c_gen = deleted_subgraph.subgraph( nx.components.node_connected_component(deleted_subgraph, v_s)) # Store number of isolated nodes infinity_num_dict.update( {art: (int(deleted_subgraph.order() - c_gen.order()), c_gen)}) # Return node to local working graph local_vertices_deleted.append(art) # Filter infinity_num_dict by maximum infinity_num_dict = { key: item for key, item in infinity_num_dict.items() if item[0] == max(l[0] for l in infinity_num_dict.values()) } # Find value to return if len(infinity_num_dict) > 1: # If there are more than one *maximum* cuts, find avg paths avg_distance_dict = { key: nx.average_shortest_path_length(item[1].copy()) for key, item in infinity_num_dict.items() } avg_distance_dict = { key: item for key, item in avg_distance_dict.items() if item == max(avg_distance_dict.values()) } return choice(list(avg_distance_dict.keys())) else: return choice(list(infinity_num_dict.keys())) else: avg_distance_list = [] for l in list_thr: local_vertices_deleted.remove(l) deleted_subgraph = local_g.subgraph(local_vertices_deleted) avg_distance_list.append( (l, nx.average_shortest_path_length( deleted_subgraph.subgraph( nx.components.node_connected_component( deleted_subgraph, v_s)).copy()))) local_vertices_deleted.append(l) max_avg_distance = max(l[1] for l in avg_distance_list) max_avg_distance_dict = dict( filter(lambda l: l[1] == max_avg_distance, avg_distance_list)) return choice(list(max_avg_distance_dict.keys()))
def test_articulation_points_cycle(): G=nx.cycle_graph(3) nx.add_cycle(G, [1, 3, 4]) pts=set(nx.articulation_points(G)) assert_equal(pts, {1})
def get_articulation_points(self, nodes): sub_G = self.G.subgraph(nodes) points = nx.articulation_points(sub_G) return list(points)
def topographic_metrics(wn): # Get a copy of the graph G = wn.get_graph_deep_copy() # Print general topographic information print nx.info(G) # Plot node and edge attributes. junction_attr = wn.query_node_attribute('elevation', node_type=wntr.network.Junction) pipe_attr = wn.query_link_attribute('length', link_type=wntr.network.Pipe) wntr.network.draw_graph(wn, node_attribute=junction_attr, link_attribute=pipe_attr, title='Node elevation and pipe length', node_size=40, link_width=2) # Compute link density print "Link density: " + str(nx.density(G)) # Compute node degree node_degree = G.degree() wntr.network.draw_graph(wn, node_attribute=node_degree, title='Node Degree', node_size=40, node_range=[1,5]) # Compute number of terminal nodes terminal_nodes = G.terminal_nodes() wntr.network.draw_graph(wn, node_attribute=terminal_nodes, title='Terminal nodes', node_size=40, node_range=[0,1]) print "Number of terminal nodes: " + str(len(terminal_nodes)) print " " + str(terminal_nodes) # Compute number of non-zero demand (NZD) nodes nzd_nodes = wn.query_node_attribute('base_demand', np.greater, 0.0) wntr.network.draw_graph(wn, node_attribute=nzd_nodes.keys(), title='NZD nodes', node_size=40, node_range=[0,1]) print "Number of NZD nodes: " + str(len(nzd_nodes)) print " " + str(nzd_nodes.keys()) # Compute pipes with diameter > threshold diameter = 0.508 # m (20 inches) pipes = wn.query_link_attribute('diameter', np.greater, diameter) wntr.network.draw_graph(wn, link_attribute=pipes.keys(), title='Pipes > 20 inches', link_width=2, link_range=[0,1]) print "Number of pipes > 20 inches: " + str(len(pipes)) print " " + str(pipes) # Compute nodes with elevation <= treshold elevation = 1.524 # m (5 feet) nodes = wn.query_node_attribute('elevation', np.less_equal, elevation) wntr.network.draw_graph(wn, node_attribute=nodes.keys(), title='Nodes <= 5 ft elevation', node_size=40, node_range=[0,1]) print "Number of nodes <= 5 ft elevation: " + str(len(nodes)) print " " + str(nodes) # Compute eccentricity, diameter, and average shortest path length # These all use an undirected graph uG = G.to_undirected() # undirected graph if nx.is_connected(uG): ecc = nx.eccentricity(uG) wntr.network.draw_graph(wn, node_attribute=ecc, title='Eccentricity', node_size=40, node_range=[15, 30]) print "Diameter: " + str(nx.diameter(uG)) ASPL = nx.average_shortest_path_length(uG) print "Average shortest path length: " + str(ASPL) # Compute cluster coefficient clust_coefficients = nx.clustering(nx.Graph(G)) wntr.network.draw_graph(wn, node_attribute=clust_coefficients, title='Clustering Coefficient', node_size=40) # Compute meshedness coefficient meshedness = float(G.number_of_edges() - G.number_of_nodes() + 1)/(2*G.number_of_nodes()-5) print "Meshedness coefficient: " + str(meshedness) # Compute betweenness centrality bet_cen = nx.betweenness_centrality(G) wntr.network.draw_graph(wn, node_attribute=bet_cen, title='Betweenness Centrality', node_size=40, node_range=[0, 0.4]) central_pt_dom = G.central_point_dominance() print "Central point dominance: " + str(central_pt_dom) # Compute articulation points Nap = list(nx.articulation_points(uG)) Nap = list(set(Nap)) # get the unique nodes in Nap Nap_density = float(len(Nap))/uG.number_of_nodes() print "Density of articulation points: " + str(Nap_density) wntr.network.draw_graph(wn, node_attribute=Nap, title='Articulation Point', node_size=40, node_range=[0,1]) # Compute bridges bridges = G.bridges() wntr.network.draw_graph(wn, link_attribute=bridges, title='Bridges', link_width=2, link_range=[0,1]) Nbr_density = float(len(bridges))/G.number_of_edges() print "Density of bridges: " + str(Nbr_density) # Compute spectal gap spectral_gap = G.spectral_gap() print "Spectal gap: " + str(spectral_gap) # Compute algebraic connectivity alg_con = G.algebraic_connectivity() print "Algebraic connectivity: " + str(alg_con) # Critical ratio of defragmentation fc = G.critical_ratio_defrag() print "Critical ratio of defragmentation: " + str(fc) # Compute closeness centrality clo_cen = nx.closeness_centrality(G) wntr.network.draw_graph(wn, node_attribute=clo_cen, title='Closeness Centrality', node_size=40)
def test_articulation_points_repetitions(): G = nx.Graph() G.add_edges_from([(0, 1), (1, 2), (1, 3)]) assert_equal(list(nx.articulation_points(G)), [1])
# nodes_color_alpha.append(0.4) # edges_color_alpha.append(0.6) # edge_width_l.append(4.0) # print str(" ") # Gcc=sorted(nx.biconnected_connected_component_subgraphs(G), key = len, reverse=True) # Ggc=Gcc[0] # graph='Ggc' # print 'Nodes of giant connected component', graph+':', Ggc.nodes() # print 'Edges of giant connected component', graph+':', Ggc.edges() # print str(" ") print 'The biconnected component edges of G are:', list(nx.biconnected_component_edges(G)) print str(" ") print 'The articulation points of G are:', set(nx.articulation_points(G)) print str(" ") print 'Isolated nodes:', nx.isolates(G) print str(" ") # n1=list(set(G.nodes()) - set(Ggc.nodes()) - set(nx.isolates(G))) # print 'Non-isolated nodes outside the giant connected component:', n1 # N1=G.subgraph(n1) # print 'Edges among non-isolated nodes outside the giant connected component:', N1.edges() plt.figure() # plt.title('Biconnected components of an undirected graph')
def test_null_graph(): G = nx.Graph() assert_false(nx.is_biconnected(G)) assert_equal(list(nx.biconnected_components(G)), []) assert_equal(list(nx.biconnected_component_edges(G)), []) assert_equal(list(nx.articulation_points(G)), [])
def test_articulation_points_repetitions(): G = nx.Graph() G.add_edges_from([(0, 1), (1, 2), (1, 3)]) assert list(nx.articulation_points(G)) == [1]
#g = nx.DiGraph() g.add_nodes_from(range(len(lines))) for row in range(len(lines)): for col in range(len(lines)): if int(lines[row][col]) == 1: g.add_edge(row,col) print "Done reading all the files" graphs[item] = g for g in graphs.keys(): try: print "====================== " , g, "===========================" print "number of isolated nodes",'\t\t\t',nx.isolates(graphs[g]) print "is graph biconnected?",'\t\t\t',nx.is_biconnected(graphs[g]) print "cut vertices are: ",'\t\t\t',list(nx.articulation_points(graphs[g])) print "number of nodes",'\t\t\t',len(graphs[g].nodes()) print "number of edges",'\t\t\t',len(graphs[g].edges()) print "degree",'\t\t\t',get_avg(graphs[g].degree()) print "diameter",'\t\t\t', nx.diameter(graphs[g]) print "radius",'\t\t\t', nx.radius(graphs[g]) print "is_bipartite?",'\t\t', bipartite.is_bipartite(graphs[g]) print "average_shortest_path_length",'\t\t', nx.average_shortest_path_length(graphs[g]) print "degree_assortativity_coefficient",'\t\t', nx.degree_assortativity_coefficient(graphs[g]) print "assortativity.average_degree_connectivity",'\t\t', nx.assortativity.average_degree_connectivity(graphs[g]) #print "degree_pearson_correlation_coefficient",'\t\t', nx.degree_pearson_correlation_coefficient(graphs[g]) print "node closeness_centrality",'\t\t\t', get_avg(nx.closeness_centrality(graphs[g])) print "clustering",'\t\t\t', get_avg(nx.clustering(graphs[g])) print "node betweeness",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=False,endpoints=False)) print "edge betweeness",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=False)) #print "spectral_bipartivity",'\t\t', bipartite.spectral_bipartivity(graphs[g])
def condensate_graph(self): graphs = [] connected_components = list( nx.connected_component_subgraphs(self.graph)) counter = 0 if not len(connected_components): self.condensed_graph = nx.Graph() return for comp in connected_components: if len(comp) == 1: g = nx.Graph() n = comp.nodes()[0] g.add_node(n, {"type": "cutpoint"}) graphs.append(g) continue g = nx.Graph() if not len(comp): pass else: components = list(nx.biconnected_components(comp)) max_component_size = max([len(x) for x in components if x]) component_dict = {} cutpoints = set(nx.articulation_points(comp)) i = 0 for c in sorted(components, key=lambda x: -len(x)): nodes = set(c) - cutpoints if not nodes: continue node_id = "Block " + str(i) g.add_node(node_id) component_dict[node_id] = nodes i += 1 g.node[node_id]["nodes"] = " ".join([x for x in nodes]) g.node[node_id]["nodes in block"] = len(nodes) g.node[node_id]["radius"] = max( int(self.max_node_size * float(len(nodes)) / max_component_size), self.min_node_size) g.node[node_id]["type"] = "block" for n in cutpoints: temp_g = comp.copy() temp_g.remove_node(n) main_c = sorted( [x for x in nx.connected_components(temp_g)], key=lambda x: len(x)) robustness = len(main_c[-1]) g.add_node(n) g.node[n]["type"] = "cutpoint" g.node[n]["Potential disconnected nodes"] = len( comp) - robustness - 1 for neigh in comp[n].keys(): if neigh in cutpoints: g.add_edge(n, neigh, {'weight': 1}) # TODO weight else: for k, v in component_dict.items(): if neigh in v: g.add_edge(n, k, {'weight': 1}) # TODO weight g.node[n]["robustness"] = 10 - int( 10 * float(robustness) / len(comp)) g.node[n]["style"] = "cutpoint_" +\ str(10 - int(10*float(robustness) / len(comp))) g.node[n]["radius"] = self.cutpoint_size[g.node[n] ["robustness"]] # let's merge some leaves i = 0 for n, data in g.nodes(data=True): tobemerged = [] mergesize = 0 if data["type"] == "cutpoint": for (neigh, ndata) in g[n].items(): if g.node[neigh]["type"] == "block" and \ len(g[neigh]) == 1: tobemerged.append(neigh) mergesize += g.node[neigh]["nodes in block"] if len(tobemerged) > 1: nodes = " ".join([g.node[y]["nodes"] for y in tobemerged]) g.add_node( i, { "nodes": nodes, "nodes in block": mergesize, "radius": max( int(self.max_node_size * float(len(tobemerged)) / max_component_size), self.min_node_size), "type": "block" }) g.add_edge(i, n, {"weight": 1}) # TODO need weight here i += 1 for n in tobemerged: g.remove_node(n) # then relabel all the blocks blocks = {} for n, data in g.nodes(data=True): if data["type"] == "block": blocks[n] = data["nodes in block"] labels = {} for n in sorted(blocks.items(), key=lambda x: -x[1]): labels[n[0]] = "Block %d" % counter counter += 1 r_g = nx.relabel_nodes(g, labels, copy=True) graphs.append(r_g) self.condensed_graph = nx.union_all(graphs)
a = coeffs[0] b = coeffs[1] poly = np.poly1d(coeffs) yfit = lambda x: np.exp(poly(np.log(x))) plt.loglog(x,yfit(x)) plt.legend(['degree-distribution','Fit-line']) plt.xlabel('OutDegree') plt.ylabel('Count') plt.title('Out-degree distribution') plt.savefig('outdegree_distribution.png') plt.show() plt.close() print("Exponents for out-degree distribution are b : %f , log(a) : %f" % (a,b)) # Finding the number of bridges bridge_node_list=list(nx.articulation_points(h)) bridge_node_set = set(bridge_node_list) print("Number of Bridges :",len(bridge_node_set)) # Number of 3-cycles # print("Number of triangles in the Graph is :",len(nx.triangles(h))/3) cycls_3 = [c for c in nx.cycle_basis(h) if len(c)==3] print("No of 3 cycles are ",len(cycls_3)) ## Point 5 edge_list = list(h.edges()) total_edges = len(edge_list) #print(total_edges) print("Total Number of edges: ",len(edge_list)) print("Number of connected components in original graph :",nx.number_connected_components(h))
def test_barbell(): G = nx.barbell_graph(8, 4) nx.add_path(G, [7, 20, 21, 22]) nx.add_cycle(G, [22, 23, 24, 25]) pts = set(nx.articulation_points(G)) assert_equal(pts, {7, 8, 9, 10, 11, 12, 20, 21, 22}) answer = [ {12, 13, 14, 15, 16, 17, 18, 19}, {0, 1, 2, 3, 4, 5, 6, 7}, {22, 23, 24, 25}, {11, 12}, {10, 11}, {9, 10}, {8, 9}, {7, 8}, {21, 22}, {20, 21}, {7, 20}, ] assert_components_equal(list(nx.biconnected_components(G)), answer) G.add_edge(2,17) pts = set(nx.articulation_points(G)) assert_equal(pts, {7, 20, 21, 22})