def observe(self): """ :return: Current time stamp job-shop graph """ g = nx.OrderedDiGraph() for job_id, job in self.jobs.items(): for op in job.ops: not_start_cond = not (op == job.ops[0]) not_end_cond = not isinstance(op, EndOperation) g.add_node(op.id, **op.x) if not_end_cond: # Construct forward flow conjunctive edges only g.add_edge(op.id, op.next_op.id, distance=(op.next_op.complete_ratio - op.complete_ratio), type=CONJUNCTIVE_TYPE, direction=FORWARD) for disj_op in op.disjunctive_ops: g.add_edge(op.id, disj_op.id, type=DISJUNCTIVE_TYPE) if not_start_cond: g.add_edge(op.id, op.prev_op.id, distance=-(op.complete_ratio - op.prev_op.complete_ratio), type=CONJUNCTIVE_TYPE, direction=BACKWARD) return g
def build_sent_graph(df_sent): """Builds the dependency graph of a sentence.""" sent_graph = nx.OrderedDiGraph() for index, row in df_sent.iterrows(): try: dep_id, head_id, dep_form = row[0], row[6], row[1] pos, deprel = row[3], row[7] node_label = row[11] sent_graph.add_node(dep_id, attr={ 'form': dep_form, 'pos': pos, 'deprel': deprel, 'node_label': node_label }) sent_graph.add_edge(dep_id, head_id, edge_label='0') except IndexError as e: print(e) sent_graph.node['0']['attr'] = { 'form': 'DUMMY-ROOT-FORM', 'pos': 'DUMMY-ROOT-POS', 'deprel': 'root', 'node_label': '0' } return sent_graph
def __init__(self, parameters): '''Set the graph up with all initial data and pruning. This includes parsing the graph file, pruning hubs of the graph and initializing vertex beliefs, vertex reliabilities and trust values on edges. ''' self.parameters = parameters self.centrality_methods = { 'degree': nx.out_degree_centrality, 'closeness': nx.closeness_centrality, 'betweenness': nx.betweenness_centrality, 'eigenvector': self.eigenvectorCentrality, 'random': self.randomCentrality, 'sgd': self.sgdCentrality } G = nx.read_edgelist(parameters["graph_filepath"], create_using=nx.OrderedGraph()) self.graph = nx.OrderedDiGraph(G.to_directed()) self.pruneGraph() self.initializeData()
def convert_to_compact(self, G, store_features): """Generates a compact networkx graph for the input graph. The features of each node and edge are converted to room categories and behavior categories, which may result in a loss of information (e.g. s_r -> s category) in the networkx compact graph. """ nxG_compact = nx.OrderedDiGraph() # Create nodes for node in G.nodes: # Create node if store_features is True: # Store a features attribute nxG_compact.add_node(node.name, room_category=room2category(node.name), features=node['features']) else: nxG_compact.add_node(node.name, room_category=room2category(node.name)) # Create edges for u, v, edge in G.edges(data='object'): if store_features is True: nxG_compact.add_edge(u.name, v.name, behavior_category=behavior_id2category(edge.behavior_id), features=edge['features']) else: nxG_compact.add_edge(u.name, v.name, behavior_category=behavior_id2category(edge.behavior_id)) assert len(nxG_compact.nodes) == len(G.nodes) assert len(nxG_compact.edges) == len(G.edges) return nxG_compact
def get_graph(input_type, loader, transformers): """Given a loader and its transformer return path to desired format e.g which output format should each transformer pick to be chained to the following one in order to obtain the desired outcome for format :param input_type: input type of first node :type input_type: str :param loader: original loader :type loader: KoshLoader :param transformers: set of transformers to be added after loader exits :type transformers: list of KoshTransformer :returns: execution graph :rtype: networkx.OrderDiGraph """ if input_type not in loader.types: raise RuntimeError( "loader cannot load mime_type {}".format(input_type)) G = nx.OrderedDiGraph() G.seed = random.random() start_node = (input_type, loader, G.seed) # so each graph is unique G.add_node(start_node) if len(transformers) == 0: # No transformer for out_format in loader.types[input_type]: node = (out_format, None, G.seed) G.add_edge(start_node, node) else: populate(G, start_node, loader.types[input_type], transformers) return G
def _find_longest_path(self, cell): """ :param cell: a list contains operations and node number such as Genotype.normal or Genotype.reduce :return longest_path: : the longest path in the Genotype.normal or Genotype.reduce as defined in Understanding-NAS """ g = nx.OrderedDiGraph() g.add_node("c_{k-2}") g.add_node("c_{k-1}") assert len(cell) % 2 == 0 steps = len(cell) // 2 for i in range(steps): g.add_node(str(i)) for i in range(steps): for k in [2 * i, 2 * i + 1]: op, j = cell[k] if j == 0: u = "c_{k-2}" elif j == 1: u = "c_{k-1}" else: u = str(j - 2) v = str(i) g.add_edge(u, v, label=op) g.add_node("c_{k}") for i in range(steps): g.add_edge(str(i), "c_{k}") longest_path = len(nx.dag_longest_path(g)) - 1 return longest_path
def __init__(self, input_model): super(NNEFImporter, self).__init__() self.graph_name = "" self.input_model = input_model self.nxgraph = nx.OrderedDiGraph() self.node_pool = collections.OrderedDict()
def test_html_like_labels(): graph = nx.OrderedDiGraph() graph.add_node( 0, label=H.table([ H.table_row([H.table_cell("A", attributes={"COLSPAN": 2})]), H.table_row([H.table_cell("C"), H.table_cell("D")]), ]), ) graph.add_node(1, label=H.bold('3 < 7 "hello" & "world" 5 > 2')) graph.add_node(2, label=H.join(["hello", H.italic("world")])) graph.add_edge(0, 1) style = nxv.Style(node=lambda u, d: d) actual = nxv.render(graph, style, format="raw") expected = textwrap.dedent(""" digraph "G" { graph []; node0000 [label=<<TABLE><TR><TD COLSPAN="2">A</TD></TR><TR><TD>C</TD><TD>D</TD></TR></TABLE>>]; node0001 [label=<<B>3 < 7 "hello" & "world" 5 > 2</B>>]; node0002 [label=<hello<I>world</I>>]; node0000 -> node0001 []; } """).strip() assert actual == expected
def basic() -> nx.OrderedDiGraph: """ Fairly simple graph for testing Returns: A simple graph """ graph = nx.OrderedDiGraph() graph.add_nodes_from([0, 1, 2, 3, 4, 5]) graph.add_edge(0, 1, weight=5000) graph.add_edge(1, 0, weight=5000) graph.add_edge(0, 5, weight=5000) graph.add_edge(5, 0, weight=5000) graph.add_edge(1, 2, weight=5000) graph.add_edge(2, 1, weight=5000) graph.add_edge(1, 5, weight=5000) graph.add_edge(5, 1, weight=5000) graph.add_edge(2, 4, weight=5000) graph.add_edge(4, 2, weight=5000) graph.add_edge(2, 5, weight=5000) graph.add_edge(5, 2, weight=5000) graph.add_edge(3, 4, weight=5000) graph.add_edge(4, 3, weight=5000) graph.add_edge(4, 5, weight=5000) graph.add_edge(5, 4, weight=5000) return graph
def __init__(self, plot=False, numUsers=1, numMalUsers=0, traPerUser=0, reattachment=False): self.time = 1.0 self.realtime = timeee.time() print("DAG: numUsers:" + str(numUsers) + " numMalUsers:" + str(numMalUsers) + " traPerUser:"******" reattachment:" + str(reattachment)) if plot: self.graph = nx.OrderedDiGraph() self.nodes = [] self.addedNodes = [] self.unvalidatedNodes = [] self.users = [] self.currTime = 0 self.nodesToAdd = [] self.traPerUser = traPerUser self.reattachment = reattachment self.numMalUsers = numMalUsers if numUsers < 3: self.users.append(User(id=0, malicious=False)) # TODO: Num mal needs to be 2lower i sayfaya ekle else: malUserIds = np.random.choice(range(2, numUsers), numMalUsers) for i in range(numUsers): self.users.append(User(id=i, malicious=(i in malUserIds)))
def TwoTask(networkGraph = None, nTasks=0, deltax = 100, mobileNodeCount = 0,**kwargs): #reset global taskId counter assert networkGraph is not None, "Network Graph for Task Gen is None" #assert nTasks > 1, "Cant create TwoTaskWithProcessing with less than 2 tasks" Task.taskId = 1 G = nx.OrderedDiGraph() pos1 = list(networkGraph.nodes())[0].pos bound1 = np.array([np.array([pos1[0]-deltax+1,pos1[0]+deltax-1]), np.array([pos1[1]-deltax+1,pos1[1]+deltax-1])]) pos2 = list(networkGraph.nodes())[-(mobileNodeCount+1)].pos bound2 = np.array([np.array([pos2[0]-deltax+1,pos2[0]+deltax-1]), np.array([pos2[1]-deltax+1,pos2[1]+deltax-1])]) first_constraint = {'location' : bound1} task1 = Task(first_constraint) G.add_node(task1) second_constraint = {'location' : bound2} task2 = Task(second_constraint) G.add_node(task2) for i, node in enumerate(list(G.nodes())): if i == 0: continue G.add_edge(list(G.nodes())[i-1], node) for task in G.nodes(): task.set_topology(G) #for x in list(G.nodes()): # print(x.taskId) return G
def OneSink(networkGraph = None, deltax = 100, deltay = 100, verbose = False, sink_location = 'center', **kwargs): assert networkGraph is not None, "Network Graph for Task Gen is None" Task.taskId = 1 G = nx.OrderedDiGraph() if kwargs['network_creator'] == topologies.Grid: ndim = kwargs['dimx'] posCenterx = np.array([list(networkGraph.nodes())[int(ndim/2)].pos[0]-101, list(networkGraph.nodes())[int(ndim/2)].pos[0]+101]) posCentery = np.array([list(networkGraph.nodes())[int(ndim/2)*ndim].pos[1]-101, list(networkGraph.nodes())[int(ndim/2)*ndim].pos[1]+101]) boundCenter = np.array([posCenterx, posCentery]) else: midTask = int(kwargs['nTasks']/2) #actually right task of the two middling tasks #includes the left neighbor as a possible sink task posCenterx = np.array([list(networkGraph.nodes())[midTask].pos[0]-101, list(networkGraph.nodes())[midTask].pos[0]+1]) boundCenter = np.array([posCenterx, np.array([-np.inf, np.inf])]) center_constraint = {'location' : boundCenter} if verbose: print(f"Boundary for center: {boundCenter}") for i in range(kwargs['nTasks']-1): G.add_node(Task({'location' : None})) G.add_node(Task(center_constraint)) for i in range(kwargs['nTasks']-1): G.add_edge(list(G.nodes())[i], list(G.nodes())[-1]) for task in G.nodes(): task.set_topology(G) return G
def EncodeDecode(networkGraph = None, nTasks = 19, deltax = 100, deltay = 100, mobileNodeCount = 0, verbose = False, **kwargs): assert networkGraph is not None, "Network Graph for Task Gen is None" Task.taskId = 1 G = nx.OrderedDiGraph() ndim = kwargs['dimx'] #encoding happens on the left half of the network, 0 - int(ndim/2) validTaskCounts = [5, 13, 19, 25, 31, 37, 43,49,55,61,67,73,79] if nTasks ==5: n_outer = 1 n_inner = 1 else: n_outer = int((nTasks-1)/3) n_inner = int((n_outer)/2) assert nTasks in validTaskCounts, f"{nTasks} is not a valid task count for the EncodeDecode Setup! \n Valid Setups: {validTaskCounts}" staticNodes = list(networkGraph.nodes)[:ndim**2] posEncode = np.array([list(staticNodes)[0].pos[0]-deltax+1, list(staticNodes)[int(ndim/2)].pos[0]+deltax-1]) boundEncode = np.array([posEncode, np.array([-np.inf, np.inf])]) if verbose: print(f"Boundary for encode: {boundEncode}") posDecode = np.array([list(staticNodes)[int(ndim/2)].pos[0]-deltax+1, list(staticNodes)[-1].pos[0]+deltax-1]) boundDecode = np.array([posDecode, np.array([-np.inf, np.inf])]) if verbose: print(f"Boundary for Decode: {boundDecode}") posCenter = np.array([list(staticNodes)[int(ndim/2)].pos[0]-deltax+1, list(staticNodes)[int(ndim/2)].pos[0]+deltax-1]) boundCenter = np.array([posCenter, np.array([-np.inf, np.inf])]) if verbose: print(f"Boundary for center: {boundCenter}") decode_constraint = {'location' : boundDecode} encode_constraint = {'location' : boundEncode} center_constraint = {'location' : boundCenter} for i in range(n_outer): G.add_node(Task(encode_constraint)) for i in range(n_inner): G.add_node(Task()) G.add_node(Task()) for i in range(n_inner): G.add_node(Task()) for i in range(n_outer): G.add_node(Task(decode_constraint)) #add edges between outer left and inner left: for i in range(n_outer): for j in range(n_outer, n_outer+n_inner): G.add_edge(list(G.nodes())[i], list(G.nodes())[j]) #edges between inner left and center for i in range(n_outer, n_outer+n_inner): G.add_edge(list(G.nodes())[i], list(G.nodes())[n_outer+n_inner]) for i in range(n_outer+n_inner+1, n_outer+n_inner+1+n_inner): G.add_edge(list(G.nodes())[n_outer+n_inner], list(G.nodes())[i]) for j in range(nTasks - n_outer, nTasks): G.add_edge(list(G.nodes())[i], list(G.nodes())[j]) for task in G.nodes(): task.set_topology(G) return G
def plot_pred(G, pred, target, devices): plt.axes().set_aspect(1.0) G = nx.OrderedDiGraph(G, nodelist=range(len(G))) plot_graph_edges(G, devices) pos=nx.get_node_attributes(G,'pos') # Fault faultpos = G.nodes[target]['pos'] plt.scatter(faultpos[0], faultpos[1], marker='x', color='red', s=130, label='Falta', zorder=25) # Devices colors = list(map({0.5: 'red', 1: 'None', 1.5: 'black'}.get, devices[:len(G)])) nx.set_node_attributes(G, dict(zip(range(len(G)), colors)), 'color') nx.set_node_attributes(G, 50, 'size') G.nodes[0]['size'] = 150 ax = nx.draw_networkx_nodes(G, pos, node_shape='s', node_size=[G.nodes[node]['size'] for node in G], node_color=[G.nodes[node]['color'] for node in G], zorder=20) pred = np.array([pred[n] for n in list(G)]) cmap=plt.cm.viridis vmin = 0 vmax = 1 ax = nx.draw_networkx_nodes(G, pos, node_size=5000*pred, alpha=0.2, cmap=cmap, node_color=pred, vmin=vmin, vmax=vmax, zorder=500) #sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=vmin, vmax=vmax)) #sm._A = [] #plt.colorbar(sm,fraction=0.022, pad=0.02, orientation='horizontal') plt.axis('off')
def sort_graph(G_): G_sort = nx.OrderedDiGraph() G_sort.graph["id"] = G_.graph["id"] G_sort.add_nodes_from( sorted(G_.nodes(data=True), key=lambda x: x[1]['order'])) G_sort.add_edges_from( sorted(G_.edges(data=True), key=lambda x: x[2]['order'])) return G_sort
def create_graphs_from_scan_ids(scan_dependents: list, scan_events: dict, ion_injection_times: dict): """ Create Directed Graph from scan dependent relationships :param scan_dependents: :param scan_events: :param ion_injection_times: :return: :rtype: """ graphs = [] G = nx.OrderedDiGraph() G.add_edges_from( sorted(list(scan_dependents), key=operator.itemgetter(0, 1))) for subgraph in [G.subgraph(c) for c in nx.weakly_connected_components(G)]: edges = sorted(list(subgraph.edges()), key=operator.itemgetter(0, 1)) nodes = sorted(subgraph.nodes()) replicates_within, its = collections.OrderedDict( ), collections.OrderedDict() for n in nodes: replicates_within.setdefault(scan_events[n], []).append(n) its.setdefault(scan_events[n], []).append(ion_injection_times[n]) G = nx.OrderedDiGraph() for rw in replicates_within: scan_info = [(None, None, 0.0)] scan_info.extend( re.findall(r'([\w\.-]+)@([a-zA-Z]+)(\d+\.\d+)', rw)) G.add_node(rw, scanids=replicates_within[rw], mslevel=len(scan_info), coltype=scan_info[-1][1], colenergy=float(scan_info[-1][2]), injectiontimes=its[rw], flag=True) G.add_edges_from([(scan_events[e[0]], scan_events[e[1]]) for e in edges]) graphs.append(G) return graphs
def test_attribute_dict_integrity(self): # we must not replace dict-like graph data structures with dicts G = nx.OrderedGraph() G.add_nodes_from("abc") H = to_networkx_graph(G, create_using=nx.OrderedGraph) assert list(H.nodes) == list(G.nodes) H = nx.OrderedDiGraph(G) assert list(H.nodes) == list(G.nodes)
def observe(self, detach_done=True): """ :return: Current time stamp job-shop graph """ g = nx.OrderedDiGraph() for job_id, job in self.jobs.items(): for op in job.ops: not_start_cond = not (op == job.ops[0]) not_end_cond = not (op == job.ops[-1]) done_cond = op.x['type'] == DONE_NODE_SIG if detach_done: if not done_cond: g.add_node(op.id, **op.x) if not_end_cond: # Construct forward flow conjunctive edges only g.add_edge(op.id, op.next_op.id, processing_time=op.processing_time, type=CONJUNCTIVE_TYPE, direction=FORWARD) for disj_op in op.disjunctive_ops: if disj_op.x['type'] != DONE_NODE_SIG: g.add_edge(op.id, disj_op.id, type=DISJUNCTIVE_TYPE) if not_start_cond: if op.prev_op.x['type'] != DONE_NODE_SIG: g.add_edge(op.id, op.prev_op.id, processing_time=-1 * op.prev_op.processing_time, type=CONJUNCTIVE_TYPE, direction=BACKWARD) else: g.add_node(op.id, **op.x) if not_end_cond: # Construct forward flow conjunctive edges only g.add_edge(op.id, op.next_op.id, processing_time=op.processing_time, type=CONJUNCTIVE_TYPE, direction=FORWARD) if not_start_cond: g.add_edge(op.id, op.prev_op.id, processing_time=-1 * op.prev_op.processing_time, type=CONJUNCTIVE_TYPE, direction=BACKWARD) for disj_op in op.disjunctive_ops: g.add_edge(op.id, disj_op.id, type=DISJUNCTIVE_TYPE) return g
def execution_graph(self, seed=None, verbose=False, png_template="LOADER_GRAPH_{}"): """makes a new graph with unique seed Helps networkx differentiate between identical loaders/transformers/operators :param seed: seed to use for new graph :type seed: int :param verbose: verbose generation, also generates a png with the grap representation Mostly used for debug purposes :type verbose: bool :param png_template: template to use to generate graph png in verbose mode "_IN"/"_OUT" will be appended and seed will be fed :type png_template: str :return a new graph with new seed :rtype: networkx.OrderedDiGraph """ G = nx.OrderedDiGraph() if seed is None: seed = random.random() G.seed = seed if verbose: try: if "DISPLAY" not in os.environ or os.environ["DISPLAY"] == "": import matplotlib matplotlib.use("agg", force=True) import matplotlib.pyplot as plt nx.draw(self._graph) plt.show() png_name = png_template + "_IN.png" plt.savefig(png_name.format(seed)) plt.clf() except ImportError: raise RuntimeError("Could not import matplotlib, will not plot anything") used_nodes = collections.OrderedDict() for (n1, n2) in self._graph.edges(): if n1 in used_nodes: # we already generated a new random number for that node N1 = used_nodes[n1] else: # Never seen that node seed = get_seed(self._graph, n1, G.seed) N1 = n1[0], n1[1], seed used_nodes[n1] = N1 if n2 in used_nodes: # we already generated a new random number for that node N2 = used_nodes[n2] else: # Never seen that node seed = get_seed(self._graph, n2, G.seed) N2 = n2[0], n2[1], seed used_nodes[n2] = N2 G.add_edge(N1, N2) if verbose: nx.draw(G) plt.show() png_name = png_template + "_OUT.png" plt.savefig(png_name.format(seed)) plt.clf() return G
def get_graph(self): try: graph = tree_graph(self.tree) except: graph = nx.OrderedDiGraph() G = nx.drawing.nx_agraph.to_agraph(graph) return G, self.active_nodes
def sizes_to_graph(fpath, total=True, progress=True): if is_path(fpath) and total is True: total = count_lines(fpath) logger.info("constructing tree") g = nx.OrderedDiGraph() total_size = 0 total_descendants = 0 with ensure_file(fpath, "rb") as f: for line in tqdm(f, total=total, desc="adding files to tree", disable=not progress): *path_b_items, size_b = line.strip().split(SEP) path = SEP.join(path_b_items) prefix = ROOT + os.sep.encode() if not path.startswith(prefix): path = os.path.join(ROOT, path) size = int(size_b) g.add_node(path, size=size, descendants=0) total_size += size total_descendants += 1 child = path for parent in path_parents(path): parent_in_g = parent in g # calculate size and descendants up front: probably slower # child_d = g.nodes[child] # if parent_in_g: # parent_d = g.nodes[parent] # parent_d["size"] += child_d["size"] # parent_d["descendants"] += 1 + child_d["descendants"] # else: # total_descendants += 1 # g.add_node( # parent, # size=child_d["size"], # descendants=child_d["descendants"] + 1 # ) g.add_edge(parent, child) # allow size and descendants to be calculated later if parent_in_g: break total_descendants += 1 child = parent logger.info( "constructed tree with files of total size %s", ieee_size(total_size), ) g.graph["total_size"] = total_size g.graph["total_descendants"] = total_descendants - 1 return g
def call(self): DG = nx.OrderedDiGraph() edge_labels = self.get_edge_labels() edge_colors = self.get_edge_colors() levels = {} for n in self.nodes: if n.state(): color = '#9bba5e' if n.first_fixed else '#5eba7d' else: color = '#d0d0d0' DG.add_node(n.pi, label=n.s_binary(), color=color) if n.level() in levels: levels[n.level()] = levels[n.level()] + 1 else: levels[n.level()] = 1 for p in list(n.elements.keys()): if n.pi != p: DG.add_edge(p, n.pi) node_positions = {} tmp = levels.copy() for n in self.nodes: l = n.level() st = -50 * l sp = (400 + l * 100) / (levels[l] + 1) node_positions[n.pi] = (sp * (levels[l] - tmp[l] + 1) + st, -50 * l) tmp[l] = tmp[l] - 1 colors = list(map(lambda n: n[1]['color'], DG.nodes(data=True))) labels = {node[0]: node[1]['label'] for node in DG.nodes(data=True)} edge_colors_ord = list( map(lambda e: edge_colors[e[0], e[1]], DG.edges(data=True))) plt.figure(figsize=(10, 8)) nx.draw(DG, connectionstyle='arc3, rad = 0.03', node_size=600, node_color=colors, pos=node_positions, prog='dot', labels=labels, edge_color=edge_colors_ord, font_size=7) nx.draw_networkx_edge_labels(DG, node_positions, edge_labels=edge_labels, font_size=6, label_pos=0.25) # plt.axis('off') plt.show()
def load_qrep(fn): assert ".pkl" in fn with open(fn, "rb") as f: query = pickle.load(f) query["subset_graph"] = \ nx.OrderedDiGraph(json_graph.adjacency_graph(query["subset_graph"])) query["join_graph"] = json_graph.adjacency_graph(query["join_graph"]) return query
def random_ordered_tree(n, seed=None, pool=None): import kwarray rng = kwarray.ensure_rng(seed, 'python') tree = nx.dfs_tree(nx.random_tree(n, seed=seed)) otree = nx.OrderedDiGraph() otree.add_edges_from(tree.edges) if pool is not None: for node in otree.nodes: otree.nodes[node]['label'] = rng.choice(pool) return otree
def get_graph(self): # Create a graph from the JSON data, or fall back to an empty graph try: graph = tree_graph(self.tree) except: graph = nx.OrderedDiGraph() G = nx.drawing.nx_agraph.to_agraph(graph) return G, self.active_nodes
def tree_graph(data, attrs=_attrs): """Return graph from tree data format. Parameters ---------- data : dict Tree formatted graph data Returns ------- G : NetworkX OrderedDiGraph attrs : dict A dictionary that contains two keys 'id' and 'children'. The corresponding values provide the attribute names for storing NetworkX-internal graph data. The values should be unique. Default value: :samp:`dict(id='id', children='children')`. Examples -------- >>> from networkx.readwrite import json_graph >>> G = nx.OrderedDiGraph([(1,2)]) >>> data = json_graph.tree_data(G,root=1) >>> H = json_graph.tree_graph(data) Notes ----- The default value of attrs will be changed in a future release of NetworkX. See Also -------- tree_graph, node_link_data, adjacency_data """ graph = nx.OrderedDiGraph() id_ = attrs['id'] children = attrs['children'] def add_children(parent, children_): for data in children_: child = data[id_] graph.add_edge(parent, child) grandchildren = data.get(children, []) if grandchildren: add_children(child, grandchildren) nodedata = dict((make_str(k), v) for k, v in data.items() if k != id_ and k != children) graph.add_node(child, **nodedata) root = data[id_] children_ = data.get(children, []) nodedata = dict((make_str(k), v) for k, v in data.items() if k != id_ and k != children) graph.add_node(root, **nodedata) add_children(root, children_) return graph
def crear_grafo(circuito): g = nx.OrderedDiGraph() for i in range(0, len(circuito)): for j in range(0, len(circuito[0])): puerta = circuito[i][j] g.add_node(puerta) if (puerta.puerta_entrada1 != None): g.add_edge(puerta.puerta_entrada1, puerta) if (puerta.puerta_entrada2 != None): g.add_edge(puerta.puerta_entrada2, puerta) nx.draw(g)
def __init__(self): self._root = None self._edges = None # DiGraph with edges pointing towards root self._disto_proximal = nx.OrderedDiGraph() # views of disto_proximal self._undirected = self._disto_proximal.to_undirected(as_view=True) self._proximo_distal = self._disto_proximal.reverse(copy=False) self._length_key = "_length"
def simple_network(): g = nx.graph_atlas(150) h = nx.OrderedDiGraph() for u, v in g.edges(): h.add_edge(u, v) net = pg.create_empty_network() for n in h.nodes: pg.create_bus(net, level="BP", name="BUS{}".format(n)) for n in [0, 3, "F"]: pg.create_bus(net, level="MP", name="BUSMP{}".format(n)) for u, v in h.edges: pg.create_pipe(net, "BUS{}".format(u), "BUS{}".format(v), length_m=1e4, diameter_m=0.05, name="PIPE{}-{}".format(u, v)) for i in [2, 4, 5]: pg.create_load(net, "BUS{}".format(i), p_kW=10.0, name="LOAD{}".format(i)) for i in [0, 3]: bus_mp = "BUSMP{}".format(i) bus_bp = "BUS{}".format(i) pg.create_station(net, bus_mp, bus_bp, p_lim_kW=50, p_Pa=1.022e5, name="STATION{}".format(i)) pg.create_pipe(net, "BUSMP0", "BUSMP3", length_m=300, diameter_m=0.05, name="PIPEMP0-3") pg.create_pipe(net, "BUSMPF", "BUSMP0", length_m=300, diameter_m=0.05, name="PIPEMPF-0") pg.create_feeder(net, "BUSMPF", p_lim_kW=50, p_Pa=0.9e5, name="FEEDER") return net
def paths_to_otree(paths): tree = nx.OrderedDiGraph() for path in sorted(paths): parts = tuple(path.split(sep)) node_path = [] for i in range(1, len(parts) + 1): node = parts[0:i] tree.add_node(node) tree.nodes[node]['label'] = node[-1] node_path.append(node) for u, v in ub.iter_window(node_path, 2): tree.add_edge(u, v) return tree