def test_biconnected_eppstein():
# tests from http://www.ics.uci.edu/~eppstein/PADS/Biconnectivity.py
G1 = nx.Graph({
0: [1, 2, 5],
1: [0, 5],
2: [0, 3, 4],
3: [2, 4, 5, 6],
4: [2, 3, 5, 6],
5: [0, 1, 3, 4],
6: [3, 4],
})
G2 = nx.Graph({
0: [2, 5],
1: [3, 8],
2: [0, 3, 5],
3: [1, 2, 6, 8],
4: [7],
5: [0, 2],
6: [3, 8],
7: [4],
8: [1, 3, 6],
})
assert_true(nx.is_biconnected(G1))
assert_false(nx.is_biconnected(G2))
answer_G2 = [{1, 3, 6, 8}, {0, 2, 5}, {2, 3}, {4, 7}]
bcc = list(nx.biconnected_components(G2))
assert_components_equal(bcc, answer_G2)
def attacks(self):
for graph in self.graph_lists:
G_topo = nx.Graph()
G_topo.add_nodes_from(range(self.node_num))
G_topo.add_edges_from(graph)
# graph connectivity measures without attacks
self.flowrobust[0]+=self.__flow_robust(G_topo)
if nx.is_biconnected(G_topo):
self.biconnect[0]+=1
self.maxdiam[0]+=self.__max_diam(G_topo)
self.mindegree[0]+=min(G_topo.degree().values())
#graph connectivity measures under node failures
for fail_rate in [0.1, 0.2, 0.3, 0.4, 0.5]:
node_to_remove = \
range(int(self.node_num*fail_rate-self.node_num*0.1),
int(self.node_num*fail_rate))
for node_index in node_to_remove:
G_topo.remove_node(self.attack_seq[node_index])
self.flowrobust[int(fail_rate*10)] += self.__flow_robust(G_topo)
if nx.is_biconnected(G_topo):
self.biconnect[int(fail_rate*10)]+=1
self.maxdiam[int(fail_rate*10)] += self.__max_diam(G_topo)
self.mindegree[int(fail_rate*10)]+=min(G_topo.degree().values())
def planar_cycle_basis_impl(g):
assert not g.is_directed()
assert not g.is_multigraph()
assert nx.is_biconnected(g) # BAND-AID
# "First" nodes/edges for each cycle are chosen in an order such that the first edge
# may never belong to a later cycle.
# rotate to (hopefully) break any ties or near-ties along the y axis
rotate_graph(g, random.random() * 2 * math.pi)
# NOTE: may want to verify that no ties exist after the rotation
nx.set_edge_attributes(g, 'used_once', {e: False for e in g.edges()})
# precompute edge angles
angles = {}
for s,t in g.edges():
angles[s,t] = edge_angle(g,s,t) % (2*math.pi)
angles[t,s] = (angles[s,t] + math.pi) % (2*math.pi)
# identify and clear away edges which cannot belong to cycles
for v in g:
if degree(g,v) == 1:
remove_filament_from_tip(g, v)
cycles = []
# sort ascendingly by y
for root in sorted(g, key = lambda v: g.node[v]['y']):
# Check edges in ccw order from the +x axis
for target in sorted(g[root], key=lambda t: angles[root,t]):
if not g.has_edge(root, target):
continue
discriminator, path = trace_ccw_path(g, root, target, angles)
if discriminator == PATH_PLANAR_CYCLE:
assert path[0] == path[-1]
remove_cycle_edges(g, path)
cycles.append(path)
# Both the dead end and the initial edge belong to filaments
elif discriminator == PATH_DEAD_END:
remove_filament_from_edge(g, root, target)
remove_filament_from_tip(g, path[-1])
# The initial edge must be part of a filament
# FIXME: Not necessarily true if graph is not biconnected
elif discriminator == PATH_OTHER_CYCLE:
remove_filament_from_edge(g, root, target)
else: assert False # complete switch
assert not g.has_edge(root, target)
assert len(g.edges()) == 0
return cycles
def bases(self):
base_flowrobust = []
base_biconnect = []
for graph in self.graph_lists:
print graph
G_topo = nx.Graph()
G_topo.add_edges_from(graph)
base_biconnect.append(nx.is_biconnected(G_topo))
base_flowrobust.append(self.__flow_robust(G_topo))
return base_flowrobust
def _generate_no_biconnected(max_attempts=50):
attempts = 0
while True:
G = nx.fast_gnp_random_graph(100, 0.0575)
if nx.is_connected(G) and not nx.is_biconnected(G):
attempts = 0
yield G
else:
if attempts >= max_attempts:
msg = "Tried %d times: no suitable Graph."
raise Exception(msg % max_attempts)
else:
attempts += 1
def _generate_no_biconnected(max_attempts=50):
attempts = 0
while True:
G = nx.fast_gnp_random_graph(100,0.0575)
if nx.is_connected(G) and not nx.is_biconnected(G):
attempts = 0
yield G
else:
if attempts >= max_attempts:
msg = "Tried %d times: no suitable Graph."
raise Exception(msg % max_attempts)
else:
attempts += 1
def relay_placement(input_file_path):
file_dir = os.path.dirname(input_file_path)
file = os.path.basename(input_file_path)
file_name, file_type = file.split('_')
out_file_path = os.path.join(file_dir, file_name)
if file_type == 'pickle':
G = pj.load_pickle(input_file_path)
subg = make_subgraph(G)
plt.figure(1)
pj.draw_graph(subg, out_file_path + "_terminals")
terminals = subg.nodes()
#print (terminals)
print(nx.is_biconnected(subg))
if nx.is_connected(subg):
mst = nx.minimum_spanning_tree(subg, weight="weight")
#print (T1.edges(data=True))
expand_mst = nx.Graph()
plt.figure(2)
pj.draw_graph(mst, out_file_path + "_terminal_mst")
#pdb.set_trace()
#expanding the MST
for e in mst.edges():
temp = G.subgraph(nx.shortest_path(G, e[0], e[1], weight="weight"))
expand_mst.add_nodes_from(temp.nodes(data=True))
expand_mst.add_edges_from(temp.edges(data=True))
plt.figure(3)
pj.draw_graph(expand_mst, out_file_path + "_expanded_mst")
steiner = nx.minimum_spanning_tree(expand_mst)
while True:
n = dict(nx.degree(steiner))
bad_leaf = [
k for k, v in n.items() if v == 1 and k not in terminals
]
print(bad_leaf)
if not len(bad_leaf):
break
steiner.remove_nodes_from(bad_leaf)
plt.figure(4)
pj.draw_graph(steiner, out_file_path + "_RNPC")
pj.store_pickle(steiner, out_file_path + "RNPC_pickle")
else:
print(
"Terminals of the given graph do not lie in a single sonnected component. Thus it cannot be processed further"
)
def add_non_connected_vertices_to_cliques(graph, cliques, duplicate_articulation = False):
for v in graph:
if v not in list( cliques.index ):
# Add to a clique to see if it connected and add it to clique if it is
for i in range(1, cliques.max() + 1):
vertices = cliques.loc[cliques == i].index.tolist()
Hsub = graph.subgraph(vertices + [v])
if nx.is_biconnected(Hsub):
cliques[v] = i
if not duplicate_articulation:
break # break if we only want articulation points in one of the cliques
# If cannot be added to an excisting clique make new clique
if v not in list( cliques.index ):
cliques[v] = cliques.max() + 1
return cliques
def prepare_adhoc_topology(self):
# Initialize switches and their locations
for i in xrange(self.total_switches):
switch_id = "s" + str(i+1)
s_dict = {"switch_id": switch_id,
"x_pos": random.uniform(self.params["min_x"], self.params["max_x"]),
"y_pos": random.uniform(self.params["min_y"], self.params["max_y"])
}
self.graph.add_node(switch_id, s=s_dict)
# Add edges if the distance between switches is within a threshold
max_dist = math.sqrt(
(self.params["max_x"] - self.params["min_x"]) ** 2 + (self.params["max_y"] - self.params["min_y"]) ** 2)
for thresh_frac in [x/1000.0 for x in xrange(1, 1000)]:
thresh = thresh_frac * max_dist
self.add_edges_within_threshold(thresh)
if is_biconnected(self.graph):
print thresh_frac
break
def setStats(self):
"""1) go through each of the disjoint graphs
2) decide if it is one of the following a) single node b) cycle
c) line d) cyclic tree like structure e) acyclic tree like structure
3) And set stats for each subgraph
if edges are still untraced, then enumerate and remove them paths using
self._branchToBranch
"""
start = time.time()
countDisjointGraphs = len(self._disjointGraphs)
for self._ithDisjointGraph, self._subGraphSkeleton in enumerate(self._disjointGraphs):
self._findAccessComponentsDisjoint()
if len(self._nodes) == 1:
self.typeGraphdict[self._ithDisjointGraph] = SubgraphTypes.singleNode.value
elif (min(self._degreeList) == max(self._degreeList) and
nx.is_biconnected(self._subGraphSkeleton) and
self._cycleCount == 1):
self._singleCycle(self._cycleList[0])
self.typeGraphdict[self._ithDisjointGraph] = SubgraphTypes.singleCycle.value
elif set(self._degreeList) == set((1, 2)) or set(self._degreeList) == {1}:
self._singleSegment(self._nodes)
self.typeGraphdict[self._ithDisjointGraph] = SubgraphTypes.singleLine.value
elif self._cycleCount != 0:
self._cyclicTree(self._cycleList)
self.typeGraphdict[self._ithDisjointGraph] = SubgraphTypes.cyclic.value
else:
self._tree()
self.typeGraphdict[self._ithDisjointGraph] = SubgraphTypes.acyclic.value
# check if any unfinished business in _subGraphSkeleton, untraced edges
if self._subGraphSkeleton.number_of_edges() != 0:
self._branchToBranch()
assert self._subGraphSkeleton.number_of_edges() == 0, ("edges not removed are"
"%i" % self._subGraphSkeleton.number_of_edges())
progress = int((100 * self._ithDisjointGraph) / countDisjointGraphs)
print("finding segment stats in progress {}% \r".format(progress), end="", flush=True)
if True:
print()
self._findAccessComponentsNetworkx()
print("time taken to calculate segments and their lengths is %0.3f seconds" % (time.time() - start))
def print_is_of_type_attrs(graph):
print("\n====== is of type X? ======")
print("Directed? ->", "Yes" if nx.is_directed(graph) else "No")
print("Directed acyclic? ->", "Yes" if nx.is_directed_acyclic_graph(graph) else "No")
print("Weighted? ->", "Yes" if nx.is_weighted(graph) else "No")
if nx.is_directed(graph):
print("Aperiodic? ->", "Yes" if nx.is_aperiodic(graph) else "No")
print("Arborescence? ->", "Yes" if nx.is_arborescence(graph) else "No")
print("Weakly Connected? ->", "Yes" if nx.is_weakly_connected(graph) else "No")
print("Semi Connected? ->", "Yes" if nx.is_semiconnected(graph) else "No")
print("Strongly Connected? ->", "Yes" if nx.is_strongly_connected(graph) else "No")
else:
print("Connected? ->", "Yes" if nx.is_connected(graph) else "No")
print("Bi-connected? ->", "Yes" if nx.is_biconnected(graph) else "No")
if not graph.is_multigraph():
print("Chordal? -> ", "Yes" if nx.is_chordal(graph) else "No")
print("Forest? -> ", "Yes" if nx.is_chordal(graph) else "No")
print("Distance regular? -> ", "Yes" if nx.is_distance_regular(graph) else "No")
print("Eulerian? -> ", "Yes" if nx.is_eulerian(graph) else "No")
print("Strongly regular? -> ", "Yes" if nx.is_strongly_regular(graph) else "No")
print("Tree? -> ", "Yes" if nx.is_tree(graph) else "No")
VN[l[0]]=l[1].replace("\n","").replace("\r","")
G.add_node(VN[l[0]])
flag=1
A = [[0 for x in range(len(V))] for x in range(len(V))]
flag=0
for each_line in pl:
l=each_line.split(',')
if len(l)==5:
if flag!=0:
#print(l[0],l[1],l[3])
A[int(l[0][1:])][int(l[1][1:])]=float(l[3])
edge=(VN[l[0]],VN[l[1]])
G.add_edge(*edge)
flag=1
else:
continue
print nx.is_biconnected(G)
comp=list(nx.biconnected_components(G))
print (len(comp))
for i in range(len(comp)):
k=0
for j in list(comp[i]):
sheet.write(k, i, j)
k+=1
book.save("biconnectedness/"+each_file[:-4]+".xls")
fp.close()
# print counte,'a'
pos = nx.spring_layout(G, k=0.15, iterations=10)
print str(" ")
print 'BICONNECTEDNESS OF UNDIRECTED GRAPHS'
print str(" ")
G.remove_nodes_from(nx.isolates(G))
lc = sorted(nx.biconnected_components(G), key=len, reverse=True)
print str(" ")
print G.name
print str(" ")
print 'Is graph G biconnected?', nx.is_biconnected(G)
print 'Is graph G connected?', nx.is_connected(G)
print 'The number of biconnected components of G is:', len(lc)
print 'The number of connected components of G is:', nx.number_connected_components(
G)
print str(" ")
print 'List of biconnected components:'
print lc
print str(" ")
deg = G.degree()
deg_dic = []
for nd in deg:
if deg[nd] > 0:
deg_dic.append(nd)
def planar_cycle_basis_impl(g):
assert not g.is_directed()
assert not g.is_multigraph()
assert nx.is_biconnected(g) # BAND-AID
# "First" nodes/edges for each cycle are chosen in an order such that the first edge
# may never belong to a later cycle.
# rotate to (hopefully) break any ties or near-ties along the y axis
rotate_graph(g, random.random() * 2 * math.pi)
# NOTE: may want to verify that no ties exist after the rotation
nx.set_edge_attributes(g, 'used_once', {e: False for e in g.edges()})
# precompute edge angles
angles = {}
for s, t in g.edges():
angles[s, t] = edge_angle(g, s, t) % (2 * math.pi)
angles[t, s] = (angles[s, t] + math.pi) % (2 * math.pi)
# identify and clear away edges which cannot belong to cycles
for v in g:
if degree(g, v) == 1:
remove_filament_from_tip(g, v)
cycles = []
# sort ascendingly by y
for root in sorted(g, key=lambda v: g.node[v]['y']):
# Check edges in ccw order from the +x axis
for target in sorted(g[root], key=lambda t: angles[root, t]):
if not g.has_edge(root, target):
continue
discriminator, path = trace_ccw_path(g, root, target, angles)
if discriminator == PATH_PLANAR_CYCLE:
assert path[0] == path[-1]
remove_cycle_edges(g, path)
cycles.append(path)
# Both the dead end and the initial edge belong to filaments
elif discriminator == PATH_DEAD_END:
remove_filament_from_edge(g, root, target)
remove_filament_from_tip(g, path[-1])
# The initial edge must be part of a filament
# FIXME: Not necessarily true if graph is not biconnected
elif discriminator == PATH_OTHER_CYCLE:
remove_filament_from_edge(g, root, target)
else:
assert False # complete switch
assert not g.has_edge(root, target)
assert len(g.edges()) == 0
return cycles
# plt.show()
# position = nx.fruchterman_reingold_layout(G)
# nx.draw_networkx_nodes(G,position, nodelist=G.nodes(), node_color="b")
nx.draw_networkx_nodes(G, position, nodelist=CDS, node_color="r")
# nx.draw_networkx_edges(G,position)
# nx.draw_networkx_labels(G,position)
plt.savefig("3_1-conn_3-dom.png")
graphCDS = G.subgraph(CDS)
if not (nx.is_biconnected(graphCDS)):
print "\n"
CDS = compute_2_connected_k_dominating_set(G, CDS)
print "2-connected 3-dominating set"
print CDS
print "\n"
else:
print "Above set is also 2-connected"
print "\n"
# position = nx.fruchterman_reingold_layout(G)
# nx.draw_networkx_nodes(G,position, nodelist=G.nodes(), node_color="b")
nx.draw_networkx_nodes(G, position, nodelist=CDS, node_color="r")
# nx.draw_networkx_edges(G,position)
def test_null_graph():
G = nx.Graph()
assert_false(nx.is_biconnected(G))
assert_equal(list(nx.biconnected_components(G)), [])
assert_equal(list(nx.biconnected_component_edges(G)), [])
assert_equal(list(nx.articulation_points(G)), [])
def test_empty_is_biconnected():
G = nx.empty_graph(5)
assert_false(nx.is_biconnected(G))
G.add_edge(0, 1)
assert_false(nx.is_biconnected(G))
def add_sna_metrics(arradata):
conn = ad.get_connection()
sql_query = ("""
SELECT main_instagrammedia."userId" user_id, photo_id, main_usersinphoto."userId" user_tagged
FROM main_usersinphoto
JOIN main_instagrammedia ON main_usersinphoto.photo_id = main_instagrammedia.id
""")
all_tag_data = pd.read_sql(sql_query, conn)
users = list(all_tag_data['user_id'].unique())
sna_col_names = [
'largest_clique',
'density',
'edge_count',
'average_clustering', #'assortativity',
'clique_count',
'transitivity',
'connected',
'connected_components',
'biconnected',
'node_connectivity',
'edge_connectivity',
'average_connectivity',
'radius',
'diameter',
'average_shortest_path',
'isolates',
'selfies_count',
'node_count'
]
all_sna_metrics = []
for u in users:
tag_data = all_tag_data[all_tag_data['user_id'] == u][[
'photo_id', 'user_tagged'
]]
selfies_count = sum(tag_data['user_tagged'] == u)
tag_data = tag_data[tag_data['user_tagged'] != u]
if tag_data.shape[0] > 0:
taggers = list(tag_data['user_tagged'].unique())
nNodes = len(taggers) + 1
tag_matrix = np.array([0] * nNodes * nNodes).reshape(
(nNodes, nNodes))
tag_index = lambda user: taggers.index(user) + 1
tag_data['tag_index'] = tag_data[[
'user_tagged'
]].applymap(tag_index)['user_tagged']
photo_list = list(tag_data['photo_id'].unique())
tag_master = [
[0] + list(tag_data[tag_data['photo_id'] == p]['tag_index'])
for p in photo_list
]
for t in tag_master:
for i in range(len(t)):
for j in range(i + 1, len(t)):
tag_matrix[t[i], t[j]] = tag_matrix[t[i], t[j]] + 1
G = nx.from_numpy_matrix(
np.matrix(tag_matrix, dtype=[('weight', int)]))
sna_metrics = [
u,
nx.graph_clique_number(G),
nx.density(G),
nx.number_of_edges(G),
nx.average_clustering(G),
#nx.degree_assortativity_coefficient(G),
nx.graph_number_of_cliques(G),
nx.transitivity(G),
nx.is_connected(G),
nx.number_connected_components(G),
nx.is_biconnected(G),
nx.node_connectivity(G),
nx.edge_connectivity(G),
nx.average_node_connectivity(G),
nx.radius(G),
nx.diameter(G),
nx.average_shortest_path_length(G),
len(nx.isolates(G)),
selfies_count,
nx.number_of_nodes(G)
]
all_sna_metrics.append(sna_metrics)
sna_df = pd.DataFrame(all_sna_metrics, columns=['user_id'] + sna_col_names)
sna_df.index = sna_df['user_id']
del sna_df.index.name
sna_df = sna_df.drop('user_id', axis=1)
#put on social shift columns
arradata = add_social_shift(arradata, conn, users)
#sna_df = sna_df.fillna({'assortativity': 0.0})
arradata = pd.merge(arradata,
sna_df,
left_index=True,
right_index=True,
how='left')
G = nx.Graph()
G.add_node(1)
sna_trivial = [
nx.graph_clique_number(G),
nx.density(G),
nx.number_of_edges(G),
nx.average_clustering(G),
#0.0, #nx.degree_assortativity_coefficient(G), same as before
nx.graph_number_of_cliques(G),
nx.transitivity(G),
nx.is_connected(G),
nx.number_connected_components(G),
nx.is_biconnected(G),
nx.node_connectivity(G),
nx.edge_connectivity(G),
nx.average_node_connectivity(G),
nx.radius(G),
nx.diameter(G),
0, #nx.average_shortest_path_length(G), although it's formally infinite...
len(nx.isolates(G)),
0, # Selfies count
nx.number_of_nodes(G)
]
sna_na_dict = {
sna_col_names[i]: sna_trivial[i]
for i in range(len(sna_trivial))
}
arradata = arradata.fillna(sna_na_dict)
arradata[
'selfies_percentage'] = arradata['selfies_count'] / arradata['media']
arradata = arradata.fillna({'selfies_percentage': 0})
sna_loc_start = list(arradata.columns).index('largest_clique')
sna_loc_end = arradata.shape[1]
trivial_cols_index = []
for i in range(sna_loc_start, sna_loc_end):
if len(arradata.ix[:, i].unique()) == 1: trivial_cols_index.append(i)
trivial_cols = [
list(arradata.columns)[index] for index in trivial_cols_index
]
ad_cleaned = arradata.drop(trivial_cols, axis=1)
sna_corr = ad_cleaned.ix[:, sna_loc_start:].corr()
corrs = []
for i in range(sna_corr.shape[0]):
ones = sna_corr.ix[i][sna_corr.ix[i] == 1.0].index.tolist()
ones_ind = [sna_corr.columns.tolist().index(o) for o in ones]
if (len(ones_ind) > 1) and ones_ind not in corrs:
corrs.append(ones_ind)
corrs_labels = [[sna_corr.columns.tolist()[a] for a in c] for c in corrs]
for l in corrs_labels:
ad_cleaned = ad_cleaned.drop(l[1:], axis=1)
return ad_cleaned
membership[n.organism] = []
membership[n.organism].append([n.name, i+1])
print '\nHistogram of component order'
print 'order\tcount'
for n in sorted(sg_order_hist):
print '{0}\t{1}'.format(n, sg_order_hist[n])
print 'Writing subgraph info table.'
with open(args.output[0] + '.subgraph', 'w') as subinfo_h:
subinfo_wr = csv.writer(subinfo_h, delimiter='\t')
subinfo_wr.writerow(['id', 'size', 'order', 'density', 'eularian', 'binconn', 'modularity'])
for i, sg in enumerate(subgraphs):
part = com.best_partition(sg)
subinfo_wr.writerow([i+1, sg.size(), sg.order(), nx.density(sg),
nx.is_eulerian(sg), nx.is_biconnected(sg), com.modularity(part, sg)])
if args.writesubs:
print 'Writing all subgraphs ...'
for i, sg in enumerate(subgraphs):
out = os.path.join(args.work_dir[0], 'og{0}.graphml'.format(i+1))
nx.write_graphml(sg, out)
iso_count = 0
for org in membership:
print 'There remained {0} isolate genes in {1}'.format(len(isolate_genes[org]), org)
with open(org + '.memb', 'w') as memb_h:
memb_wr = csv.writer(memb_h, delimiter='\t')
memb_wr.writerow(['gene','og'])
for gn in membership[org]:
memb_wr.writerow(gn)
nx.write_adjlist(G, "test.adjlist")
# find node near center (0.5,0.5)
dmin = 1
ncenter = 0
for n in pos:
print pos[n]
x, y = pos[n]
d = (x - 0.5)**2 + (y - 0.5)**2
if d < dmin:
ncenter = n
dmin = d
print 'is connected: %s' % (nx.is_connected(G))
print 'is bi-connected: %s' % (nx.is_biconnected(G))
nx.draw(G, pos)
plt.show()
# color by path length from node near center
#p=nx.single_source_shortest_path_length(G,ncenter)
#plt.figure(figsize=(8,8))
#nx.draw_networkx_edges(G,pos,nodelist=[ncenter],alpha=0.4)
#nx.draw_networkx_nodes(G,pos,nodelist=p.keys(),
#node_size=80,
#node_color=p.values(),
#cmap=plt.cm.Reds_r)
#plt.xlim(-10,10)
g = nx.Graph()
#g = nx.DiGraph()
g.add_nodes_from(range(len(lines)))
for row in range(len(lines)):
for col in range(len(lines)):
if int(lines[row][col]) == 1:
g.add_edge(row,col)
print "Done reading all the files"
graphs[item] = g
for g in graphs.keys():
try:
print "====================== " , g, "==========================="
print "number of isolated nodes",'\t\t\t',nx.isolates(graphs[g])
print "is graph biconnected?",'\t\t\t',nx.is_biconnected(graphs[g])
print "cut vertices are: ",'\t\t\t',list(nx.articulation_points(graphs[g]))
print "number of nodes",'\t\t\t',len(graphs[g].nodes())
print "number of edges",'\t\t\t',len(graphs[g].edges())
print "degree",'\t\t\t',get_avg(graphs[g].degree())
print "diameter",'\t\t\t', nx.diameter(graphs[g])
print "radius",'\t\t\t', nx.radius(graphs[g])
print "is_bipartite?",'\t\t', bipartite.is_bipartite(graphs[g])
print "average_shortest_path_length",'\t\t', nx.average_shortest_path_length(graphs[g])
print "degree_assortativity_coefficient",'\t\t', nx.degree_assortativity_coefficient(graphs[g])
print "assortativity.average_degree_connectivity",'\t\t', nx.assortativity.average_degree_connectivity(graphs[g])
#print "degree_pearson_correlation_coefficient",'\t\t', nx.degree_pearson_correlation_coefficient(graphs[g])
print "node closeness_centrality",'\t\t\t', get_avg(nx.closeness_centrality(graphs[g]))
print "clustering",'\t\t\t', get_avg(nx.clustering(graphs[g]))
print "node betweeness",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=False,endpoints=False))
print "edge betweeness",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=False))
def test_null_graph():
G = nx.Graph()
assert_false(nx.is_biconnected(G))
assert_equal(list(nx.biconnected_components(G)), [])
assert_equal(list(nx.biconnected_component_edges(G)), [])
assert_equal(list(nx.articulation_points(G)), [])
nx.write_adjlist(G, "test.adjlist")
# find node near center (0.5,0.5)
dmin=1
ncenter=0
for n in pos:
print pos[n]
x,y=pos[n]
d=(x-0.5)**2+(y-0.5)**2
if d<dmin:
ncenter=n
dmin=d
print 'is connected: %s' % (nx.is_connected(G))
print 'is bi-connected: %s' % (nx.is_biconnected(G))
nx.draw(G,pos)
plt.show()
# color by path length from node near center
#p=nx.single_source_shortest_path_length(G,ncenter)
#plt.figure(figsize=(8,8))
#nx.draw_networkx_edges(G,pos,nodelist=[ncenter],alpha=0.4)
#nx.draw_networkx_nodes(G,pos,nodelist=p.keys(),
#node_size=80,
#node_color=p.values(),
#cmap=plt.cm.Reds_r)
#plt.xlim(-10,10)
def min_tree(input_file_path):
file_dir = os.path.dirname(input_file_path)
file = os.path.basename(input_file_path)
file_name, file_type = file.split('_')
out_file_path = os.path.join(file_dir, file_name)
test_path = os.path.join(file_dir, 'steps', 'try_')
if file_type == 'pickle':
G = pj.load_pickle(input_file_path)
reduced_graph = remove_relay(G)
# plt.figure(1)
# pj.draw_graph(reduced_graph, out_file_path+"_terminals")
fig = 1
pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig))
fig += 1
#terminals = reduced_graph.nodes()
#print (terminals)
#finding the sink (Base Station)
for node in reduced_graph.nodes(data=True):
if node[1]['type'] == 'BS':
sink_id = node[1]['id']
break
print(nx.is_biconnected(reduced_graph))
if nx.is_connected(reduced_graph):
#CMST begins================================================
#initialize:----------------------------------
Tree = nx.Graph()
#getting hop counts and max hop counts
hop_tuples = []
for node in reduced_graph.nodes():
reduced_graph.nodes[node]['hops'] = nx.shortest_path_length(
reduced_graph, sink_id, node)
if reduced_graph.nodes[node]['hops'] > 1:
hop_tuples += [(node, reduced_graph.nodes[node]['hops'])]
hop_tuples = sorted(hop_tuples, key=lambda x: x[1])
max_hop_count = hop_tuples[-1][1]
single_hop = []
#finding and connecting roots of top sub-trees
for sink, branch_root in reduced_graph.edges(sink_id):
single_hop += [branch_root]
temprary = G.subgraph([sink] +
reduced_graph.edges[sink,
branch_root]['link'] +
[branch_root])
Tree.add_nodes_from(temprary.nodes(data=True))
Tree.add_edges_from(temprary.edges(data=True))
# plt.figure(2)
# pj.draw_graph(Tree, out_file_path+"_tree")
pj.draw_graph(Tree, test_path + "tree" + str(fig))
fig += 1
#updating reduced tree - removing unrequired edges
# is this needed?
for i in list(combinations(single_hop, 2)):
if reduced_graph.has_edge(i[0], i[1]):
reduced_graph.remove_edge(i[0], i[1])
# plt.figure(1)
# pj.draw_graph(reduced_graph, out_file_path+"_terminals")
pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig))
fig += 1
#UPDATES
#defining branches, their loads and their components
branches = {}
dfs_edges = list(nx.dfs_edges(Tree, source=sink_id))
for parent, child in dfs_edges:
if parent == sink_id:
branch = child
branches[branch] = {}
branches[branch]['nodes'] = set([child])
branches[branch]['load'] = 0
if Tree.nodes[child]['type'] == 'S':
branches[branch]['load'] += 1
else:
branches[branch]['nodes'] = set([child
]) | branches[branch]['nodes']
if Tree.nodes[child]['type'] == 'S':
branches[branch]['load'] += 1
#print (dfs_edges)
#print (branches)
#UPDATES
#making growth sets, parent sets and hop sets
all_sets = {}
hop_set = {}
#print(hop_tuples)
for node, hop in hop_tuples:
if hop in hop_set:
hop_set[hop] = set([node]) | hop_set[hop]
else:
hop_set[hop] = set([node])
all_sets[node] = {'growth': set([]), 'parents': set([])}
for vertex, adj_vert in reduced_graph.edges(node):
#if parent
if reduced_graph.nodes[adj_vert]['hops'] < reduced_graph.nodes[
vertex]['hops']:
all_sets[node]['parents'] = set(
[adj_vert]) | all_sets[node]['parents']
elif reduced_graph.nodes[adj_vert][
'hops'] > reduced_graph.nodes[vertex]['hops']:
all_sets[node]['growth'] = set(
[adj_vert]) | all_sets[node]['growth']
#print(all_sets)
#print(hop_set)
#iteration
for h in range(2, max_hop_count + 1):
done = []
left_tuple = []
#directly connecting nodes with single parent
for node in hop_set[h]:
if len(all_sets[node]['parents']) == 1:
done += [node]
temp = G.subgraph([node] + reduced_graph.edges[
node, all_sets[node]['parents'][0]]['link'] +
all_sets[node]['parents'])
Tree.add_nodes_from(temp.nodes(data=True))
Tree.add_edges_from(temp.edges(data=True))
else:
left_tuple += [(node, len(all_sets[node]['growth']))]
# plt.figure(2)
# pj.draw_graph(Tree, out_file_path+"_tree")
pj.draw_graph(Tree, test_path + "tree" + str(fig))
fig += 1
#updating reduced tree - removing unrequired edges
# is this needed?
for i in done:
for j in hop_set[h]:
if reduced_graph.has_edge(i, j):
reduced_graph.remove_edge(i, j)
# plt.figure(1)
# pj.draw_graph(reduced_graph, out_file_path+"_terminals")
pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig))
fig += 1
#updating branches, their loads and their components
dfs_edges = list(nx.dfs_edges(Tree, source=sink_id))
for parent, child in dfs_edges:
if parent == sink_id:
branch = child
branches[branch] = {}
branches[branch]['nodes'] = set([child])
branches[branch]['load'] = 0
if Tree.nodes[child]['type'] == 'S':
branches[branch]['load'] += 1
else:
branches[branch]['nodes'] = set(
[child]) | branches[branch]['nodes']
if Tree.nodes[child]['type'] == 'S':
branches[branch]['load'] += 1
while len(left_tuple) > 0:
left_tuple = sorted(left_tuple, key=lambda x: x[0])
left_tuple = sorted(left_tuple, key=lambda x: x[1])
node = left_tuple[0][0]
left_tuple_temp = left_tuple[1:]
left_tuple = []
metric_tuple = []
for branch in branches:
if len(branches[branch]['nodes']
& all_sets[node]['parents']) > 0:
#generate the search set if h<max_hop_count
for parent in (branches[branch]['nodes']
& all_sets[node]['parents']):
ss = set([])
relay_set = set([])
temp_redgraph = reduced_graph.copy()
for i in done:
if temp_redgraph.has_edge(node, i):
temp_redgraph.remove_edge(node, i)
for p in all_sets[node]['parents']:
if temp_redgraph.has_edge(node, p):
temp_redgraph.remove_edge(node, p)
for c in all_sets[node]['growth']:
flag = 0
for cp in all_sets[c]['parents']:
if cp != node and flag == 0:
for path in nx.all_simple_paths(
temp_redgraph,
source=cp,
target=sink_id,
cutoff=h):
if len(
set(path)
& branches[branch]['nodes']
) == 0:
flag = 1
break
if flag == 0:
ss = ss | set([c])
relay_set = relay_set | set(
reduced_graph.edges[node, c]['link'])
#print ('ss = '+str(ss))
#TODO - replace with link weight
relay_set = relay_set | set(
reduced_graph.edges[node, parent]['link'])
relay_count = len(relay_set -
branches[branch]['nodes'])
#case1 metric
#metric = branches[branch]['load']+1+len(ss)+relay_count
#case2 metric
metric = branches[branch]['load'] + 1 + len(ss)
# checking if branches are fusing
relay_flag = 0
for b in branches:
if b != branch:
if len(relay_set
& branches[b]['nodes']) > 0:
relay_flag = 1
break
if (relay_flag == 0):
metric_tuple += [(metric, relay_count, branch,
parent, ss)]
#TODO - devise how to choose the best parent within a branch
metric_tuple = sorted(metric_tuple, key=lambda y: y[1])
metric_tuple = sorted(metric_tuple, key=lambda y: y[0])
#TODO - add search set addition and remove them from further hop metrix and their links too
temp = G.subgraph(
[node] +
reduced_graph.edges[node, metric_tuple[0][3]]['link'] +
[metric_tuple[0][3]])
Tree.add_nodes_from(temp.nodes(data=True))
Tree.add_edges_from(temp.edges(data=True))
for n in metric_tuple[0][4]:
temp = G.subgraph([n] +
reduced_graph.edges[n, node]['link'] +
[node])
Tree.add_nodes_from(temp.nodes(data=True))
Tree.add_edges_from(temp.edges(data=True))
# plt.figure(2)
# pj.draw_graph(Tree, out_file_path+"_tree")
pj.draw_graph(Tree, test_path + "tree" + str(fig))
fig += 1
#updating reduced tree - removing unrequired edges
# is this needed?
for i in hop_set[h]:
if reduced_graph.has_edge(node, i):
reduced_graph.remove_edge(node, i)
for p in all_sets[node]['parents']:
if p != metric_tuple[0][3]:
reduced_graph.remove_edge(node, p)
for n in metric_tuple[0][4]:
hop_set[h + 1] = hop_set[h + 1] - set([n])
for i in hop_set[h + 1]:
if reduced_graph.has_edge(n, i):
reduced_graph.remove_edge(n, i)
for p in all_sets[n]['parents']:
if p != node:
reduced_graph.remove_edge(n, p)
# plt.figure(1)
# pj.draw_graph(reduced_graph, out_file_path+"_terminals")
pj.draw_graph(reduced_graph, test_path + "terminal" + str(fig))
fig += 1
done += [node]
#updating branches, their loads and their components
dfs_edges = list(nx.dfs_edges(Tree, source=sink_id))
for parent, child in dfs_edges:
if parent == sink_id:
branch = child
branches[branch] = {}
branches[branch]['nodes'] = set([child])
branches[branch]['load'] = 0
if Tree.nodes[child]['type'] == 'S':
branches[branch]['load'] += 1
else:
branches[branch]['nodes'] = set(
[child]) | branches[branch]['nodes']
if Tree.nodes[child]['type'] == 'S':
branches[branch]['load'] += 1
#TODO - may need to change these for higher hop count nodes as well
#updating growth sets and parent sets
for n, a in left_tuple_temp:
all_sets[n] = {'growth': set([]), 'parents': set([])}
for vertex, adj_vert in reduced_graph.edges(n):
#if parent
if reduced_graph.nodes[adj_vert][
'hops'] < reduced_graph.nodes[vertex]['hops']:
all_sets[n]['parents'] = set(
[adj_vert]) | all_sets[n]['parents']
elif reduced_graph.nodes[adj_vert][
'hops'] > reduced_graph.nodes[vertex]['hops']:
all_sets[n]['growth'] = set(
[adj_vert]) | all_sets[n]['growth']
left_tuple += [(n, len(all_sets[n]['growth']))]
plt.figure(fig)
pj.draw_graph(reduced_graph, out_file_path + "_skeletontree")
plt.figure(fig + 1)
pj.draw_graph(Tree, out_file_path + "_fulltree")
pj.store_pickle(Tree, out_file_path + "balancedtree_pickle")
else:
print(
"Terminals of the given graph do not lie in a single sonnected component. Thus it cannot be processed further"
)
def test_is_biconnected():
G=nx.cycle_graph(3)
assert_true(nx.is_biconnected(G))
nx.add_cycle(G, [1, 3, 4])
assert_false(nx.is_biconnected(G))
def case_split(self):
node = self.bd.graph['root']
leaf = dict()
for e in self.bd.edges(node):
if (self.bd.degree(e[1]) != 1):
leaf[e] = self.bd.edge[e[0]][e[1]]['label'].sort()
else:
v = e[1]
mid = self.bd.edge[e[0]][e[1]]['label']
one_list = list()
for e in leaf.keys():
if set(leaf[e]).issubset(mid):
one_list.append(e)
while one_list:
curr_edge = one_list.pop()
curr_node = int(self.bd.number_of_nodes())
self.bd.add_node(curr_node, nodetype=int, label=list())
lab = set
for e in leaf.keys():
if e[1] != curr_edge[1] and e[1] != v:
self.bd.add_edge(curr_node, e[1], label=leaf[e])
lab |= set(leaf[e])
self.bd.remove_edge(e[1], node)
self.bd.add_edge(node, curr_node, label=list(lab))
v = node
node = curr_node
mid = list(lab)
self.bd.graph['root'] = curr_node
if nx.is_biconnected(self.g):
ga = nx.Graph()
nodes = set()
for e in self.bd.edges(node):
if self.bd.degree(e[1]) == 1:
nodes |= set(self.bd.edge[e[0]][e[1]]['label'])
nodes |= {
self.edge.keys()[self.edge.values().index(
self.bd.edge[e[0]][e[1]]['label'].sort())]
}
for i in range(len(nodes)):
nodes[i] = nodes[1] - 1
ga = self.g.subgraph(list(nodes))
for n in ga.nodes():
if ga.degree(n) == 1 and n + 1 not in mid:
e = ga.edges(n)
alert = 0
curr_edge1 = list()
curr_edge1.append(n)
for e1 in ga.edges(e[1]):
curr_edge1.append(e1[1])
if e1[1] in mid:
alert = 1
if alert != 1:
curr_edge = leaf.keys()[leaf.values().index(
(curr_edge1.sort()))]
curr_node = int(self.bd.number_of_nodes())
self.bd.add_node(curr_node, nodetype=int, label=list())
lab = set
for e in leaf.keys():
if e[1] != curr_edge[1] and e[1] != v:
self.bd.add_edge(curr_node,
e[1],
label=leaf[e])
lab |= set(leaf[e])
self.bd.remove_edge(e[1], node)
self.bd.add_edge(node, curr_node, label=list(lab))
v = node
node = curr_node
mid = list(lab)
self.bd.graph['root'] = curr_node
ga = nx.Graph()
nodes = set()
for e in self.bd.edges(node):
if self.bd.degree(e[1]) == 1:
nodes |= set(self.bd.edge[e[0]][e[1]]['label'])
nodes |= {
self.edge.keys()[self.edge.values().index(
self.bd.edge[e[0]][e[1]]['label'].sort())]
}
for i in range(len(nodes)):
nodes[i] = nodes[1] - 1
ga = self.g.subgraph(list(nodes))
if nx.is_connected(ga):
return False
else:
comp = nx.connected_components(ga)
def test_empty_is_biconnected():
G=nx.empty_graph(5)
assert_false(nx.is_biconnected(G))
G.add_edge(0, 1)
assert_false(nx.is_biconnected(G))
def test_null_graph():
G = nx.Graph()
assert not nx.is_biconnected(G)
assert list(nx.biconnected_components(G)) == []
assert list(nx.biconnected_component_edges(G)) == []
assert list(nx.articulation_points(G)) == []
def test_is_biconnected():
G = nx.cycle_graph(3)
assert_true(nx.is_biconnected(G))
nx.add_cycle(G, [1, 3, 4])
assert_false(nx.is_biconnected(G))
def test_is_biconnected():
G = nx.cycle_graph(3)
assert nx.is_biconnected(G)
nx.add_cycle(G, [1, 3, 4])
assert not nx.is_biconnected(G)
pos=nx.spring_layout(G,k=0.15,iterations=10)
print str(" ")
print 'BICONNECTEDNESS OF UNDIRECTED GRAPHS'
print str(" ")
G.remove_nodes_from(nx.isolates(G))
lc=sorted(nx.biconnected_components(G), key = len, reverse=True)
print str(" ")
print G.name
print str(" ")
print 'Is graph G biconnected?', nx.is_biconnected(G)
print 'Is graph G connected?', nx.is_connected(G)
print 'The number of biconnected components of G is:', len(lc)
print 'The number of connected components of G is:', nx.number_connected_components(G)
print str(" ")
print 'List of biconnected components:'
print lc
print str(" ")
deg=G.degree()
deg_dic=[]
for nd in deg:
if deg[nd]>0:
deg_dic.append(nd)
node0 = random.choice(deg_dic)
print 'Writing subgraph info table.'
with open(args.output[0] + '.subgraph', 'w') as subinfo_h:
subinfo_wr = csv.writer(subinfo_h, delimiter='\t')
subinfo_wr.writerow([
'id', 'size', 'order', 'density', 'eularian', 'binconn', 'modularity'
])
for i, sg in enumerate(subgraphs):
part = com.best_partition(sg)
subinfo_wr.writerow([
i + 1,
sg.size(),
sg.order(),
nx.density(sg),
nx.is_eulerian(sg),
nx.is_biconnected(sg),
com.modularity(part, sg)
])
if args.writesubs:
print 'Writing all subgraphs ...'
for i, sg in enumerate(subgraphs):
out = os.path.join(args.work_dir[0], 'og{0}.graphml'.format(i + 1))
nx.write_graphml(sg, out)
iso_count = 0
for org in membership:
print 'There remained {0} isolate genes in {1}'.format(
len(isolate_genes[org]), org)
with open(org + '.memb', 'w') as memb_h:
memb_wr = csv.writer(memb_h, delimiter='\t')
def calculate(graph):
return nx.is_biconnected(graph)
print("seed matrix size: ")
print(_V_)
print("iterations: ")
print(k)
G = StochasticKroneckerGenerator.generateStochasticKroneckerGraph(
initiator, k, True)
print("=== GRAPH GENERATION COMPLETE ===")
bipartite = nx.is_bipartite(G)
print("Is Bipartite: ")
print(bipartite)
connected = nx.is_biconnected(G)
print("Is Connected: ")
print(connected)
nx.draw_networkx(G,
node_color='red',
pos=nx.spring_layout(G),
node_size=10,
with_labels=False)
plt.show()
print("Generating statistics...")
statistics = generateStatistics(G)
print(statistics)
