def main():
# Create a directed graph
G = nx.DiGraph()
# An example
l=[ ('a','b'),
('b','c'),
('c','d'),
('d','e'),
('e','f'),
('w','x'),
('w','t'),
('t','q'),
('q','r'),
('q','u')]
# Build up a graph
for t in l:
G.add_edge(t[0], t[1])
# Plot trees
pos = graphviz_layout(G, prog='dot')
nx.draw(G, pos, with_labels=True, arrows=False)
plt.savefig('draw_trees_with_pygraphviz.png', bbox_inches='tight')
plt.show()
def draw(self, zscale=1):
for n in self.history:
if len(self.history[n]) % 2 != 0:
self.history[n].append(self.turn)
pos = graphviz_layout(self.wot, "twopi")
for n in self.history:
periods = list(zip(self.history[n], self.history[n][1:]))
for i, p in enumerate(periods):
nbpoints = abs(p[1] - p[0])*zscale
zline = linspace(p[0]*zscale, p[1]*zscale, nbpoints)
xline = linspace(pos[n][0], pos[n][0], nbpoints)
yline = linspace(pos[n][1], pos[n][1], nbpoints)
plot = self.ax.plot(xline, zline, yline, zdir='y', color=self.colors[n][0], alpha=1/(i % 2 + 1))
for link in self.past_links:
nbpoints = abs(pos[link[2]][0] - pos[link[1]][1])*zscale
zline = linspace(link[0]*zscale, link[0]*zscale, nbpoints)
xline = linspace(pos[link[2]][0], pos[link[1]][0], nbpoints)
yline = linspace(pos[link[2]][1], pos[link[1]][1], nbpoints)
if link[1] in self.colors:
self.ax.plot(xline, zline, yline, zdir='y', color=self.colors[link[1]][0], alpha=0.1)
#txt = self.ax.text(pos[n][0], pos[n][1], self.history[n][0]*zscale, n[:5], 'z')
self.ax.set_xlim3d(-5, max([p[0] for p in pos.values()]))
self.ax.set_ylim3d(-5, max([p[1] for p in pos.values()]))
self.ax.set_zlim3d(-5, (self.turn+1)*zscale)
def draw_comm_detection_res(graph):
pos = graphviz_layout(graph)
color_list = ['r', 'g', 'b', 'y']
comm_dict, partition = get_comm_dict_and_partition(graph)
# nodes
for comm_id in comm_dict:
nx.draw_networkx_nodes(graph, pos, nodelist=comm_dict[comm_id],
node_color=color_list[comm_id], node_size=500, alpha=0.8)
# edges
def get_edge_dict():
edge_dict = {}
for comm_id in comm_dict:
edge_dict[comm_id] = []
for edge in graph.edges():
if partition[edge[0]] == partition[edge[1]]:
edge_dict[partition[edge[0]]].append(edge)
return edge_dict
edge_list_dict = get_edge_dict()
nx.draw_networkx_edges(graph, pos, width=4.0, alpha=0.5, edge_color='grey')
for comm_id in edge_list_dict:
print comm_id, color_list[comm_id], edge_list_dict[comm_id]
nx.draw_networkx_edges(graph, pos, edgelist=edge_list_dict[comm_id],
width=8, alpha=0.5, edge_color=color_list[comm_id])
# labels
nx.draw_networkx_labels(graph, pos, font_size=16)
plt.axis('off')
plt.savefig('./karate_partition.pdf', bbox_inches='tight', pad_inches=0, transparent=True)
plt.savefig('./karate_partition.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def drawTrie(trie_dict):
"""
Draws the trie structure of the PHT from dictionnary.
@param trie_dict: Dictionnary of index entries (prefix -> entry).
@type trie_dict: dict
"""
prefixes = list(trie_dict.keys())
if len(prefixes) == 0:
return
edges = list([])
for prefix in prefixes:
for i in range(-1, len(prefix)-1):
u = prefix[:i+1]
x = ("." if i == -1 else u, u+"0")
y = ("." if i == -1 else u, u+"1")
if x not in edges:
edges.append(x)
if y not in edges:
edges.append(y)
# TODO: use a binary tree position layout...
# UPDATE : In a better way [change lib]
G = nx.Graph(sorted(edges, key=lambda x: len(x[0])))
plt.title("PHT: Tree")
pos=graphviz_layout(G,prog='dot')
nx.draw(G, pos, with_labels=True, node_color='white')
plt.show()
def draw_graph(graph):
pos = graphviz_layout(graph)
nx.draw(graph, pos, width=4.0, alpha=0.5, edge_color='grey',
node_color='white', node_size=500, with_labels=True)
plt.axis('off')
plt.savefig('./origin_graph_before_lp' '.pdf', bbox_inches='tight', pad_inches=0, transparent=True)
plt.savefig('./origin_graph_before_lp' '.png', bbox_inches='tight', pad_inches=0, transparent=True)
def get_tree_layout(self, connected_component):
layout = None
tree = self.get_underlying_tree(connected_component)
try:
# Nice circular layout if you have graphviz
from networkx.drawing.nx_agraph import graphviz_layout
layout = graphviz_layout(tree, prog='twopi', root=str(tree.root))
# Scale to fit grid, since twopi seems to ignore the size option
min_x = min(pos[0] for pos in layout.values())
max_x = max(pos[0] for pos in layout.values())
min_y = min(pos[1] for pos in layout.values())
max_y = max(pos[1] for pos in layout.values())
center_x = min_x + (max_x - min_x) / 2
center_y = min_y + (max_y - min_y) / 2
# Re-center, scale and shift to fit the desired bounding box
try:
x_scale = (0.5 - self.layout_margin - 0.005) / (center_x - min_x)
except ZeroDivisionError:
x_scale = 1
try:
y_scale = (0.5 - self.layout_margin - 0.005) / (center_y - min_y)
except ZeroDivisionError:
y_scale = 1
for vert, pos in layout.iteritems():
layout[vert] = ((pos[0] - center_x) * x_scale + 0.5,
(pos[1] - center_y) * y_scale + 0.5)
except ImportError:
# Spring layout if you do not have grahpviz
layout = nx.spring_layout(tree, scale=1-2*self.layout_margin-0.01,
center=(0.5, 0.5))
return layout
def draw_graph(nodes, edges, graphs_dir, default_lang='all'):
lang_graph = nx.MultiDiGraph()
lang_graph.add_nodes_from(nodes)
for edge in edges:
if edges[edge] == 0:
lang_graph.add_edge(edge[0], edge[1])
else:
lang_graph.add_edge(edge[0], edge[1], weight=float(edges[edge]), label=str(edges[edge]))
# print graph info in stdout
# degree centrality
print('-----------------\n\n')
print(default_lang)
print(nx.info(lang_graph))
try:
# When ties are associated to some positive aspects such as friendship or collaboration,
# indegree is often interpreted as a form of popularity, and outdegree as gregariousness.
DC = nx.degree_centrality(lang_graph)
max_dc = max(DC.values())
max_dc_list = [item for item in DC.items() if item[1] == max_dc]
except ZeroDivisionError:
max_dc_list = []
# https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8
print('maxdc', str(max_dc_list), sep=': ')
# assortativity coef
AC = nx.degree_assortativity_coefficient(lang_graph)
print('AC', str(AC), sep=': ')
# connectivity
print("Слабо-связный граф: ", nx.is_weakly_connected(lang_graph))
print("количество слабосвязанных компонент: ", nx.number_weakly_connected_components(lang_graph))
print("Сильно-связный граф: ", nx.is_strongly_connected(lang_graph))
print("количество сильносвязанных компонент: ", nx.number_strongly_connected_components(lang_graph))
print("рекурсивные? компоненты: ", nx.number_attracting_components(lang_graph))
print("число вершинной связности: ", nx.node_connectivity(lang_graph))
print("число рёберной связности: ", nx.edge_connectivity(lang_graph))
# other info
print("average degree connectivity: ", nx.average_degree_connectivity(lang_graph))
print("average neighbor degree: ", sorted(nx.average_neighbor_degree(lang_graph).items(),
key=itemgetter(1), reverse=True))
# best for small graphs, and our graphs are pretty small
print("pagerank: ", sorted(nx.pagerank_numpy(lang_graph).items(), key=itemgetter(1), reverse=True))
plt.figure(figsize=(16.0, 9.0), dpi=80)
plt.axis('off')
pos = graphviz_layout(lang_graph)
nx.draw_networkx_edges(lang_graph, pos, alpha=0.5, arrows=True)
nx.draw_networkx(lang_graph, pos, node_size=1000, font_size=12, with_labels=True, node_color='green')
nx.draw_networkx_edge_labels(lang_graph, pos, edges)
# saving file to draw it with dot-graphviz
# changing overall graph view, default is top-bottom
lang_graph.graph['graph'] = {'rankdir': 'LR'}
# marking with blue nodes with maximum degree centrality
for max_dc_node in max_dc_list:
lang_graph.node[max_dc_node[0]]['fontcolor'] = 'blue'
write_dot(lang_graph, os.path.join(graphs_dir, default_lang + '_links.dot'))
# plt.show()
plt.savefig(os.path.join(graphs_dir, 'python_' + default_lang + '_graph.png'), dpi=100)
plt.close()
def visualize(graphs, viz_path, args_viz_format):
import matplotlib
from networkx.drawing.nx_agraph import graphviz_layout
meta_graph = networkx.Graph()
for graph in graphs:
add_graph(meta_graph, graph)
pos = graphviz_layout(meta_graph)
networkx.draw(meta_graph, pos)
if viz_path:
ext = os.path.splitext(viz_path)[1]
if ext == '.dot':
viz_format = 'graphviz'
elif ext == '.png':
viz_format = 'png'
else:
viz_format = args_viz_format
if viz_format == 'graphviz':
from networkx.drawing.nx_pydot import write_dot
assert viz_path is not None, 'Must provide a filename to --visualize if using --viz-format "graphviz".'
base_path = os.path.splitext(viz_path)
write_dot(meta_graph, base_path+'.dot')
run_command('dot', '-T', 'png', '-o', base_path+'.png', base_path+'.dot')
logging.info('Wrote image of graph to '+base_path+'.dot')
elif viz_format == 'png':
if viz_path is None:
matplotlib.pyplot.show()
else:
matplotlib.pyplot.savefig(viz_path)
def main( ):
g = nx.DiGraph( )
# Add x nodes.
xs = np.arange(0, 11)
ys = np.arange(0, 11)
[ g.add_node( 'x=%d' % i, w = i ) for i in xs ]
[ g.add_node( 'y=%d' % i, w = i ) for i in ys ]
# Now add edges.
img = { }
for x in xs:
for z in [1,2,3]:
y = (x + z) % 11
g.add_edge( 'x=%d' % x, 'y=%d' % y, label='z=%d' % z, prob=1/3)
print( '%d + %d -> %d' % (x, z, y) )
img[ (x, y) ] = 1/3
mat = np.zeros( shape=(11,11) )
for k, v in img.items( ):
mat[ k ] = v
nx.draw_networkx( g, pos = graphviz_layout( g, 'dot' ) )
nx.drawing.nx_agraph.write_dot( g, 'network.dot' )
plt.savefig( 'graph.png' )
def draw_comm_detection_res(graph):
pos = graphviz_layout(graph)
color_list = ['r', 'g', 'b', 'y']
comm_dict, partition = get_comm_dict_and_partition()
# nodes
for comm_id in comm_dict:
nx.draw_networkx_nodes(graph, pos, nodelist=comm_dict[comm_id],
node_color=color_list[comm_id], node_size=500, alpha=0.8)
nx.draw_networkx_nodes(graph, pos, nodelist=[9, 11],
node_color='w', node_size=500, alpha=0.8)
nx.draw_networkx_nodes(graph, pos, nodelist=[31], node_color='y', node_size=500, alpha=0.8)
nx.draw_networkx_nodes(graph, pos, nodelist=[0], node_color='magenta', node_size=500, alpha=0.8)
nx.draw_networkx_edges(graph, pos, width=4.0, alpha=0.5, edge_color='grey')
# labels
nx.draw_networkx_labels(graph, pos, font_size=16)
plt.axis('off')
plt.savefig('./clique_percolation_karate_partition.pdf', bbox_inches='tight', pad_inches=0, transparent=True)
plt.savefig('./clique_percolation_karate_partition.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def plot_graph(graph):
from networkx.drawing.nx_agraph import graphviz_layout
pos = graphviz_layout(graph, prog='dot')
for h in nx.connected_component_subgraphs(graph.to_undirected()):
nx.draw(h, pos, with_labels=True)
plt.show()
def visualize_a_graph(graph):
pos = graphviz_layout(graph)
nx.draw(graph, pos, width=4.0, alpha=0.5, edge_color='grey',
node_color='white', node_size=500, with_labels=True)
nx.draw_networkx_edge_labels(graph, pos)
nx.draw_networkx_labels(graph, pos)
plt.axis('off')
plt.show()
def plot_nx(bn,**kwargs):
"""
Draw BayesNet object from networkx engine
"""
g = nx.DiGraph(bn.E)
pos = graphviz_layout(g,'dot')
#node_size=600,node_color='w',with_labels=False
nx.draw_networkx(g,pos=pos, **kwargs)
plt.axis('off')
plt.show()
def graph_traditional_object_file(self, nodes_to_ignore):
if len(self.object_list) == 0:
return
G = nx.DiGraph()
node_rooms_list = []
node_labels = {}
for o in self.object_list:
if o.parent_id in nodes_to_ignore:
nodes_to_ignore.append(o.object_id)
continue
elif o.object_id in nodes_to_ignore:
continue
G.add_node(o.object_key())
if ROOM_ATTRIBUTE_KEY in (int(attribute) for attribute in o.attributes):
node_rooms_list.append(o.object_key())
node_labels[o.object_key()] = o.description
for o in self.object_list:
if o.object_key() not in G.nodes():
continue
if o.parent_id != 0 and o.object_id not in nodes_to_ignore:
parent_key = self.object_list[o.parent_id - 1].object_key()
node_key_to_get = node_labels.get(parent_key, "")
if node_key_to_get is not "":
node_labels[parent_key] = node_key_to_get + '\n\t' + o.description
else:
node_labels[parent_key] = o.description
for direction, node in o.directions.items():
if node < len(self.object_list):
G.add_edge(self.object_list[node-1].object_key(), o.object_key(), direction=direction)
pos = graphviz_layout(G, prog='dot')
edge_labels = dict([((u, v,), d['direction'])
for u, v, d in G.edges(data=True)])
nx.draw_networkx_nodes(G, pos, nodelist=node_rooms_list,
node_color="b", node_size=5000, alpha=0.8)
nx.draw_networkx_edges(G, pos)
nx.draw_networkx_labels(G, pos, labels=node_labels, font_size=8)
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8, alpha=0.5)
plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None)
plt.show()
def one_layout(self, func, kwargs):
"""Calculates one arbitrary layout"""
if 'fixed' in kwargs.keys():
if not kwargs['fixed'] is None:
kwargs['pos'] = nx.random_layout(self.G, dim=kwargs['dim'])
if func == 'dh_spring_layout':
return self.dh_spring_layout(self.G, **kwargs)
elif func == 'draw_graphviz':
return graphviz_layout(self.G, **kwargs)
else:
return getattr(nx, func)(self.G, **kwargs)
def desenhaGrafo(G,pngfilename): # desenha o grafo e salva numa imagem png
edge_labels=dict([((u,v,),d['weight']) # gera os labels das arestas
for u,v,d in G.edges(data=True)])
colors = [G[u][v]['color'] for u,v in G.edges()]
pos = graphviz_layout(G,prog='neato') # obtem a posicao dos nos (para desenhalo) # TODO: desativar isso?
nx.draw_networkx_edges(G,pos, edge_color=colors) # desenha as arestas
nx.draw_networkx_labels(G,pos) # desenha os labels das arestas
nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels) # desenha os labels dos nos
nx.draw_networkx_nodes(G,pos,node_color='w') # desenha os nos
plt.axis('off') # desativa os eixos
plt.savefig(pngfilename)
plt.close("all")
def plot(self, savepath=None):
"""
Draw this individual.
"""
from networkx.drawing.nx_agraph import graphviz_layout
fig = plt.figure(figsize=(40, 30))
tree = self.tree # type: nx.DiGraph
pos = graphviz_layout(tree, root=0, prog='dot')
node_list = tree.nodes(data=True)
edge_list = tree.edges(data=True)
node_labels = {
x[0]: '%s: %s\n%s' % (str(x[1]['node_id']), str(x[1]['label']), '%s/%s' % (
str(x[1]['inst_correct']), str(x[1]['inst_total'])) if x[1]['terminal'] else '')
for x in node_list
}
node_colors = [x[1]['color'] for x in node_list]
edge_labels = {(x1, x2): d['threshold'] for x1, x2, d in edge_list}
nx.draw_networkx_nodes(tree, pos, node_size=1000, node_color=node_colors) # nodes
nx.draw_networkx_edges(tree, pos, edgelist=edge_list, style='dashed') # edges
nx.draw_networkx_labels(tree, pos, node_labels, font_size=16) # node labels
nx.draw_networkx_edge_labels(tree, pos, edge_labels=edge_labels, font_size=16)
plt.text(
0.2,
0.9,
'\n'.join([
'individual id: %03.d' % self.ind_id,
'height: %d' % self.height,
'n_nodes: %d' % self.n_nodes,
'train accuracy: %0.4f' % self.train_acc_score,
'val accuracy: %0.4f' % self.val_acc_score,
'test accuracy: %0.4f' % self.test_acc_score if self.test_acc_score is not None else '',
'iteration: %d' % self.iteration if self.iteration is not None else ''
]),
fontsize=15,
horizontalalignment='right',
verticalalignment='top',
transform=fig.transFigure
)
plt.axis('off')
if savepath is not None:
plt.savefig(savepath, bbox_inches='tight', format='pdf')
plt.close()
def vis_input(graph):
pos = graphviz_layout(graph)
nx.draw(graph, with_labels=True, pos=pos, font_size=16, node_size=600, alpha=0.8, width=4,
edge_color='grey', node_color='white')
edge_dict = {}
for edge in graph.edges():
edge_dict[edge] = graph[edge[0]][edge[1]]['w']
nx.draw_networkx_edge_labels(graph, pos, edge_labels=edge_dict, font_size=14, alpha=0.1, font_color='blue')
plt.axis('off')
plt.savefig('./demo_graph.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def draw_circular_graph(self):
""" Draws a circular graph from the previously computed graph
:return: None
"""
pos = graphviz_layout(self.graph, prog="twopi", args="")
plt.figure(figsize=(8, 8))
nx.draw(self.graph, pos, node_size=20, alpha=0.5, node_color="blue", with_labels=False)
nx.draw_networkx_labels(self.graph, pos, self.labels, font_size=6)
plt.axis("equal")
plt.savefig("circular_tree.png")
plt.show()
def draw_link_graph(graph):
pos = graphviz_layout(graph)
# pos = nx.circular_layout(graph)
nx.draw(graph, pos, width=4.0, alpha=0.5, edge_color='grey', node_size=2000, node_shape='s', with_labels=True,
font_size=20, node_color='w')
edge_dict = {}
for edge in graph.edges():
edge_dict[edge] = str(list(set(edge[0]).intersection(set(edge[1]))))
# nx.draw_networkx_edge_labels(graph, pos,edge_labels=edge_dict, font_size=6)
plt.axis('off')
plt.savefig('./link_graph.pdf', bbox_inches='tight', pad_inches=0, transparent=True)
plt.savefig('./link_graph.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def draw_label_propagation_graph(graph, comm_dict, number):
pos = graphviz_layout(graph)
nx.draw(graph, pos, width=4.0, alpha=0.5, edge_color='grey',
node_color='white', node_size=500, with_labels=True)
color_dict = {6: 'red', 8: 'green', 10: 'blue', 13: 'yellow', 27: 'pink', 29: 'purple', 31: 'black', 32: 'orange',
33: 'cyan'}
for idx, comm in comm_dict.iteritems():
nx.draw_networkx_nodes(graph, pos, nodelist=comm, node_color=color_dict[idx], node_size=500, alpha=0.5)
plt.axis('off')
plt.savefig('./label_propagation_iter' + str(number) + '.pdf', bbox_inches='tight', pad_inches=0, transparent=True)
plt.savefig('./label_propagation_iter' + str(number) + '.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def vis_post_output(graph, comm_list, color_list):
pos = graphviz_layout(graph)
nx.draw(graph, with_labels=True, pos=pos, font_size=16, node_size=600, alpha=0.8, width=4,
edge_color='grey', node_color='white')
for idx, comm in enumerate(comm_list):
nx.draw_networkx_nodes(graph, with_labels=True, pos=pos, font_size=16, node_size=600, alpha=0.8, width=4,
node_color=color_list[idx], nodelist=comm)
edge_dict = {}
for edge in graph.edges():
edge_dict[edge] = graph[edge[0]][edge[1]]['w']
nx.draw_networkx_edge_labels(graph, pos, edge_labels=edge_dict, font_size=14, alpha=0.1, font_color='blue')
plt.axis('off')
plt.savefig('./output_post_graph' + '.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def draw_lanl_graph(self):
""" Draws a lanl graph from the previously computed graph.
:return: None
"""
lanl_graph = sorted(nx.connected_component_subgraphs(self.graph), key=len, reverse=True)[0]
plt.figure(figsize=(8, 8))
# use graphviz to find radial layout
pos = graphviz_layout(self.graph, prog="twopi", root=self.root)
# draw nodes, coloring by rtt ping time
nx.draw(self.graph, pos, with_labels=False, alpha=0.5, node_size=15)
# adjust the plot limits
xmax = 1.02 * max(xx for xx, yy in pos.values())
ymax = 1.02 * max(yy for xx, yy in pos.values())
plt.xlim(0, xmax)
plt.ylim(0, ymax)
# plt.show()
plt.savefig("lanl_routes.png")
def dbg_draw(self, filename):
"""
Draw the graph and save it to a PNG file.
"""
import matplotlib.pyplot as pyplot # pylint: disable=import-error
from networkx.drawing.nx_agraph import graphviz_layout # pylint: disable=import-error
tmp_graph = networkx.DiGraph()
for from_block, to_block in self.transition_graph.edges():
node_a = "%#08x" % from_block.addr
node_b = "%#08x" % to_block.addr
if node_b in self._ret_sites:
node_b += "[Ret]"
if node_a in self._call_sites:
node_a += "[Call]"
tmp_graph.add_edge(node_a, node_b)
pos = graphviz_layout(tmp_graph, prog='fdp') # pylint: disable=no-member
networkx.draw(tmp_graph, pos, node_size=1200)
pyplot.savefig(filename)
def handle_file(path):
i = open(path, "r")
lines = i.readlines()
g = nx.parse_edgelist(lines[1:], nodetype=int, data=(('weight', float),))
x1, x2, vol = lines[0].rstrip("\n").split(" ")
i.close()
x1 = int(x1)
x2 = int(x2)
vol = float(vol)
g.add_node(0)
g.add_weighted_edges_from([(0, x1, 0), (0, x2, 0)])
calculate(g, vol)
# create directed graph for presentation
result = nx.DiGraph()
result.add_nodes_from(nx.nodes(g))
for x1, x2 in nx.edges(g):
sx1, sx2 = tuple(sorted((x1, x2)))
if g[x1][x2]['current'] > 0:
result.add_edge(sx1, sx2, current=g[x1][x2]['current'])
else:
result.add_edge(sx2, sx1, current=-g[x1][x2]['current'])
pos = graphviz_layout(result, prog='sfdp',)
nx.draw_networkx_nodes(result, pos=pos, node_size=250, node_color='white')
edges = nx.edges(result)
currents_dict = nx.get_edge_attributes(result, 'current')
currents_list = tuple(currents_dict[e] for e in edges)
widths_list = tuple(0.3 + 4 * x/max(currents_list) for x in currents_list)
colors = ("green", "yellow", "red")
colors_list = [colors[(math.floor(len(colors)*x/max(widths_list) - 0.1))]
for x in widths_list]
for key, val in currents_dict.items():
currents_dict[key] = "{:.1f}".format(val)
nx.draw_networkx_edges(result, pos=pos, edgelist=edges, width=widths_list,
edge_color=colors_list)
bbox_props = dict(boxstyle="square,pad=0", fc="none", ec='none', lw=2)
nx.draw_networkx_edge_labels(result, pos=pos, edge_labels=currents_dict,
font_size=8, bbox=bbox_props)
nx.draw_networkx_labels(result, pos=pos, font_size=8)
plt.get_current_fig_manager().full_screen_toggle()
plt.show()
def plot_network_with_results(psstc, model, time=0):
G = create_network(psstc)
fig, axs = plt.subplots(1, 1, figsize=(12, 9))
ax = axs
line_color_dict = dict()
hour = 0
for i, b in branch_df.iterrows():
if model.ThermalLimit[i] != 0:
line_color_dict[(b['F_BUS'], b['T_BUS'])] = round(abs(model.LinePower[i, hour].value / model.ThermalLimit[i]), 2)
else:
line_color_dict[(b['F_BUS'], b['T_BUS'])] = 0
gen_color_dict = dict()
hour = 0
for i, g in generator_df.iterrows():
gen_color_dict[(i, g['GEN_BUS'])] = round(abs(model.PowerGenerated[i, hour].value / model.MaximumPowerOutput[i]), 2)
color_dict = line_color_dict.copy()
color_dict.update(gen_color_dict)
edge_color = list()
for e in G.edges():
try:
edge_color.append( color_dict[(e[0], e[1])] )
except KeyError:
edge_color.append( color_dict[(e[1], e[0])] )
ax.axis('off')
pos = graphviz_layout(G, prog='sfdp')
nx.draw_networkx_nodes(G, pos, list(generator_df.index),)
nx.draw_networkx_nodes(G, pos, list(bus_df.index), node_color='black',)
edges = nx.draw_networkx_edges(G, pos, edge_color=edge_color, edge_cmap=cmap, width=3)
nx.draw_networkx_edge_labels(G, pos, edge_labels=color_dict)
divider = make_axes_locatable(ax)
cax = divider.append_axes("left", size="5%", pad=0.05)
cb = plt.colorbar(edges, cax=cax)
cax.yaxis.set_label_position('left')
cax.yaxis.set_ticks_position('left')
def main(fname):
try:
cells, spacing, zones, J, _ = parse_qca_file(fname, one_zone=True)
except:
print('Failed to process QCA file: {0}'.format(fname))
return None
# convert J to specified adjacency
J = 1.*(convert_adjacency(cells, spacing, J, adj=ADJ) != 0)
G = nx.Graph(J)
for k in G:
G.node[k]['w'] = 1./len(G[k])**2
pos = graphviz_layout(G)
nx.draw(G, pos=pos, with_labels=True)
plt.show()
chlebikova(G)
def show_tree(J, tree):
''' '''
G = nx.Graph(J)
pos = graphviz_layout(G)
if not tree['children']:
return
# color nodes
colors = ['r', 'b', 'g', 'k', 'm', 'c', 'o', 'y']
for i, child in enumerate(tree['children']):
inds = child['inds']
print(inds)
color = colors[i%len(colors)]
nx.draw_networkx_nodes(G, pos, nodelist=inds, node_color=color)
nx.draw_networkx_edges(G, pos)
plt.show()
for child in tree['children']:
inds = child['inds']
show_tree(J[inds, :][:, inds], child)
def draw_partitioned_link_graph(graph, comm_list):
pos = graphviz_layout(graph)
# pos = nx.circular_layout(graph)
nx.draw(graph, pos, width=4.0, alpha=0.8, edge_color='grey',
node_color='white', node_size=2000, node_shape='s', with_labels=True, font_size=20)
color_list = ['red', 'green', 'blue', 'purple', 'pink', 'orange', 'black', 'orange']
for idx, comm in enumerate(comm_list):
print idx, comm
nx.draw_networkx_nodes(graph, pos, nodelist=comm, node_color=color_list[idx],
node_size=2000, node_shape='s', alpha=0.4, font_size=20)
edge_dict = {}
for edge in graph.edges():
edge_dict[edge] = str(list(set(edge[0]).intersection(set(edge[1]))))
# nx.draw_networkx_edge_labels(graph, pos,edge_labels=edge_dict, font_size=6)
plt.axis('off')
plt.savefig('./link_partition_graph.pdf', bbox_inches='tight', pad_inches=0, transparent=True)
plt.savefig('./link_partition_graph.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def try_different_layouts(graph):
layout_dir = 'graph_layout'
if not os.path.exists(layout_dir):
os.mkdir('graph_layout')
nx.draw_random(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'rand.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_circular(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'circular.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_spectral(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'spectral.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_networkx(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'networkx.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw(graph, pos=graphviz_layout(graph), with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4,
edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'graphviz.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_shell(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'shell.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_spring(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'spring.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
from os.path import join as pJoin
from networkx.drawing.nx_agraph import graphviz_layout
_myDir = os.path.dirname(os.path.abspath(__file__))
IN_PATH_OMD = pJoin(_myDir, 'superModel Tomorrow.omd')
OUT_PATH_OMD = pJoin(_myDir, 'superModel Tomorrow with latlons.omd')
with open(IN_PATH_OMD, 'r') as jsonFile:
omd = json.load(jsonFile)
tree = omd['tree']
# Use graphviz to lay out the graph.
inGraph = feeder.treeToNxGraph(tree)
# HACK: work on a new graph without attributes because graphViz tries to read attrs.
cleanG = nx.Graph(inGraph.edges())
# HACK2: might miss nodes without edges without the following.
cleanG.add_nodes_from(inGraph)
pos = graphviz_layout(cleanG, prog='neato')
# # Charting the feeder in matplotlib:
# feeder.latLonNxGraph(inGraph, labels=False, neatoLayout=True, showPlot=True)
# Insert the latlons.
for key in tree:
obName = tree[key].get('name', '')
thisPos = pos.get(obName, None)
if thisPos != None:
tree[key]['longitude'] = thisPos[0]
tree[key]['latitude'] = thisPos[1]
with open(OUT_PATH_OMD, 'w') as outFile:
json.dump(omd, outFile)
def visualize_pouct_search_tree(root,
max_depth=1,
visit_threshold=1,
anonymize=False,
anonymize_actions=False,
anonymize_observations=False,
output_file=None,
use_dot=False,
ax=None):
"""
Visualize the given tree up to depth `max_depth`. Display nodes
with number of visits >= `visit_threshold`.
If anonymize is True, will only display actions as a1,a2,... and observations
as o1,o2,... .
"""
relabel_actions = {}
relabel_observations = {}
if anonymize:
anonymize_actions = True
anonymize_observations = True
if anonymize_actions or anonymize_observations:
_build_relabel_dict(root,
None,
0,
relabel_actions,
relabel_observations,
max_depth=max_depth,
visit_threshold=visit_threshold)
print("---- Action labels ----")
action_map = {
relabel_actions[action]: action
for action in relabel_actions
}
for label in sorted(action_map):
print("%s : %s" % (label, action_map[label]))
print("---- Observation labels ----")
observation_map = {
relabel_observations[ob]: ob
for ob in relabel_observations
}
for label in sorted(observation_map):
print("%s : %s" % (label, observation_map[label]))
if not anonymize_actions:
relabel_actions = {}
if not anonymize_observations:
relabel_observations = {}
# Build a networkx graph.
G = nx.DiGraph()
_build_graph(G,
root,
None,
None,
0,
max_depth=max_depth,
visit_threshold=visit_threshold,
relabel_actions=relabel_actions,
relabel_observations=relabel_observations)
if use_dot:
if output_file is None:
raise TypeError("Please provide output .dot file.")
nx.nx_agraph.write_dot(G, output_file)
print("Dot file saved at %s" % output_file)
print("Please run `dot -Tpng %s > %s.png" % (output_file, output_file))
else:
node_labels = {}
color_map = []
for node in G.nodes():
belief_str = ""
if hasattr(node, "belief"):
belief_str = " | %d" % len(node.belief)
if isinstance(node, RootVNode):
color_map.append("cyan")
node_labels[node] = "R(%d | %.2f%s)" % (node.num_visits,
node.value, belief_str)
elif isinstance(node, VNode):
color_map.append("yellow")
node_labels[node] = "V(%d | %.2f%s)" % (node.num_visits,
node.value, belief_str)
else:
color_map.append("orange")
node_labels[node] = "Q(%d | %.2f)" % (node.num_visits,
node.value)
edge_labels = {(edge[0], edge[1]): edge[2]["label"]
for edge in G.edges(data=True)}
edge_widths = [edge[2]["weight"] for edge in G.edges(data=True)]
pos = graphviz_layout(G, prog='dot')
nx.draw_networkx(G,
pos,
node_color=color_map,
labels=node_labels,
width=edge_widths,
font_size=7,
ax=ax)
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, ax=ax)
if output_file is None:
plt.show()
else:
plt.savefig(output_file)
def pathmodel_pathway_picture(asp_code, picture_name, input_filename):
"""
Create the pathway picture using ASP results code from PathModel inference.
Args:
asp_code (str): string containing PathModel results
picture_name (str): path to the output picture file
input_filename (str): path to PathModel intermediary file
"""
DG = nx.DiGraph()
known_compounds = []
inferred_compounds = []
known_reactions = []
inferred_reactions = []
absent_molecules = []
with open(input_filename, 'r') as intermediate_file:
for answer in ASP(intermediate_file.read(), use_clingo_module=False
).parse_args.by_predicate.discard_quotes:
for predicate in answer:
if predicate == "absentmolecules":
for atom in answer[predicate]:
absent_molecules.append(atom[0])
for answer in ASP(
asp_code,
use_clingo_module=False).parse_args.by_predicate.discard_quotes:
for predicate in answer:
for atom in answer[predicate]:
reaction = atom[0]
reactant = atom[1]
product = atom[2]
if predicate == "reaction":
if reactant not in absent_molecules:
known_compounds.append(reactant)
if product not in absent_molecules:
known_compounds.append(product)
if product not in absent_molecules and reactant not in absent_molecules:
known_reactions.append((reactant, product))
DG.add_edge(reactant, product, label=reaction)
elif predicate == "newreaction":
if 'Prediction_' in reactant:
inferred_compounds.append(reactant)
if 'Prediction_' in product:
inferred_compounds.append(product)
inferred_reactions.append((reactant, product))
DG.add_edge(reactant, product, label=reaction)
plt.figure(figsize=(25, 25))
nx.draw_networkx_nodes(DG,
graphviz_layout(DG, prog='neato'),
nodelist=known_compounds,
node_color="green",
node_size=3000,
node_shape='s',
alpha=0.5)
nx.draw_networkx_nodes(DG,
graphviz_layout(DG, prog='neato'),
nodelist=inferred_compounds,
node_color="blue",
node_size=2000,
node_shape='s',
alpha=0.5)
nx.draw_networkx_edges(DG,
graphviz_layout(DG, prog='neato'),
edgelist=known_reactions,
edge_color="green",
alpha=0.5,
width=2.0,
arrows=True,
arrowstyle='->',
arrowsize=14)
nx.draw_networkx_edges(DG,
graphviz_layout(DG, prog='neato'),
edgelist=inferred_reactions,
edge_color="blue",
alpha=0.5,
width=2.0,
arrows=True,
arrowstyle='->',
arrowsize=14)
nx.draw_networkx_labels(DG,
graphviz_layout(DG, prog='neato'),
font_size=15)
ax = plt.gca()
ax.set_axis_off()
extension = os.path.splitext(picture_name)[1].strip('.')
plt.savefig(picture_name, dpi=144, format=extension)
def crunch_graphical_model(pgm_path, path_datasets):
from networkx.drawing.nx_agraph import graphviz_layout
import plotly.graph_objs as go
from plotly.offline import plot
def build_graph(series):
G = nx.DiGraph()
node_labels = dict()
for node_id in xrange(series.shape[1]):
probs = series[:, node_id]
G.add_node(node_id,
attr_dict=dict(color=max(probs),
probs='<br>'.join([
'%2.3f : %s' % (y, x)
for x, y in it.izip(columns, probs)
])))
parent = get_parent(node_id)
if parent is not None:
G.add_edge(parent, node_id)
node_labels[node_id] = node_id
return G
def build_edges(_G):
edge_trace = go.Scatter(x=[],
y=[],
line=go.Line(width=0.5, color='#999'),
hoverinfo='none',
mode='lines',
name='edges')
for edge in _G.edges():
x0, y0 = pos[edge[0]]
x1, y1 = pos[edge[1]]
edge_trace['x'] += [x0, x1, None]
edge_trace['y'] += [y0, y1, None]
return edge_trace
def build_nodes(_G, _generation):
nodes = _G.nodes(data=True)
_node_trace = go.Scatter(
x=[pos[node[0]][0] for node in nodes],
y=[pos[node[0]][1] for node in nodes],
name='gen %d' % _generation,
text=[x[1]['probs'] for x in nodes],
mode='markers',
visible=True if _generation == 0 else 'legendonly',
hoverinfo='text',
marker=go.Marker(
showscale=True,
color=[x[1]['color'] for x in nodes],
colorscale='RdBu',
colorbar=dict(
title='Assurance',
xpad=100,
),
cmin=0., # minimum color value
cmax=1., # maximum color value
cauto=False, # do not automatically fit color values
reversescale=False,
size=15,
line=dict(width=2)))
return _node_trace
sep = '\\' if os.name == 'nt' else '/'
dataset_name = pgm_path.split(sep)[-1].split('_')[0]
dataset = load_dataframe(
os.path.join(path_datasets, dataset_name + '.arff'))
columns = dataset.columns
n_columns = dataset.shape[1]
del dataset
data = []
with open(pgm_path, 'r') as f:
csv_w = csv.reader(f, delimiter=',', quotechar='\"')
for generation, line in enumerate(csv_w):
series = np.array(line, dtype=np.float).reshape(
n_columns,
-1) # each row is an attribute, each column a generation
G = build_graph(series)
pos = graphviz_layout(G, root=0, prog='dot')
if generation == 0:
data.append(build_edges(G))
node_trace = build_nodes(G, generation)
data += [node_trace]
fig = go.Figure(
data=go.Data(data),
layout=go.Layout(
title='Probabilistic Graphical Model<br>Dataset %s' %
dataset_name,
titlefont=dict(size=16),
showlegend=True,
hovermode='closest',
xaxis=go.XAxis(showgrid=False,
zeroline=False,
showticklabels=False),
yaxis=go.YAxis(showgrid=False,
zeroline=False,
showticklabels=False),
))
plot(fig, filename=pgm_path.split(sep)[-1] + '.html')
print('Initial Graph G')
print('Edges: ')
print(G.edges(data=True))
print('Nodes: ')
print(G.nodes(data=True))
n = len(G)
#creating the source sensor node graph with fixed edges
# G = nx.cycle_graph(5)
# G.add_edge(0,1,weight=2)
# G.add_edge(0,3,weight=3)
# G.add_edge(0,4,weight=3)
# G.add_edge(1,2,weight=3)
# G.add_edge(2,3,weight=5)
# G.add_edge(3,4,weight=2)
G.pos = graphviz_layout(G)
#sensor nodes are represented by green and relay nodes by red
print("Green nodes indicate Sensor nodes and Red nodes indicate Relay nodes")
colorvalues = [
'green' if node[1].get('sensornode') else 'red'
for node in G.nodes(data=True)
]
#ploting the source sensor node graph G
plt.figure(figsize=(20, 14))
plt.title("Sensor Node Graph G")
pos = G.pos
edge_labels = nx.get_edge_attributes(G, 'length')
nx.draw_networkx_edge_labels(G,
pos,
def display_graph(self):
"""
Transform the graph to a `networkx.DiGraph`-structure and display it using `matplotlib` -- if the necessary
libraries are installed.
:return: `True` if the graph was drawn, `False` otherwise.
"""
G = self.create_network_graph()
if _nx and _plt and G:
try:
from networkx.drawing.nx_agraph import graphviz_layout
pos = graphviz_layout(G, prog='dot')
except ModuleNotFoundError:
from networkx.drawing.layout import shell_layout
pos = shell_layout(G)
except ImportError:
from networkx.drawing.layout import shell_layout
pos = shell_layout(G)
_plt.subplot(111)
_plt.axis('off')
_nx.draw_networkx_nodes(G,
pos,
node_color='r',
node_size=1250,
nodelist=[
v.display_name for v in self.vertices
if v.is_sampled
])
_nx.draw_networkx_nodes(G,
pos,
node_color='b',
node_size=1250,
nodelist=[
v.display_name for v in self.vertices
if v.is_observed
])
for v in self.vertices:
_nx.draw_networkx_edges(G,
pos,
arrows=True,
edgelist=[(a.display_name,
v.display_name)
for a in v.ancestors])
if v.condition_ancestors is not None and len(
v.condition_ancestors) > 0:
_nx.draw_networkx_edges(G,
pos,
arrows=True,
style='dashed',
edge_color='g',
edgelist=[
(a.display_name,
v.display_name)
for a in v.condition_ancestors
])
_nx.draw_networkx_labels(G,
pos,
font_color='w',
font_weight='bold')
_plt.show()
return True
else:
return False
def p_statement_if(p):
'''statement : IF LPAREN comparison RPAREN COLON NAME EQUALS expression SEMICOLON
| IF LPAREN comparison RPAREN COLON NAME EQUALS expression SEMICOLON ELSE COLON NAME EQUALS expression SEMICOLON'''
if p[3]:
names[p[6]] = p[8]
if p[12] is not None:
plt.clf()
plt.cla()
b.clear()
b.add_node('stmt')
b.add_nodes_from(['if','comp','stmt1','else','stmt2'])
b.add_edges_from([('stmt','if'),('stmt','comp'),('stmt','stmt1'),('stmt','else'),('stmt','stmt2')])
b.add_node(p[3])
b.add_edge('comp',p[3])
b.add_nodes_from(['name1','equel1','exp1'])
b.add_edges_from([('stmt1','name1'),('stmt1','equel1'),('stmt1','exp1')])
b.add_nodes_from(['name2','equel2','exp2'])
b.add_edges_from([('stmt2','name2'),('stmt2','equel2'),('stmt2','exp2')])
b.add_node(p[6])
b.add_node(p[8])
b.add_edge('name1',p[6])
b.add_edge('exp1',p[8])
b.add_node(p[12])
b.add_node(p[14])
b.add_edge('name2',p[12])
b.add_edge('exp2',p[14])
plt.title("if-else-statement")
pos = graphviz_layout(b, prog='dot')
nx.draw(b,pos, with_labels=True, arrows=True, node_size=600)
plt.show()
plt.clf()
plt.cla()
else:
plt.clf()
plt.cla()
b.clear()
b.add_node('stmt')
b.add_nodes_from(['if','comp','stmt1'])
b.add_edges_from([('stmt','if'),('stmt','comp'),('stmt','stmt1')])
b.add_node(p[3])
b.add_edge('comp',p[3])
b.add_nodes_from(['name1','equel1','exp1'])
b.add_edges_from([('stmt1','name1'),('stmt1','equel1'),('stmt1','exp1')])
b.add_node(p[6])
b.add_node(p[8])
b.add_edge('name1',p[6])
b.add_edge('exp1',p[8])
plt.title("ifstatement")
pos = graphviz_layout(b, prog='dot')
nx.draw(b,pos, with_labels=True, arrows=True, node_size=600)
plt.show()
plt.clf()
plt.cla()
else:
try:
if p[12] is not None:
names[p[12]] = p[14]
plt.clf()
plt.cla()
b.clear()
b.add_node('stmt')
b.add_nodes_from(['if','comp','stmt1','else','stmt2'])
b.add_edges_from([('stmt','if'),('stmt','comp'),('stmt','stmt1'),('stmt','else'),('stmt','stmt2')])
b.add_node(p[3])
b.add_edge('comp',p[3])
b.add_nodes_from(['name1','equel1','exp1'])
b.add_edges_from([('stmt1','name1'),('stmt1','equel1'),('stmt1','exp1')])
b.add_nodes_from(['name2','equel2','exp2'])
b.add_edges_from([('stmt2','name2'),('stmt2','equel2'),('stmt2','exp2')])
b.add_node(p[6])
b.add_node(p[8])
b.add_edge('name1',p[6])
b.add_edge('exp1',p[8])
b.add_node(p[12])
b.add_node(p[14])
b.add_edge('name2',p[12])
b.add_edge('exp2',p[14])
plt.title("if-else-statement")
nx.nx_agraph.write_dot(b,'test.dot')
pos = graphviz_layout(b, prog='dot')
nx.draw(b,pos, with_labels=True, arrows=True, node_size=600)
plt.show()
plt.clf()
plt.cla()
except:
pass
ip.pop(i-1)
ip.pop(i)
i = 0
top_prio, count_ops = find_top_prio(ip)
if len(ip) == 1:
op_lst.append(['=', ip[i], ' ', 'a'])
i += 1
i = 1
while i in range(1,len(op_lst)):
print(op_lst[i])
i+=1
b.clear()
for i in range(1,len(op_lst)):
if op_lst[i][2]==' ':
break
else:
b.add_node(op_lst[i][1])
b.add_node(op_lst[i][2])
b.add_node(op_lst[i][3])
b.add_edges_from([(op_lst[i][3],op_lst[i][1]),(op_lst[i][3],op_lst[i][2])])
if len(op_lst)>1:
plt.title("calcustatement")
pos = graphviz_layout(b, prog='dot')
nx.draw(b,pos, with_labels=True, arrows=True, node_size=600)
plt.show()
plt.clf()
plt.cla()
parser.parse(s)
def drawPlot(tree,
nodeDict=None,
edgeDict=None,
edgeLabsDict=None,
displayLabs=False,
customColormap=False,
perUnitScale=False,
rezSqIn=400,
neatoLayout=False):
''' Draw a color-coded map of the voltage drop on a feeder.
path is the full path to the GridLAB-D .glm file or OMF .omd file.
workDir is where GridLAB-D will run, if it's None then a temp dir is used.
neatoLayout=True means the circuit is displayed using a force-layout approach.
edgeLabs property must be either 'Name', 'Current', 'Power', 'Rating', 'PercentOfRating', or None
nodeLabs property must be either 'Name', 'Voltage', 'VoltageImbalance', or None
edgeCol and nodeCol can be set to false to avoid coloring edges or nodes
customColormap=True means use a one that is nicely scaled to perunit values highlighting extremes.
Returns a matplotlib object.'''
# Be quiet matplotlib:
# warnings.filterwarnings('ignore')
# Build the graph.
fGraph = feeder.treeToNxGraph(tree)
# TODO: consider whether we can set figsize dynamically.
wlVal = int(math.sqrt(float(rezSqIn)))
chart = plt.figure(figsize=(wlVal, wlVal))
plt.axes(frameon=0)
plt.axis('off')
chart.gca().set_aspect('equal')
plt.tight_layout()
# Need to get edge names from pairs of connected node names.
edgeNames = []
for e in fGraph.edges():
edgeNames.append(
(fGraph.edge[e[0]][e[1]].get('name', 'BLANK')).replace('"', ''))
#set axes step equal
if neatoLayout:
# HACK: work on a new graph without attributes because graphViz tries to read attrs.
cleanG = nx.Graph(fGraph.edges())
cleanG.add_nodes_from(fGraph)
positions = graphviz_layout(cleanG, prog='neato')
else:
positions = {n: fGraph.node[n].get('pos', (0, 0)) for n in fGraph}
#create custom colormap
if customColormap:
custom_cm = matplotlib.colors.LinearSegmentedColormap.from_list(
'custColMap', [(0.0, 'blue'), (0.15, 'darkgray'),
(0.7, 'darkgray'), (1.0, 'red')])
custom_cm.set_under(color='black')
else:
custom_cm = plt.cm.get_cmap('viridis')
drawColorbar = False
emptyColors = {}
#draw edges with or without colors
if edgeDict != None:
drawColorbar = True
edgeList = [edgeDict.get(n, 1) for n in edgeNames]
else:
edgeList = [emptyColors.get(n, .6) for n in edgeNames]
edgeIm = nx.draw_networkx_edges(fGraph,
pos=positions,
edge_color=edgeList,
width=1,
edge_cmap=custom_cm)
#draw edge labels
if displayLabs:
edgeLabelsIm = nx.draw_networkx_edge_labels(fGraph,
pos=positions,
edge_labels=edgeLabsDict,
font_size=8)
# draw nodes with or without color
if nodeDict != None:
nodeList = [nodeDict.get(n, 1) for n in fGraph.nodes()]
drawColorbar = True
else:
nodeList = [emptyColors.get(n, .6) for n in fGraph.nodes()]
if perUnitScale:
vmin = 0
vmax = 1.25
else:
vmin = None
vmax = None
nodeIm = nx.draw_networkx_nodes(fGraph,
pos=positions,
node_color=nodeList,
linewidths=0,
node_size=30,
vmin=vmin,
vmax=vmax,
cmap=custom_cm)
#draw node labels
if displayLabs and nodeDict != None:
nodeLabelsIm = nx.draw_networkx_labels(fGraph,
pos=positions,
labels=nodeDict,
font_size=8)
plt.sci(nodeIm)
# plt.clim(110,130)
if drawColorbar:
plt.colorbar()
return chart
#!/usr/bin/env python3
import json
import matplotlib.pyplot as plt
import networkx as nx
from networkx.drawing.nx_agraph import graphviz_layout
jpath = 'rumor/3567665295750659.json'
data = json.load(open(jpath))
G = nx.Graph()
cnt = 0
for item in data:
if item['parent']:
G.add_edge(item['parent'], item['mid'])
else:
cnt += 1
print(cnt)
pos = graphviz_layout(G, prog='twopi')
plt.figure(figsize=(8, 8))
nx.draw(G, pos, node_size=10, alpha=0.5, node_color='blue', with_labels=False)
plt.axis('equal')
plt.show()
#!/usr/bin/python
import matplotlib.pyplot as plt
import networkx as nx
import test_spack
from networkx.drawing.nx_agraph import graphviz_layout
G = nx.DiGraph()
for case in test_spack.all_test_cases:
G.add_node(case.package_name)
for dep in case.depends_on:
G.add_edge(case.package_name, dep)
pos = graphviz_layout(G, prog='neato')
nx.draw_networkx_edges(G, pos)
nx.draw_networkx_labels(G, pos, font_size=10)
plt.show()
def display_graph(vertices):
"""
Transform the graph to a `networkx.DiGraph`-structure and display it using `matplotlib` -- if the necessary
libraries are installed.
:return: `True` if the graph was drawn, `False` otherwise.
"""
G = create_network_graph(vertices)
_is_conditioned = None
if _nx and _plt and G:
try:
from networkx.drawing.nx_agraph import graphviz_layout
pos = graphviz_layout(G, prog='dot')
except ModuleNotFoundError:
from networkx.drawing.layout import shell_layout
pos = shell_layout(G)
except ImportError:
from networkx.drawing.layout import shell_layout
pos = shell_layout(G)
_plt.subplot(111)
_plt.axis('off')
_nx.draw_networkx_nodes(
G,
pos,
node_color='r',
node_size=1250,
nodelist=[v.display_name for v in vertices if v.is_sampled])
_nx.draw_networkx_nodes(
G,
pos,
node_color='b',
node_size=1250,
nodelist=[v.display_name for v in vertices if v.is_observed])
for v in vertices:
_nx.draw_networkx_edges(G,
pos,
arrows=True,
edgelist=[(a.display_name, v.display_name)
for a in v.ancestors])
if v.condition_ancestors is not None and len(
v.condition_ancestors) > 0:
_is_conditioned = 1
_nx.draw_networkx_edges(G,
pos,
arrows=True,
style='dashed',
edge_color='g',
edgelist=[
(a.display_name, v.display_name)
for a in v.condition_ancestors
])
_nx.draw_networkx_labels(G, pos, font_color='w', font_weight='bold')
# for node, _ in G.nodes():
red_patch = mpatches.Circle((0, 0),
radius=2,
color='r',
label='Sampled Variables')
blue_patch = mpatches.Circle((0, 0),
radius=2,
color='b',
label='Observed Variables')
green_patch = mpatches.Circle(
(0, 0), radius=2, color='g',
label='Conditioned Variables') if _is_conditioned else 0
if _is_conditioned:
_plt.legend(handles=[red_patch, blue_patch, green_patch])
else:
_plt.legend(handles=[red_patch, blue_patch])
_plt.show()
return True
else:
return False
def draw_graph(G,
save=False,
file_name="stochastic_block_graph",
file_type='png',
transparent=False,
title="Stochastic Block Model"):
"""
Handles rendering and drawing the network.
Parameters
----------
:param G: `optional`
a networkx graph. If present draws this graph instead of the one built in the constructor.
:param save: `optional`
A boolean. If true saves an image of the graph to `/visualizations` otherwise renders the graph.
:param file_type: `optional`
A string. If save flag is true it saves graph with this file extension.
:param transparent: `optional`
A Boolean. If true it only renders the tweet's; no edges or user nodes.
"""
print("--- Adding colours and labels ---")
colors = []
legend = set()
labels = {}
pbar = tqdm.tqdm(total=len(G.nodes()))
for node in G.nodes():
attributes = G.nodes[node]
if 'type' in attributes:
if attributes['type'] == 'retweet':
colors.append(
'#79bfd3ff') if not transparent else colors.append("white")
elif attributes['type'] == 'tweet':
cluster = return_colour(attributes["lda_cluster"])
legend.add(cluster)
colors.append(cluster[0])
elif attributes['type'] == 'user':
labels[node] = node
colors.append('red') if not transparent else colors.append(
"white")
pbar.update(1)
pbar.close()
plt.figure(figsize=(30, 30))
pos = graphviz_layout(G, prog="sfdp")
print("--- Drawing {} nodes and {} edges ---".format(
len(G.nodes()), G.number_of_edges()))
width = 0.2 if not transparent else 0
node_size = 20 if not transparent else 200
nx.draw_networkx(G,
pos,
node_color=colors,
with_labels=False,
alpha=0.75,
node_size=node_size,
width=width,
arrows=False)
nx.draw_networkx_labels(G, pos, labels, font_size=16, font_color='r')
plt.legend(handles=return_legend(legend), loc="best")
plt.title(title, fontdict={'fontsize': 30})
# Turn off borders
plt.box(False)
plt.savefig("../visualizations/random_graphs/{}.{}".format(
file_name, file_type),
bbox_inches="tight") if save else plt.show()
plt.cla()
plt.close()
def voltPlot(glmPath, workDir=None, neatoLayout=False):
''' Draw a color-coded map of the voltage drop on a feeder.
Returns a matplotlib object. '''
tree = omf.feeder.parse(glmPath)
# # Get rid of schedules and climate:
for key in tree.keys():
if tree[key].get("argument",
"") == "\"schedules.glm\"" or tree[key].get(
"tmyfile", "") != "":
del tree[key]
# Make sure we have a voltDump:
def safeInt(x):
try:
return int(x)
except:
return 0
biggestKey = max([safeInt(x) for x in tree.keys()])
tree[str(biggestKey * 10)] = {
"object": "voltdump",
"filename": "voltDump.csv"
}
tree[str(biggestKey * 10 + 1)] = {
"object": "currdump",
"filename": "currDump.csv"
}
# Run Gridlab.
if not workDir:
workDir = tempfile.mkdtemp()
print '@@@@@@', workDir
gridlabOut = omf.solvers.gridlabd.runInFilesystem(tree,
attachments=[],
workDir=workDir)
with open(pJoin(workDir, 'voltDump.csv'), 'r') as dumpFile:
reader = csv.reader(dumpFile)
reader.next() # Burn the header.
keys = reader.next()
voltTable = []
for row in reader:
rowDict = {}
for pos, key in enumerate(keys):
rowDict[key] = row[pos]
voltTable.append(rowDict)
with open(pJoin(workDir, 'currDump.csv'), 'r') as currDumpFile:
reader = csv.reader(currDumpFile)
reader.next() # Burn the header.
keys = reader.next()
currTable = []
for row in reader:
rowDict = {}
for pos, key in enumerate(keys):
rowDict[key] = row[pos]
currTable.append(rowDict)
# Calculate average node voltage deviation. First, helper functions.
def digits(x):
''' Returns number of digits before the decimal in the float x. '''
return math.ceil(math.log10(x + 1))
def avg(l):
''' Average of a list of ints or floats. '''
return sum(l) / len(l)
# Detect the feeder nominal voltage:
for key in tree:
ob = tree[key]
if type(ob) == dict and ob.get('bustype', '') == 'SWING':
feedVoltage = float(ob.get('nominal_voltage', 1))
# Tot it all up.
nodeVolts = {}
for row in voltTable:
allVolts = []
for phase in ['A', 'B', 'C']:
phaseVolt = abs(float(row['volt' + phase + '_real']))
if phaseVolt != 0.0:
if digits(phaseVolt) > 3:
# Normalize to 120 V standard
phaseVolt = phaseVolt * (120 / feedVoltage)
allVolts.append(phaseVolt)
nodeVolts[row.get('node_name', '')] = avg(allVolts)
# Add up currents.
edgeCurrents = {}
for row in currTable:
phaseCurr = 0.0
for phase in ['A', 'B', 'C']:
phaseCurr += abs(float(row['curr' + phase + '_real']))
edgeCurrents[row.get('link_name', '')] = phaseCurr
# create edgeCurrent copy with to and from tuple as keys for labeling
edgeTupleCurrents = {}
for edge in edgeCurrents:
for obj in tree.values():
if obj.get('name') == edge:
coord = (obj.get('from'), obj.get('to'))
currVal = edgeCurrents.get(edge)
edgeTupleCurrents[coord] = "{0:.3f}".format(currVal)
# Build the graph.
fGraph = omf.feeder.treeToNxGraph(tree)
voltChart = plt.figure(figsize=(15, 15))
plt.axes(frameon=0)
plt.axis('off')
voltChart.gca().set_aspect('equal')
plt.tight_layout()
# Need to get edge names from pairs of connected node names.
edgeNames = []
for e in fGraph.edges():
edgeNames.append(fGraph.edge[e[0]][e[1]].get('name', 'BLANK'))
#set axes step equal
if neatoLayout:
# HACK: work on a new graph without attributes because graphViz tries to read attrs.
cleanG = nx.Graph(fGraph.edges())
cleanG.add_nodes_from(fGraph)
positions = graphviz_layout(cleanG, prog='neato')
else:
positions = {n: fGraph.node[n].get('pos', (0, 0)) for n in fGraph}
edgeIm = nx.draw_networkx_edges(
fGraph,
pos=positions,
edge_color=[edgeCurrents.get(n, 0) for n in edgeNames],
width=1,
edge_vmin=None,
edge_vmax=None,
edge_cmap=plt.cm.jet)
edgeLabelsIm = nx.draw_networkx_edge_labels(fGraph,
pos=positions,
edge_labels=edgeTupleCurrents,
font_size=10)
nodeIm = nx.draw_networkx_nodes(
fGraph,
pos=positions,
node_color=[nodeVolts.get(n, 0) for n in fGraph.nodes()],
linewidths=0,
node_size=30,
vmin=110,
vmax=130,
cmap=plt.cm.jet)
plt.sci(nodeIm)
# plt.clim(110,130)
plt.colorbar()
return voltChart
def slice_network(G, T, copy=True):
"""
Remove all edges witth weight<T from G or its copy,
"""
F = G.copy() if copy else G
F.remove_edges_from(
(n1, n2) for n1, n2, w in F.edges(data="weight") if w < T)
return F
# Draw different degrees of slicing for a random graph
ergraph = nx.erdos_renyi_graph(100, 0.1)
nx.set_edge_attributes(ergraph, {(n1, n2): random.random()
for n1, n2 in ergraph.edges()}, "weight")
pos = graphviz_layout(ergraph)
for i, threshold in enumerate([0, 0.7, 0.8, 0.9, 0.95, 1.0]):
ax = plt.subplots(3, 2, i + 1)
slice_network(ergraph, threshold, copy=False)
nx.draw_networkx_edges(ergraph,
pos,
alpha=0.65,
ax=ax,
**dzcnapy.small_attrs)
nx.draw_networkx_nodes(ergraph, pos, ax=ax, **dzcnapy.small_attrs)
dzcnapy.set_extent(pos, ax, "Threshold={}".format(threshold))
dzcnapy.plot("slicing")
def p_statement_for(p):
'''statement : FOR statement LOOP NUMBER COLON NAME EQUALS expression PLUS expression SEMICOLON
| FOR statement LOOP NUMBER COLON NAME EQUALS expression MINUS expression SEMICOLON
| FOR statement LOOP NUMBER COLON NAME EQUALS expression TIMES expression SEMICOLON
| FOR statement LOOP NUMBER COLON NAME EQUALS expression DIVIDE expression SEMICOLON
| FOR statement LOOP NUMBER COLON NAME EQUALS expression EXPON expression SEMICOLON
| FOR statement LOOP NUMBER COLON NAME EQUALS expression ROOT expression SEMICOLON '''
plt.clf()
plt.cla()
b.clear()
b.add_node('stmt')
b.add_nodes_from(['for','stmt1','loop','time','stmt2'])
b.add_edges_from([('stmt','for'),('stmt','stmt1'),('stmt','loop'),('stmt','time'),('stmt','stmt2')])
b.add_node(p[6])
b.add_node(p[4])
b.add_edge('stmt1',p[6])
b.add_edge('time',p[4])
b.add_node('=')
b.add_edge('stmt2',p[6])
b.add_edge('stmt2','=')
if p[9]=='+':
b.add_node('+stmt')
b.add_edge('stmt2','+stmt')
b.add_node('t1')
b.add_edge('+stmt','t1')
elif p[9]=='-':
b.add_node('-stmt')
b.add_edge('stmt2','-stmt')
b.add_node('t1')
b.add_edge('-stmt','t1')
elif p[9]=='*':
b.add_node('*stmt')
b.add_edge('stmt2','*stmt')
b.add_node('t1')
b.add_edge('*stmt','t1')
elif p[9]=='/':
b.add_node('/stmt')
b.add_edge('stmt2','/stmt')
b.add_node('t1')
b.add_edge('/stmt','t1')
elif p[9]=='^':
b.add_node('^stmt')
b.add_edge('stmt2','^stmt')
b.add_node('t1')
b.add_edge('^stmt','t1')
elif p[9]=='**':
b.add_node('**stmt')
b.add_edge('stmt2','**stmt')
b.add_node('t1')
b.add_edge('**stmt','t1')
plt.title("forstatement")
pos = graphviz_layout(b, prog='dot')
nx.draw(b,pos, with_labels=True, arrows=True, node_size=600)
plt.show()
plt.clf()
plt.cla()
if p[4]>0:
for names[p[2]] in range(1,p[4]+1):
names[p[2]]=names[p[2]]+1
p[8]=int(names[p[2]])
if p[9]=='+':
if(names[p[2]]<=1):
p[0]=p[8]+p[10]
else:
p[0]=names[p[6]]+p[10]
names[p[6]]=p[0]
elif p[9]=='-':
if(names[p[2]]<=1):
p[0]=p[8]-p[10]
else:
p[0]=names[p[6]]-p[10]
names[p[6]]=p[0]
elif p[9]=='*':
if(names[p[2]]<=1):
p[0]=p[8]*p[10]
else:
p[0]=names[p[6]]*p[10]
names[p[6]]=p[0]
elif p[9]=='/':
if(names[p[2]]<=1):
p[0]=p[8]/p[10]
else:
p[0]=names[p[6]]/p[10]
names[p[6]]=p[0]
elif p[9]=='^':
if(names[p[2]]<=1):
p[0]=math.pow(p[8] , p[10])
else:
p[0]=math.pow(names[p[6]],p[10])
names[p[6]]=p[0]
elif p[9]=='**':
if(names[p[2]]<=1):
p[0]=math.pow(p[8] , 1/p[10])
else:
p[0]=math.pow(names[p[6]],1/p[10])
names[p[6]]=p[0]
G = nx.DiGraph()
G.add_node("A", rank=0)
G.add_nodes_from(['B', 'C', 'D'], style='filled', fillcolor='red')
G.add_nodes_from(['D', 'F', 'G'])
G.add_nodes_from(['H'], label='target')
G.add_edge('A', 'B', arrowsize=2.0)
G.add_edge('A', 'C', penwidth=2.0)
G.add_edge('A', 'D')
G.add_edges_from([('B', 'E'), ('B', 'F')], color='blue')
G.add_edges_from([('C', 'E'), ('C', 'G')])
G.add_edges_from([('D', 'F'), ('D', 'G')])
G.add_edges_from([('E', 'H'), ('F', 'H'), ('G', 'H')])
# set defaults
G.graph['graph'] = {'rankdir': 'TD'}
G.graph['node'] = {'shape': 'circle'}
G.graph['edges'] = {'arrowsize': '4.0'}
A = to_agraph(G)
print(A)
A.layout('dot')
A.draw('abcd.png')
nx.draw(G,
pos=graphviz_layout(G),
node_size=1600,
cmap=plt.cm.Reds,
node_color=range(len(G)),
prog='dot',
with_labels=True)
plt.show()
lista_nodos_bi = todos
for node_ in lista_nodos_bi:
if node_ % 2 == 0:
color_map_bi.append('lightcoral')
#print("female color")
else:
color_map_bi.append('mediumseagreen')
#print("male color")
########################################################
#Full binary tree plot
fig = plt.figure(figsize=cm2inch(12, 10))
pos = graphviz_layout(G, prog='dot')
nx.draw(G,
pos,
with_labels=True,
node_color=color_map_bi,
edge_color='gray',
font_size=5,
node_size=150,
arrows=True,
width=0.5)
vmin = 0
vmax = len(generation)
#sm = plt.cm.ScalarMappable(norm=matplotlib.colors.Normalize(vmin=vmin, vmax=vmax))
#sm._A = []
plt.savefig(r_dir + "/test_tree_bi" + str(seed) + ".png",
dpi=300,
def gDraw(edgelist, nodelist, colors, digName, visTimes, startV, lengthOfRW):
#plotly.offline.init_notebook_mode()
g = nx.Graph()
g.add_edges_from(edgelist)
# a dictionary to store these edges by their partition id
partitionsDic = {}
for e in edgelist:
k = e[2]["partition"]
ev = (e[0], e[1])
if partitionsDic.has_key(k):
partitionsDic[k].append(ev)
else:
partitionsDic[k] = [ev]
# a dict to store the replica factor of each vertex
verRF = {}
verSets = []
for bid, edges in partitionsDic.iteritems():
tset = set()
for x in edges:
tset.add(x[0])
tset.add(x[1])
verSets.append(tset)
for vset in verSets:
for ver in vset:
if verRF.has_key(ver):
rf = verRF[ver]
verRF[ver] = rf+1
else:
verRF[ver] = 1
#partitionsDic = edgelist
#for k, v in partitionsDic.iteritems():
# print k, len(v)
# a list to store those seeds
seeds = []
# a list to store other normal vertices
otherVertices = []
for n in nodelist:
if n[1] == "s":
seeds.append(n[0])
else:
otherVertices.append(n[0])
#import matplotlib.pyplot as plt
#pos=nx.spring_layout(g) # positions for all nodes
# position is stored as node attribute data for random_geometric_graph
#pos=nx.get_node_attributes(g,'pos')
# layout graphs with positions using graphviz neato
import pygraphviz
from networkx.drawing.nx_agraph import graphviz_layout
#pos = graphviz_layout(g, prog="sfdp")
pos = graphviz_layout(g, prog="neato")
#pos = nx.fruchterman_reingold_layout(g)
#pos=nx.spectral_layout(g)
# to get the positions of seeds
seeds_Xv = []
seeds_Yv = []
for s in seeds:
if pos.has_key(s):
seeds_Xv.append(pos[s][0])
seeds_Yv.append(pos[s][1])
# to get the positions of other normal vertices
nor_Xv = []
nor_Yv = []
for s in otherVertices:
if pos.has_key(s):
nor_Xv.append(pos[s][0])
nor_Yv.append(pos[s][1])
# a list to store the names of seeds
seedNms = []
for i in range(len(seeds)):
seedNms.append("seed_"+str(i+1))
# the trace of seeds
trace_vs = go.Scatter(x=seeds_Xv,
y=seeds_Yv,
xaxis='x2',
yaxis='y2',
mode='markers',
name='Seeds',
marker=go.Marker(symbol='dot',
size=10,
#color='#e1441c',
line=go.Line(color='rgb(50,50,50)', width=0.6)
),
text=seedNms,
hoverinfo='text'
)
# the trace of other vertices
trace_ov = go.Scatter(x=nor_Xv,
y=nor_Yv,
xaxis='x2',
yaxis='y2',
mode='markers',
name='Normal Vertices',
hoverinfo='none',
marker=go.Marker(symbol='dot',
size=2,
#color='#6959CD',
line=go.Line(color='rgb(50,50,50)', width=0.2)
),
)
# the list of datas for plotting
ds = []
col = 100
i = 0
for key, val in partitionsDic.iteritems():
block_id = "partition_" + str(key)
Xed = []
Yed = []
#parNames = []
for edge in val:
Xed += [pos[edge[0]][0], pos[edge[1]][0], None]
Yed += [pos[edge[0]][1], pos[edge[1]][1], None]
#tep = block_id
#parNames.append(tep)
#col = col+30
#scol = str(col)
#rgbcol = "rgb("+scol+","+scol+","+scol+")"
#hoinfo = [block_id] * len(val)
trace = go.Scatter(x=Xed,
y=Yed,
xaxis='x2',
yaxis='y2',
mode='lines',
name=block_id,
#text=parNames,
#hoverinfo='text',
hoverinfo='name',
#line=go.Line(color=colors[i], width=2),
line=go.Line(width=2),
)
i = i+1
ds.append(trace)
ds.append(trace_vs)
ds.append(trace_ov)
'''
the display of visit times to each vertex in Random Walk Toy
1) to category the vertices upon its visit times
2) to draw each vertex upon its category
'''
if visTimes:
numOfScals = lengthOfRW/scal
# we use the scale of colors in 'Viridis', 3 ~ -3
pd = numOfScals/float(6)
# a dict to store the vertices of each scale upon visit-times
scalsDic = {}
for i in range(0, numOfScals+1):
scalsDic[i] = []
for v, tms in visTimes.iteritems():
if tms > 0:
scalsDic[tms/scal].append(v)
# to draw the vertices
for categ, vers in scalsDic.iteritems():
if vers:
# to get the positions of vertices in this category
Xv = []
Yv = []
vts = []
for s in vers:
if pos.has_key(s):
Xv.append(pos[s][0])
Yv.append(pos[s][1])
vts.append("VisTimes:"+str(visTimes[s]))
# the trace of vertices
trace = go.Scatter(x=Xv,
y=Yv,
xaxis='x2',
yaxis='y2',
mode='markers',
name='visit-times in RW:' + str(categ*scal+1) + ' ~ ' + str(categ*scal+scal),
text=vts,
hoverinfo='text',
marker=dict(
size=str((categ+1)*3 + 13),
color=5.0 - categ/pd,
colorscale='Viridis'
)
)
ds.append(trace)
'''
to display/draw the starting vertex of RW
'''
# to get the positions of starting Vertex
startV_Xv = []
startV_Yv = []
if pos.has_key(startV):
startV_Xv.append(pos[startV][0])
startV_Yv.append(pos[startV][1])
# the trace of starting vertex
sv = []
sv.append("Starting Vertex")
trace_startV = go.Scatter(x=startV_Xv,
y=startV_Yv,
xaxis='x2',
yaxis='y2',
mode='markers',
name='The Starting Vertex of Random Walk(Toy)',
text=sv,
hoverinfo='text',
marker=dict(
size = '15',
color= 'rgb(0,0,0)',
line=go.Line(color='rgb(250,250,250)', width=0.5)
)
)
ds.append(trace_startV)
data1 = go.Data(ds)
"""
Test:
"""
# to calculate the overall times of communication happened in graph
overTims = 0
for ver, ts in visTimes.iteritems():
overTims += ts * (verRF[ver]-1)
# to get the sizes of partitions
sizes = ""
for bid, par in partitionsDic.iteritems():
sizes += str(len(par))+", "
# to calculate the VRF
overallRF = 0
for vset in verSets:
overallRF += len(vset)
vrf = overallRF/float(len(verRF))
# Add table data
table_data = [['Term', 'Result'],
['Number of Vertices', str(len(verRF))],
['Number of Edges', str(len(edgelist))],
#['Number of Blocks(for our method)', '...'],
['Sizes of Partitions', sizes],
['Vertex Replica Factor(VRF)', str(vrf)],
['Length of Random Walk(RW)', str(lengthOfRW)],
['Number of Communications(Inter-Partitions) during RW', str(overTims)]
]
# Initialize a figure with FF.create_table(table_data)
#font = ['#FCFCFC','#000000','#000000','#000000','#000000', '#FF3030', '#0099ff','#0099ff']
font = ['#FCFCFC', '#000000', '#000000', '#000000', '#FF3030', 'blue', 'blue']
figure = FF.create_table(table_data, font_colors=font)
# Add trace data to figure
figure['data'].extend(data1)
# Edit layout for subplots
figure.layout.yaxis.update({'domain': [0, .25]})
figure.layout.yaxis2.update({'domain': [.3, 1]})
# The graph's yaxis2 MUST BE anchored to the graph's xaxis2 and vice versa
figure.layout.yaxis2.update({'anchor': 'x2'})
figure.layout.xaxis2.update({'anchor': 'y2'})
#figure.layout.yaxis.update({'title': 'The Results of Partitioning and Random Walk Application'})
# Update the margins to add a title and see graph x-labels.
figure.layout.margin.update({'t': 75, 'l': 50})
#figure.layout.update({'title': '2016 Hockey Stats'})
# Update the height because adding a graph vertically will interact with
# the plot height calculated for the table
figure.layout.update({'height': 800})
pu = plotly.offline.plot(figure, auto_open=False, filename=digName + ".html")
#fig1 = go.Figure(data=data1)
#pu = plotly.offline.plot(fig1, auto_open=False, filename=digName+".html")
#pu = plotly.offline.plot_mpl(fig, auto_open=False)
#plot_url = py.iplot_mpl(fig)
print "pu: ", pu
return pu
def DrawGraph(ax, edgelist, sz=1, labels=False, weighted=False, threshold=1.0, show_th=False, \
show_wts=False, save_graphx=False, gx_dir=None, seg_id=None, percentile=None, \
percent=None, prune_jns=True, is_tree=False):
def ShrinkGraph(G, threshold, debug=False, prune_jns=True):
"""
Do not contract an edge if edge part of a triangle loop
with length shorter than the threshold.
"""
def GetOrphan(a1, a2, s1, s2, G):
orphan_, other_, orph_node_ = None, None, None
if len(s1) == 0 and len(s2) == 2:
orphan_ = a2
other_ = a1
if len(s2) == 0 and len(s1) == 2:
orphan_ = a1
other_ = a2
# if no edge exists between two adjacent nodes
# of orphan, then orphan can be deleted.
if orphan_ is not None:
orph_node_ = a1
m, n = set(G[orphan_].keys()).difference({other_})
if n not in G[m].keys():
return orph_node_
return None
if threshold == 0.0: return G
if debug: PrintSummary(G)
if percentile is not None:
wts = np.array([d['weight'] for d in G.edges.values()])
threshold = np.percentile(wts, percentile)
perc_wts = wts / np.sum(wts)
base_ = np.percentile(perc_wts, percentile)
pivots = [percentile + 0.5 * (j + 1) for j in range(70)]
for p in pivots:
if p < 100 and np.percentile(perc_wts, p) > 50 * base_:
threshold = np.percentile(wts, p)
print('Threshold found at {:.2f}'.format(p))
break
delete_count = 0
while True:
wts = np.array([d['weight'] for d in G.edges.values()])
if prune_jns:
idx = np.asarray(wts < threshold).nonzero()[0]
else:
mask = [(len(G[e[0][0]].keys()) == 1) or (len(G[e[0][1]].keys()) == 1) \
for e in G.edges.items()]
idx = np.asarray((wts < threshold) & mask).nonzero()[0]
if len(idx) == 0:
break
u, v = None, None
orphan_node = None
# find a candidate edge to delete in this loop
for i in idx:
a1, a2 = G.edges.items()[i][0]
s1, s2 = set(G[a1].keys()).difference({a2}), \
set(G[a2].keys()).difference({a1})
intersect_ = s1 & s2
# If no common node in adjacency list then break
if len(intersect_) == 0:
u, v = a1, a2
orphan_node = GetOrphan(a1, a2, s1, s2, G)
break
# Else, make sure no triangular loop of decent size breaks
else:
crucial_edge = False
for n in intersect_:
w1 = G.get_edge_data(n, a1)['weight']
w2 = G.get_edge_data(n, a2)['weight']
# if a loop (containing this edge) with
# len > 3*thresh exists, don't delete this edge
if w1 + w2 > 3 * threshold - wts[i]:
crucial_edge = True
break
if not crucial_edge:
u, v = a1, a2
orphan_node = GetOrphan(a1, a2, s1, s2, G)
break
if u is None:
break
G = nx.contracted_nodes(G, u, v, self_loops=False)
delete_count += 1
if orphan_node is not None:
m, n = G[orphan_node].keys()
wm, wn = G[orphan_node][m]['weight'], G[orphan_node][n][
'weight']
# add edge between m and n
G.add_edge(m, n, weight=(wm + wn))
# delete orphan node
G.remove_node(orphan_node)
if debug:
print('Deleted edge {}-{}'.format(u, v))
PrintSummary(G)
print('Total edges deleted {}'.format(delete_count))
return G
G = nx.Graph()
if not weighted:
G.add_edges_from(edgelist)
pos = graphviz_layout(G)
nx.draw_networkx(G,
pos=pos,
node_size=sz,
ax=ax,
with_labels=labels,
font_size=8,
font_color='white',
font_weight='bold',
edge_color='red')
else:
G.add_edges_from(edgelist)
t0_shrink = time.time()
if is_tree:
if True:
factor = 5.0**(-3)
wt = GetWt(G)
t = factor * wt
G = MergeTwoEdges(G)
q0 = 20
t0 = GetLeafPercentile(G, perc=q0)
print('Original {:.0f}%ile weight {:.2f}'.format(q0, t0))
for p in [25, 40, 80, 40, 20]:
t = GetLeafPercentile(G, perc=p)
G = DeLeaf(G, thresh=t)
G = MergeTwoEdges(G)
G = ShrinkGraph(G, threshold=t0, prune_jns=True)
G = DeLeaf(G, thresh=t0)
G = MergeTwoEdges(G)
max_n, max_deg = GetMaxDegree(G)
if max_n in G.nodes.keys():
AddCenter(G, max_n)
else:
G = ShrinkGraph(G, threshold=threshold, prune_jns=True)
if save_graphx:
nx.write_gpickle(
G, os.path.join(gx_dir,
str(seg_id) + '_networkx.obj'))
print('Graph shrunk in {:.2f}s'.format(time.time() - t0_shrink))
if show_th:
edge_dict = {e[0]: '({:.1f}, {:.1f})'.format(e[1]['weight'], \
e[1]['thick']) for e in G.edges.items()}
else:
edge_dict = {
e[0]: '{:.1f}'.format(e[1]['weight'])
for e in G.edges.items()
}
pos = graphviz_layout(G)
nx.draw_networkx(G,
pos=pos,
node_size=sz,
ax=ax,
with_labels=labels,
font_size=5,
font_color='white',
font_weight='bold') #, edge_color='red')
if show_wts:
nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=edge_dict)
def draw_and_show(self, figsize=(8, 8)):
pos = graphviz_layout(self)
plt.figure(figsize=figsize)
nx.draw_networkx(self, pos=pos, with_labels=True)
plt.show(block=True)
nb = 0
added_edges = []
while nb < 5:
first_node = choice(G.nodes()) # pick a random node
possible_nodes = set(G.nodes())
neighbours = G.neighbors(first_node) + [first_node]
possible_nodes.difference_update(
neighbours
) # remove the first node and all its neighbours from the candidates
second_node = choice(list(possible_nodes))
G.add_edge(first_node, second_node, weight=1)
added_edges.append((first_node, second_node))
added_edges.append((second_node, first_node))
print(first_node, second_node)
nb += 1
pos = graphviz_layout(G, prog='sfdp')
nx.draw(G, pos, with_labels=False, node_size=1)
plt.show()
itr = 7
E_final = {}
for edge in G.edges():
E_final[edge] = 0
while itr > 0:
X = Algebraic_Rank.get_algebraic_rank(G, 0.5, 100)
E = {}
for edge in G.edges():
E[edge] = abs(X[edge[0]] - X[edge[1]])
if (E_final[edge] < E[edge]):
E_final[edge] = E[edge]
## aws logs get-log-events --log-group-name A --log-stream-name a --output text > a.log
## cat a.log | grep -v REJECT | awk '/ / {print $6, $7}' > a-accept.log
## vi a-accept.log
## type:
## 1,$ s/ /", "/g
## and type:
## 1,$norm I ("
## and type:
## 1,$norm A"),
## and type:
## :wq
## vi networkmap.py
## and type:
## :set number
## should see line 8 as start or lincoln_list
## go to row 29 and type:
## :.-1read a-accept.log
## that will read in the accepted connection hosts
## and type:
## :wq
#print(str(netmap))
#]
F = nx.DiGraph(netmap)
#F = nx.DiGraph(lincoln_list)
pos = graphviz_layout(F)
nx.draw_networkx(F, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot ("lincoln")
def voltPlot(omd, workDir=None, neatoLayout=False):
''' Draw a color-coded map of the voltage drop on a feeder.
Returns a matplotlib object. '''
tree = omd.get('tree', {})
# # Get rid of schedules and climate:
for key in tree.keys():
if tree[key].get("argument",
"") == "\"schedules.glm\"" or tree[key].get(
"tmyfile", "") != "":
del tree[key]
# Make sure we have a voltDump:
def safeInt(x):
try:
return int(x)
except:
return 0
biggestKey = max([safeInt(x) for x in tree.keys()])
tree[str(biggestKey * 10)] = {
"object": "voltdump",
"filename": "voltDump.csv"
}
# Run Gridlab.
if not workDir:
workDir = tempfile.mkdtemp()
gridlabOut = gridlabd.runInFilesystem(tree,
attachments=omd.get(
'attachments', {}),
workDir=workDir)
with open(pJoin(workDir, 'voltDump.csv'), 'r') as dumpFile:
reader = csv.reader(dumpFile)
reader.next() # Burn the header.
keys = reader.next()
voltTable = []
for row in reader:
rowDict = {}
for pos, key in enumerate(keys):
rowDict[key] = row[pos]
voltTable.append(rowDict)
# Calculate average node voltage deviation. First, helper functions.
def pythag(x, y):
''' For right triangle with sides a and b, return the hypotenuse. '''
return math.sqrt(x**2 + y**2)
def digits(x):
''' Returns number of digits before the decimal in the float x. '''
return math.ceil(math.log10(x + 1))
def avg(l):
''' Average of a list of ints or floats. '''
return sum(l) / len(l)
# Detect the feeder nominal voltage:
for key in tree:
ob = tree[key]
if type(ob) == dict and ob.get('bustype', '') == 'SWING':
feedVoltage = float(ob.get('nominal_voltage', 1))
# Tot it all up.
nodeVolts = {}
for row in voltTable:
allVolts = []
for phase in ['A', 'B', 'C']:
phaseVolt = pythag(float(row['volt' + phase + '_real']),
float(row['volt' + phase + '_imag']))
if phaseVolt != 0.0:
if digits(phaseVolt) > 3:
# Normalize to 120 V standard
phaseVolt = phaseVolt * (120 / feedVoltage)
allVolts.append(phaseVolt)
nodeVolts[row.get('node_name', '')] = avg(allVolts)
# Color nodes by VOLTAGE.
fGraph = feeder.treeToNxGraph(tree)
voltChart = plt.figure(figsize=(15, 15))
plt.axes(frameon=0)
plt.axis('off')
#set axes step equal
voltChart.gca().set_aspect('equal')
if neatoLayout:
# HACK: work on a new graph without attributes because graphViz tries to read attrs.
cleanG = nx.Graph(fGraph.edges())
cleanG.add_nodes_from(fGraph)
positions = graphviz_layout(cleanG, prog='neato')
else:
positions = {n: fGraph.node[n].get('pos', (0, 0)) for n in fGraph}
edgeIm = nx.draw_networkx_edges(fGraph, positions)
nodeIm = nx.draw_networkx_nodes(
fGraph,
pos=positions,
node_color=[nodeVolts.get(n, 0) for n in fGraph.nodes()],
linewidths=0,
node_size=30,
cmap=plt.cm.jet)
plt.sci(nodeIm)
plt.clim(110, 130)
plt.colorbar()
return voltChart
def draw(self, ax):
pos = graphviz_layout(self._td, prog='twopi', args='')
nx.draw(self._td, pos, ax=ax, node_size=100, alpha=0.5, node_color='g')
L = nx.get_node_attributes(self._td, 'label')
nx.draw_networkx_labels(self._td, pos, ax=ax, font_size=8, labels=L)
ax.margins(0.2) # to restrict label-cut-off
def drawPlot(path,
workDir=None,
neatoLayout=False,
edgeLabs=None,
nodeLabs=None,
edgeCol=None,
nodeCol=None,
faultLoc=None,
faultType=None,
customColormap=False,
scaleMin=None,
scaleMax=None,
rezSqIn=400,
simTime='2000-01-01 0:00:00',
loadLoc=None):
''' Draw a color-coded map of the voltage drop on a feeder.
path is the full path to the GridLAB-D .glm file or OMF .omd file.
workDir is where GridLAB-D will run, if it's None then a temp dir is used.
neatoLayout=True means the circuit is displayed using a force-layout approach.
edgeCol property must be either 'Current', 'Power', 'Rating', 'PercentOfRating', or None
nodeCol property must be either 'Voltage', 'VoltageImbalance', 'perUnitVoltage', 'perUnit120Voltage', or None
edgeLabs and nodeLabs properties must be either 'Name', 'Value', or None
edgeCol and nodeCol can be set to false to avoid coloring edges or nodes
customColormap=True means use a one that is nicely scaled to perunit values highlighting extremes.
faultType and faultLoc are the type of fault and the name of the line that it occurs on.
Returns a matplotlib object.'''
# Be quiet matplotlib:
# warnings.filterwarnings("ignore")
if path.endswith('.glm'):
tree = feeder.parse(path)
attachments = []
elif path.endswith('.omd'):
with open(path) as f:
omd = json.load(f)
tree = omd.get('tree', {})
attachments = omd.get('attachments', [])
else:
raise Exception('Invalid input file type. We require a .glm or .omd.')
#print path
# add fault object to tree
def safeInt(x):
try:
return int(x)
except:
return 0
biggestKey = max([safeInt(x) for x in tree.keys()])
# Add Reliability module
tree[str(biggestKey * 10)] = {
"module": "reliability",
"maximum_event_length": "18000",
"report_event_log": "true"
}
CLOCK_START = simTime
dt_start = parser.parse(CLOCK_START)
dt_end = dt_start + relativedelta(seconds=+20)
CLOCK_END = str(dt_end)
CLOCK_RANGE = CLOCK_START + ',' + CLOCK_END
if faultType != None:
# Add eventgen object (the fault)
tree[str(biggestKey * 10 + 1)] = {
"object": "eventgen",
"name": "ManualEventGen",
"parent": "RelMetrics",
"fault_type": faultType,
"manual_outages": faultLoc + ',' + CLOCK_RANGE
} # TODO: change CLOCK_RANGE to read the actual start and stop time, not just hard-coded
# Add fault_check object
tree[str(biggestKey * 10 + 2)] = {
"object": "fault_check",
"name": "test_fault",
"check_mode": "ONCHANGE",
"eventgen_object": "ManualEventGen",
"output_filename": "Fault_check_out.txt"
}
# Add reliabilty metrics object
tree[str(biggestKey * 10 + 3)] = {
"object": "metrics",
"name": "RelMetrics",
"report_file": "Metrics_Output.csv",
"module_metrics_object": "PwrMetrics",
"metrics_of_interest": '"SAIFI,SAIDI,CAIDI,ASAI,MAIFI"',
"customer_group": '"groupid=METERTEST"',
"metric_interval": "5 h",
"report_interval": "5 h"
}
# Add power_metrics object
tree[str(biggestKey * 10 + 4)] = {
"object": "power_metrics",
"name": "PwrMetrics",
"base_time_value": "1 h"
}
# HACK: set groupid for all meters so outage stats are collected.
noMeters = True
for key in tree:
if tree[key].get('object', '') in ['meter', 'triplex_meter']:
tree[key]['groupid'] = "METERTEST"
noMeters = False
if noMeters:
raise Exception(
"No meters detected on the circuit. Please add at least one meter to allow for collection of outage statistics."
)
for key in tree:
if 'clock' in tree[key]:
tree[key]['starttime'] = "'" + CLOCK_START + "'"
tree[key]['stoptime'] = "'" + CLOCK_END + "'"
# dictionary to hold info on lines present in glm
edge_bools = dict.fromkeys([
'underground_line', 'overhead_line', 'triplex_line', 'transformer',
'regulator', 'fuse', 'switch'
], False)
# Map to speed up name lookups.
nameToIndex = {tree[key].get('name', ''): key for key in tree.keys()}
# Get rid of schedules and climate and check for all edge types:
for key in list(tree.keys()):
obtype = tree[key].get("object", "")
if obtype == 'underground_line':
edge_bools['underground_line'] = True
elif obtype == 'overhead_line':
edge_bools['overhead_line'] = True
elif obtype == 'triplex_line':
edge_bools['triplex_line'] = True
elif obtype == 'transformer':
edge_bools['transformer'] = True
elif obtype == 'regulator':
edge_bools['regulator'] = True
elif obtype == 'fuse':
edge_bools['fuse'] = True
elif obtype == 'switch':
edge_bools['switch'] = True
if tree[key].get("argument",
"") == "\"schedules.glm\"" or tree[key].get(
"tmyfile", "") != "":
del tree[key]
# Make sure we have a voltage dump and current dump:
tree[str(biggestKey * 10 + 5)] = {
"object": "voltdump",
"filename": "voltDump.csv"
}
tree[str(biggestKey * 10 + 6)] = {
"object": "currdump",
"filename": "currDump.csv"
}
# Line rating dumps
tree[feeder.getMaxKey(tree) + 1] = {'module': 'tape'}
for key in edge_bools.keys():
if edge_bools[key]:
tree[feeder.getMaxKey(tree) + 1] = {
'object': 'group_recorder',
'group': '"class=' + key + '"',
'property': 'continuous_rating',
'file': key + '_cont_rating.csv'
}
#Record initial status readout of each fuse/recloser/switch/sectionalizer before running
# Reminder: fuse objects have 'phase_X_status' instead of 'phase_X_state'
protDevices = dict.fromkeys(
['fuse', 'recloser', 'switch', 'sectionalizer'], False)
#dictionary of protective device initial states for each phase
protDevInitStatus = {}
#dictionary of protective devices final states for each phase after running Gridlab-D
protDevFinalStatus = {}
#dictionary of protective device types to help the testing and debugging process
protDevTypes = {}
protDevOpModes = {}
for key in tree:
obj = tree[key]
obType = obj.get('object')
if obType in protDevices.keys():
obName = obj.get('name', '')
protDevTypes[obName] = obType
if obType != 'fuse':
protDevOpModes[obName] = obj.get('operating_mode',
'INDIVIDUAL')
protDevices[obType] = True
protDevInitStatus[obName] = {}
protDevFinalStatus[obName] = {}
for phase in ['A', 'B', 'C']:
if obType != 'fuse':
phaseState = obj.get('phase_' + phase + '_state', 'CLOSED')
else:
phaseState = obj.get('phase_' + phase + '_status', 'GOOD')
if phase in obj.get('phases', ''):
protDevInitStatus[obName][phase] = phaseState
#print protDevInitStatus
#Create a recorder for protective device states
for key in protDevices.keys():
if protDevices[key]:
for phase in ['A', 'B', 'C']:
if key != 'fuse':
tree[feeder.getMaxKey(tree) + 1] = {
'object': 'group_recorder',
'group': '"class=' + key + '"',
'property': 'phase_' + phase + '_state',
'file': key + '_phase_' + phase + '_state.csv'
}
else:
tree[feeder.getMaxKey(tree) + 1] = {
'object': 'group_recorder',
'group': '"class=' + key + '"',
'property': 'phase_' + phase + '_status',
'file': key + '_phase_' + phase + '_state.csv'
}
# Run Gridlab.
if not workDir:
workDir = tempfile.mkdtemp()
print('@@@@@@', workDir)
# for i in range(6):
# gridlabOut = gridlabd.runInFilesystem(tree, attachments=attachments, workDir=workDir)
# #HACK: workaround for shoddy macOS gridlabd build.
# if 'error when setting parent' not in gridlabOut.get('stderr','OOPS'):
# break
gridlabOut = gridlabd.runInFilesystem(tree,
attachments=attachments,
workDir=workDir)
#Record final status readout of each fuse/recloser/switch/sectionalizer after running
try:
for key in protDevices.keys():
if protDevices[key]:
for phase in ['A', 'B', 'C']:
with open(pJoin(workDir,
key + '_phase_' + phase + '_state.csv'),
newline='') as statusFile:
reader = csv.reader(statusFile)
# loop past the header,
keys = []
vals = []
for row in reader:
if '# timestamp' in row:
keys = row
i = keys.index('# timestamp')
keys.pop(i)
vals = next(reader)
vals.pop(i)
for pos, key2 in enumerate(keys):
protDevFinalStatus[key2][phase] = vals[pos]
except:
pass
#print protDevFinalStatus
#compare initial and final states of protective devices
#quick compare to see if they are equal
#print cmp(protDevInitStatus, protDevFinalStatus)
#find which values changed
changedStates = {}
#read voltDump values into a dictionary.
try:
with open(pJoin(workDir, 'voltDump.csv'), newline='') as dumpFile:
reader = csv.reader(dumpFile)
next(reader) # Burn the header.
keys = next(reader)
voltTable = []
for row in reader:
rowDict = {}
for pos, key in enumerate(keys):
rowDict[key] = row[pos]
voltTable.append(rowDict)
except:
raise Exception(
'GridLAB-D failed to run with the following errors:\n' +
gridlabOut['stderr'])
# read currDump values into a dictionary
with open(pJoin(workDir, 'currDump.csv'), newline='') as currDumpFile:
reader = csv.reader(currDumpFile)
next(reader) # Burn the header.
keys = next(reader)
currTable = []
for row in reader:
rowDict = {}
for pos, key in enumerate(keys):
rowDict[key] = row[pos]
currTable.append(rowDict)
# read line rating values into a single dictionary
lineRatings = {}
rating_in_VA = []
for key1 in edge_bools.keys():
if edge_bools[key1]:
with open(pJoin(workDir, key1 + '_cont_rating.csv'),
newline='') as ratingFile:
reader = csv.reader(ratingFile)
# loop past the header,
keys = []
vals = []
for row in reader:
if '# timestamp' in row:
keys = row
i = keys.index('# timestamp')
keys.pop(i)
vals = next(reader)
vals.pop(i)
for pos, key2 in enumerate(keys):
lineRatings[key2] = abs(float(vals[pos]))
#edgeTupleRatings = lineRatings copy with to-from tuple as keys for labeling
edgeTupleRatings = {}
for edge in lineRatings:
for obj in tree.values():
if obj.get('name', '').replace('"', '') == edge:
nodeFrom = obj.get('from')
nodeTo = obj.get('to')
coord = (nodeFrom, nodeTo)
ratingVal = lineRatings.get(edge)
edgeTupleRatings[coord] = ratingVal
# Calculate average node voltage deviation. First, helper functions.
def digits(x):
''' Returns number of digits before the decimal in the float x. '''
return math.ceil(math.log10(x + 1))
def avg(l):
''' Average of a list of ints or floats. '''
# HACK: add a small value to the denominator to avoid divide by zero for out of service locations (i.e. zero voltage).
return sum(l) / (len(l) + 0.00000000000000001)
# Detect the feeder nominal voltage:
for key in tree:
ob = tree[key]
if type(ob) == dict and ob.get('bustype', '') == 'SWING':
feedVoltage = float(ob.get('nominal_voltage', 1))
# Tot it all up.
nodeVolts = {}
nodeVoltsPU = {}
nodeVoltsPU120 = {}
voltImbalances = {}
for row in voltTable:
allVolts = []
allVoltsPU = []
allDiffs = []
nodeName = row.get('node_name', '')
for phase in ['A', 'B', 'C']:
realVolt = abs(float(row['volt' + phase + '_real']))
imagVolt = abs(float(row['volt' + phase + '_imag']))
phaseVolt = math.sqrt((realVolt**2) + (imagVolt**2))
if phaseVolt != 0.0:
treeKey = nameToIndex.get(nodeName, 0)
nodeObj = tree.get(treeKey, {})
try:
nominal_voltage = float(nodeObj['nominal_voltage'])
except:
nominal_voltage = feedVoltage
allVolts.append(phaseVolt)
normVolt = (phaseVolt / nominal_voltage)
allVoltsPU.append(normVolt)
avgVolts = avg(allVolts)
avgVoltsPU = avg(allVoltsPU)
avgVoltsPU120 = 120 * avgVoltsPU
nodeVolts[nodeName] = float("{0:.2f}".format(avgVolts))
nodeVoltsPU[nodeName] = float("{0:.2f}".format(avgVoltsPU))
nodeVoltsPU120[nodeName] = float("{0:.2f}".format(avgVoltsPU120))
if len(allVolts) == 3:
voltA = allVolts.pop()
voltB = allVolts.pop()
voltC = allVolts.pop()
allDiffs.append(abs(float(voltA - voltB)))
allDiffs.append(abs(float(voltA - voltC)))
allDiffs.append(abs(float(voltB - voltC)))
maxDiff = max(allDiffs)
voltImbal = maxDiff / avgVolts
voltImbalances[nodeName] = float("{0:.2f}".format(voltImbal))
# Use float("{0:.2f}".format(avg(allVolts))) if displaying the node labels
nodeLoadNames = {}
nodeNames = {}
for key in nodeVolts.keys():
nodeNames[key] = key
if key == loadLoc:
nodeLoadNames[key] = "LOAD: " + key
# find edge currents by parsing currdump
edgeCurrentSum = {}
edgeCurrentMax = {}
for row in currTable:
allCurr = []
for phase in ['A', 'B', 'C']:
realCurr = abs(float(row['curr' + phase + '_real']))
imagCurr = abs(float(row['curr' + phase + '_imag']))
phaseCurr = math.sqrt((realCurr**2) + (imagCurr**2))
allCurr.append(phaseCurr)
edgeCurrentSum[row.get('link_name', '')] = sum(allCurr)
edgeCurrentMax[row.get('link_name', '')] = max(allCurr)
# When just showing current as labels, use sum of the three lines' current values, when showing the per unit values (current/rating), use the max of the three
#edgeTupleCurrents = edgeCurrents copy with to-from tuple as keys for labeling
edgeTupleCurrents = {}
#edgeValsPU = values normalized per unit by line ratings
edgeValsPU = {}
#edgeTupleValsPU = edgeValsPU copy with to-from tuple as keys for labeling
edgeTupleValsPU = {}
#edgeTuplePower = dict with to-from tuples as keys and sim power as values for debugging
edgeTuplePower = {}
#edgeTupleNames = dict with to-from tuples as keys and names as values for debugging
edgeTupleNames = {}
#edgeTupleFaultNames = dict with to-from tuples as keys and the name of the Fault as the only value
edgeTupleFaultNames = {}
#edgeTupleProtDevs = dict with to-from tuples as keys and the initial of the type of protective device as the value
edgeTupleProtDevs = {}
#linePhases = dictionary containing the number of phases on each line for line-width purposes
linePhases = {}
edgePower = {}
for edge in edgeCurrentSum:
for obj in tree.values():
obname = obj.get('name', '').replace('"', '')
if obname == edge:
objType = obj.get('object')
nodeFrom = obj.get('from')
nodeTo = obj.get('to')
coord = (nodeFrom, nodeTo)
currVal = edgeCurrentSum.get(edge)
voltVal = avg([nodeVolts.get(nodeFrom), nodeVolts.get(nodeTo)])
power = (currVal * voltVal) / 1000
lineRating = lineRatings.get(edge, 10.0**9)
edgePerUnitVal = (edgeCurrentMax.get(edge)) / lineRating
edgeTupleCurrents[coord] = "{0:.2f}".format(currVal)
edgeTuplePower[coord] = "{0:.2f}".format(power)
edgePower[edge] = power
edgeValsPU[edge] = edgePerUnitVal
edgeTupleValsPU[coord] = "{0:.2f}".format(edgePerUnitVal)
edgeTupleNames[coord] = edge
if faultLoc == edge:
edgeTupleFaultNames[coord] = "FAULT: " + edge
phaseStr = obj.get('phases', '').replace('"', '').replace(
'N', '').replace('S', '')
numPhases = len(phaseStr)
if (numPhases < 1) or (numPhases > 3):
numPhases = 1
linePhases[edge] = numPhases
protDevLabel = ""
protDevBlownStr = ""
if objType in protDevices.keys():
for phase in protDevFinalStatus[obname].keys():
if objType == 'fuse':
if protDevFinalStatus[obname][phase] == "BLOWN":
protDevBlownStr = "!"
else:
if protDevFinalStatus[obname][phase] == "OPEN":
protDevBlownStr = "!"
if objType == 'fuse':
protDevLabel = 'F'
elif objType == 'switch':
protDevLabel = 'S'
elif objType == 'recloser':
protDevLabel = 'R'
elif objType == 'sectionalizer':
protDevLabel = 'X'
edgeTupleProtDevs[coord] = protDevLabel + protDevBlownStr
#define which dict will be used for edge line color
edgeColors = edgeValsPU
#define which dict will be used for edge label
edgeLabels = edgeTupleValsPU
# Build the graph.
fGraph = feeder.treeToNxGraph(tree)
# TODO: consider whether we can set figsize dynamically.
wlVal = int(math.sqrt(float(rezSqIn)))
voltChart = plt.figure(figsize=(wlVal, wlVal))
plt.axes(frameon=0)
plt.axis('off')
voltChart.gca().set_aspect('equal')
plt.tight_layout()
#set axes step equal
if neatoLayout:
# HACK: work on a new graph without attributes because graphViz tries to read attrs.
cleanG = nx.Graph(fGraph.edges())
cleanG.add_nodes_from(fGraph)
positions = graphviz_layout(cleanG, prog='neato')
else:
remove_nodes = [
n for n in fGraph if fGraph.nodes[n].get('pos', (0, 0)) == (0, 0)
]
fGraph.remove_nodes_from(remove_nodes)
positions = {n: fGraph.nodes[n].get('pos', (0, 0)) for n in fGraph}
# Need to get edge names from pairs of connected node names.
edgeNames = []
for e in fGraph.edges():
edgeNames.append((fGraph.edges[e].get('name',
'BLANK')).replace('"', ''))
#create custom colormap
if customColormap:
if scaleMin != None and scaleMax != None:
scaleDif = scaleMax - scaleMin
custom_cm = matplotlib.colors.LinearSegmentedColormap.from_list(
'custColMap', [(scaleMin, 'blue'),
(scaleMin + (0.12 * scaleDif), 'darkgray'),
(scaleMin + (0.56 * scaleDif), 'darkgray'),
(scaleMin + (0.8 * scaleDif), 'red')])
vmin = scaleMin
vmax = scaleMax
else:
custom_cm = matplotlib.colors.LinearSegmentedColormap.from_list(
'custColMap', [(0.0, 'blue'), (0.15, 'darkgray'),
(0.7, 'darkgray'), (1.0, 'red')])
vmin = 0
vmax = 1.25
custom_cm.set_under(color='black')
else:
custom_cm = plt.cm.get_cmap('viridis')
if scaleMin != None and scaleMax != None:
vmin = scaleMin
vmax = scaleMax
else:
vmin = None
vmax = None
drawColorbar = False
emptyColors = {}
#draw edges with or without colors
if edgeCol != None:
drawColorbar = True
if edgeCol == "Current":
edgeList = [edgeCurrentSum.get(n, 1) for n in edgeNames]
drawColorbar = True
elif edgeCol == "Power":
edgeList = [edgePower.get(n, 1) for n in edgeNames]
drawColorbar = True
elif edgeCol == "Rating":
edgeList = [lineRatings.get(n, 10.0**9) for n in edgeNames]
drawColorbar = True
elif edgeCol == "PercentOfRating":
edgeList = [edgeValsPU.get(n, .5) for n in edgeNames]
drawColorbar = True
else:
edgeList = [emptyColors.get(n, .6) for n in edgeNames]
print(
"WARNING: edgeCol property must be 'Current', 'Power', 'Rating', 'PercentOfRating', or None"
)
else:
edgeList = [emptyColors.get(n, .6) for n in edgeNames]
edgeIm = nx.draw_networkx_edges(
fGraph,
pos=positions,
edge_color=edgeList,
width=[linePhases.get(n, 1) for n in edgeNames],
edge_cmap=custom_cm)
#draw edge labels
if edgeLabs != None:
if edgeLabs == "Name":
edgeLabels = edgeTupleNames
elif edgeLabs == "Fault":
edgeLabels = edgeTupleFaultNames
elif edgeLabs == "Value":
if edgeCol == "Current":
edgeLabels = edgeTupleCurrents
elif edgeCol == "Power":
edgeLabels = edgeTuplePower
elif edgeCol == "Rating":
edgeLabels = edgeTupleRatings
elif edgeCol == "PercentOfRating":
edgeLabels = edgeTupleValsPU
else:
edgeLabels = None
print(
"WARNING: edgeCol property cannot be set to None when edgeLabs property is set to 'Value'"
)
elif edgeLabs == "ProtDevs":
edgeLabels = edgeTupleProtDevs
else:
edgeLabs = None
print(
"WARNING: edgeLabs property must be either 'Name', 'Value', or None"
)
if edgeLabs != None:
edgeLabelsIm = nx.draw_networkx_edge_labels(fGraph,
pos=positions,
edge_labels=edgeLabels,
font_size=8)
# draw nodes with or without color
if nodeCol != None:
if nodeCol == "Voltage":
nodeList = [nodeVolts.get(n, 1) for n in fGraph.nodes()]
drawColorbar = True
elif nodeCol == "VoltageImbalance":
nodeList = [voltImbalances.get(n, 1) for n in fGraph.nodes()]
drawColorbar = True
elif nodeCol == "perUnitVoltage":
nodeList = [nodeVoltsPU.get(n, .5) for n in fGraph.nodes()]
drawColorbar = True
elif nodeCol == "perUnit120Voltage":
nodeList = [nodeVoltsPU120.get(n, 120) for n in fGraph.nodes()]
drawColorbar = True
else:
nodeList = [emptyColors.get(n, 1) for n in fGraph.nodes()]
print(
"WARNING: nodeCol property must be 'Voltage', 'VoltageImbalance', 'perUnitVoltage', 'perUnit120Voltage', or None"
)
else:
nodeList = [emptyColors.get(n, .6) for n in fGraph.nodes()]
nodeIm = nx.draw_networkx_nodes(fGraph,
pos=positions,
node_color=nodeList,
linewidths=0,
node_size=30,
vmin=vmin,
vmax=vmax,
cmap=custom_cm)
#draw node labels
nodeLabels = {}
if nodeLabs != None:
if nodeLabs == "Name":
nodeLabels = nodeNames
elif nodeLabs == "Value":
if nodeCol == "Voltage":
nodeLabels = nodeVolts
elif nodeCol == "VoltageImbalance":
nodeLabels = voltImbalances
elif nodeCol == "perUnitVoltage":
nodeLabels = nodeVoltsPU
elif nodeCol == "perUnit120Voltage":
nodeLabels = nodeVoltsPU120
else:
nodeLabels = None
print(
"WARNING: nodeCol property cannot be set to None when nodeLabs property is set to 'Value'"
)
#HACK: add hidden node label option for displaying specified load name
elif nodeLabs == "Load":
nodeLabels = nodeLoadNames
else:
nodeLabs = None
print(
"WARNING: nodeLabs property must be either 'Name', 'Value', or None"
)
if nodeLabs != None:
nodeLabelsIm = nx.draw_networkx_labels(fGraph,
pos=positions,
labels=nodeLabels,
font_size=8)
plt.sci(nodeIm)
# plt.clim(110,130)
if drawColorbar:
plt.colorbar()
return voltChart
G0.rtt = {}
for n in G0:
G0.rtt[n] = time[n]
return G0
if __name__ == '__main__':
G = lanl_graph()
print("graph has %d nodes with %d edges"
% (nx.number_of_nodes(G), nx.number_of_edges(G)))
print(nx.number_connected_components(G), "connected components")
plt.figure(figsize=(8, 8))
# use graphviz to find radial layout
pos = graphviz_layout(G, prog="twopi", root=0)
# draw nodes, coloring by rtt ping time
nx.draw(G, pos,
node_color=[G.rtt[v] for v in G],
with_labels=False,
alpha=0.5,
node_size=15)
# adjust the plot limits
xmax = 1.02 * max(xx for xx, yy in pos.values())
ymax = 1.02 * max(yy for xx, yy in pos.values())
plt.xlim(0, xmax)
plt.ylim(0, ymax)
plt.show()
def plot_nx_succession_diagram(g,
fig_dimensions=[],
pos='pydot',
detailed_labels=True,
node_size=[],
node_color='grey',
font_size=12,
font_color='black'):
"""Plot the input succession diagram. Requires matplotlib. For finer control
over plot appearance, it is recommended to plot g directly.
Parameters
----------
g : networkx.DiGraph
Labeled succession diagram, e.g., as is output from
Export.networkx_succession_diagram_reduced_network_based().
fig_dimensions : (int,int)
Dimensions of the output figure. If [], then the dimensions are calculated
based on the number of nodes in g (the default is []).
pos : str or graphviz_layout
Layout for the node labels; if 'pydot', these are automatically computed
using pydot (requires pydot) (the default is 'pydot').
detailed_labels : bool
Whether node labels should be drawn (True) or left as metadata (False)
(the default is True).
node_size : int
Size of the nodes. If [], the size is proportional to the number of nodes
in g (the default is []).
node_color : color or array of colors
Node color. Can be a single color or a sequence of colors with the same
length as nodelist. (the default is 'grey').
font_size : int
Font size for labels (the default is 12).
font_color : str
Color for label text (the default is 'black').
"""
from networkx.drawing.nx_agraph import graphviz_layout
import matplotlib.pyplot as plt
if fig_dimensions == []:
fig_dimensions = (2 * (g.number_of_nodes() + 2),
g.number_of_nodes() + 2)
if node_size == []:
node_size = 50 * g.number_of_nodes()
if pos == 'pydot':
pos = graphviz_layout(g, prog='dot')
plt.figure(figsize=fig_dimensions)
nx.drawing.draw_networkx_nodes(g,
pos,
node_shape='s',
node_color=node_color,
node_size=node_size)
nx.draw_networkx_edges(g, pos, arrowstyle='fancy', arrowsize=10)
if detailed_labels:
nx.drawing.draw_networkx_labels(g,
pos,
labels=dict(g.nodes('label')),
font_size=font_size,
font_color=font_color)
else:
nx.drawing.draw_networkx_labels(g,
pos,
font_size=font_size,
font_color=font_color)
plt.axis('off')
plt.show()
def generateVoltChart(tree, rawOut, modelDir, neatoLayout=True):
''' Map the voltages on a feeder over time using a movie.'''
# We need to timestamp frames with the system clock to make sure the browser caches them appropriately.
genTime = str(datetime.datetime.now()).replace(':', '.')
# Detect the feeder nominal voltage:
for key in tree:
ob = tree[key]
if type(ob) == dict and ob.get('bustype', '') == 'SWING':
feedVoltage = float(ob.get('nominal_voltage', 1))
# Make a graph object.
fGraph = feeder.treeToNxGraph(tree)
if neatoLayout:
# HACK: work on a new graph without attributes because graphViz tries to read attrs.
cleanG = nx.Graph(fGraph.edges())
cleanG.add_nodes_from(fGraph)
# was formerly : positions = nx.graphviz_layout(cleanG, prog='neato') but this threw an error
positions = graphviz_layout(cleanG, prog='neato')
else:
rawPositions = {n: fGraph.node[n].get('pos', (0, 0)) for n in fGraph}
# HACK: the import code reverses the y coords.
def yFlip(pair):
try:
return (pair[0], -1.0 * pair[1])
except:
return (0, 0)
positions = {k: yFlip(rawPositions[k]) for k in rawPositions}
# Plot all time steps.
nodeVolts = {}
for step, stamp in enumerate(rawOut['aVoltDump.csv']['# timestamp']):
# Build voltage map.
nodeVolts[step] = {}
for nodeName in [
x for x in rawOut.get('aVoltDump.csv', {}).keys() +
rawOut.get('1nVoltDump.csv', {}).keys() +
rawOut.get('1mVoltDump.csv', {}).keys() if x != '# timestamp'
]:
allVolts = []
for phase in ['a', 'b', 'c', '1n', '2n', '1m', '2m']:
try:
voltStep = rawOut[phase + 'VoltDump.csv'][nodeName][step]
except:
continue # the nodeName doesn't have the phase we're looking for.
# HACK: Gridlab complex number format sometimes uses i, sometimes j, sometimes d. WTF?
if type(voltStep) is str: voltStep = voltStep.replace('i', 'j')
v = complex(voltStep)
phaseVolt = abs(v)
if phaseVolt != 0.0:
if _digits(phaseVolt) > 3:
# Normalize to 120 V standard
phaseVolt = phaseVolt * (120 / feedVoltage)
allVolts.append(phaseVolt)
# HACK: Take average of all phases to collapse dimensionality.
nodeVolts[step][nodeName] = avg(allVolts)
# Draw animation.
voltChart = plt.figure(figsize=(15, 15))
plt.axes(frameon=0)
plt.axis('off')
#set axes step equal
voltChart.gca().set_aspect('equal')
custom_cm = matplotlib.colors.LinearSegmentedColormap.from_list(
'custColMap', [(0.0, 'blue'), (0.25, 'darkgray'), (0.75, 'darkgray'),
(1.0, 'yellow')])
custom_cm.set_under(color='black')
edgeIm = nx.draw_networkx_edges(fGraph, positions)
nodeIm = nx.draw_networkx_nodes(
fGraph,
pos=positions,
node_color=[nodeVolts[0].get(n, 0) for n in fGraph.nodes()],
linewidths=0,
node_size=30,
cmap=custom_cm)
plt.sci(nodeIm)
plt.clim(110, 130)
plt.colorbar()
plt.title(rawOut['aVoltDump.csv']['# timestamp'][0])
def update(step):
nodeColors = np.array(
[nodeVolts[step].get(n, 0) for n in fGraph.nodes()])
plt.title(rawOut['aVoltDump.csv']['# timestamp'][step])
nodeIm.set_array(nodeColors)
return nodeColors,
anim = FuncAnimation(voltChart,
update,
frames=len(rawOut['aVoltDump.csv']['# timestamp']),
interval=200,
blit=False)
anim.save(pJoin(modelDir, 'voltageChart.mp4'),
codec='h264',
extra_args=['-pix_fmt', 'yuv420p'])
# Reclaim memory by closing, deleting and garbage collecting the last chart.
voltChart.clf()
plt.close()
del voltChart
gc.collect()
return genTime
with open(sys.argv[1]) as f:
for line in f:
adapters.append(int(line.strip()))
adapters.sort()
device = adapters[-1] + 3
adapters = [0] + adapters + [device]
labels = {}
G = nx.DiGraph()
for a in adapters:
labels[a] = a
reachable = [x for x in adapters if 1 <= x - a <= 3]
for b in reachable:
G.add_edge(a, b)
# plt.figure(figsize=(15, 15))
# nx.draw_kamada_kawai(G)
# node_colors = ["red" if x == "shiny gold" else "C0" for x in G.nodes()]
pos = graphviz_layout(G, prog="neato")
print(pos)
nx.draw(G, pos, labels=labels, font_color="white", font_size=10, arrowsize=14)
# nx.draw(G, pos, node_color=node_colors, arrowsize=12, node_size=10, edge_color=(0, 0, 0, 0.2))
# edge_labels = nx.get_edge_attributes(G,'weight')
# nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
if "--save" in sys.argv:
plt.savefig("day10_viz.svg")
else:
plt.show()
