def scoring(self):
if self.players_loc[0][1] == self.size - 1:
if self.index == 0:
return 1000
else:
return -1000
if self.players_loc[1][1] == 0:
if self.index == 0:
return -1000
else:
return 1000
con1 = nx.node_connected_component(self.graph, tuple(self.players_loc[0]))
con1 = filter(lambda x: x[1] == self.size - 1, con1)
d1 = min(nx.shortest_path_length(self.graph, tuple(self.players_loc[0]), node) for node in con1)
con2 = nx.node_connected_component(self.graph, tuple(self.players_loc[1]))
con2 = filter(lambda x: x[1] == 0, con2)
d2 = min(nx.shortest_path_length(self.graph, tuple(self.players_loc[1]), node) for node in con2)
wall_score = WALL_SCORE * (self.wall_counts[1] - self.wall_counts[0])
distance_score = DISTANCE_SCORE * (d2 - d1)
if self.score_func0 is not None and self.score_func1 is not None:
v0 = self.score_func0 * self.wall_counts[0]
v1 = self.score_func1 * self.wall_counts[1]
if self.index == 0:
return distance_score - (v1 - v0)
else:
return -distance_score + (v1 - v0)
if self.index == 0:
return distance_score - wall_score
else:
return -distance_score + wall_score
def get_path_two_residues(hbfile, sourceRes, targetRes, pathCutoff, edgeCutoff, middleRes="ARGA0082"):
'''Get all the pathways between two residues.
The weight of each edge should be larger than or equal to the threshold,
and the length of the pathway should be equal to or less than the number specified by lenLessThan.
'''
g = nx.Graph()
for eachLine in open(hbfile):
fields = eachLine.split()
if len(fields) == 3 and float(fields[2]) < edgeCutoff:
continue
g.add_edge(fields[0], fields[1])
if (sourceRes in g.nodes()) and (targetRes in g.nodes()) and (nx.has_path(g, sourceRes, targetRes)):
for eachPath in sorted(nx.all_simple_paths(g, sourceRes, targetRes, pathCutoff), key=lambda p: len(p)):
print eachPath
else:
print "No path"
if (sourceRes in g.nodes()) and (targetRes in g.nodes()):
print "Both %s and %s in the network but are not connected" % (sourceRes, targetRes)
if sourceRes in g.nodes():
print "%s in: " % sourceRes, nx.node_connected_component(g, sourceRes)
if middleRes in nx.node_connected_component(g, sourceRes):
print "%s connecting with %s" % (middleRes, sourceRes)
if targetRes in g.nodes():
print "%s in: " % targetRes, nx.node_connected_component(g, targetRes)
if middleRes in nx.node_connected_component(g, targetRes):
print "%s connecting with %s" % (middleRes, targetRes)
if middleRes in g.nodes():
print "%s in: " % middleRes, nx.node_connected_component(g, middleRes)
def convertir_en_conexo(grafo):
nodos = grafo.nodes()
nodos_conectados = nx.node_connected_component(grafo, 0)
nodos.sort()
nodos_conectados.sort()
conectar = []
while nodos != nodos_conectados:
nodo_en_esta_componente = -1
nodo_en_otra_componente = -1
# elijo nodo de una y otra componente
for v in nodos:
if v not in nodos_conectados:
nodo_en_otra_componente = v
else:
nodo_en_esta_componente = v
if nodo_en_esta_componente != -1 and nodo_en_otra_componente != -1:
break
#recuerdo que conectar
conectar.append((nodo_en_otra_componente, nodo_en_esta_componente))
# actualizo nodos y nodos_conectados
for v in nodos_conectados:
nodos.remove(v)
if len(nodos) > 0:
nodos_conectados = nx.node_connected_component(grafo, nodo_en_otra_componente)
nodos_conectados.sort()
#conecto las componentes conexas
for u, v in conectar:
grafo.add_edge(u, v)
def get_junction_tree(G):
print("triangulate it")
G_triangulated = triangulate_graph(G)
print("get cliques")
cliques = nx.find_cliques(G_triangulated)
print("make the junction tree")
junction_tree = nx.Graph()
junction_tree.add_nodes_from([tuple(clique) for clique in cliques])
intersection_size = {
combo: len(combo[0] + combo[1]) - len(set(combo[0] + combo[1]))
for combo in combinations(junction_tree.nodes(), 2)
}
intersection_size = {
key: val
for key, val in intersection_size.items() if val != 0
}
ordered_by_weights = {
pair[0]
for pair in sorted(intersection_size.items(), key=lambda kv: -kv[1])
}
for pair in ordered_by_weights:
cluster_1 = pair[0]
cluster_2 = pair[1]
if not nx.node_connected_component(
junction_tree, cluster_1) == nx.node_connected_component(
junction_tree, cluster_2):
junction_tree.add_edge(cluster_1, cluster_2)
return junction_tree
def find_nearest_neighbors2(db, a, nmax=10, rates=None, Peq=None):
if rates is None:
edges = [ (ts.minimum1, ts.minimum2, ts.energy) for ts in
db.transition_states(order_energy=True)]
else:
edges = [((u,v), k*Peq[u]) for (u,v), k in
rates.iteritems() if u<v]
edges.sort(key=lambda uvk: -uvk[1])
assert edges[0][1] > edges[1][1]
edges = [uv for uv, k in edges]
subtrees = nx.utils.UnionFind()
subtrees[a]
graph = nx.Graph()
graph.add_node(a)
for u,v, e in edges:
uroot = subtrees[u]
vroot = subtrees[v]
if uroot != vroot:
subtrees.union(u,v)
graph.add_edge(u,v)
# graph.add_edge(u,v)
if subtrees[u] == subtrees[a]:
print "energy", e, u._id, v._id
cc = nx.node_connected_component(graph, a)
if len(cc) >= nmax:
print "found a tree of sufficient size"
return cc
print "finishing without having found a tree of sufficient size"
cc = nx.node_connected_component(graph, a)
return cc
def segment(segment_graph, sorted_edges):
for u,v,d in sorted_edges:
connected1 = nx.node_connected_component(segment_graph, u)
connected2 = nx.node_connected_component(segment_graph, v)
if d['weight'] <= min_internal_diff(connected1, connected2, segment_graph):
segment_graph.add_edge(u,v,weight=d['weight'])
return segment_graph
def check_connected(self):
# Make sure there are still ways to reach the end
self.graph.remove_edges_from(self.special_edges)
con1 = nx.node_connected_component(self.graph, tuple(self.players_loc[0]))
con2 = nx.node_connected_component(self.graph, tuple(self.players_loc[1]))
connected = any(y == self.size - 1 for x, y in con1) and any(y == 0 for x, y in con2)
self.graph.add_edges_from(self.special_edges)
return connected
def min_cut_volume(recorder, graph, labels, params):
assert params.n_shot == 1 and params.n_way == 2
cut = nx.minimum_edge_cut(graph, 0, 1)
graph.remove_edges_from(cut)
part_a = nx.node_connected_component(graph, 0)
part_b = nx.node_connected_component(graph, 1)
label_0, label_1 = labels[0].item(), labels[1].item()
return connect_parts_labels(recorder, graph, part_a, part_b, labels,
label_0, label_1)
def test_inversion_option(c1,c2,join_options,ograph,linked):
a=c1
b=linked[c1]
c=c2
d=linked[c2]
#k=linked[internal_node]
ograph.remove_edge(a,b)
ograph.remove_edge(c,d)
## ---b a-------c d----
if a in nx.node_connected_component(ograph,c): ## exchance labels of a,b if necessary, so the nodes are in this config: ---a b-------c d------
x=b
b=a
a=x
## ---b a-------d c----
if a in nx.node_connected_component(ograph,d): ## exchance labels of a,b if necessary, so the nodes are in this config: ---a b-------c d------
x=b
b=a
a=x
x=d
d=c
c=x
## ---a b-------d c----
if b in nx.node_connected_component(ograph,d): ## exchance labels of c,d if necessary, so the nodes are in this config: ---a b-------c d------
x=d
d=c
c=x
n_scaffold = old_div(len(nx.node_connected_component(ograph,b)),2)
print("inversion n nodes",n_scaffold)
total_i_len = sum( ograph[i][j]['length'] for i,j in nx.bfs_edges(ograph,b) )
print("inv len",total_i_len)
if total_i_len < 10000.0 or n_scaffold<2:
print("inversion length",total_i_len,n_scaffold,"too short")
join_options.append( (0.0,(),() ) )
ograph.add_edge(a,b,length=default_gapsize,contig=False)
ograph.add_edge(c,d,length=default_gapsize,contig=False)
return
interc_score0 = intercalation_score_raw(a,b,d,ograph)
interc_score1 = intercalation_score_raw(a,c,d,ograph)
print("inversion0", interc_score0)
print("inversion", interc_score1)
join_options.append( (interc_score0,(),() ) )
join_options.append( (interc_score1,((a,c),(b,d)),((a,b),(c,d)) ) )
ograph.add_edge(a,b,length=default_gapsize,contig=False)
ograph.add_edge(c,d,length=default_gapsize,contig=False)
return
def sparsity_heuristic(graph, i, j):
#TODO: consider 8X8 window around diagonal only
cc_1 = nx.node_connected_component(graph, (i, j))
cc_2 = nx.node_connected_component(graph, (i + 1, j))
score = min(abs(len(cc_1) - len(cc_2)), 64)
if len(cc_1) < len(cc_2):
graph[(i, j)][(i + 1, j + 1)][HEURISTICS_SCORE] = graph[
(i, j)][(i + 1, j + 1)][HEURISTICS_SCORE] + score
elif len(cc_1) > len(cc_2):
graph[(i + 1, j)][(i, j + 1)][HEURISTICS_SCORE] = graph[
(i + 1, j)][(i, j + 1)][HEURISTICS_SCORE] + score
def prune_loops(g, s, t):
ps = list(nx.articulation_points(g))
for p in ps:
if p in g and p not in [s, t]:
g1 = nx.Graph(g)
g1.remove_node(p)
cs = nx.node_connected_component(g1, s)
ct = nx.node_connected_component(g1, t)
c = cs.union(ct)
c.add(p)
g.remove_nodes_from([n for n in g if n not in c])
def largest_cluster(self, distribution=False):
sizes = []
for node in self.__latt.nodes():
if len(nx.node_connected_component(self.__latt, node)) != 1:
sizes.append(
len(nx.node_connected_component(self.__latt, node)))
mx = max(sizes) if len(sizes) > 0 else 0
if not distribution:
del sizes
return mx
else:
return sizes
def _calculate_groups_size_function(self, T):
G = T.copy()
for edge in T.edges():
u, v = edge
G.remove_edge(u, v)
Nu = nx.node_connected_component(G, u)
Nu = len(Nu)
Nv = nx.node_connected_component(G, v)
Nv = len(Nv)
T[u][v]["group_size"] = T[u][v]["weight"] * min(Nu, Nv)
G.add_edge(u, v)
G[u][v] = T[u][v]
def _calculate_groups_size_function(self, T):
G = T.copy()
for edge in T.edges():
u, v = edge
G.remove_edge(u, v)
Nu = nx.node_connected_component(G, u)
Nu = len(Nu)
Nv = nx.node_connected_component(G, v)
Nv = len(Nv)
T[u][v]["group_size"] = T[u][v]["weight"] * min(Nu, Nv)
G.add_edge(u, v)
G[u][v] = T[u][v]
def stoer_wagner_volume(recorder, graph, labels, params):
assert params.n_way == 2
try:
_, (part_a, part_b) = nx.stoer_wagner(graph)
except nx.exception.NetworkXError:
assert params.n_shot == 1
part_a = nx.node_connected_component(graph, 0)
part_b = nx.node_connected_component(graph, 1)
label_0, label_1 = torch.min(labels).item(), torch.max(labels).item()
assert (labels == label_0).sum().item() * 2 == len(graph)
return connect_parts_labels(recorder, graph, part_a, part_b, labels,
label_0, label_1)
def reduce_graph(g):
# show_graph(g,3)
nx.set_edge_attributes(g, 'capacity', 1)
g = nx.convert_node_labels_to_integers(g, 0)
g1 = nx.Graph()
for edge in g.edges():
if edge in g1.edges():
g1.edge[edge[0]][edge[1]]['capacity'] += 1
else:
g1.add_edge(edge[0], edge[1], capacity=1)
construction(g1, 0, set(g1.nodes()))
# show_graph(A, 3)
capacities=nx.get_edge_attributes(A,'capacity')
if max(capacities.values())<=1:
return g,None,1
if max(capacities.values())==2:
return g,None,2
remove_edges = list()
biconnected = list()
for e in A.edges(data=True):
if e[2]['capacity'] <= 2:
remove_edges.append(e)
if e[2]['capacity'] == 2:
biconnected.append(e)
A.remove_edges_from(remove_edges)
for e in biconnected:
cut_edges = list(nx.minimum_edge_cut(g1, e[0], e[1]))
if cut_edges[1][0] in nx.node_connected_component(A, cut_edges[0][0]):
g.add_edge(cut_edges[0][0], cut_edges[1][0])
if cut_edges[1][1] in nx.node_connected_component(A, cut_edges[0][1]):
g.add_edge(cut_edges[0][1], cut_edges[1][1])
else:
raise Exception("Biconnected edge does not match")
elif cut_edges[1][0] in nx.node_connected_component(A, cut_edges[0][1]):
g.add_edge(cut_edges[0][0], cut_edges[1][1])
if cut_edges[1][1] in nx.node_connected_component(A, cut_edges[0][0]):
g.add_edge(cut_edges[0][1], cut_edges[1][0])
else:
raise Exception("Biconnected edge does not match")
else:
raise Exception("Biconnected edge does not match")
# print e[0],g1[e[0]]
# print e[1],g1[e[1]]
# show_graph(A, 1)
# show_graph(g,1)
G = list(nx.connected_components(A))
connected_components=list(nx.connected_components(A))
for i in connected_components:
if len(i)<3:
G.remove(i)
if G==[]:
return g,None,2
return g,G,3
def distance(self, game):
con1 = nx.node_connected_component(game.graph, tuple(game.players_loc[0]))
con1 = filter(lambda x: x[1] == game.size - 1, con1)
d1 = min(nx.shortest_path_length(game.graph, tuple(game.players_loc[0]), node) for node in con1)
con2 = nx.node_connected_component(game.graph, tuple(game.players_loc[1]))
con2 = filter(lambda x: x[1] == 0, con2)
d2 = min(nx.shortest_path_length(game.graph, tuple(game.players_loc[1]), node) for node in con2)
distance_score = d2 - d1
if game.index == 0:
return distance_score
else:
return -distance_score
def calc_closeness(G, normalized=True):
# Calculates the closeness centrality
closeness = {node: nx.closeness_centrality(G, node) for node in G}
if not normalized:
g_n = len(G)
closeness = {
node: value * (G.number_of_nodes() - 1) /
(len(nx.node_connected_component(G, node)) - 1)
if 0 < len(nx.node_connected_component(G, node)) else 0
for node, value in closeness.items()
}
#end if
return closeness
def get_molecules_change(self, bond_change):
# Compute the change in molecules.
atoms_involved = np.unique(
bond_change[:, :2]
) # Atoms indices that are involved in one of the reaction of bond_change
molecule_subset_old = set()
molecule_subset_new = set()
# Get the molecules involved in the reactions of bond_change.
for atom in atoms_involved:
molecule_subset_old = molecule_subset_old.union(
nx.node_connected_component(self.molecule_graph, atom))
# Get the molecules before the reaction
[
old_molecules, old_molecules_count, old_molecules_frame,
old_mol_atoms_involved
] = self.get_molecules_frame(
self.molecule_graph.subgraph(molecule_subset_old), atoms_involved)
old_molecule_bond_change = self.get_molecule_bond_change(
old_mol_atoms_involved, atoms_involved, bond_change)
# Update the graph of the system with the reactions in bond_change
self.update_molecule_graph(bond_change)
for atom in atoms_involved:
molecule_subset_new = molecule_subset_new.union(
nx.node_connected_component(self.molecule_graph, atom))
# Get the molecules after the reactions.
[
new_molecules, new_molecules_count, new_molecules_frame,
new_mol_atoms_involved
] = self.get_molecules_frame(
self.molecule_graph.subgraph(molecule_subset_new), atoms_involved)
new_molecule_bond_change = self.get_molecule_bond_change(
new_mol_atoms_involved, atoms_involved, bond_change)
molecules_frame_change = new_molecules.copy()
molecules_counts_change = new_molecules_count.copy()
# Calculate the molecules changes
for mol in range(old_molecules.shape[0]):
molecule_idx = np.where(
(molecules_frame_change == old_molecules[mol, :]).all(axis=1))
if molecule_idx[0].shape[0] == 0:
molecules_frame_change = np.vstack(
[molecules_frame_change, old_molecules[mol, :]])
molecules_counts_change = np.append(molecules_counts_change,
-old_molecules_count[mol])
elif molecule_idx[0].shape[0] == 1:
molecules_counts_change[
molecule_idx[0]] -= old_molecules_count[mol]
return [
molecules_frame_change, molecules_counts_change,
old_molecules_frame, old_molecule_bond_change, new_molecules_frame,
new_molecule_bond_change
]
def connected_paths(self, path_id, include_self=False):
"""
Given an index of self.paths find other paths which
overlap with that path.
Parameters
-----------
path_id : int
Index of self.paths
include_self : bool
Should the result include path_id or not
Returns
-----------
path_ids : (n, ) int
Indexes of self.paths that overlap input path_id
"""
if len(self.root) == 1:
path_ids = np.arange(len(self.polygons_closed))
else:
path_ids = list(nx.node_connected_component(
self.enclosure,
path_id))
if include_self:
return np.array(path_ids)
return np.setdiff1d(path_ids, [path_id])
def multi_collapse(self):
"""
performs collapsing across multiple ProphetExperiment
retains only core complexes seen in multiple experiments
i.e exp 1 A-B-C
exp 2 A-B-D
exp3 A-B-C
keep ABC as most frequent combination of subunits
"""
allhypo = pd.concat([exp.get_hypo() for exp in self.allexps])
# this is only for later splitting to make sure there is no other $
names = list(allhypo.index + "$" + allhypo["CREP"])
annot_gr = self.simil_graph_weight(allhypo, names)
allhypo["nm"] = names
# now we need to uniform the name across all annotation
tosub = []
count = 1
for test in names:
try:
torename = nx.node_connected_component(annot_gr, test)
annot_gr.remove_nodes_from(torename)
# select only hypo in torename and rename using cmplx + count
tmp = allhypo[allhypo["nm"].isin(torename)]
tmp["ID"] = "cmplx__" + str(count)
tosub.append(tmp)
except KeyError:
# remove inplace faster to catch than test has_node
pass
finally:
count += 1
if tosub:
self.all_hypo = pd.concat(tosub, axis=0)
else:
self.allhypo = pd.DataFrame()
def testFun(filePath):
import networkx as nx
cmd.delete("all")
cmd.fetch("1C3W")
cmd.hide("lines", "all")
cmd.show("cartoon", "1C3W")
cmd.color("green", "all")
#------------------------------ cmd.color("yellow", "resi 194 and resn GLU")
#------------------------------- cmd.show("sticks", "resi 194 and resn GLU")
highlightRes("GLUA0194", color="yellow")
highlightRes("GLUA0204", color="yellow")
g = loadHbTxt(filePath)
allNodes = nx.node_connected_component(g, "GLUA0194")
#===========================================================================
# print allNodes
#===========================================================================
accRes = {}
for line in open("/Users/xzhu/sibyl/BR/1C3W/hydro/def/raw/acc.res"):
fields = line.split()
resString = fields[1] + fields[2]
acc = float(fields[4])
accRes[resString] = acc
colorThreshold = 0.02
for eachResidue in accRes.keys():
if accRes[eachResidue] > colorThreshold:
if eachResidue in allNodes:
print eachResidue
highlightRes(eachResidue)
def find_all_subgraphs(di_graph_object, list_of_nodes_to_exclude=None):
assert isinstance(di_graph_object, nx.DiGraph)
di_graph_object_copy = di_graph_object.copy()
tmp_di_graph_object = remove_list_of_nodes(di_graph_object_copy,
list_of_nodes_to_exclude)
tmp_list_of_bottleneck_nodes = look_for_bottleneck_nodes(
tmp_di_graph_object)
tmp_list_of_subgraph_node_pairs = []
tmp_subgraph_dict = {}
tmp_subgraph_dict['graph'] = nx.DiGraph()
tmp_subgraph_dict[
'condition'] = qmlReader.new_questionnaire_classes.ConditionObject(
condition_string=True)
subgraph_dict = defaultdict(tmp_subgraph_dict)
for i in range(len(tmp_list_of_bottleneck_nodes) - 1):
tmp_list_of_subgraph_node_pairs.append(
(tmp_list_of_bottleneck_nodes[i],
tmp_list_of_bottleneck_nodes[i + 1]))
subgraph_dict.append()
tmp_subgraph_nodes_dict = {}
for node in tmp_list_of_bottleneck_nodes:
di_graph_object_copy = remove_all_edges_connecting_to_node(
di_graph_object_copy, node=node)
for node_pair in tmp_list_of_subgraph_node_pairs:
tmp_di_graph_object_copy = di_graph_object_copy.copy()
# tmp_subgraph_nodes_dict[node_pair] = find_all_nodes_inbetween(di_graph_object=tmp_di_graph_object, source=node_pair[0], target=node_pair[1])
tmp_subgraph_nodes_dict[node_pair] = nx.node_connected_component(
nx.to_undirected(tmp_di_graph_object_copy), node_pair[0])
return tmp_subgraph_nodes_dict
def get_connected_components_jaccard_similarity(documents,
jaccard_threshold=.2,
field_type="text"):
"""
Find the connected components of documents sharing the same n-gram based on a threshold for Jaccard similarity.
"""
document_text = {}
for k, v in documents.items():
try:
document_text[k] = v[field_type]
except:
pass
G = nx.Graph()
similarity = {}
ads = list(document_text)
G.add_nodes_from(ads)
for i in range(0, len(ads) - 1):
a = []
for j in range(i + 1, len(ads)):
similarity[(ads[i], ads[j])] = round(
distance.jaccard(document_text[ads[i]], document_text[ads[j]]),
3)
for k, v in similarity.items():
if v <= jaccard_threshold:
G.add_edge(k[0], k[1])
connected_components = set()
for i in G.nodes():
connected_components.add(str(sorted(nx.node_connected_component(G,
i))))
return connected_components
def far_end(g, n):
if not g.degree(n) == 1:
print("wtf: this should be a leaf")
exit(0)
for m in nx.node_connected_component(g, n):
if (not m == n) and g.degree(m) == 1:
return m
def test_endInversion_option(free_end, internal_node, join_options, ograph,
linked):
if free_end in linked:
x = free_end
free_end = internal_node
internal_node = x
print("end inversion", free_end, linked.get(free_end), internal_node,
linked[internal_node])
k = linked[internal_node]
ograph.remove_edge(internal_node, k)
if free_end in nx.node_connected_component(ograph, internal_node):
x = k
k = internal_node
internal_node = x
sc = link_test(ograph, k, internal_node)
join_options.append((sc, (), ()))
print("end inversion existing:", sc)
sc = link_test(ograph, free_end, internal_node)
join_options.append(
(sc, ((free_end, internal_node), ), ((internal_node, k), )))
print("end inversion:", sc)
ograph.add_edge(internal_node, k, length=default_gapsize, contig=False)
return
def get_connected_components_jaccard_similarity(documents, jaccard_threshold=.2, field_type="text"):
"""
Find the connected components of documents sharing the same n-gram based on a threshold for Jaccard similarity.
"""
document_text = {}
for k,v in documents.items():
try:
document_text[k] = v[field_type]
except:
pass
G = nx.Graph()
similarity = {}
ads = list(document_text)
G.add_nodes_from(ads)
for i in range(0,len(ads)-1):
a = []
for j in range(i+1,len(ads)):
similarity[(ads[i],ads[j])] = round(distance.jaccard(document_text[ads[i]], document_text[ads[j]]),3)
for k, v in similarity.items():
if v <= jaccard_threshold:
G.add_edge(k[0],k[1])
connected_components = set()
for i in G.nodes():
connected_components.add(str(sorted(nx.node_connected_component(G, i))))
return connected_components
def sdg_min_cut(G, u, v):
"""
Computes minimum u, v cut using Ford-Fulkerson Algorithm, from
"Computing the minimum cut and maximum flow of undirected graphs" by
Schroeder, Jonatan and Guedes, ALP and Duarte Jr, Elias P.
:param G: graph
:param u: source vertex
:param v: sink vertex
:return: partition of vertices of G, S1 and S2, as well as the corresponding max flow.
"""
D = G.to_directed()
max_flow = 0
path_queue, flow = breadth_first_search_path(D, u, v)
while flow != -1:
max_flow += flow
predecessor = path_queue.popleft()
while len(path_queue) != 0:
successor = path_queue.popleft()
if D[predecessor][successor]['weight'] == flow:
D.remove_edge(predecessor, successor)
D.remove_edge(successor, predecessor)
else:
D[predecessor][successor]['weight'] -= flow
D[successor][predecessor]['weight'] += flow
predecessor = successor
path_queue, flow = breadth_first_search_path(D, u, v)
S1 = nx.node_connected_component(D.to_undirected(), u)
S2 = {v for v in G.nodes_iter() if v not in S1}
return S1, S2, max_flow
def toggleComponentSuspicious(self, state):
if not self.selectedDomain:
return
graphComponent=nx.node_connected_component(self.suspiciousGraph,
self.selectedDomain)
for domain in graphComponent:
node=self.suspiciousGraph.node[domain]
if state==Qt.Checked:
node['isMalicious']=True
self.componentsTableModel.setComponentMalicious(domain, True)
elif state==Qt.Unchecked:
node['isMalicious']=False
self.componentsTableModel.setComponentMalicious(domain, False)
"""
update table data
"""
if self.toggleHideNotMaliciousDomains.isChecked():
self.toggleHideNonMalicious(Qt.Checked)
else:
self.toggleHideNonMalicious(Qt.Unchecked)
self.updateStatusBar()
def _reduce_graph(self, graph, min0list):
"""determine how much of the graph to include in the disconnectivity graph
"""
used_nodes = []
# make sure we include the subgraph containing min0
if len(min0list) > 0:
for min0 in min0list:
nodes = nx.node_connected_component(graph, min0)
if len(nodes) > 2:
used_nodes += nodes
else:
print("dgraph: too few nodes connected to", min0)
if len(used_nodes) == 0:
# use the biggest connected cluster
cc = sorted(nx.connected_components(graph), key=len, reverse=True)
used_nodes += cc[0] # list is ordered by size of cluster
if self.subgraph_size is not None:
node_lists = nx.connected_components(graph)
for nodes in node_lists:
if len(nodes) >= self.subgraph_size:
used_nodes += nodes
newgraph = graph.subgraph(used_nodes).copy()
return newgraph
def test1(n, p):
"""tests DC and BFS-based connectivity alg on a G(n,p)"""
#seed(69)
G = nx.gnp_random_graph(n, p)
print("G has {} connected components".format(
nx.number_connected_components(G)))
DC = DynamicCon(G)
N = 100
allTrues1 = [False] * N
allTrues2 = [False] * N
for i in range(N):
node1, node2 = getRandomConnectedNodes(G)
allTrues1[i] = areConnected(G, node1, node2)
allTrues2[i] = DC.connected(node1, node2)
print("The BFS-based alg works correctly = " + str(False not in allTrues1))
print("The DC-based alg works correctly = " + str(False not in allTrues2))
allFalses1 = [True] * N
allFalses2 = [True] * N
for i in range(N):
node1, node2 = getRandomNotConnectedNodes(G)
allFalses1[i] = areConnected(G, node1, node2)
allFalses2[i] = DC.connected(node1, node2)
if allFalses2[i]:
print("DC reports that {} and {} are connected!".format(
node1, node2))
print("Node1: {}, node2: {}. CC of node1: {}".format(
node1, node2, nx.node_connected_component(G, node1)))
print("The BFS-based alg works correctly = " + str(True not in allFalses1))
print("The DC-based alg works correctly = " + str(True not in allFalses2))
def recommend(self, i, items):
kk = np.zeros(len(items))
for c in self.G:
H = nx.node_connected_component(self.G[c], i)
d = np.shape(self.S[0])[0]
Sc = np.zeros((d, d))
bc = np.zeros(d)
Tc = 0
for j in H:
Sc += self.S[j]
bc += self.b[j]
Tc += self.T[j]
if invertible(Sc):
Sinv = np.linalg.inv(Sc)
theta_est = np.dot(Sinv, bc)
for l in self.i_clusters[c]:
kk[l] = np.dot(items[l, :],
theta_est) + self.beta * np.dot(
items[l, :], np.dot(Sinv, items[l, :]))
else:
for l in self.i_clusters[c]:
kk[l] = np.random.uniform(0, 1, 1)
return np.argmax(kk)
def create_dataset_from_parquet(pages, links, views):
mapping, edges, ts = sample_random(pages, links, views)
# get subgraph and compute pagerank
g = nx.subgraph(
nx.from_pandas_edgelist(edges,
source="src",
target="dst",
create_using=nx.DiGraph),
ts.id,
)
print(f"sampled graph has {g.number_of_nodes()} nodes")
pr = nx.pagerank(g)
ordered = sorted(pr.keys(), key=pr.get, reverse=True)
# only keep the largest connected component, top pagerank node is most
# likely to be part of the largest fully connected component
g = nx.Graph(g).subgraph(
nx.node_connected_component(nx.Graph(g), ordered[0]))
print(f"largest component has {g.number_of_nodes()} nodes")
# create a list sorted by pagerank
connected = pd.DataFrame({
"id": g.nodes(),
"pagerank": [pr[x] for x in g.nodes()]
}).sort_values("pagerank", ascending=False)
return connected.merge(mapping), edges, connected.merge(ts).drop(
"pagerank", axis=1)
def far_end(g,n):
if not g.degree(n)==1:
print("wtf: this should be a leaf")
exit(0)
for m in nx.node_connected_component(g,n):
if (not m==n) and g.degree(m)==1:
return m
def build_beatles_cluster():
nodes = nx.node_connected_component(G, "303")
print 'beatles nodes', len(nodes)
p = r.pipeline()
for node in nodes:
p.sadd('BEATLES-SET', node)
p.execute()
def test_endInversion_option(free_end,internal_node,join_options,ograph,linked):
if free_end in linked:
x=free_end
free_end = internal_node
internal_node = x
print("end inversion",free_end,linked.get(free_end),internal_node,linked[internal_node])
k=linked[internal_node]
ograph.remove_edge(internal_node,k)
if free_end in nx.node_connected_component(ograph,internal_node):
x=k
k=internal_node
internal_node=x
sc = link_test(ograph,k,internal_node)
join_options.append( (sc,(),()))
print("end inversion existing:",sc)
sc = link_test(ograph,free_end,internal_node)
join_options.append( (sc ,((free_end,internal_node),),((internal_node,k),) ) )
print("end inversion:",sc)
ograph.add_edge(internal_node,k,length=default_gapsize, contig=False)
return
def generic_product_rule(g, op):
sel1 = random.sample(g.nodes(), 2)
if nx.has_path(g, *sel1):
g.add_edge(*sel1)
return sel1
sel2 = random.sample(g.nodes(), 2)
if nx.has_path(g, *sel2):
g.add_edge(*sel2)
return sel2
elif op( len(nx.node_connected_component(g, sel2[0])) * len(nx.node_connected_component(g, sel2[1])), \
len(nx.node_connected_component(g, sel1[0])) * len(nx.node_connected_component(g, sel1[1])) ):
g.add_edge(*sel2)
return sel2
else:
g.add_edge(*sel1)
return sel1
def connected_paths(self, path_id, include_self=False):
"""
Given an index of self.paths find other paths which
overlap with that path.
Parameters
-----------
path_id : int
Index of self.paths
include_self : bool
Should the result include path_id or not
Returns
-----------
path_ids : (n, ) int
Indexes of self.paths that overlap input path_id
"""
if len(self.root) == 1:
path_ids = np.arange(len(self.polygons_closed))
else:
path_ids = list(
nx.node_connected_component(self.enclosure, path_id))
if include_self:
return np.array(path_ids)
return np.setdiff1d(path_ids, [path_id])
def min_ab_sep(G, C_i, C_j):
#copy G for edge deletion
G_copy = G.copy()
#find neigbors of C_i
A_C_i = []
for node in C_i:
u = [n for n in G.neighbors(node) if n not in C_i]
A_C_i = A_C_i + u
#remove edges from Ci to ACi and between ACi
for i in C_i:
for l in A_C_i:
if G_copy.has_edge(i, l):
G_copy.remove_edge(i, l)
elif G_copy.has_edge(l, i):
G_copy.remove_edge(l, i)
for i in A_C_i:
for l in A_C_i:
if G_copy.has_edge(i, l):
G_copy.remove_edge(i, l)
#select node from Cj and find all connected nodes
j = C_j[0]
R_j = nx.node_connected_component(G_copy, j)
#determine minimal a,b-separator
intersection = list(set(A_C_i) & set(R_j))
return intersection
def __init__(self, points, sensing_radius, boundary):
alpha_complex = AlphaComplex(points)
simplex_tree = alpha_complex.create_simplex_tree(
max_alpha_square=sensing_radius**2)
self._simplices = [[], [], []]
self._simplices[0] = [
simplex[0] for simplex, _ in simplex_tree.get_skeleton(0)
]
self._simplices[1] = [
tuple(simplex) for simplex, _ in simplex_tree.get_skeleton(1)
if len(simplex) == 2
]
self._simplices[2] = [
tuple(simplex) for simplex, _ in simplex_tree.get_skeleton(2)
if len(simplex) == 3
]
graph = nx.Graph()
graph.add_nodes_from(self._simplices[0])
graph.add_edges_from(self._simplices[1])
self._boundary_cycles = CMap(graph, points).get_boundary_cycles()
self._boundary_cycles.remove(boundary.alpha_cycle)
self._connected_nodes = nx.node_connected_component(graph, 0)
def lay_down_nodes(self):
"""
Given a directed graph, finds the connected component which includes
the root node and then determines positions in the circular view.
:return: Positions of the nodes from the perspective of the root node
!!! returned dict does not contain positions of unconnected nodes!
"""
# Find undirected graph (needed for connected component discovery)
gr_undirected = self.graph.to_undirected()
# Remove disconnected nodes from the graph
component_nodes = nx.node_connected_component(gr_undirected, self.root_node)
for node in list(gr_undirected.nodes()):
if node not in component_nodes:
gr_undirected.remove_node(node)
# Find bfs tree of the connected components
bfs_tree = nx.bfs_tree(gr_undirected, self.root_node)
self.bfs_tree[self.root_node] = bfs_tree
# Position the nodes in a circular fashion according to the bfs tree
pos = gpos.hierarchy_pos(bfs_tree, self.root_node,
width=2 * math.pi, xcenter=0.5)
new_pos = {u: (r * math.cos(theta), r * math.sin(theta))
for u, (theta, r) in pos.items()}
# Set positions to the networkx object
nx.set_node_attributes(self.graph, name='pos', values=new_pos)
# Also, return the positions
return new_pos
def determine_2Dness(
self, delta): #obtain dimension and direction for the delta value
G = self.define_bonds(delta)
ranks = []
directions = []
for loc in np.arange(0, len(self.structure),
8): #all atoms in a unit cell
if self.check_3Dmetal(self.structure.species_and_occu[loc]
): #check if it is a magnetic metal
rank_nodes = np.array([], dtype=np.int16)
accepted_nodes = np.arange(8) + loc
try:
for node in nx.node_connected_component(G, loc):
if (node in accepted_nodes):
rank_nodes = np.append(rank_nodes, node)
except KeyError:
rank_nodes = [0]
rank_matrix = np.array([np.round(self.frac_coords[node],decimals=3) \
for node in rank_nodes])
rank_matrix = rank_matrix - rank_matrix[0]
rank = np.linalg.matrix_rank(rank_matrix)
ranks.append(rank)
#find direction
direction = "0"
if rank == 1:
direction = str(rank_matrix[1])
elif rank == 2:
direction = str(
np.cross(rank_matrix[1], rank_matrix[-1]) * 4)
directions.append(direction)
return [np.amax(ranks), directions[np.argmax(ranks)]]
def reduce_rates(rates, B, A=None):
B = set(B)
if A is not None:
A = set(A)
if A.intersection(B):
raise Exception("A and B share", len(A.intersection(B)), "nodes")
graph = nx.Graph()
graph.add_edges_from(rates.iterkeys())
# remove nodes not connected to B
# TODO: this only works if B is fully connected
connected_nodes = nx.node_connected_component(graph, iter(B).next())
connected_nodes = set(connected_nodes)
all_nodes = set(graph.nodes())
if len(connected_nodes) != len(all_nodes):
print "removing", len(all_nodes) - len(connected_nodes), "nodes that are not connected to B"
rates = dict((uv, rate) for uv, rate in rates.iteritems() if uv[0] in connected_nodes)
if B - connected_nodes:
raise Exception("the nodes in B are not all connected")
if A is not None:
if A - connected_nodes:
raise Exception("the A nodes are not all connected to the B nodes")
return rates
def reduce_rates(rates, B, A=None):
B = set(B)
if A is not None:
A = set(A)
if A.intersection(B):
raise Exception("A and B share", len(A.intersection(B)), "nodes")
graph = nx.Graph()
graph.add_edges_from(rates.iterkeys())
# remove nodes not connected to B
# TODO: this only works if B is fully connected
connected_nodes = nx.node_connected_component(graph, iter(B).next())
connected_nodes = set(connected_nodes)
all_nodes = set(graph.nodes())
if len(connected_nodes) != len(all_nodes):
print "removing", len(all_nodes) - len(
connected_nodes), "nodes that are not connected to B"
rates = dict((uv, rate) for uv, rate in rates.iteritems()
if uv[0] in connected_nodes)
if B - connected_nodes:
raise Exception("the nodes in B are not all connected")
if A is not None:
if A - connected_nodes:
raise Exception(
"the A nodes are not all connected to the B nodes")
return rates
def from_hfp_to_connectedcomps(self, index):
"""
Computes connected components upto a death of a 0-cycle.
Parameters:
-----------
hfp : Homology peristenece class from dionysus2
filtration : filtration from dionysus2
num_vertices : number of 0-dimensional simplices in the data (typically number of data points)
index : filtration index of death of 0-cycle
Returns:
--------
List of connected components as a set
"""
total_iters = np.arange(self.num_vertices, index + 1)
adj = np.eye(self.num_vertices)
for i, doi in enumerate(total_iters):
current_vertices = list(self.filtration[doi])
if doi == index:
repvertex = current_vertices[1]
adj[current_vertices[0], current_vertices[1]] = 1
adj = np.maximum(adj, adj.T)
graph = csr_matrix(adj)
n_components, labels = connected_components(csgraph=graph,
directed=False,
return_labels=True)
G = nx.from_scipy_sparse_matrix(graph)
concomps = nx.node_connected_component(G, repvertex)
# print('Vertex %d is connected to'%(repvertex),concomps)
return concomps
def _reduce_graph(self, graph, min0list):
"""determine how much of the graph to include in the disconnectivity graph
"""
used_nodes = []
# make sure we include the subgraph containing min0
if len(min0list) > 0:
for min0 in min0list:
nodes = nx.node_connected_component(graph, min0)
if len(nodes) > 2:
used_nodes += nodes
else:
print("dgraph: too few nodes connected to", min0)
if len(used_nodes) == 0:
# use the biggest connected cluster
cc = sorted(nx.connected_components(graph), key=len, reverse=True)
used_nodes += cc[0] # list is ordered by size of cluster
if self.subgraph_size is not None:
node_lists = nx.connected_components(graph)
for nodes in node_lists:
if len(nodes) >= self.subgraph_size:
used_nodes += nodes
newgraph = graph.subgraph(used_nodes).copy()
return newgraph
def __init__(self, num_users, d, num_rounds, L, random_init=True):
super(COFIBA, self).__init__(num_users, d, num_rounds)
self.L = L
if random_init:
self.G = {
0: nx.gnp_random_graph(num_users, edge_probability(num_users))
}
self.GI = nx.gnp_random_graph(L, edge_probability(num_users))
c = 0
self.i_ind = np.zeros(L)
self.i_clusters = {}
C = set(range(L))
while len(C) != 0:
l = next(iter(C))
C0 = set(nx.node_connected_component(self.GI, l))
self.i_clusters[c] = list(C0)
for l1 in C0:
self.i_ind[l1] = c
c += 1
C = C - C0
else:
self.G = {0: nx.complete_graph(num_users)}
self.i_ind = np.zeros(L)
self.i_clusters = {0: [i for i in range(L)]}
self.GI = nx.complete_graph(L)
self.alpha = 4 * np.sqrt(d)
self.num_clusters = np.ones(num_rounds)
def find_attractor(decStateTransMap):
'''
Arguments:
-- 1. decStateTransMap
Return:
-- attractor
'''
attractor_list = nx.simple_cycles(decStateTransMap) #in case of deterministic system, any cycle without considering edge direction will be directed cycle.
attractors = {}
#attractors['fixed'] = []
#attractors['cycle'] = []
undirectedMap = nx.DiGraph.to_undirected(decStateTransMap)
for u in attractor_list:
attractors[u[0]] = {}
if len(u) == 1:
attractors[u[0]]['type'] = 'fixed'
else:
attractors[u[0]]['type'] = 'cycle'
for v in attractors.iterkeys():
basin = nx.node_connected_component(undirectedMap, v)
attractors[v]['basin'] = basin
attractors[v]['basin-size'] = len(basin)
sorted_attractors = OrderedDict(sorted(attractors.items(), key=lambda kv: kv[1]['basin-size'], reverse=True))
return sorted_attractors
def connected_paths(self, path_id, include_self = False):
if len(self.root) == 1:
path_ids = np.arange(len(self.polygons_closed))
else:
path_ids = list(nx.node_connected_component(self.enclosure, path_id))
if include_self:
return np.array(path_ids)
return np.setdiff1d(path_ids, [path_id])
def wordrank(node):
response = my_localRtr.get_Rel_one(node,"Fw", len(nx.node_connected_component(my_localRtr.G, node)) )
nodesandpaths=[]
for n,p in response.iteritems():
path=p[1]
nodesandpaths.append([n,path])
response=json.dumps(nodesandpaths)
return make_response(response)
def connected_open(graph):
broken = set()
for node, degree in graph.degree().items():
if degree == 2: continue
if node in broken: continue
[broken.add(i) for i in nx.node_connected_component(g, node)]
okay = set(graph.nodes()).difference(broken)
return broken, okay
def test_interc_option( gap_edge1, gap_edge2, free_end1, join_options, ograph ):
if not ograph.has_edge(gap_edge1,gap_edge2):
print("expected nodes to be connected: {} {}".format(gap_edge1, gap_edge2))
raise Exception('not connected')
ograph.remove_edge( gap_edge1, gap_edge2 )
if gap_edge1 in nx.node_connected_component(ograph,gap_edge2):
print("problem: these should be disconnected now:",gap_edge1,gap_edge2)
raise Exception('too connected i')
if gap_edge2 in nx.node_connected_component(ograph,free_end1):
print("problem: these should have been disconnected all along",free_end1,gap_edge2)
raise Exception('too connected j')
if gap_edge1 in nx.node_connected_component(ograph,free_end1):
print("problem: these should have been disconnected all along",free_end1,gap_edge1)
raise Exception('too connected k')
interc_score = intercalation_score(gap_edge1,free_end1,gap_edge2,ograph)
ograph.add_edge(gap_edge1, gap_edge2, length=default_gapsize,contig=False)
d = far_end(ograph,free_end1)
join_options.append( (interc_score,((gap_edge1,free_end1),(d,gap_edge2)),((gap_edge1, gap_edge2),) ) )
def get_Rel_one(self,ipt,tp,N,cut=6.0):
if N>= len( nx.node_connected_component(self.G, ipt) ):
N=len( nx.node_connected_component(self.G, ipt) )
T2L,T2P=nx.single_source_dijkstra(self.G,ipt,cutoff=cut,weight=tp)
count=len(T2L.keys())
while count<N:
cut=cut+1.0
T2L,T2P=nx.single_source_dijkstra(self.G,ipt,cutoff=cut,weight=tp)
count=len(T2L.keys())
sorted_T=sorted(T2L.keys(),key=T2L.get)[:N]
Rel=[]
for t in sorted_T:
Rel.append((t,[T2L[t],T2P[t]]))
Rel=collections.OrderedDict(Rel)
return Rel
def edges_for_group(edges, group_id):
import pandas as pd
import networkx as nx
g = nx.Graph()
g.add_edges_from(edges)
group_nodes = nx.node_connected_component(g, group_id) # (Used in query below)
edge_df = pd.DataFrame(edges, columns=['u', 'v'])
group_edges = edge_df.query('u in @group_nodes or v in @group_nodes')
return group_edges.values
def connected_edges(G, nodes):
'''
Given graph G and list of nodes, return the list of edges that
are connected to nodes
'''
nodes_in_G = deque()
for node in nodes:
if not G.has_node(node): continue
nodes_in_G.extend(nx.node_connected_component(G, node))
edges = G.subgraph(nodes_in_G).edges()
return edges
def main_algorithm(G,exploration_strategy):
K = set()
p = position(entiers=True)
while len(K) < len(nx.node_connected_component(G,p)):
p = position(entiers=True)
if p not in K:
if effaceLesAretesBloquees(G,K):
draw_graph(G)
K.add( p )
exploration_strategy(G,K)
def test_clustering(G, n, s, t, delim):
"""
Given a node, find the connected component n is in.
"""
sub_g = G.subgraph(nx.node_connected_component(G,n ))
print ("Nodes:")
pprint(sub_g.nodes())
print("\nEdges")
pprint(sub_g.edges())
print("\nCluster")
pprint(get_merged_cluster(tumor_g, s, t, delim))
def link_test(og,a,b,gapsize=default_gapsize,max_stretch=200000):
coords = {}
facing={}
traverse_and_layout(a,coords,facing,0,-1,og,maxD=200000)
traverse_and_layout(b,coords,facing,gapsize,+1,og,maxD=200000)
# print "#x:setup done"
sys.stdout.flush()
score=0.0
for n1 in nx.node_connected_component(og,a):
if abs(coords.get(n1,-1e10))>max_stretch: continue
for n2 in nx.node_connected_component(og,b):
if abs(coords.get(n2,1e10))>max_stretch: continue
if strand_check(n1,n2,coords,facing):
distance = coords[n2] - coords[n1]
if distance < max_stretch:
x=get_score(n1,n2,distance)
# print "#x:partial",n1,n2,x
sys.stdout.flush()
score += x
return score
def intercalation_score_raw(a,b,c,og):
# print "#intercalation test:",a,b,c
if a in nx.node_connected_component(og,b): print("a should not be connected to b",a,b)
if b in nx.node_connected_component(og,c): print("b should not be connected to c",b,c)
if a in nx.node_connected_component(og,c): print("a should not be connected to c",a,c)
# coordinates1={}
coordinates2={}
facing={}
traverse_and_layout(a,coordinates2,facing,0,-1,og)
# coordinates2=dict(coordinates1)
# traverse_and_layout(c,coordinates1,facing,1000,+1,og)
traverse_and_layout(b,coordinates2,facing,default_gapsize,+1,og)
traverse_and_layout(c,coordinates2,facing,default_gapsize+max(coordinates2.values()),+1,og)
# score_0=0.0
# for n1 in nx.node_connected_component(og,a):
# for n2 in nx.node_connected_component(og,c):
# if strand_check(n1,n2,coordinates1,facing):
# distance = coordinates1[n2] - coordinates1[n1]
# if distance < 200000:
# if distance<0: print "wtf1?"
# score_0 += get_score(n1,n2,distance)
score_1=0.0
for n1 in nx.node_connected_component(og,a):
for n2 in nx.node_connected_component(og,c):
if strand_check(n1,n2,coordinates2,facing):
distance = coordinates2[n2] - coordinates2[n1]
if distance < 200000:
if distance<0: print("wtf2?")
score_1 += get_score(n1,n2,distance)
for n2 in nx.node_connected_component(og,b):
if strand_check(n1,n2,coordinates2,facing):
distance = coordinates2[n2] - coordinates2[n1]
if distance < 200000:
if distance<0: print("wtf3?")
score_1 += get_score(n1,n2,distance)
for n1 in nx.node_connected_component(og,b):
for n2 in nx.node_connected_component(og,c):
if strand_check(n1,n2,coordinates2,facing):
distance = coordinates2[n2] - coordinates2[n1]
if distance < 200000:
if distance<0: print("wtf4?")
score_1 += get_score(n1,n2,distance)
# print "#intercalation scores:",score_1,score_0
return (score_1)
def nodeInConnectedComponent(self, node): """ Place a node in a connected component of the graph. Arguments: node - the node whose connected component is desired. Returns: A connected subgraph of the original graph which contains the node. """ gr = self.g neighhboringNodes = nx.node_connected_component(gr, node) subgraph = nx.subgraph(gr, neighhboringNodes) return subgraph
