def copy_layout(from_fname, to_fname): if not from_fname[-4:] =='.gml': from_name +='.gml' if not to_fname[-4:] =='.gml': to_name +='.gml' print 'reading A=', from_fname,'..', g1 = NX.read_gml(from_fname) labels1 = NX.get_node_attributes(g1, 'label') n1 = set(labels1.values()) print len(n1),'nodes' print 'reading B=', to_fname,'..', g2 = NX.read_gml(to_fname) labels2 = NX.get_node_attributes(g2, 'label') n2 = set(labels2.values()) print len(n2),'nodes' intersection = len(n2.intersection(n1)) percent=100.*intersection/len(n2) print 'B.intersect(A)=',intersection,'(%.1f%%)'%percent print 'copying layout..', mapping = {} for L1 in labels1: for L2 in labels2: if labels1[L1]==labels2[L2]: mapping[L1] = L2 break layout = NX.get_node_attributes(g1, 'graphics') attr = dict([ ( mapping[ID], {'x':layout[ID]['x'],'y':layout[ID]['y']} ) for ID in mapping]) NX.set_node_attributes(g2, 'graphics', attr) NX.write_gml(g2, to_fname) print 'done.'
def test_planned_path_smoothing(): start_pos = [2650, 2650] goal_pos = [1900, 400] graph_path = plan_path(start_pos, goal_pos) path_pos = nx.get_node_attributes(graph_path, 'pos') #this relies on the fact that nodes are sorted properly od = OrderedDict(sorted(path_pos.items(), key=lambda t: t[0])) path_keys = od.keys() path_list = od.values() #finally, actual smoothing smoothed_path = smooth(path_list) printpaths(path_list, smoothed_path) smoothed_graph = deepcopy(graph_path) for i, k in enumerate(path_keys): smoothed_graph.node[k]['pos'] = smoothed_path[i] smoothed_pos = nx.get_node_attributes(smoothed_graph, 'pos') plot_map() nx.draw(smoothed_graph, smoothed_pos, node_size=5, edge_color='r') nx.draw(graph_path, path_pos, node_size=5, edge_color='b') #nx.draw_networkx_labels(graph_path, path_pos) plt.show()
def run_monte_carlo(self, pickle_fn=None, init=False): if init: self.results = [] for nnodes in self.nnodes: print 'Running MC n='+repr(nnodes) embed_param = self.get_embed_param(nnodes) for mc in xrange(self.nmc): G = self.get_random_graph(nnodes) for epar in embed_param: embed = epar['embed'] x = embed.embed(G) x = embed.get_embedding(epar['dim'], epar['scale']) k_means = KMeans(init='k-means++', k=self.k, n_init=5) pred = k_means.fit(x).labels_ epar['num_diff'][mc] = num_diff_w_perms( nx.get_node_attributes(G, 'block').values(), pred) epar['rand_idx'][mc] = metrics.adjusted_rand_score( nx.get_node_attributes(G, 'block').values(), pred) [epar.pop('embed') for epar in embed_param] # pop off the Embedding to save space self.results.extend(embed_param) if pickle_fn: pickle.dump(self, open(pickle_fn,'wb')) print 'Saved to '+pickle_fn return self.results
def loc_save(self,S): """ save txt node ID , True pos x , True pos y , est pos x , est pos y , timestamp Attributes: ---------- S : Simulation Scipy.Simulation object """ pos=nx.get_node_attributes(self,'p') pe=nx.get_node_attributes(self,'pe_alg') typ = nx.get_node_attributes(self,'type') if self.idx == 0: entete = 'NodeID, True Position x, True Position y, Est Position x, Est Position y, Timestamp\n' file=open(basename+'/' + pstruc['DIRNETSAVE'] +'/simulation.txt','write') file.write(entete) file.close() try: file=open(basename+'/' + pstruc['DIRNETSAVE'] +'/simulation.txt','a') for n in self.nodes(): if typ[n] != 'ap': data = n + ',' + str(pos[n][0]) + ',' + str(pos[n][1]) + ',' + str(pe[n][0][0]) + ',' + str(pe[n][0][1]) + ',' +pyu.timestamp(S.now()) +',\n' file.write(data) file.close() self.idx = self.idx +1 except: pass
def find_seq_changes(nodes, G, name): limit = len(nodes) errors =[] G1=G.copy() nodes_to_be_deleted=nodes[:] ranks = nx.get_node_attributes(G1,"weight_rank") ranks_keys = {y:x for x,y in ranks.iteritems()} for count in range(1,limit): weights_original = nx.get_node_attributes(G1, "weight_sum") G1, interface_nodes_new = delete_node_by_rank(nodes_to_be_deleted, G1, 1) nodes_to_be_deleted.remove(ranks_keys[1]) G1 = find_ranks(interface_nodes_new, G1, find_weights, 'weight') weights_new = nx.get_node_attributes(G1, "weight_sum") error =0.0 for node in weights_new: error += np.square(weights_original[node] - weights_new[node]) G.node[ranks_keys[1]][name+"_sum"] = round(error/len(nodes), 6) errors.append((ranks_keys[1], round(error/len(nodes), 6))) ranks = nx.get_node_attributes(G1,"weight_rank") ranks_keys = {y:x for x,y in ranks.iteritems()} G.node[nodes_to_be_deleted[0]][name+"_sum"] = 0 errors.append((nodes_to_be_deleted[0], 0)) return sorted(errors, key=operator.itemgetter(1)), G
def plot_graph(cls, G, filename=None, node_attribute_name='id', edge_attribute_name=None, colored_nodes=None, colored_edges=None, colored_path=None, **kwargs): #def plot_graph(self, G, out_file, **kwd): """plot graph""" plt.clf() # get the layout of G pos = nx.get_node_attributes(G, 'pos') if not pos: pos = nx.spring_layout(G) # get node attributes with_labels = False node_labels = None if node_attribute_name == 'id': with_labels = True elif node_attribute_name: node_labels = nx.get_node_attributes(G, node_attribute_name) # get edge attributes if not edge_attribute_name: edge_labels = nx.get_edge_attributes(G, edge_attribute_name) # colored nodes node_default_color = '0.75' # Gray shades node_color = node_default_color if colored_nodes: node_color = ['r' if node in colored_nodes else node_default_color for node in G.nodes()] # colored path if colored_path: nrof_nodes = len(colored_path) idx = 0 colored_edges = list() while idx < nrof_nodes-1: colored_edges.append((colored_path[idx], colored_path[idx+1])) idx += 1 # colored edges edge_default_color = 'k' # black edge_color = edge_default_color if colored_edges: set_colored_edges = {frozenset(t) for t in colored_edges} # G.edges returns a list of 2-tuples edge_color = ['r' if frozenset([u, v]) in set_colored_edges else edge_default_color for u, v in G.edges()] # draw nx.draw(G, pos, with_labels=with_labels, node_color=node_color, edge_color=edge_color, **kwargs) if node_labels: nx.draw_networkx_labels(G, pos, labels=node_labels) nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels) if filename: plt.savefig(filename, bbox_inches='tight', pad_inches=0) else: plt.show()
def _retrieve_skycoords(V): coords_l = [] # Accessing the borders one by one. At this step, V_subgraphs contains a list of cycles # (i.e. one describing the external border of the MOC component and several describing the holes # found in the MOC component). V_subgraphs = nx.connected_component_subgraphs(V) for v in V_subgraphs: # Compute the MST for each cycle v = nx.convert_node_labels_to_integers(v) mst = nx.minimum_spanning_tree(v) # Get one end of the span tree by looping over its node and checking if the degree is one src = None for (node, deg) in mst.degree(): if deg == 1: src = node break # Get the unordered lon and lat ra = np.asarray(list(nx.get_node_attributes(v, 'ra').values())) dec = np.asarray(list(nx.get_node_attributes(v, 'dec').values())) coords = np.vstack((ra, dec)).T # Get the ordering from the MST ordering = np.asarray(list(nx.dfs_preorder_nodes(mst, src))) # Order the coords coords = coords[ordering] # Get a skycoord containing N coordinates computed from the Nx2 `coords` array coords = SkyCoord(coords, unit="deg") coords_l.append(coords) return coords_l
def process_graph(graph): for (n, data) in graph.nodes(data=True): data["orig_id"] = str(n) # get largest connected component sc = sorted(nx.connected_components(graph), key=len, reverse=True) lcc = graph.subgraph(sc[0]) graph = lcc graph = nx.convert_node_labels_to_integers(graph) if hasattr(graph, 'pos'): pos = graph.pos else: x = nx.get_node_attributes(graph, 'x') y = nx.get_node_attributes(graph, 'y') if len(x) != 0 and len(y) != 0: pos = { n: [x[n], y[n]] for n in graph.nodes() } else: pos = nx.spring_layout(graph) #graph = nx.Graph(graph) # in case of di/multi graph graph.pos = pos if len(nx.get_edge_attributes(graph, 'weight')) == 0: for (u,v) in graph.edges(): weight = 1 graph[u][v]['weight'] = weight return graph
def clust(Graph): """ Returns the graph that merges artificial loops into a single node. Detects the nodes included to the triangles and merges them. Uses the extern function merge_nodes. Parameters -------- Graph : input graph with artificial loops Returns ------- G : a graph without loops; triangles of neighboring nodes are replaced by a single node  """ G = Graph.copy() size = G.number_of_nodes() for i in G.nodes(): neigh = nx.get_node_attributes(G, 'neig') index = nx.get_node_attributes(G, 'index') if (i in G.nodes() and nx.triangles(G, i))>0: n = nx.all_neighbors(G,i) l = [i] for k in n: if ((neigh[k]>2) and (nx.get_edge_attributes(G, 'length')[min(i,k), max(i,k)]<2)): l = np.append(l, k) merge_nodes(G,l,size+1,index = index[i], neig = neigh[i]) size+=1 if (i==G.number_of_nodes()): break G = nx.convert_node_labels_to_integers(G, first_label=1) return G
def _split_nodes(self, node_class_names): """ Split nodes based on the attribute specified in self.node_class_attribute :param node_class_names: Values of node_class_attribute which will be included in the plot (in clockwise order) :type node_class_names: list :return: A dictionary whose keys are the node class attribute values, and values are lists of nodes belonging to that class :rtype: dict """ node_attribute_dict = nx.get_node_attributes(self.network, self.node_class_attribute) if self.order_nodes_by != 'degree': valid_node_set = set(nx.get_node_attributes(self.network, self.order_nodes_by)) else: valid_node_set = set(node_attribute_dict) if node_class_names is None: node_class_names = set(node_attribute_dict.values()) if len(node_class_names) > 3: raise ValueError("Nodes should be in 3 or fewer classes based on their {} attribute.".format( self.node_class_attribute)) node_class_names = sorted(node_class_names) else: for_deletion = [] for node in node_attribute_dict: if node_attribute_dict[node] not in node_class_names: for_deletion.append(node) for fd in for_deletion: node_attribute_dict.pop(fd) split_nodes = OrderedDict([(node_class, []) for node_class in node_class_names]) for node_name, node_class in node_attribute_dict.items(): if node_name in valid_node_set: split_nodes[node_class].append(node_name) return split_nodes
def test_weights_planning(): plot_map() start_pos = [ 2650, 2650 ] L, c = grid_graph(start_pos, dim=10, width=1000) filename = os.path.join(root, 'flash', 'fft2', 'processed', 'map.png') img_data = imread(filename) custom_labels = add_weights(L, img_data) astar_path = nx.astar_path(L, (5, 5), (0, 4)) H = L.subgraph(astar_path) h_pos = nx.get_node_attributes(H, 'pos') pos = nx.get_node_attributes(L,'pos') nx.draw(L, pos, node_size=5) edge_weight=dict([((u,v,),int(d['weight'])) for u,v,d in L.edges(data=True)]) nx.draw_networkx_edge_labels(L,pos,edge_labels=edge_weight) nx.draw_networkx_nodes(L,pos, node_size=0) nx.draw_networkx_edges(L,pos) nx.draw_networkx_labels(L,pos, labels=custom_labels) nx.draw(H,h_pos, node_size=5, edge_color='r') plt.show()
def get_pos(self,RAT=None): """ get node positions Parameters ---------- RAT : specify a RAT to display node position. If None, all RAT are displayed Returns ------- dictionnary : key : node ID value : np.array node position """ if RAT == None: if self.node[self.nodes()[0]].has_key('p'): return nx.get_node_attributes(self,'p') else : return nx.get_node_attributes(self,'pe') else : try: if self.SubNet[RAT].node[self.SubNet[RAT].nodes()[0]].has_key('p'): return nx.get_node_attributes(self.SubNet[RAT],'p') else : return nx.get_node_attributes(self.SubNet[RAT],'pe') except: raise NameError('invalid RAT name')
def consistent(self): """ Determine if the assignment of values to the lattice is self-consistant. Returns ------- valid : bool True if the lattice is self-consistent, False otherwise. """ reds = nx.get_node_attributes(self._lattice, 'red') pis = nx.get_node_attributes(self._lattice, 'pi') if self.SELF_REDUNDANCY: # pragma: no branch for node in self._lattice: if len(node) == 1: red = reds[node] mi = coinformation(self._dist, [node[0], self._output]) if not np.isclose(red, mi, atol=1e-5, rtol=1e-5): # pragma: no cover return False # ensure that the mobius inversion holds for node in self._lattice: red = reds[node] parts = sum(pis[n] for n in descendants(self._lattice, node, self=True)) if not np.isnan(red) and not np.isnan(parts): if not np.isclose(red, parts, atol=1e-5, rtol=1e-5): return False return True
def recursive_f (scopegraph, scope): #no need to calc this every scope, find another solution ex_scopes=nx.get_node_attributes(scopegraph, 'ex') cond_scopes=nx.get_node_attributes(scopegraph, 'cond') ab_scopes=nx.get_node_attributes(scopegraph, 'ab') print ("new scope {0}".format(scope)) ex = ex_scopes[scope] print ab_state = ab_scopes[scope] cond = cond_scopes[scope] #print ("ex: {0}, cond{1}".format(ex, cond)) flag = True while(len(ab_state._abstract_store) != 0): if(flag): flag = False ab_state = abex.abstract_execution_for_simple_loop(ab_state, ex, cond, True) if len(scopegraph.successors(scope)) != 0: #multi edges not supported print ("scopegraph succesors {0}".format(scopegraph.successors(scope)[0])) recursive_f(scopegraph, scopegraph.successors(scope)[0]) #scopegraph.remove_node(scopegraph.succesors(node)) else: ab_state = abex.abstract_execution_for_simple_loop(ab_state, ex, cond, False) if len(scopegraph.successors(scope)) != 0: #multi edges not supported print ("scopegraph succesors {0}".format(scopegraph.successors(scope)[0])) recursive_f(scopegraph, scopegraph.successors(scope)[0])
def test_build_unique_fragments(self): edges = {(e[0], e[1]): None for e in self.pc_edges} mol_graph = MoleculeGraph.with_edges(self.pc, edges) unique_fragments = mol_graph.build_unique_fragments() self.assertEqual(len(unique_fragments), 295) nm = iso.categorical_node_match("specie", "ERROR") for ii in range(295): # Test that each fragment is unique for jj in range(ii + 1, 295): self.assertFalse( nx.is_isomorphic(unique_fragments[ii].graph, unique_fragments[jj].graph, node_match=nm)) # Test that each fragment correctly maps between Molecule and graph self.assertEqual(len(unique_fragments[ii].molecule), len(unique_fragments[ii].graph.nodes)) species = nx.get_node_attributes(unique_fragments[ii].graph, "specie") coords = nx.get_node_attributes(unique_fragments[ii].graph, "coords") mol = unique_fragments[ii].molecule for ss, site in enumerate(mol): self.assertEqual(str(species[ss]), str(site.specie)) self.assertEqual(coords[ss][0], site.coords[0]) self.assertEqual(coords[ss][1], site.coords[1]) self.assertEqual(coords[ss][2], site.coords[2]) # Test that each fragment is connected self.assertTrue(nx.is_connected(unique_fragments[ii].graph.to_undirected()))
def import_layout(from_fname, to_graph): if not from_fname[-4:] =='.gml': from_fname +='.gml' print 'importing layout from', from_fname+'..' g1 = NX.read_gml(from_fname) labels1 = NX.get_node_attributes(g1, 'label') n1 = set(labels1.values()) g2 = to_graph n2 = set(g2.nodes()) if not n1: print ' empty target graph' return if not n2: print ' empty layout graph' return mapping = {} for L1 in labels1: for name in n2: if labels1[L1]==name: mapping[L1] = name break intersection = len(n2.intersection(n1)) percent=100.*intersection/len(n2) print ' %.1f%%'%percent,'(%i positions)'%intersection layout = NX.get_node_attributes(g1, 'graphics') attr = dict([ ( mapping[ID], {'x':layout[ID]['x'],'y':layout[ID]['y']} ) for ID in mapping]) NX.set_node_attributes(g2, 'graphics', attr)
def compare_list(self, graph_list, types, h, D): """ Compute the all-pairs kernel values for a list of graph representations of verification tasks """ all_graphs_number_of_nodes = 0 node_labels = [0] * (h+1) node_depth = [0] * len(graph_list) edge_types = [0] * len(graph_list) edge_truth = [0] * len(graph_list) for it in range(h+1): node_labels[it] = [0] * len(graph_list) for i, g in enumerate(graph_list): node_labels[0][i] = {key: self._compress(value) for key, value in nx.get_node_attributes(g, 'label').items()} node_depth[i] = nx.get_node_attributes(g, 'depth') edge_types[i] = nx.get_edge_attributes(g, 'type') edge_truth[i] = nx.get_edge_attributes(g, 'truth') all_graphs_number_of_nodes += len([node for node in nx.nodes_iter(g) if node_depth[i][node] <= D]) # if i == 0: # self._graph_to_dot(g, node_labels[0][i], "graph{}.dot".format(i)) # all_graphs_number_of_nodes is upper bound for number of possible edge labels phi = np.zeros((all_graphs_number_of_nodes, len(graph_list)), dtype=np.uint64) # h = 0 for i, g in enumerate(graph_list): for node in g.nodes_iter(): if node_depth[i][node] <= D: label = node_labels[0][i][node] phi[self._compress(label), i] += 1 K = np.dot(phi.transpose(), phi) # h > 0 for it in range(1, h+1): # Todo check if the shape fits in all cases phi = np.zeros((2*all_graphs_number_of_nodes, len(graph_list)), dtype=np.uint64) print('Updating node labels of graphs in iteration {}'.format(it), flush=True) # for each graph update edge labels for i, g in tqdm(list(enumerate(graph_list))): node_labels[it][i] = {} for node in g.nodes_iter(): if node_depth[i][node] <= D: label_collection = self._collect_labels(node, i, g, it-1, node_labels, node_depth, types, D, edge_types, edge_truth) long_label = "_".join(str(x) for x in [np.concatenate([np.array([node_labels[it-1][i][node]]), np.sort(label_collection)])]) node_labels[it][i][node] = self._compress(long_label) phi[self._compress(long_label), i] += 1 # node_labels[it][i][node] = long_label # phi[self._compress(long_label), i] += 1 # if i == 0: # self._graph_to_dot(g, node_labels[it][i], "graph{}_it{}.dot".format(i, it)) K += np.dot(phi.transpose(), phi) return K
def fts_async_product(self,fts2): assert type(fts2) == FTS result = FTS(set([]),set([])) nodes_prod = lambda u,v: tuple((list(u) if self.size>1 else [u]) + (list(v) if fts2.size>1 else [v])) labels_prod = lambda u,v: flatten((u,v)) labels = nx.get_node_attributes(self,'label') labels_fts2 = nx.get_node_attributes(fts2,'label') for u in self.nodes(): for v in fts2.nodes(): result.add_node(nodes_prod(u,v),label=labels_prod(labels[u],labels_fts2[v]),weight=1.0) for (u,v) in self.edges(): for (x,y) in fts2.edges(): result.add_edge(nodes_prod(u,x),nodes_prod(u,y),weight=1.0) result.add_edge(nodes_prod(u,x),nodes_prod(v,x),weight=1.0) result.add_edge(nodes_prod(u,x),nodes_prod(v,y),weight=1.0) for u in self.graph['initial']: for v in fts2.graph['initial']: result.graph['initial'].add(nodes_prod(u,v)) for u in self.graph['symbols']: for v in fts2.graph['symbols']: result.graph['symbols'].add(nodes_prod(u,v)) result.size = self.size + fts2.size return copy.deepcopy(result)
def draw_network_plt(graph, name=False, scale=100, size=False): """Will create a networkx matplotlib graph. Options: If name is specified, will save with name, otherwise will show plot""" colors = False scaled_sizes = False labels = {} for node in graph.nodes(): labels[node] = graph.node[node]['label'] if 'color' in graph.nodes(data=True)[0][1].keys(): colors = nx.get_node_attributes(graph, 'color').values() if size: sizes = nx.get_node_attributes(graph, size).values() scaled_sizes = [x * scale for x in sizes] if colors and scaled_sizes: nx.draw(graph, node_size=scaled_sizes, node_color=colors, labels=labels) elif colors and not scaled_sizes: nx.draw(graph, node_color=colors, labels=labels) elif scaled_sizes and not colors: nx.draw(graph, node_size=scaled_sizes, labels=labels) else: nx.draw(graph, labels=labels) if not name: plt.show() else: plt.savefig('../Images/'+str(name)+'.png') plt.clf()
def main(global_map, init, goal, steering_noise, distance_noise, measurement_noise, weight_data, weight_smooth, p_gain, d_gain): start_pos = [2650, 2650] goal_pos = [1900, 400] graph_path = plan_path(start_pos, goal_pos) path_pos = nx.get_node_attributes(graph_path, 'pos') sg = smooth_graph(graph_path, start_pos, goal_pos, True, weight_data, weight_smooth) sg_pos = nx.get_node_attributes(sg, 'pos') spath = graph_to_path(sg) global_map.plot() nx.draw(sg, sg_pos, node_size=5, edge_color='r') (reached_goal, penalty, num_steps, mg) = run(global_map, start_pos, goal_pos, spath, [p_gain, d_gain]) mg_pos = nx.get_node_attributes(mg, 'pos') nx.draw(mg, mg_pos, node_size=5, edge_color='b') plt.show()
def generator_priority(G): nodes_number = G.nodes() node_name_data = nx.get_node_attributes(G,'name') type_data = nx.get_node_attributes(G,'type') generator_list = [] APU_list = [] for i in range(0,nx.number_of_nodes(G)): x = nodes_number[i] if type_data[x]=='generator': generator_list.append(x) elif type_data[x]=='APU': APU_list.append(x) if len(APU_list) == 0: return clause = '(assert (=> ' if len(generator_list) > 1: clause += '(and' for i in range(0, len(generator_list)): g_name = node_name_data[generator_list[i]] clause += ' ' + g_name clause += ') ' if len(APU_list) > 1: clause += '(and ' for i in range(0, len(APU_list)): apu_name = node_name_data[APU_list[i]] clause += '(not ' + apu_name + ')' clause += ')))\n' return clause
def showXY(fnm, x="kx", y="ky"): g = nx.read_graphml(fnm) x = nx.get_node_attributes(g, x) y = nx.get_node_attributes(g, y) coords = zip(x.values(),y.values()) pos = dict(zip(g.nodes(), coords)) nx.draw(g,pos)
def plotGraph(self): self.posH = nx.get_node_attributes(self.H,'xy') self.posG = nx.get_node_attributes(self.G,'xy') self.posDG = nx.get_node_attributes(self.DG,'xy') self.color=[] for i,j in self.H.edges_iter(): self.color.append(self.H[i][j]['color']) self.elabels = dict([((u,v,),int(d['key'])) for u,v,d in self.G.edges(data=True)]) #for i,j in self.H.edges_iter(): # print self.H[i][j]['color'] #print elabels #nx.draw_networkx_nodes(self.G, posG, with_labels=False, node_size = 50, ax=self.a) #nx.draw_networkx_edges(self.G, posG, edge_labels=elabels, edge_color='b', with_labels=True, width = 2, ax=self.a) nx.draw_networkx_nodes(self.G, self.posG, with_labels=False, node_size = 150, node_color='#A0CBE2', ax=self.a) nx.draw_networkx_edges(self.H, self.posH, edge_color=self.color, edge_cmap=self.cmap, width = 5, alpha=1, ax=self.a) # , edge_vmin=0, edge_vmax=1 nx.draw_networkx_nodes(self.DG, self.posDG, node_size=150, alpha=1, ax=self.a, arrows=True, edge_color='r') #nx.draw_networkx_edges(self.DG, self.posDG, alpha=1, width = 2, ax=self.a, arrows=True, edge_color='r') #nx.draw_networkx_edges(self.H, posH, edge_color='k', width = 0.5, alpha=1., ax=self.a) nx.draw_networkx_edge_labels(self.G, self.posG, edge_labels=self.elabels, font_size= 12, alpha = 0.4, rotate=True) self.a.set_title("Gas Network colored by values of pressure.") self.a.text(0.45,0.05, "Time t = %.4f hours" % 0,transform=self.a.transAxes ) self.ax1 = self.f.add_axes([ 0.02, 0.05, 0.04, 0.9]) norm = mpl.colors.Normalize(vmin=3, vmax=7) cb1 = mpl.colorbar.ColorbarBase(self.ax1, cmap=self.cmap, norm=norm, orientation='vertical') #, norm=norm, orientation='horizontal') cb1.set_ticks([3, 4, 5, 6, 7]) cb1.set_label('Pressure in MPa', labelpad=3) self.canvas.draw()
def init(G, uncon_comp_tups, contactor_tups): nodes_number = G.nodes() edges_number = G.edges() node_name_data = nx.get_node_attributes(G, 'name') edge_name_data = nx.get_edge_attributes(G, 'name') edge_type_data = nx.get_edge_attributes(G, 'type') node_type_data = nx.get_node_attributes(G, 'type') declaration = '(set-option :print-success false)\n' declaration += '(set-option :produce-models true)\n(set-logic QF_UF)\n' for i in range(0, len(nodes_number)): x = nodes_number[i] node_type = node_type_data[x] if node_type != 'dummy': clause = '(declare-fun ' + node_name_data[x] + ' () Bool)\n' if node_type == 'generator' or node_type=='APU' or node_type == 'rectifier_dc': uncon_comp_tups.append(node_name_data[x]) declaration += clause for i in range(0, len(edges_number)): idx = edges_number[i] edge_type = edge_type_data[idx] if edge_type == 'contactor': edge_name = edge_name_data[idx] flag = 0 for j in range(0, len(contactor_tups)): if edge_name == contactor_tups[j]: flag = 1 break if flag == 0: contactor_tups.append(edge_name) for i in range(0, len(contactor_tups)): clause = '(declare-fun ' + contactor_tups[i] + ' () Bool)\n' declaration += clause return declaration
def copy_layout_GML2NX(Fname, Graph, verbose=1): if not Fname[-4:]=='.gml': Fname+='.gml' print 'Copying layout from', Fname+'..' g1 = NX.read_gml( Fname ) labels1 = NX.get_node_attributes(g1, 'label') n1 = set(labels1.values()) nodes = set( Graph.nodes() ) if not n1: print ' empty layout graph' return if not nodes: print ' empty target graph' return mapping = {} for L1 in labels1: for name in nodes: if labels1[L1]==name: mapping[L1] = name break intersection = len(nodes.intersection(n1)) percent=100.*intersection/len(nodes) print ' %.1f%%'%percent,'(%i positions)'%intersection layout = NX.get_node_attributes(g1, 'graphics') attr = dict([ ( mapping[ID], {'x':layout[ID]['x'],'y':layout[ID]['y']} ) for ID in mapping]) NX.set_node_attributes( Graph, 'graphics', attr)
def drawGraph(G): xcords = nx.get_node_attributes(G,'x') ycords = nx.get_node_attributes(G,'y') coordinates = dict([(k, [xcords[k], ycords[k]]) for k in xcords]) ns = nx.get_node_attributes(G, 'n') nx.draw_networkx(G,pos=coordinates,node_color=[1 if int(ns[i])>0 else 0 for i in ns],cmap=py.cm.PuBu) py.show()
def _reproduce_sexually(self, partner): # TODO: Broken. """Sexual reproduction between two networks""" inherited_state = -1 # -1 would be most recent network_props = ['num_nodes'] node_props = ['threshold', 'energy_consumption', 'spontaneity'] # node_props = ['threshold'] edge_props = ['weight'] child = copy.deepcopy(self) partner.children.append(child) # partner.reproductive_energy_cost = self.reproductive_energy_cost child.parents, child.children = [self, partner], [] if np.random.randint(0, 2) == 1: internal_net = copy.deepcopy(self.internal) child._cloned_from, child._not_cloned_from = self, partner else: internal_net = copy.deepcopy(partner.internal) child._cloned_from, child._not_cloned_from = partner, self # print "Kin with %d neurons, copied from net with %d neurons" %(internal_net.simdata[-1].number_of_nodes(), self.internal.simdata[-1].number_of_nodes()) child.set_internal_network(copy.deepcopy(internal_net), t0=self.t) child.internal.simdata[inherited_state] = copy.copy(internal_net.simdata[inherited_state]) choices = np.random.randint(2, size=(2, len(node_props))) # randomly choose attributes for j, n in enumerate(node_props): p1 = nx.get_node_attributes(self.internal.simdata[inherited_state], n) p2 = nx.get_node_attributes(partner.internal.simdata[inherited_state], n) # add/remove nodal information based on the inherited number of nodes # chosen = self if choices[0][j] else partner # print "Using %s(N%d) for %s" %(chosen.ind_id, chosen.internal.simdata[inherited_state].number_of_nodes(), n) utils.set_node_attributes(child.internal.simdata[inherited_state], n, p1 if choices[0][j] else p2) for j, e in enumerate(edge_props): p1 = nx.get_edge_attributes(self.internal.simdata[inherited_state], e) p2 = nx.get_edge_attributes(partner.internal.simdata[inherited_state], e) utils.set_edge_attributes(child.internal.simdata[inherited_state], n, p1 if choices[1][j] else p2) return child
def compute_LDPs(self,ln,RAT): """compute edge LDP Parameters ---------- n1 : float/string node ID n2 : float/string node ID RAT : string A specific RAT which exist in the network ( if not , raises an error) value : list : [LDP value , LDP standard deviation] method : ElectroMagnetic Solver method ( 'direct', 'Multiwall', 'PyRay' """ p=nx.get_node_attributes(self.SubNet[RAT],'p') epwr=nx.get_node_attributes(self.SubNet[RAT],'epwr') sens=nx.get_node_attributes(self.SubNet[RAT],'sens') e=self.link[RAT]#self.SubNet[RAT].edges() re=self.relink[RAT] # reverse link aka other direction of link lp,lt, d, v= self.EMS.solve(p,e,'all',RAT,epwr,sens) lD=[{'Pr':lp[i],'TOA':lt[np.mod(i,len(e))] ,'d':d[np.mod(i,len(e))],'vis':v[i]} for i in range(len(d))] self.update_LDPs(iter(e+re),RAT,lD)
def drawLabels(self, labelAll=True): """Draw labels on nodes in graph (nodeId by default)""" # circleNodes = [ n for (n, m) in self.G.nodes(data=True) if m.get('shape','circle') == 'circle'] # pdb.set_trace() if labelAll: nx.draw_networkx_labels(self.G, pos=nx.get_node_attributes(self.G, 'pos'), font_size=10, labels=self.labelMap) else: # boxNodes = [ n for (n, m) in self.G.nodes(data=True) if m.get('shape','circle') == 'box'] # lm = {} # for n in boxNodes: # lm[n]=self.labelMap[n] # nx.draw_networkx_labels(self.G, # pos=nx.get_node_attributes(self.G, 'pos'), # font_size=10, # labels=lm) emptyNodes = [ n for (n,m) in self.G.nodes(data=True) if m.get('shape','circle') == 'empty'] if emptyNodes: lm = {} for n in emptyNodes: lm[n]=self.labelMap[n] nx.draw_networkx_labels(self.G, pos=nx.get_node_attributes(self.G, 'pos'), font_size=10, labels=lm)
def CheapestPath(Net, pNet, cost_dictionary, origin, destination, depth): global rscost global stations_data global track_data "Iterates through every simple path calculating cost and finds the cheapest" cost_path_dict = {} build_flag_dict = {} for path in nx.all_simple_paths(pNet, source=origin, target=destination, cutoff = depth): cost = 0 build_flag = 0 #check if we need to add cost of reloading buildings for start nodes if (5*(nx.get_node_attributes(Net,'obj')[path[0]].reloading_buildings)) < (nx.get_node_attributes(Net,'obj')[path[0]].ship_in + 1): #rscost is cost of adding reloading station cost += rscost build_flag = 1 for i in range(0,len(path) - 1): cost += cost_dictionary['{0}--->{1}'.format(path[i],path[i +1])] cost_path_dict[cost] = path build_flag_dict[cost] = build_flag ##find cheapest path and its cost ccost = min(list(cost_path_dict.keys())) cpath = cost_path_dict[ccost] print('For next additional unit, Cheapest Path from {0} to {1} is {2} at ${3}'.format(origin,destination,\ cpath, ccost)) #check if we needed to build a reloading station at start node if build_flag_dict[ccost] == 1: stations_data[cpath[0]-1][2] += 1 print(' -build reloading building at station {0}'\ .format(cpath[0])) ##find recomendations based on that path for i in range(0,len(cpath) - 1): x = Net.get_edge_data(cpath[i],cpath[i+1]) if type(x) is dict: #if no edges along the path are built y = Net.get_edge_data(cpath[i+1], cpath[i]) if (type(y) is dict and all(y[key]['obj'].is_built == 0 for key in y) ) and all(x[key]['obj'].is_built == 0 for key in x): print(' -build path and track from {0} to {1}'\ .format(cpath[i],cpath[i+1])) track_data.append([cpath[i],cpath[i+1],1]) #if line built but at capacity, need to build another so add that cost elif all((x[key]['obj'].load + 1) > 10 for key in x) or all(x[key]['obj'].is_built == 0 for key in x): print(' -build track from {0} to {1}'\ .format(cpath[i],cpath[i+1])) track_data.append([cpath[i],cpath[i+1],1]) #iterate through each edge in dictionary of edges along that path #print(x) #print edge objects for debuging #track reloading buildings added rl_added = 0 for key in x: #if not enough reloading stations at destination, add that cost if 5*(nx.get_node_attributes(Net,'obj')[cpath[i+1]].reloading_buildings+rl_added) < \ (nx.get_node_attributes(Net,'obj')[cpath[i+1]].ship_in + 1): print(' -build reloading building at station {0}'\ .format(cpath[i+1])) stations_data[cpath[i+1]-1][2] += 1 rl_added += 1 return [origin, destination, cpath, ccost]
rnaList = [ rotate("ACCGGUAGU", 0), rotate("ACAUGAUGGCCAUGU", 0), rotate("UCGUAACGAUACGAGCAUAGCGGCUA", 0) ] for rna in rnaList: n = len(rna) print(f"Input RNA string {rna} of length {len(rna)}") pairsCount, resultPairs = find_secondary_structure(rna) print(f"Has secondary structure of {pairsCount} pairs: ") print(f"\t{resultPairs} (len {len(resultPairs)})\n") G = nx.Graph() G.add_nodes_from([(i + 1) for i in range(len(rna))]) for node in G.nodes(): G.nodes()[node]["pos"] = (node, node * node * node) for i in range(1, n): G.add_edge(i, i + 1) for i, j in resultPairs: G.add_edge(i, j) pos = nx.get_node_attributes(G, "pos") labels = dict([(i + 1, rna[i]) for i in range(n)]) plt.figure(figsize=(8, 8)) plt.axis("off") nx.draw(G, labels=labels, with_labels=True, pos=pos) plt.show()
def draw_plotly_3d_scatter(in_graph): """COMMENT ME! """ # Get the coordinate attributes back out of the graph. x_vals = [x for x in nx.get_node_attributes(in_graph, 'x').values()] y_vals = [x for x in nx.get_node_attributes(in_graph, 'y').values()] z_vals = [x for x in nx.get_node_attributes(in_graph, 'z').values()] # Create the color and size lists. c_vals = [x for x in nx.get_node_attributes(in_graph, 'color').values()] s_vals = [x for x in nx.get_node_attributes(in_graph, 'size').values()] # Add the points to a scatter plot. trace1 = go.Scatter3d( x=x_vals, y=y_vals, z=z_vals, mode='markers', hovertext=[x for x in in_graph.nodes()], marker=dict(sizemode='area', color=c_vals, size=s_vals, opacity=0.8), ) # Create empty list for line segments Xe = [] Ye = [] Ze = [] # Iterate through the edges, and draw line segments for each set. for edge in in_graph.edges(): # Assign the node edge indecies. node_a = edge[0] node_b = edge[1] # Assign the x, y, z variables. xa = in_graph.node('x')[node_a] ya = in_graph.node('y')[node_a] za = in_graph.node('z')[node_a] xb = in_graph.node('x')[node_b] yb = in_graph.node('y')[node_b] zb = in_graph.node('z')[node_b] # Add these values to a corresponding list. # The third value is none, otherwise a plane would be drawn. Xe += [xa, xb, None] Ye += [ya, yb, None] Ze += [za, zb, None] # Add the node edges / line segments to the plot. trace2 = go.Scatter3d(x=Xe, y=Ye, z=Ze, mode='lines', line=go.Line(color='rgb(125,125,125)', width=1), hoverinfo='none') # Show the plot. data = [trace1, trace2] fig = go.Figure(data=data) # iplot(fig) return fig
#121 g.add_edge('Stafford','Woodbridge', distance = 121.68) #132 g.add_edge('Stafford','Glen_Allen', distance = 88.78) g.add_edge('Gloucester','Richmond', distance = 44.93) g.add_edge('Gloucester','Woodbridge', distance =92.68) ''' #Without Weights Edges 12, 113, 133, 30 , 64 (p=5) g.add_edge('Norton', 'Wytheville', distance=85.84) g.add_edge('Henry', 'Wytheville', distance=67.78) g.add_edge('Henry', 'South_Hill', distance=98.14) g.add_edge('Southampton', 'South_Hill', distance=78.99) g.add_edge('Southampton', 'Norfolk', distance=1.50) g.add_edge('Middlesex', 'Glen_Allen', distance=48.29) g.add_edge('Middlesex', 'Hampton', distance=137.48) g.add_edge('Hampton', 'Norfolk', distance=1.50) pos = { city: (long, lat) for (city, (lat, long)) in nx.get_node_attributes(g, 'pos').items() } nx.draw(g, pos, with_labels=True, node_size=50) #red current superchargers nx.draw_networkx_nodes(g, pos, node_color='r', node_size=50, alpha=0.4) #Blue new superchargers print(nx.dijkstra_path(g, 'Wytheville', 'Woodbridge')) plt.show()
dol_part_FGreedy = clusteringDolphins('fg') dol_part_IMap = clusteringDolphins('im') dol_part_NewGir = dol_part_NewGirAll[3] part_methods = { 'l': dol_part_Louvain, 'fg': dol_part_FGreedy, 'im': dol_part_IMap, 'ng': dol_part_NewGir } dfc = {} # Number of nodes N = len(dolphins.nodes()) # Number of males Nm = list(nx.get_node_attributes(dolphins, 'gender').values()).count('m') pThresh = 0.05 dfFisher = pd.DataFrame() for m in part_methods: for comm in range(max(list(part_methods[m].values())) + 1): L0 = [] for n in dolphins.nodes(): if part_methods[m][n] == comm: L0.append(dolphins.nodes[n]['gender']) A = len(L0) Am = L0.count('m') oddsratio, pvalue = stats.fisher_exact( [[Am, A - Am], [Nm - Am, N - A - (Nm - Am)]], 'less') if pvalue < pThresh:
G = ox.graph_from_point(location_point, network_type='drive', distance=distance, simplify=True) print(G.number_of_nodes()) print(G.number_of_edges()) print(G.is_directed()) # ox.save_graphml(G, filename="tt.graphml") # ox.save_graph_shapefile(G, 'cityshape') # %% get node properties pos = {} nDic = {} x = nx.get_node_attributes(G, "x") y = nx.get_node_attributes(G, "y") t = nx.get_node_attributes(G, "highway") idx = [] lat = [] lon = [] n_idx = [] for i, n in enumerate(G.nodes()): idx.append(i + 1) n_idx.append(n) lon.append(x[n]) lat.append(y[n]) nDic[n] = i + 1 pos[n] = (x[n], y[n]) if n in t:
def get_map(serv): from datetime import datetime from pytz import timezone import networkx as nx import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt date = funct.get_data('config') cfg = hap_configs_dir + serv + "-" + date + ".cfg" print('<center>') print("<h3>Map from %s</h3><br />" % serv) G = nx.DiGraph() funct.get_config(serv, cfg) try: conf = open(cfg, "r") except IOError: print( '<div class="alert alert-danger">Can\'t read import config file</div>' ) node = "" line_new2 = [1, ""] i = 1200 k = 1200 j = 0 m = 0 for line in conf: if "listen" in line or "frontend" in line: if "stats" not in line: node = line i = i - 500 if line.find("backend") == 0: node = line i = i - 500 G.add_node(node, pos=(k, i), label_pos=(k, i + 150)) if "bind" in line: try: bind = line.split(":") if stats_port not in bind[1]: bind[1] = bind[1].strip(' ') bind = bind[1].split("crt") node = node.strip(' \t\n\r') node = node + ":" + bind[0] G.add_node(node, pos=(k, i), label_pos=(k, i + 150)) except: pass if "server " in line or "use_backend" in line or "default_backend" in line and "stats" not in line: if "timeout" not in line and "default-server" not in line and "#" not in line and "stats" not in line: i = i - 300 j = j + 1 if "check" in line: line_new = line.split("check") else: line_new = line.split("if ") if "server" in line: line_new1 = line_new[0].split("server") line_new[0] = line_new1[1] line_new2 = line_new[0].split(":") line_new[0] = line_new2[0] line_new[0] = line_new[0].strip(' \t\n\r') line_new2[1] = line_new2[1].strip(' \t\n\r') if j % 2 == 0: G.add_node(line_new[0], pos=(k + 250, i - 350), label_pos=(k + 225, i - 100)) else: G.add_node(line_new[0], pos=(k - 250, i - 50), label_pos=(k - 225, i + 180)) if line_new2[1] != "": G.add_edge(node, line_new[0], port=line_new2[1]) else: G.add_edge(node, line_new[0]) os.system("/bin/rm -f " + cfg) os.chdir(cgi_path) pos = nx.get_node_attributes(G, 'pos') pos_label = nx.get_node_attributes(G, 'label_pos') edge_labels = nx.get_edge_attributes(G, 'port') try: plt.figure(10, figsize=(9.5, 15)) nx.draw(G, pos, with_labels=False, font_weight='bold', width=3, alpha=0.1, linewidths=5) nx.draw_networkx_nodes(G, pos, node_color="skyblue", node_size=100, alpha=0.8, node_shape="p") nx.draw_networkx_labels(G, pos=pos_label, alpha=1, font_color="green", font_size=10) nx.draw_networkx_edges(G, pos, width=0.5, alpha=0.5, edge_color="#5D9CEB", arrows=False) nx.draw_networkx_edge_labels(G, pos, label_pos=0.5, font_color="blue", labels=edge_labels, font_size=8) plt.savefig("map.png") plt.show() except Exception as e: print('<div class="alert alert-danger">' + str(e) + '</div>') commands = [ "rm -f " + fullpath + "/map*.png", "mv %s/map.png %s/map%s.png" % (cgi_path, fullpath, date) ] funct.ssh_command("localhost", commands) print('<img src="/map%s.png" alt="map">' % date)
def detect(self): """detect the source with GSBA. Returns: @rtype:int the detected source """ self.reset_centrality() self.prior_detector.set_data(self.data) self.prior_detector.detect() self.prior = nx.get_node_attributes(self.subgraph, 'centrality') self.reset_centrality() rc = rumor_center.RumorCenter() rc.set_data(self.data) rc.detect() rumor_centralities = nx.get_node_attributes(self.subgraph, 'centrality') self.reset_centrality() infected_nodes = set(self.subgraph.nodes()) n = len(infected_nodes) posterior = {} included = set() neighbours = set() weights = self.data.weights for v in infected_nodes: """find the approximate upper bound by greedy searching""" included.clear() neighbours.clear() included.add(v) neighbours.add(v) likelihood_upper = 1 w = {} # effective propagation probabilities: node->w w_key_sorted = blist() w[v] = 1 w_key_sorted.append(v) while len(included) < n: w_sum = sum([w[j] for j in neighbours]) u = w_key_sorted.pop() # pop out the last element from w_key_sorted with the largest w likelihood_upper *= w[u] / w_sum included.add(u) neighbours.remove(u) new = nx.neighbors(self.data.graph, u) for h in new: if h in included: continue neighbours.add(h) # compute w for h w_h2u = weights[self.data.node2index[u],self.data.node2index[h]] if h in w.keys(): w[h] = 1-(1-w[h])*(1-w_h2u) else: w[h] = w_h2u # h_neighbor = nx.neighbors(self.data.graph, h) # w_h = 1 # for be in included.intersection(h_neighbor): # w_h *= 1 - self.data.get_weight(h, be) # w[h] = 1 - w_h """insert h into w_key_sorted, ranking by w from small to large""" if h in infected_nodes: if h in w_key_sorted: w_key_sorted.remove(h) # remove the old w[h] k = 0 while k < len(w_key_sorted): if w[w_key_sorted[k]] > w[h]: break k += 1 w_key_sorted.insert(k,h) #w_key_sorted[k:k] = [h] """find the approximate lower bound by greedy searching""" included.clear() neighbours.clear() included.add(v) neighbours.add(v) likelihood_lower = 1 w = {} # effective propagation probabilities: node->w w_key_sorted = blist() w[v] = 1 w_key_sorted.append(v) while len(included) < n: w_sum = sum([w[j] for j in neighbours]) u = w_key_sorted.pop() # pop out the last element from w_key_sorted with the largest w likelihood_lower *= w[u] / w_sum included.add(u) neighbours.remove(u) new = nx.neighbors(self.data.graph, u) for h in new: if h in included: continue neighbours.add(h) # compute w for h w_h2u = weights[self.data.node2index[u], self.data.node2index[h]] if h in w.keys(): w[h] = 1 - (1 - w[h]) * (1 - w_h2u) else: w[h] = w_h2u """insert h into w_key_sorted, ranking by w from large to small""" if h in infected_nodes: if h in w_key_sorted: w_key_sorted.remove(h) # remove the old w[h] k = 0 while k < len(w_key_sorted): if w[w_key_sorted[k]] < w[h]: break k += 1 w_key_sorted.insert(k, h) # w_key_sorted[k:k] = [h] likelihood = decimal.Decimal(likelihood_lower + likelihood_upper)*rumor_centralities[v]/2 posterior[v] = decimal.Decimal(self.prior[v])* likelihood nx.set_node_attributes(self.subgraph, 'centrality', posterior) return self.sort_nodes_by_centrality()
n_nodes = adj.shape[0] # Some preprocessing adj_tilde = adj + np.identity(n=adj.shape[0]) d_tilde_diag = np.squeeze(np.sum(np.array(adj_tilde), axis=1)) d_tilde_inv_sqrt_diag = np.power(d_tilde_diag, -1 / 2) d_tilde_inv_sqrt = np.diag(d_tilde_inv_sqrt_diag) adj_norm = np.dot(np.dot(d_tilde_inv_sqrt, adj_tilde), d_tilde_inv_sqrt) adj_norm_tuple = us.sparse_to_tuple(scipy.sparse.coo_matrix(adj_norm)) # Features are just the identity matrix feat_x = np.identity(n=adj.shape[0]) feat_x_tuple = us.sparse_to_tuple(scipy.sparse.coo_matrix(feat_x)) # Semi-supervised memberships = [m - 1 for m in nx.get_node_attributes(g, 'membership').values()] nb_classes = len(set(memberships)) targets = np.array([memberships], dtype=np.int32).reshape(-1) one_hot_targets = np.eye(nb_classes)[targets] # Pick one at random from each class labels_to_keep = [ np.random.choice(np.nonzero(one_hot_targets[:, c])[0]) for c in range(nb_classes) ] y_train = np.zeros(shape=one_hot_targets.shape, dtype=np.float32) y_val = one_hot_targets.copy() train_mask = np.zeros(shape=(n_nodes, ), dtype=np.bool)
solver='full') # Set the 4 centrality measures as node attributes nx.set_node_attributes(Gw, 'betweenness', bw) nx.set_node_attributes(Gw, 'current_flow_closeness', cfc) nx.set_node_attributes(Gw, 'eigenvector', ev) nx.set_node_attributes(Gw, 'current_flow_betweenness', cfbw) centrality_measures = ['betweenness', 'current_flow_closeness', \ 'eigenvector', 'current_flow_betweenness'] for cm in centrality_measures: # Visualise the graph plt.figure(figsize=(10, 10)) plt.title(cm + ' centrality measure') pos = nx.spring_layout(Gw, k=.25, iterations=2000) labs = nx.get_node_attributes(Gw, cm) for key, value in labs.items(): labs[key] = round(value, 3) nx.draw(Gw, pos, node_color='lightblue', edge_color=[d['weight'] for (u, v, d) in Gw.edges(data=True)], width=3, edge_cmap=plt.cm.Blues, alpha=.4, node_size=np.add( np.multiply(list(nx.get_node_attributes(Gw, cm).values()), 10000), 200)) nx.draw_networkx_labels(Gw, pos, labels=labs,
def run(self, raw_data, objects): graphs = [] new_objects = [] for overlay in self.__sub_overlays: g = overlay.substitutes(raw_data) graphs.append(g) graph = graphs.pop(0) for h in graphs: graph = nx.compose(graph, h) components = nx.connected_component_subgraphs(graph) closed_polygons = [] polygons = [] for component in components: minimum_cycles = planar_cycles(component) collected_options = itertools.chain( *nx.get_node_attributes(component, 'options').values()) options = list(set(collected_options)) # the polygons are the same as the minimum cycles closed_polygons += minimum_cycles path_graph = nx.Graph() path_graph.add_nodes_from(component.nodes()) for polygon in minimum_cycles: polygons.append(Polygon(polygon, options)) path_graph.add_cycle(polygon) remaining_graph = nx.difference(component, path_graph) for n in remaining_graph.nodes(): if remaining_graph.degree(n) == 0: remaining_graph.remove_node(n) if len(remaining_graph.edges()) > 0: remaining_components = nx.connected_component_subgraphs( remaining_graph) for c in remaining_components: new_objects.append(OpenGraph(c, options)) new_objects = new_objects + polygons z_order_graph = nx.DiGraph() z_order_graph.add_nodes_from(new_objects) for i in range(0, len(polygons)): polygon1 = polygons[i] for j in range(i + 1, len(polygons)): polygon2 = polygons[j] if polygon1 != polygon2: if polygon1.contains(polygon2): z_order_graph.add_edge(polygon1, polygon2) elif polygon2.contains(polygon1): z_order_graph.add_edge(polygon2, polygon1) for obj in new_objects: for edge in obj.edges(): if 'below' in graph[edge[0]][edge[1]]: below = graph[edge[0]][edge[1]]['below'] if below != None: for obj_above in new_objects: if obj != obj_above: if obj_above.has_edge(below.start(), below.end()): z_order_graph.add_edge(obj, obj_above) if 'above' in graph[edge[0]][edge[1]]: above = graph[edge[0]][edge[1]]['above'] if above != None: for obj_below in new_objects: if obj != obj_below: if obj_below.has_edge(above.start(), above.end()): z_order_graph.add_edge(obj_below, obj) if 'z_order' in graph[edge[0]][edge[1]]: z_order = graph[edge[0]][edge[1]]['z_order'] if z_order != None: for other_obj in new_objects: if obj != other_obj: if (isinstance(other_obj, Polygon) and other_obj.frame().intersects(edge) ) or (isinstance(other_obj, OpenGraph) and other_obj.intersects(edge)): if z_order == 'above': z_order_graph.add_edge(other_obj, obj) elif z_order == 'below': z_order_graph.add_edge(obj, other_obj) else: raise ValueError, "Wrong value for z_order." cycle_gen = nx.simple_cycles(z_order_graph) try: cycles = list(cycle_gen) for cycle in cycles: cycle_edges = [(cycle[i], cycle[i + 1]) for i in range(0, len(cycle) - 1)] for edge in cycle_edges: z_order_graph.remove_edge(edge[0], edge[1]) if cycles: warnings.warn( "The diagram contains objects. that have an ambiguous z-order. Shaape estimates their z-order.", RuntimeWarning) except: pass current_z_order = 0 while z_order_graph.nodes(): nodes_without_predecessors = [ node for node in z_order_graph.nodes() if not z_order_graph.predecessors(node) ] for node in nodes_without_predecessors: node.set_z_order(current_z_order) current_z_order = current_z_order + 1 z_order_graph.remove_nodes_from(nodes_without_predecessors) for o in new_objects: if type(o) == Polygon or type(o) == OpenGraph: o.reduce_nodes() objects = objects + new_objects objects.append(graph) self._objects = objects self._parsed_data = raw_data return
edges = network_graph.edges() edgelist = [] for u,v in edges: if network_graph[u][v]["weight"] > 2: edgelist.append((u,v)) #colors = [G[u][v]['color'] for u,v in edges] #print (edgelist) color_map = [] for node in network_graph.nodes(data=True): if "color" in node[1]: color_map.append(node[1]["color"]) else: color_map.append("blue") <<<<<<< HEAD labels = nx.get_node_attributes(network_graph, 'label') ======= labels = nx.get_node_attributes(network_graph, 'label') >>>>>>> 37c289bb9f1ea1bf3d1b2249381a42ba3f24027d weights = [network_graph[u][v]['weight'] for u,v in list(edgelist)] degree = network_graph.degree() <<<<<<< HEAD ======= >>>>>>> 37c289bb9f1ea1bf3d1b2249381a42ba3f24027d # blockchain_length = broadcasting_block_logs[key][0]["metadata"]["message"][1]["protocol_state"]["body"]["consensus_state"]["blockchain_length"] pos=nx.nx_agraph.graphviz_layout(network_graph, prog="dot", args="-Nk=30")
def train(self, max_iterations=10000, output_images_dir='images'): """.""" if not os.path.isdir(output_images_dir): os.makedirs(output_images_dir) print("Ouput images will be saved in: {0}".format(output_images_dir)) fignum = 0 self.save_img(fignum, output_images_dir) for i in xrange(1, max_iterations): print("Iterating..{0:d}/{1}".format(i, max_iterations)) for x in self.data: self.update_winner(x) # step 8: if number of input signals generated so far if i % self.lambda_ == 0 and len(self.graph.nodes()) <= self.max_nodes: # find a node with the largest error errorvectors = nx.get_node_attributes(self.graph, 'error') import operator node_largest_error = max(iteritems(errorvectors), key=operator.itemgetter(1))[0] # find a node from neighbor of the node just found, # with largest error neighbors = self.graph.neighbors(node_largest_error) max_error_neighbor = None max_error = -1 errorvectors = nx.get_node_attributes(self.graph, 'error') for n in neighbors: if errorvectors[n] > max_error: max_error = errorvectors[n] max_error_neighbor = n # insert a new unit half way between these two self.pos = nx.get_node_attributes(self.graph, 'pos') newnodepos = self.get_average_dist(self.pos[node_largest_error], self.pos[max_error_neighbor]) self.count = self.count + 1 newnode = self.count self.graph.add_node(newnode, pos=newnodepos) # insert edges between new node and other two nodes self.graph.add_edge(newnode, max_error_neighbor, age=0) self.graph.add_edge(newnode, node_largest_error, age=0) # remove edge between the other two nodes self.graph.remove_edge(max_error_neighbor, node_largest_error) # decrease error variable of other two nodes by multiplying with alpha errorvectors = nx.get_node_attributes(self.graph, 'error') error_max_node = self.alpha * errorvectors[node_largest_error] error_max_second = self.alpha * max_error self.graph.add_node(max_error_neighbor, error=error_max_second) self.graph.add_node(node_largest_error, error=error_max_node) # initialize the error variable of newnode with max_node self.graph.add_node(newnode, error=error_max_node) fignum += 1 self.save_img(fignum, output_images_dir) # step 9: Decrease all error variables errorvectors = nx.get_node_attributes(self.graph, 'error') for i in self.graph.nodes(): olderror = errorvectors[i] newerror = olderror - self.d * olderror self.graph.add_node(i, error=newerror)
or link_types[links] == 'left_bell'] # set delay equal to 1 ms in edge links and equal to 2 ms in core links fnss.set_delays_constant(fnss_topo, 1, 'ms', edge_links) fnss.set_delays_constant(fnss_topo, 2, 'ms', core_links) # set capacity of 10 Mbps in edge links and 40 Mbps in core links fnss.set_capacities_constant(fnss_topo, 10, 'Mbps', edge_links) fnss.set_capacities_constant(fnss_topo, 40, 'Mbps', core_links) # Set buffer size constant to all interfaces fnss.set_buffer_sizes_constant(fnss_topo, 50, 'packets') # Now we deploy a traffic sources on right bell and traffic receivers on left # bell node_types = nx.get_node_attributes(fnss_topo, 'type') core_nodes = [nodes for nodes in node_types if node_types[nodes] == 'core'] left_nodes = [nodes for nodes in node_types if node_types[nodes] == 'left_bell'] right_nodes = [nodes for nodes in node_types if node_types[nodes] == 'right_bell'] # Set nodes on bells to be hosts and nodes on bottleneck path to be switches. # Differently from datacenter topologies, which already provide annotation of # what nodes are hosts and switches, we need to explicitly tell which nodes # are switches and which are hosts to deploy the topology in Mininet hosts = left_nodes + right_nodes switches = core_nodes # Convert FNSS topology to Mininet
G.nodes[i]['pos'] = (3,x-7) G.nodes[i]['dem'] = retailers[i] x += 1 G.add_edges_from([(f,d) for f in factories for d in dcs]) G.add_edges_from([(d,r) for d in dcs for r in retailers]) # Add costs to edges costs = [40,40,42.5,32.5,35,45,35,42.5,25,25,35,40,27.5,25,42.5,35,40,32.5,20,32.5,40,30,27.5,30] c = 0 for i in G.edges: G.edges[i]['cost'] = costs[c] c += 1 pos = nx.get_node_attributes(G, 'pos') sup = nx.get_node_attributes(G, 'sup') dem = nx.get_node_attributes(G, 'dem') cap = nx.get_node_attributes(G, 'cap') cost = nx.get_edge_attributes(G, 'cost') dem_loc, sup_loc, cap_loc = {}, {}, {} for x in pos: if x in factories.keys(): sup_loc[x] = (pos[x][0], pos[x][1]+.15) elif x in retailers.keys(): dem_loc[x] = (pos[x][0], pos[x][1]+.15) else: if x == 'IA': cap_loc[x] = (pos[x][0], pos[x][1]-.15)
def get_infected(G): return [ k for k, v in nx.get_node_attributes(G, STATUS).items() if v == INFECTED ]
def get_status(G): return nx.get_node_attributes(G, STATUS)
os.path.abspath(cmd_args.in_filename)) start_nodes = len(main_dict) #Print plot showing kmer_distribution fig = plt.hist([math.log10(x) for x in main_dict.values()]) #fig = plt.gcf() plt.savefig("kmer_frequency_histo" + output_id + ".png", format="png") #Convert Primary Dictionary to Node_set, filter out kmers with fewer than a minimum occurance cutoff node_set = [(i, { 'weight': j }) for i, j in main_dict.items() if j >= cmd_args.min_node] #Create Nodes in Network with a weight characteristic m_graph.add_nodes_from(node_set) node_weights = nx.get_node_attributes(m_graph, 'weight').values() #If background is defined load the data, check enrichment levels #Remove all nodes that have an enrichment lower than allowable enrichment. if cmd_args.in_background != "": print("Input path resolved to:", os.path.abspath(cmd_args.in_background), file=error_log) background_dict, total_back, seq_back = load_sequences( os.path.abspath(cmd_args.in_background)) back_set = [(i, {'weight': j}) for i, j in background_dict.items()] b_graph = nx.Graph() b_graph.add_nodes_from(back_set) remove_list = []
def any_infected(G): return INFECTED in nx.get_node_attributes(G, STATUS).values()
def drawGraph(G, pos, a, labels): print(globalLabSize, "glob") #Changing G for threshold here #Check filter metric if (globalOptionsMet4 == "Default"): G = G if (globalOptionsMet4 == "Degree"): displayedNodes = [] nx.set_node_attributes(G, values=nx.degree_centrality(G), name='degree') for node, data in G.nodes(data=True): if (data['degree'] > threshold): displayedNodes.append(node) G = G.subgraph(displayedNodes) if (globalOptionsMet4 == "Between Centrality"): displayedNodes = [] # Metrics computing betweenCentralities = nx.betweenness_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=betweenCentralities, name='betweenCentrality') # iterate trough nodes for node, data in G.nodes(data=True): if (data['betweenCentrality'] > threshold): displayedNodes.append(node) G = G.subgraph(displayedNodes) if (globalOptionsMet4 == "Load Centrality"): displayedNodes = [] # Metrics computing loadCentralities = nx.load_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=loadCentralities, name='loadCentrality') # iterate trough nodes for node, data in G.nodes(data=True): if (data['loadCentrality'] > threshold): displayedNodes.append(node) G = G.subgraph(displayedNodes) if (globalOptionsMet4 == "Subgraph Centrality"): displayedNodes = [] # Metrics computing subgraphCentralities = nx.subgraph_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=subgraphCentralities, name='subgraphCentrality') # iterate trough nodes for node, data in G.nodes(data=True): if (data['subgraphCentrality'] > threshold): displayedNodes.append(node) G = G.subgraph(displayedNodes) #Choosing size, the size list will be defined here for the rest of the function sizeM = maxSize sizes = [] if (globalOptionsMet3 == "Default"): for node, data in G.nodes(data=True): sizes.append(sizeM) if (globalOptionsMet3 == "Degree"): degrees = nx.degree_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=degrees, name='degree') # minmax minDeg = min(degrees.values()) maxDeg = max(degrees.values()) #loop trough nodes for node, data in G.nodes(data=True): sizes.append( (normalizeSize(data['degree'], maxDeg, minDeg, sizeM) + 5)) if (globalOptionsMet3 == "Between Centrality"): # Metrics computing betweenCentralities = nx.betweenness_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=betweenCentralities, name='betweenCentrality') # minmax minBetween = min(betweenCentralities.values()) maxBetween = max(betweenCentralities.values()) #loop trough nodes for node, data in G.nodes(data=True): sizes.append((normalizeSize(data['betweenCentrality'], maxBetween, minBetween, sizeM) + 5)) if (globalOptionsMet3 == "Load Centrality"): # Metrics computing loadCentralities = nx.load_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=loadCentralities, name='loadCentrality') # minmax minLoad = min(loadCentralities.values()) maxLoad = max(loadCentralities.values()) #loop trough nodes for node, data in G.nodes(data=True): sizes.append((normalizeSize(data['loadCentrality'], maxLoad, minLoad, sizeM) + 5)) if (globalOptionsMet3 == "Subgraph Centrality"): # Metrics computing subgraphCentralities = nx.subgraph_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=subgraphCentralities, name='subgraphCentrality') # minmax minSub = min(subgraphCentralities.values()) maxSub = max(subgraphCentralities.values()) #loop trough nodes for node, data in G.nodes(data=True): sizes.append((normalizeSize(data['subgraphCentrality'], maxSub, minSub, sizeM) + 5)) #Choosing cmap for colors cmapChosen = plt.cm.viridis if (cmap1 == "Viridis"): cmapChosen = plt.cm.viridis if (cmap1 == "Magma"): cmapChosen = plt.cm.magma if (cmap1 == "Plasma"): cmapChosen = plt.cm.plasma if (cmap1 == "Blues"): cmapChosen = plt.cm.Blues if (cmap1 == "Purples"): cmapChosen = plt.cm.Purples if (cmap1 == "Reds"): cmapChosen = plt.cm.Reds if (cmap1 == "Greens"): cmapChosen = plt.cm.Greens if (cmap1 == "YlOrRd"): cmapChosen = plt.cm.YlOrRd #drawing if (globalOptionsMet2 == "Default"): labelDic = nx.get_node_attributes(G, 'label') nx.draw_networkx_nodes(G, pos=pos, ax=a, node_color=range(len(G)), cmap=cmapChosen, node_size=sizes) nx.draw_networkx_edges(G, pos, edge_color=globalEdgeCol, style=globalEdgeType, alpha=globalEdgeOpacity, ax=a) if (labels): nx.draw_networkx_labels(G, pos, font_size=globalLabSize, ax=a, font_color=globalLabelCol) if (globalOptionsMet2 == "Communities"): cmapUsed = "" if (cmap1 == "Pale"): cmapUsed = ListedColormap( palettable.colorbrewer.qualitative.Set3_12.mpl_colors, N=len(G)) if (cmap1 == "Bright"): cmapUsed = ListedColormap( palettable.colorbrewer.qualitative.Set1_9.mpl_colors, N=len(G)) partition = community.best_partition(G) labelSet = nx.get_node_attributes(G, 'label') size = float(len(set(partition.values()))) count = 0. for com in set(partition.values()): count = count + 1. list_nodes = [ nodes for nodes in partition.keys() if partition[nodes] == com ] nx.draw_networkx_nodes(G, pos, list_nodes, label=labelSet, node_color=cmapUsed(com), ax=a, node_size=sizes) nx.draw_networkx_edges(G, pos, ax=a, edge_color=globalEdgeCol, style=globalEdgeType, alpha=globalEdgeOpacity) if (labels): nx.draw_networkx_labels(G, pos, ax=a, font_size=globalLabSize, font_color=globalLabelCol) if (globalOptionsMet2 == "Degree"): # Metrics computing degrees = nx.degree_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=degrees, name='degree') # minmax minDeg = min(degrees.values()) maxDeg = max(degrees.values()) colDeg = [] # Set the colors that could be used next for node, data in G.nodes(data=True): colDeg.append(normalize(data['degree'], maxDeg, minDeg)) nx.draw_networkx_nodes(G, pos=pos, vmax=1, vmin=0, cmap=cmapChosen, with_labels=labels, node_size=sizes, node_color=colDeg, ax=a) nx.draw_networkx_edges(G, pos, edge_color=globalEdgeCol, style=globalEdgeType, alpha=globalEdgeOpacity, ax=a) if (labels): nx.draw_networkx_labels(G, pos, font_size=globalLabSize, ax=a, font_color=globalLabelCol) if (globalOptionsMet2 == "Between Centrality"): # Metrics computing betweenCentralities = nx.betweenness_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=betweenCentralities, name='betweenCentrality') # minmax minBetween = min(betweenCentralities.values()) maxBetween = max(betweenCentralities.values()) colBetween = [] # Set the colors that could be used next for node, data in G.nodes(data=True): colBetween.append( normalize(data['betweenCentrality'], maxBetween, minBetween)) nx.draw_networkx_nodes(G, pos=pos, vmax=1, vmin=0, cmap=cmapChosen, with_labels=labels, node_size=sizes, node_color=colBetween, ax=a) nx.draw_networkx_edges(G, pos, edge_color=globalEdgeCol, style=globalEdgeType, alpha=globalEdgeOpacity, ax=a) if (labels): nx.draw_networkx_labels(G, pos, font_size=globalLabSize, ax=a, font_color=globalLabelCol) if (globalOptionsMet2 == "Subgraph Centrality"): # Metrics computing subgraphCentralities = nx.subgraph_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=subgraphCentralities, name='subgraphCentrality') # minmax minSub = min(subgraphCentralities.values()) maxSub = max(subgraphCentralities.values()) colSub = [] # Set the colors that could be used next for node, data in G.nodes(data=True): colSub.append(normalize(data['subgraphCentrality'], maxSub, minSub)) nx.draw_networkx_nodes(G, pos=pos, vmax=1, vmin=0, cmap=cmapChosen, with_labels=labels, node_size=sizes, node_color=colSub, ax=a) nx.draw_networkx_edges(G, pos, edge_color=globalEdgeCol, style=globalEdgeType, alpha=globalEdgeOpacity, ax=a) if (labels): nx.draw_networkx_labels(G, pos, font_size=globalLabSize, ax=a, font_color=globalLabelCol) if (globalOptionsMet2 == "Load Centrality"): # Metrics computing loadCentralities = nx.load_centrality(G) # Add metrics as params of the nodes nx.set_node_attributes(G, values=loadCentralities, name='loadCentrality') # minmax minLoad = min(loadCentralities.values()) maxLoad = max(loadCentralities.values()) colLoad = [] # Set the colors that could be used next for node, data in G.nodes(data=True): colLoad.append(normalize(data['loadCentrality'], maxLoad, minLoad)) nx.draw_networkx_nodes(G, pos=pos, vmax=1, vmin=0, cmap=cmapChosen, with_labels=labels, node_size=sizes, node_color=colLoad, ax=a) nx.draw_networkx_edges(G, pos, edge_color=globalEdgeCol, style=globalEdgeType, alpha=globalEdgeOpacity, ax=a) if (labels): nx.draw_networkx_labels(G, pos, font_size=globalLabSize, ax=a, font_color=globalLabelCol)
def setup(self): self._base_class_super_called = True # Code that follows the flow-graph and propagates thermo setup data down the chain node_types = nx.get_node_attributes(self._flow_graph, 'type') node_parents = nx.get_node_attributes(self._flow_graph, 'parent') node_port_names = nx.get_node_attributes(self._flow_graph, 'port_name') G = self._flow_graph # put all starting nodes into a FIFO queue queue = [node for node in self._flow_graph if G.in_degree(node) == 0] visited = set() # use a set, because checking "in" on a queue is slow # loop over all child subsystems and push down cycle level options cycle_level_options = ['thermo_method', 'thermo_data', 'design'] for child_name, child in self._children.items(): for opt in cycle_level_options: if opt in child.options: child.options[opt] = self.options[opt] # note: three kinds of nodes in graph, elements, in_ports, out_ports. # The graph is a tree with (potentially) multiple separate root nodes. # We will do a breadth first search, starting from all starting nodes at the same time. # This makes sure that Elements with multiple inputs will have all # predecessors set up before we get to them. while queue: node = queue.pop(0) node_type = node_types[node] # make sure we've already processed all predecessor nodes # if not skip this one, we'll hit it again later ready_for_node = True for p in G.predecessors(node): if p not in visited: ready_for_node = False break if not ready_for_node: continue queue.extend(G.successors(node)) if node not in visited: if node_type == 'element': node_element = self._get_subsystem(node) node_element.pyc_setup_output_ports() # connection will be out_port -> in_port elif node_type == 'out_port': src_element = self._get_subsystem(node_parents[node]) links = G.out_edges(node) for link in links: # in almost every case there should only be one link, because otherwise you are creating extra mass flow # the one exception is for the cooling calcs, which get some "weak" connections from turbine and bleed srcs target_element = self._get_subsystem( node_parents[link[1]]) # if target element is None there are two options: # 1) there is a sub-cycle that you need to push into # in this case, get the containing sub-cycle and push some starting nodes into its graph based on this linkage # 2) they made a mistake in the element name, so throw an error print(node_parents[link[1]]) out_port = node_port_names[node] in_port = node_port_names[link[1]] # this passes whatever configuration data there was from the src element to the target keyed by port names if out_port not in src_element.Fl_O_data: raise RuntimeError( f'in {self.pathname},{src_element.pathname}.{out_port} has not been properly setup.' f'something is wrong with one of your `pyc_setup_output_ports` method in {src_element.pathname}' ) target_element.Fl_I_data[ in_port] = src_element.Fl_O_data[out_port] visited.add(node)
def __init__(self, G): self._graph = G self.intersections = nx.get_node_attributes(G, "pos") self.roads = [list(G[node]) for node in G.nodes()]
def show_map(M, start=None, goal=None, path=None): G = M._graph pos = nx.get_node_attributes(G, 'pos') edge_trace = Scatter( x=list([]), y=list([]), line=Line(width=0.5,color='#888'), hoverinfo='none', mode='lines') for edge in G.edges(): x0, y0 = G.node[edge[0]]['pos'] x1, y1 = G.node[edge[1]]['pos'] edge_trace['x'] += (x0, x1, None) edge_trace['y'] += (y0, y1, None) x_list = list() y_list = list() color_list = list() text_list = list() for node in G.nodes(): x, y = G.node[node]['pos'] x_list.append(x) y_list.append(y) for node, adjacencies in enumerate(G.adjacency()): color = 0 if path and node in path: color = 2 if node == start: color = 3 elif node == goal: color = 1 # node_trace['marker']['color'].append(len(adjacencies)) color_list.append(color) node_info = "Intersection " + str(node) text_list.append(node_info) node_trace = Scatter( x=x_list, y=y_list, text=text_list, mode='markers', hoverinfo='text', marker=Marker( showscale=False, # colorscale options # 'Greys' | 'Greens' | 'Bluered' | 'Hot' | 'Picnic' | 'Portland' | # Jet' | 'RdBu' | 'Blackbody' | 'Earth' | 'Electric' | 'YIOrRd' | 'YIGnBu' colorscale='Hot', reversescale=True, color=color_list, size=10, colorbar=dict( thickness=15, title='Node Connections', xanchor='left', titleside='right' ), line=dict(width=2))) fig = Figure(data=Data([edge_trace, node_trace]), layout=Layout( title='<br>Network graph made with Python', titlefont=dict(size=16), showlegend=False, hovermode='closest', margin=dict(b=20,l=5,r=5,t=40), xaxis=XAxis(showgrid=False, zeroline=False, showticklabels=False), yaxis=YAxis(showgrid=False, zeroline=False, showticklabels=False))) fig.show()
distance = sqrt((normalizedX - normalized_nodeX) ** 2 + (normalizedy - normalized_nodeY) ** 2) #print(distance) if distance < 1000: node_color[i] = 'green' refreshGraph(graph, node_color, fig) break ''' for file_path in file_paths: relative_path = relpath(file_path, r"C:\Users\Chrips\Aalborg Universitet\Frederik Myrup Thiesson - data\data_for_paper") print(f"{relative_path}") # Plot Original Graph to Get Scale Factor nxg = nx.read_gpickle(file_path) label_dict = nx.get_node_attributes(nxg, 'label') labels = list(label_dict.values()) values = list(set(labels)) # create empty list for node colors node_color = [] # for each node in the graph for lab in labels: if lab == 0.0: node_color.append('blue') elif lab == 1.0: node_color.append('red') pos = nx.get_node_attributes(nxg, 'pos') w, h = figaspect(5 / 3) fig, ax = plt.subplots(figsize=(w, h)) nx.draw(nxg, pos, node_color=node_color, node_size=20, ax=ax)
Method : spectral clustering [] http://scikit-learn.org/stable/modules/clustering.html#spectral-clustering """ import numpy as np import networkx as nx from sklearn.cluster import SpectralClustering from sklearn import metrics np.random.seed(1) # Get your mentioned graph G = nx.karate_club_graph() # Get ground-truth: club-labels -> transform to 0/1 np-array # (possible overcomplicated networkx usage here) gt_dict = nx.get_node_attributes(G, 'club') gt = [gt_dict[i] for i in G.nodes()] gt = np.array([0 if i == 'Mr. Hi' else 1 for i in gt]) # Get adjacency-matrix as numpy-array adj_mat = nx.to_numpy_matrix(G) print('ground truth') print(gt) # Cluster sc = SpectralClustering(2, affinity='precomputed', n_init=100) sc.fit(adj_mat) # Compare ground-truth and clustering-results print('spectral clustering')
core_links = [links for links in link_types if link_types[links] == 'core'] edge_links = [links for links in link_types if link_types[links] == 'right_bell' or link_types[links] == 'left_bell'] # set delay equal to 1 ms in edge links and equal to 2 ms in core links fnss.set_delays_constant(topology, 1, 'ms', edge_links) fnss.set_delays_constant(topology, 2, 'ms', core_links) # set capacity of 10 Mbps in edge links and 40 Mbps in core links fnss.set_capacities_constant(topology, 10, 'Mbps', edge_links) fnss.set_capacities_constant(topology, 40, 'Mbps', core_links) # Now we deploy a traffic sources on right bell and traffic receivers on left # bell node_types = nx.get_node_attributes(topology, 'type') left_nodes = [nodes for nodes in node_types if node_types[nodes] == 'left_bell'] right_nodes = [nodes for nodes in node_types if node_types[nodes] == 'right_bell'] for node in left_nodes: fnss.add_application(topology, node, 'receiver', {}) for node in right_nodes: fnss.add_application(topology, node, 'source', {}) # now create a function that generate events def rand_request(source_nodes, receiver_nodes): source = random.choice(source_nodes) receiver = random.choice(receiver_nodes)
def __init__(self, molecule, optimize=False): """ Instantiation method for FunctionalGroupExtractor. :param molecule: Either a filename, a pymatgen.core.structure.Molecule object, or a pymatgen.analysis.graphs.MoleculeGraph object. :param optimize: Default False. If True, then the input molecule will be modified, adding Hydrogens, performing a simple conformer search, etc. """ self.molgraph = None if isinstance(molecule, str): try: if optimize: obmol = BabelMolAdaptor.from_file(molecule, file_format="mol") # OBMolecule does not contain pymatgen Molecule information # So, we need to wrap the obmol in a BabelMolAdapter obmol.add_hydrogen() obmol.make3d() obmol.localopt() self.molecule = obmol.pymatgen_mol else: self.molecule = Molecule.from_file(molecule) except OSError: raise ValueError("Input must be a valid molecule file, a " "Molecule object, or a MoleculeGraph object.") elif isinstance(molecule, Molecule): if optimize: obmol = BabelMolAdaptor(molecule) obmol.add_hydrogen() obmol.make3d() obmol.localopt() self.molecule = obmol.pymatgen_mol else: self.molecule = molecule elif isinstance(molecule, MoleculeGraph): if optimize: obmol = BabelMolAdaptor(molecule.molecule) obmol.add_hydrogen() obmol.make3d() obmol.localopt() self.molecule = obmol.pymatgen_mol else: self.molecule = molecule.molecule self.molgraph = molecule else: raise ValueError("Input to FunctionalGroupExtractor must be" "str, Molecule, or MoleculeGraph.") if self.molgraph is None: self.molgraph = MoleculeGraph.with_local_env_strategy( self.molecule, OpenBabelNN()) # Assign a specie and coordinates to each node in the graph, # corresponding to the Site in the Molecule object self.molgraph.set_node_attributes() self.species = nx.get_node_attributes(self.molgraph.graph, "specie")
def test_preimage_random_grid_k_median_nb(): ds = {'name': 'MUTAG', 'dataset': '../datasets/MUTAG/MUTAG_A.txt', 'extra_params': {}} # node/edge symb Gn, y_all = loadDataset(ds['dataset'], extra_params=ds['extra_params']) # Gn = Gn[0:50] remove_edges(Gn) gkernel = 'marginalizedkernel' lmbda = 0.03 # termination probalility r_max = 5 # iteration limit for pre-image. l = 500 # update limit for random generation # alpha_range = np.linspace(0.5, 0.5, 1) # k = 5 # k nearest neighbors # parameters for GED function ged_cost='CHEM_1' ged_method='IPFP' saveGXL='gedlib' # number of graphs; we what to compute the median of these graphs. nb_median_range = [2, 3, 4, 5, 10, 20, 30, 40, 50, 100] # number of nearest neighbors. k_range = [5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 100] # find out all the graphs classified to positive group 1. idx_dict = get_same_item_indices(y_all) Gn = [Gn[i] for i in idx_dict[1]] # # compute Gram matrix. # time0 = time.time() # km = compute_kernel(Gn, gkernel, True) # time_km = time.time() - time0 # # write Gram matrix to file. # np.savez('results/gram_matrix_marg_itr10_pq0.03_mutag_positive.gm', gm=km, gmtime=time_km) time_list = [] dis_ks_min_list = [] sod_gs_list = [] sod_gs_min_list = [] nb_updated_list = [] g_best = [] for idx_nb, nb_median in enumerate(nb_median_range): print('\n-------------------------------------------------------') print('number of median graphs =', nb_median) random.seed(1) idx_rdm = random.sample(range(len(Gn)), nb_median) print('graphs chosen:', idx_rdm) Gn_median = [Gn[idx].copy() for idx in idx_rdm] # for g in Gn_median: # nx.draw(g, labels=nx.get_node_attributes(g, 'atom'), with_labels=True) ## plt.savefig("results/preimage_mix/mutag.png", format="PNG") # plt.show() # plt.clf() ################################################################### gmfile = np.load('results/gram_matrix_marg_itr10_pq0.03_mutag_positive.gm.npz') km_tmp = gmfile['gm'] time_km = gmfile['gmtime'] # modify mixed gram matrix. km = np.zeros((len(Gn) + nb_median, len(Gn) + nb_median)) for i in range(len(Gn)): for j in range(i, len(Gn)): km[i, j] = km_tmp[i, j] km[j, i] = km[i, j] for i in range(len(Gn)): for j, idx in enumerate(idx_rdm): km[i, len(Gn) + j] = km[i, idx] km[len(Gn) + j, i] = km[i, idx] for i, idx1 in enumerate(idx_rdm): for j, idx2 in enumerate(idx_rdm): km[len(Gn) + i, len(Gn) + j] = km[idx1, idx2] ################################################################### alpha_range = [1 / nb_median] * nb_median time_list.append([]) dis_ks_min_list.append([]) sod_gs_list.append([]) sod_gs_min_list.append([]) nb_updated_list.append([]) g_best.append([]) for k in k_range: print('\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n') print('k =', k) time0 = time.time() dhat, ghat, nb_updated = preimage_random(Gn, Gn_median, alpha_range, range(len(Gn), len(Gn) + nb_median), km, k, r_max, l, gkernel) time_total = time.time() - time0 + time_km print('time: ', time_total) time_list[idx_nb].append(time_total) print('\nsmallest distance in kernel space: ', dhat) dis_ks_min_list[idx_nb].append(dhat) g_best[idx_nb].append(ghat) print('\nnumber of updates of the best graph: ', nb_updated) nb_updated_list[idx_nb].append(nb_updated) # show the best graph and save it to file. print('the shortest distance is', dhat) print('one of the possible corresponding pre-images is') nx.draw(ghat, labels=nx.get_node_attributes(ghat, 'atom'), with_labels=True) plt.savefig('results/preimage_random/mutag_median_nb' + str(nb_median) + '_k' + str(k) + '.png', format="PNG") # plt.show() plt.clf() # print(ghat_list[0].nodes(data=True)) # print(ghat_list[0].edges(data=True)) # compute the corresponding sod in graph space. sod_tmp, _ = ged_median([ghat], Gn_median, ged_cost=ged_cost, ged_method=ged_method, saveGXL=saveGXL) sod_gs_list[idx_nb].append(sod_tmp) sod_gs_min_list[idx_nb].append(np.min(sod_tmp)) print('\nsmallest sod in graph space: ', np.min(sod_tmp)) print('\nsods in graph space: ', sod_gs_list) print('\nsmallest sod in graph space for each set of median graphs and k: ', sod_gs_min_list) print('\nsmallest distance in kernel space for each set of median graphs and k: ', dis_ks_min_list) print('\nnumber of updates of the best graph for each set of median graphs and k by IAM: ', nb_updated_list) print('\ntimes:', time_list)
def test_random_preimage_2combination(): ds = {'name': 'MUTAG', 'dataset': '../datasets/MUTAG/MUTAG_A.txt', 'extra_params': {}} # node/edge symb Gn, y_all = loadDataset(ds['dataset'], extra_params=ds['extra_params']) # Gn = Gn[0:12] remove_edges(Gn) gkernel = 'marginalizedkernel' # dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, gkernel=gkernel) # print(dis_max, dis_min, dis_mean) lmbda = 0.03 # termination probalility r_max = 10 # iteration limit for pre-image. l = 500 alpha_range = np.linspace(0, 1, 11) k = 5 # k nearest neighbors # randomly select two molecules np.random.seed(1) idx_gi = [187, 167] # np.random.randint(0, len(Gn), 2) g1 = Gn[idx_gi[0]].copy() g2 = Gn[idx_gi[1]].copy() # nx.draw(g1, labels=nx.get_node_attributes(g1, 'atom'), with_labels=True) # plt.savefig("results/random_preimage/mutag10.png", format="PNG") # plt.show() # nx.draw(g2, labels=nx.get_node_attributes(g2, 'atom'), with_labels=True) # plt.savefig("results/random_preimage/mutag11.png", format="PNG") # plt.show() ###################################################################### # Gn_mix = [g.copy() for g in Gn] # Gn_mix.append(g1.copy()) # Gn_mix.append(g2.copy()) # ## g_tmp = iam([g1, g2]) ## nx.draw_networkx(g_tmp) ## plt.show() # # # compute # time0 = time.time() # km = compute_kernel(Gn_mix, gkernel, True) # time_km = time.time() - time0 ################################################################### idx1 = idx_gi[0] idx2 = idx_gi[1] gmfile = np.load('results/gram_matrix_marg_itr10_pq0.03.gm.npz') km = gmfile['gm'] time_km = gmfile['gmtime'] # modify mixed gram matrix. for i in range(len(Gn)): km[i, len(Gn)] = km[i, idx1] km[i, len(Gn) + 1] = km[i, idx2] km[len(Gn), i] = km[i, idx1] km[len(Gn) + 1, i] = km[i, idx2] km[len(Gn), len(Gn)] = km[idx1, idx1] km[len(Gn), len(Gn) + 1] = km[idx1, idx2] km[len(Gn) + 1, len(Gn)] = km[idx2, idx1] km[len(Gn) + 1, len(Gn) + 1] = km[idx2, idx2] ################################################################### time_list = [] nb_updated_list = [] g_best = [] dis_ks_min_list = [] # for each alpha for alpha in alpha_range: print('\n-------------------------------------------------------\n') print('alpha =', alpha) time0 = time.time() dhat, ghat, nb_updated = preimage_random(Gn, [g1, g2], [alpha, 1 - alpha], range(len(Gn), len(Gn) + 2), km, k, r_max, l, gkernel) time_total = time.time() - time0 + time_km print('time: ', time_total) time_list.append(time_total) dis_ks_min_list.append(dhat) g_best.append(ghat) nb_updated_list.append(nb_updated) # show best graphs and save them to file. for idx, item in enumerate(alpha_range): print('when alpha is', item, 'the shortest distance is', dis_ks_min_list[idx]) print('one of the possible corresponding pre-images is') nx.draw(g_best[idx], labels=nx.get_node_attributes(g_best[idx], 'atom'), with_labels=True) plt.show() plt.savefig('results/random_preimage/mutag_alpha' + str(item) + '.png', format="PNG") plt.clf() print(g_best[idx].nodes(data=True)) print(g_best[idx].edges(data=True)) # # compute the corresponding sod in graph space. (alpha range not considered.) # sod_tmp, _ = median_distance(g_best[0], Gn_let) # sod_gs_list.append(sod_tmp) # sod_gs_min_list.append(np.min(sod_tmp)) # sod_ks_min_list.append(sod_ks) # nb_updated_list.append(nb_updated) # print('\nsmallest sod in graph space for each alpha: ', sod_gs_min_list) print('\nsmallest distance in kernel space for each alpha: ', dis_ks_min_list) print('\nnumber of updates for each alpha: ', nb_updated_list) print('\ntimes:', time_list)
def draw_subnetwork_bottom(ax, graph, edge_interest, n=4): """ Creates the sub network from the original network which just includes the neighbors of the interesting edge. The figure displays the rating of the lines in the neighborhood of the critical line. Parameters ---------- ax : matplotlib axes object The axes on which the networkx network would be plotted. graph: networkx MultiGraph object The networkx graph representing the power grid network. n : integer, optional Number of hops to consider from the interesting edge.. The default is 4. Returns ------- ax : matplotlib axes object The axes on which the networkx network would be plotted. """ rate = nx.get_edge_attributes(graph, 'rating') p_inj = nx.get_node_attributes(graph, 'power') interest = get_neighbors(graph, edge_interest, n) xpts = [buses.cord[n][0] for n in list(interest.nodes())] ypts = [buses.cord[n][1] for n in list(interest.nodes())] # Color by rating edgelist_inset = list(interest.edges(keys=True)) nodelist_inset = list(interest.nodes()) ewidth = [] ecolor = [] for e in edgelist_inset: alt_e = (e[1], e[0], e[2]) if e == critical or alt_e == critical: ewidth.append(10) # if e in rate: ewidth.append(rate[e]/200.0) # else: ewidth.append(rate[alt_e]/200.0) ecolor.append('crimson') elif (e in t_sce) or (alt_e in t_sce): ewidth.append(10) ecolor.append('blue') else: ewidth.append(3) # if e in rate: ewidth.append(rate[e]/200.0) # else: ewidth.append(rate[alt_e]/200.0) ecolor.append('black') # Color/size by load and generation nsize = [] ncolor = [] for n in nodelist_inset: if p_inj[n] > 0.0: nsize.append(p_inj[n] / 1.0) ncolor.append('lightsalmon') elif p_inj[n] < 0.0: nsize.append(-p_inj[n] / 1.0) ncolor.append('royalblue') else: nsize.append(2.0) ncolor.append('limegreen') # elabel={(r[0],r[1]):rate[r] for r in rate \ # if r in edgelist_inset or (r[1],r[0],r[2]) in edgelist_inset} nx.draw_networkx(interest, with_labels=False, ax=ax, nodelist=nodelist_inset, pos=buses.cord, node_size=nsize, node_color=ncolor, edgelist=edgelist_inset, width=ewidth, style='dashed', edge_color=ecolor) # nx.draw_networkx_edge_labels(interest,ax=ax,pos=buses.cord,edge_labels=elabel, # font_weight='normal',font_size=25) ax.set_xlim(min(xpts), max(xpts)) ax.set_ylim(min(ypts), max(ypts)) ax.tick_params(bottom=False, left=False, labelleft=False, labelbottom=False) return ax
def get_node_indx(self, node_id) -> int: return nx.get_node_attributes(self._graph, 'indx')[node_id]