def graph_generation():
graph = nx.MultiDiGraph()
data = load_data()
# 导入对象属性边
for i in data['object_attribute']:
label, successor, predecessors = i
graph.add_edge(successor,
predecessors,
label,
label=label,
type='object')
# 导入值属性边
for i in data['valued_attribute']:
label, successor, value_type = i
predecessors = '%s:%s' % (value_type, label)
graph.add_edge(successor,
predecessors,
label,
label=label,
type='value')
# 为节点导入属性
for n in graph.nodes:
if ':' in n:
graph.node[n]['label'] = 'literal'
else:
graph.node[n]['label'] = 'concept'
nx.freeze(graph)
return graph
def graph_generation(ontology_dir):
temp_graph = nx.MultiDiGraph()
data = load_data(ontology_dir)
# 导入对象属性边
for i in data['object_attribute']:
relation_name, label, successor, predecessors = i
temp_graph.add_edge(successor,
predecessors,
label,
label=label,
type='object',
relation_name=relation_name)
# 导入值属性边
for i in data['valued_attribute']:
label, successor, value_type = i
predecessors = '%s:%s' % (value_type, label)
temp_graph.add_edge(successor,
predecessors,
label,
label=label,
type='value')
# 为节点导入属性
for n in temp_graph.nodes:
if ':' in n:
temp_graph.node[n]['label'] = 'literal'
else:
temp_graph.node[n]['label'] = 'concept'
# 使graph不能再被修改
nx.freeze(temp_graph)
# self.graph = temp_graph
return temp_graph
def __init__(
self,
nodes: List[AssemblyNode],
container: AlignmentContainer,
full_assembly_graph: nx.DiGraph,
query_key: str,
query: SeqRecord,
seqdb,
do_raise: bool = True,
):
self.logger = logger(self)
self._nodes = tuple(nodes)
self._reactions = tuple()
self.validate_input_nodes()
self.seqdb = seqdb
self.query_key = query_key
self.query = query
self._full_graph = full_assembly_graph
self.container = container
self.groups = container.groups()
if len(self.groups) == 0:
raise DasiDesignException("No groups were found in container.")
self.graph = self._subgraph(self._full_graph, nodes, do_raise=do_raise)
nx.freeze(self.graph)
if do_raise:
self.post_validate(do_raise)
def freeze(graphs):
'''freeze graphs
:param graphs: List<Graph>
:return: void
'''
for graph in graphs:
nx.freeze(graph)
def createGraphFromTXT(txtFile):
f = open(txtFile) #Open file with read only permits
line = f.readline() #read first line
G = nx.Graph() #Create Graph object G from JSON data, G is symmetrical
# If the file is not empty keep reading line one at a time
# till the file is empty
while line != '\n' and line != '':
link = line.strip('\n').split(' ') #Turn to usable link format
if len(link) == 3:
weight = float(link[0])
source = int(link[1])
target = int(link[2])
dist = 1 - weight
#print('Weight: %.12f, From: %d, To: %d' % (weight,source,target))
#TODO: INDEX TO TRACK ID?????
if weight > 0 and dist > 0:
G.add_edge(source, target, similarity=weight, distance=dist)
else:
print(link)
line = f.readline()
f.close() #Clean up
nx.freeze(G) #Turn Immutable
return G
def MakeAdjacencyGraph(n, type, freq=0.5, wexc=0.1):
'''Temporary implementation that only generates complete graph.'''
G = nx.complete_graph(n, nx.DiGraph())
# Should profile this.
for edge in G.edges_iter():
nx.set_edge_attributes(G, 'weight', {edge: wexc})
nx.freeze(G) # To prevent unintended modification of G's structure
return G
def setUp(self):
self.G_basic = tg.node_generate(
[[10, 11], [20], [30, 31], [40, 41], [50]],
itertools.count(step=100))
self.G_basic.add_path([10, 20, 30, 40, 50])
self.G_basic.add_path([11, 20, 31])
self.G_basic.add_path([30, 41, 50])
nx.freeze(self.G_basic)
def asia_graph():
"""Return the 'Asia' PGM graph."""
G = nx.DiGraph(name="asia")
G.add_edges_from([('asia', 'tuberculosis'), ('smoking', 'cancer'),
('smoking', 'bronchitis'), ('tuberculosis', 'either'),
('cancer', 'either'), ('either', 'xray'),
('either', 'dyspnea'), ('bronchitis', 'dyspnea')])
nx.freeze(G)
return G
def complete(self):
nx.freeze(self.DAG)
self.__order = self.DAG.order()
self.__roots = self.DAG.roots()
self.__rv_roots = find_rv_roots(self)
self.__leaves = self.DAG.leaves()
self.__exo = find_exo(self)
self.json = form_js(self)
self.script = form_script(self)
def get_nodal_graph(geometry):
# Mathematical graph of all nodal lines connected by finite strips
nodal_graph = nx.DiGraph()
# Add nodal lines
for node_id, (x, z) in geometry['nodal_lines'].items():
nodal_graph.add_node(node_id, x=x, z=z)
# Add finite strips
for strip_id, (node1_id, node2_id, material_id) in enumerate(geometry['finite_strips'], start=1):
dx = nodal_graph.node[node2_id]['x'] - nodal_graph.node[node1_id]['x']
dz = nodal_graph.node[node2_id]['z'] - nodal_graph.node[node1_id]['z']
b = np.sqrt(dx**2 + dz**2) # [mm] strip width
R = get_transformation_matrix(dx, dz, b) # global<->local coordinates transformation matrix
# Deduced from Fortran block 83:94
astiff_blocks = (node1_id-1, node2_id-1) # Python counts from 0
astiff_fill_indices = []
for row in xrange(2):
for col in xrange(2):
astiff_row_start = ASTIFF_BLOCK_SIZE * astiff_blocks[row]
astiff_row_end = ASTIFF_BLOCK_SIZE + astiff_row_start
astiff_col_start = ASTIFF_BLOCK_SIZE * astiff_blocks[col]
astiff_col_end = ASTIFF_BLOCK_SIZE + astiff_col_start
astiff_indices = (
slice(astiff_row_start, astiff_row_end),
slice(astiff_col_start, astiff_col_end)
)
segment_row_start = ASTIFF_BLOCK_SIZE * row
segment_row_end = ASTIFF_BLOCK_SIZE + segment_row_start
segment_col_start = ASTIFF_BLOCK_SIZE * col
segment_col_end = ASTIFF_BLOCK_SIZE + segment_col_start
segment_indices = (
slice(segment_row_start, segment_row_end),
slice(segment_col_start, segment_col_end)
)
astiff_fill_indices.append((astiff_indices, segment_indices))
label = "(%d)" % strip_id
edge_data_keys = 'material_id, b, R, astiff_fill_indices, label'.split(', ')
nodal_graph.add_edge(node1_id, node2_id, dict(zip(
edge_data_keys,
(material_id, b, R, astiff_fill_indices, label)
)))
# Disallow further changes to the nodal_graph
nx.freeze(nodal_graph)
# Cache the traversal through strips for performance
strip_data = nodal_graph.edges(data=True)
return nodal_graph, strip_data
def _generate_graph(self):
'''
Generate both the unpacked and the packed graph and
set default attributes to the nodes in the packed graph
'''
edges = self._generate_edges()
self._unpacked_graph = nx.DiGraph()
self._unpacked_graph.add_edges_from(edges)
nx.freeze(self._unpacked_graph)
self.graph = nx.DiGraph(self._unpacked_graph)
self._pack_graph()
self._set_nodes_attributes()
def setUp(self):
graph_a = nx.Graph(id=1)
graph_a.add_node(1, label=0)
graph_a.add_node(2, label=0)
graph_a.add_edge(1, 2, label=0)
self.tiny_graph = nx.freeze(graph_a)
graph_b = nx.Graph(graph_a)
graph_b.add_node(3, label=3)
graph_b.add_edge(1, 3, label=13)
graph_b.add_edge(2, 3, label=23)
self.small_graph = nx.freeze(graph_b)
def make_site_map(self) -> None:
"""Sycncronous function to make the site map using async run_crawler().
Returns
-------
None
"""
asyncio.run(self._run_crawler())
self.site_graph.remove_node(0)
networkx.freeze(self.site_graph)
self.logger.info("Site map building done!")
def build_meetups_graph(groups, topics, members, events):
graph = nx.Graph()
for group in groups:
key = group['id']
graph.add_node(key, name=group['name'], type=Type.Groups, members=group['members'])
link_members(graph, group,members)
link_topics(graph, group, topics)
link_members_to_topics(graph, members, topics)
link_members_to_events(graph, members, events)
nx.freeze(graph)
logging.info('graph built')
return graph
def setup_class(cls):
G = nx.Graph(name="test")
e = [('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e'), ('e', 'f'), ('a', 'f')]
G.add_edges_from(e, width=10)
G.add_node('g', color='green')
G.graph['number'] = 1
DG = nx.DiGraph(G)
MG = nx.MultiGraph(G)
MG.add_edge('a', 'a')
MDG = nx.MultiDiGraph(G)
MDG.add_edge('a', 'a')
fG = G.copy()
fDG = DG.copy()
fMG = MG.copy()
fMDG = MDG.copy()
nx.freeze(fG)
nx.freeze(fDG)
nx.freeze(fMG)
nx.freeze(fMDG)
cls.G = G
cls.DG = DG
cls.MG = MG
cls.MDG = MDG
cls.fG = fG
cls.fDG = fDG
cls.fMG = fMG
cls.fMDG = fMDG
def setup_class(cls):
G = nx.Graph(name="test")
e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
G.add_edges_from(e, width=10)
G.add_node("g", color="green")
G.graph["number"] = 1
DG = nx.DiGraph(G)
MG = nx.MultiGraph(G)
MG.add_edge("a", "a")
MDG = nx.MultiDiGraph(G)
MDG.add_edge("a", "a")
fG = G.copy()
fDG = DG.copy()
fMG = MG.copy()
fMDG = MDG.copy()
nx.freeze(fG)
nx.freeze(fDG)
nx.freeze(fMG)
nx.freeze(fMDG)
cls.G = G
cls.DG = DG
cls.MG = MG
cls.MDG = MDG
cls.fG = fG
cls.fDG = fDG
cls.fMG = fMG
cls.fMDG = fMDG
def setUp(self):
G=nx.Graph(name="test")
e=[('a','b'),('b','c'),('c','d'),('d','e'),('e','f'),('a','f')]
G.add_edges_from(e,width=10)
G.add_node('g',color='green')
G.graph['number']=1
DG=nx.DiGraph(G)
MG=nx.MultiGraph(G)
MG.add_edge('a', 'a')
MDG=nx.MultiDiGraph(G)
MDG.add_edge('a', 'a')
fG = G.copy()
fDG = DG.copy()
fMG = MG.copy()
fMDG = MDG.copy()
nx.freeze(fG)
nx.freeze(fDG)
nx.freeze(fMG)
nx.freeze(fMDG)
self.G=G
self.DG=DG
self.MG=MG
self.MDG=MDG
self.fG=fG
self.fDG=fDG
self.fMG=fMG
self.fMDG=fMDG
def asia_graph():
"""Return the 'Asia' PGM graph."""
G = nx.DiGraph(name="asia")
G.add_edges_from([
("asia", "tuberculosis"),
("smoking", "cancer"),
("smoking", "bronchitis"),
("tuberculosis", "either"),
("cancer", "either"),
("either", "xray"),
("either", "dyspnea"),
("bronchitis", "dyspnea"),
])
nx.freeze(G)
return G
def generic_graph_view(G, create_using=None):
if create_using is None:
newG = G.__class__()
else:
newG = nx.empty_graph(0, create_using)
if G.is_multigraph() != newG.is_multigraph():
raise NetworkXError("Multigraph for G must agree with create_using")
newG = nx.freeze(newG)
# create view by assigning attributes from G
newG._graph = G
newG.graph = G.graph
newG._node = G._node
if newG.is_directed():
if G.is_directed():
newG._succ = G._succ
newG._pred = G._pred
newG._adj = G._succ
else:
newG._succ = G._adj
newG._pred = G._adj
newG._adj = G._adj
elif G.is_directed():
if G.is_multigraph():
newG._adj = UnionMultiAdjacency(G._succ, G._pred)
else:
newG._adj = UnionAdjacency(G._succ, G._pred)
else:
newG._adj = G._adj
return newG
def flatten(item, freeze=True):
"""Flattens a item (a task or flow) into a single execution graph."""
graph = _post_flatten(_flatten(item, set()))
if freeze:
# Frozen graph can't be modified...
return nx.freeze(graph)
return graph
def _swap(self, replacement_graph):
"""Validates the replacement graph and then swaps the underlying graph
with a frozen version of the replacement graph (this maintains the
invariant that the underlying graph is immutable).
"""
self._validate(replacement_graph)
self._graph = nx.freeze(replacement_graph)
def create_clusters(positions, *, feature_size, coordinate_system):
"""
Create clusters from the given positions, by joining all positions which are
less than twice the ``feature_size`` apart.
Arguments
---------
positions : list(list(float))
The list of positions to cluster.
feature_size : float
Distance between two nodes where they are considered to belong to different clusters.
coordinate_system : CoordinateSystem
Coordinate system used to calculate distances between positions.
Returns
-------
list(nx.Graph) :
A list of connected graphs, each representing one cluster.
"""
graph = _create_graph(positions,
feature_size=feature_size,
coordinate_system=coordinate_system)
return [
nx.freeze(subgraph)
for subgraph in nx.algorithms.connected_component_subgraphs(graph)
]
def subgraph_view(G, filter_node=no_filter, filter_edge=no_filter):
newG = nx.freeze(G.__class__())
newG._NODE_OK = filter_node
newG._EDGE_OK = filter_edge
# create view by assigning attributes from G
newG._graph = G
newG.graph = G.graph
newG._node = FilterAtlas(G._node, filter_node)
if G.is_multigraph():
Adj = FilterMultiAdjacency
def reverse_edge(u, v, k):
return filter_edge(v, u, k)
else:
Adj = FilterAdjacency
def reverse_edge(u, v):
return filter_edge(v, u)
if G.is_directed():
newG._succ = Adj(G._succ, filter_node, filter_edge)
newG._pred = Adj(G._pred, filter_node, reverse_edge)
newG._adj = newG._succ
else:
newG._adj = Adj(G._adj, filter_node, filter_edge)
return newG
def from_mininet(cls, mininet_topo):
"""Create a VirtualNetwork from a mininet Topo."""
from mininet.topo import Topo
assert isinstance(mininet_topo, Topo), "Invalid Network Format"
g = nx.Graph()
for u in mininet_topo.nodes():
cpu = mininet_topo.nodeInfo(u).get("cpu", 0)
memory = mininet_topo.nodeInfo(u).get("memory", 0)
if type(memory) == str:
if memory.endswith("MB"):
memory = int(float(memory[:-2]))
elif memory.endswith("GB"):
memory = int(float(memory[:-2]) * 1000)
g.add_node(
u,
cores=cpu,
memory=memory,
)
for (u, v) in mininet_topo.iterLinks(withInfo=False):
g.add_edge(u, v, rate=mininet_topo.linkInfo(u, v).get("bw", 0))
return cls(nx.freeze(g))
def main():
seed(0) #set seed
#get graph info
G = nx.read_gpickle("input/graphMTC_CentroidsLength5.gpickle") #noCentroidsLength15.gpickle") #does not have centroidal links
print '|V| = ', len(G.nodes())
print '|E| = ', len(G.edges())
G = nx.freeze(G) #prevents edges or nodes to be added or deleted
#get od info. This is in format of a dict keyed by od, like demand[sd1][sd2] = 200000.
demand = bd.build_demand('input/BATS2000_34SuperD_TripTableData.csv', 'input/superdistricts_centroids.csv') #bd.build_demand('input/BATS2000_34SuperD_TripTableData.csv', 'input/superdistricts_centroids.csv')
#get earthquake info
q = QuakeMaps('input/20130210_mtc_total_lnsas3.pkl', 'input/20130210_mtc_magnitudes3.pkl', 'input/20130210_mtc_faults3.pkl', 'input/20130210_mtc_weights3.pkl', 'input/20130210_mtc_scenarios3.pkl') #(input/20130107_mtc_total_lnsas1.pkl', 'input/20130107_mtc_magnitudes1.pkl', 'input/20130107_mtc_faults1.pkl', 'input/20130107_mtc_weights1.pkl', 'input/20130107_mtc_scenarios1.pkl') #totalfilename=None, magfilename=None, faultfilename=None, weightsfilename=None, scenariofilename=None): 'input/20130210_mtc_total_lnsas3.pkl', 'input/20130210_mtc_magnitudes3.pkl', 'input/20130210_mtc_faults3.pkl', 'input/20130210_mtc_weights3.pkl', 'input/20130210_mtc_scenarios3.pkl') #(
q.num_sites = len(q.lnsas[0])
#determine which scenarios you want to run
good_indices = pick_scenarios(q.lnsas, q.weights)
travel_index_times = []
index = 0
#loop over scenarios
for scenario in q.lnsas: #each 'scenario' has 1557 values of lnsa, i.e. one per site
if index in good_indices:
print 'index: ', index
(travel_time, vmt) = run_iteration(G, scenario, demand)
travel_index_times.append((index, travel_time, vmt))
# print 'new travel times: ', travel_index_times
if index%100 ==0:
util.write_2dlist(time.strftime("%Y%m%d")+'_travel_time.txt',travel_index_times)
index += 1 #IMPORTANT
util.write_2dlist(time.strftime("%Y%m%d")+'_travel_time.txt',travel_index_times)
def flatten(item, freeze=True):
"""Flattens a item (a task or flow) into a single execution graph."""
graph = _post_flatten(_flatten(item, set()))
if freeze:
# Frozen graph can't be modified...
return nx.freeze(graph)
return graph
def from_file(cls, filename):
"""Create a VirtualNetwork from json files."""
g = nx.MultiGraph()
# filename can be the path to a file or the name of a local topology
if os.path.isabs(filename):
filepath = filename
else:
raise ValueError("Wrong file path")
with open(filepath) as f:
data = json.load(f)
for node in data["nodes"]:
g.add_node(
node,
cores=data["nodes"][node].get("cores", 0),
memory=data["nodes"][node].get("memory", 0),
)
for link in data["links"]:
u, v = link.split(" ")
rate = data["links"][link]["rate"]
g.add_edge(u, v, rate=rate)
return cls(nx.freeze(g))
def __init__(self, graph:str or networkx.Graph):
if isinstance(graph, networkx.Graph):
nxgraph = networkx.Graph(graph)
elif isinstance(graph, str):
nxgraph = phasme.build_graph.graph_from_file(graph)
else:
raise ValueError("Unexpected {}".format(graph))
# internal graph representation
self.__edges = map(frozenset, nxgraph.edges)
if const.TEST_INTEGRITY:
self.__edges = tuple(self.__edges)
for args in self.__edges:
if len(args) > 2:
print('WARNING: Weird edge: {}. It will be filtered.'.format(args))
else:
assert len(args) == 2, args
self.__edges = set(edge for edge in self.__edges if len(edge) == 2)
# data
self.__nodes = set(nxgraph.nodes)
self.__uid = str(min(self.__nodes, key=str))
self.__nb_node = len(self.__nodes)
self.__nb_cc = networkx.number_connected_components(nxgraph)
self._nxgraph = nxgraph if constants.KEEP_NX_GRAPH else networkx.freeze(nxgraph)
self.__initial_number_of_edge = len(self.__edges)
self.__active_recipe = None
self.__hierarchy = set() # inclusions between powernodes
self.__powernodes = defaultdict(set) # (step, set) -> {node in powernode}
self.__poweredges = defaultdict(set) # (step, set) -> (step, set)
def _swap(self, replacement_graph):
"""Validates the replacement graph and then swaps the underlying graph
with a frozen version of the replacement graph (this maintains the
invariant that the underlying graph is immutable).
"""
self._validate(replacement_graph)
self._graph = nx.freeze(replacement_graph)
def __init__(self, graph: str or networkx.Graph):
if isinstance(graph, networkx.Graph):
nxgraph = networkx.Graph(graph)
elif isinstance(graph, str):
nxgraph = phasme.build_graph.graph_from_file(graph)
else:
raise ValueError("Unexpected {}".format(graph))
# internal graph representation
self.__edges = map(frozenset, nxgraph.edges)
if const.TEST_INTEGRITY:
self.__edges = tuple(self.__edges)
for args in self.__edges:
if len(args) > 2:
print(
'WARNING: Weird edge: {}. It will be filtered.'.format(
args))
else:
assert len(args) == 2, args
self.__edges = set(edge for edge in self.__edges if len(edge) == 2)
# data
self.__nodes = set(nxgraph.nodes)
self.__uid = str(min(self.__nodes, key=str))
self.__nb_node = len(self.__nodes)
self.__nb_cc = networkx.number_connected_components(nxgraph)
self._nxgraph = nxgraph if constants.KEEP_NX_GRAPH else networkx.freeze(
nxgraph)
self.__initial_number_of_edge = len(self.__edges)
self.__active_recipe = None
self.__hierarchy = set() # inclusions between powernodes
self.__powernodes = defaultdict(
set) # (step, set) -> {node in powernode}
self.__poweredges = defaultdict(set) # (step, set) -> (step, set)
def plan(self):
""" Plan execution order of functions, along with initial conditions to check
Chainable.
"""
if len(self._graph) == 0:
logger.warning('Planning an empty graph!')
if self._is_planned:
logger.info('Graph is already planned. Skipping...')
return
sorted_graph = dag.topological_sort(self._graph)
initial_nodes = set()
execution_plan = []
for nm in sorted_graph:
node = self[nm]
if not node.is_complete:
initial_nodes.add(node.name)
else:
execution_plan.append(node)
self.initial_nodes = initial_nodes
self.execution_plan = execution_plan
self._graph = nx.freeze(self._graph)
self._is_planned = True
return self
def subgraph_view(G, filter_node=no_filter, filter_edge=no_filter):
newG = nx.freeze(G.__class__())
newG._NODE_OK = filter_node
newG._EDGE_OK = filter_edge
# create view by assigning attributes from G
newG._graph = G
newG.graph = G.graph
newG._node = FilterAtlas(G._node, filter_node)
if G.is_multigraph():
Adj = FilterMultiAdjacency
def reverse_edge(u, v, k): return filter_edge(v, u, k)
else:
Adj = FilterAdjacency
def reverse_edge(u, v): return filter_edge(v, u)
if G.is_directed():
newG._succ = Adj(G._succ, filter_node, filter_edge)
newG._pred = Adj(G._pred, filter_node, reverse_edge)
newG._adj = newG._succ
else:
newG._adj = Adj(G._adj, filter_node, filter_edge)
return newG
def generic_graph_view(G, create_using=None):
if create_using is None:
newG = G.__class__()
else:
newG = nx.empty_graph(0, create_using)
if G.is_multigraph() != newG.is_multigraph():
raise NetworkXError("Multigraph for G must agree with create_using")
newG = nx.freeze(newG)
# create view by assigning attributes from G
newG._graph = G
newG.graph = G.graph
newG._node = G._node
if newG.is_directed():
if G.is_directed():
newG._succ = G._succ
newG._pred = G._pred
newG._adj = G._succ
else:
newG._succ = G._adj
newG._pred = G._adj
newG._adj = G._adj
elif G.is_directed():
if G.is_multigraph():
newG._adj = UnionMultiAdjacency(G._succ, G._pred)
else:
newG._adj = UnionAdjacency(G._succ, G._pred)
else:
newG._adj = G._adj
return newG
def clean_up(self):
if nx.is_frozen(self.G):
return
if self.use_virtual_nodes:
if self.verbose > 0:
print("Remove virtual nodes")
print("\nCurrent graph:")
print("Nodes: {}".format(self.G.number_of_nodes()))
print("Edges: {}".format(self.G.number_of_edges()))
self.G.remove_nodes_from(self.virtual_nodes)
self.assignments = np.delete(self.assignments, self.virtual_nodes)
self.fixed = np.delete(self.fixed, self.virtual_nodes)
if self.verbose > 0:
print("\nVirtual nodes removed:")
print("Nodes: {}".format(self.G.number_of_nodes()))
print("Edges: {}".format(self.G.number_of_edges()))
# Add partition attribute to nodes
for i in range(0, len(self.assignments)):
self.G.add_nodes_from([i], partition=str(self.assignments[i]))
# Remove original node/edge weights
for node in self.G.nodes_iter(data=True):
if 'weight_orig' in node[1]:
del node[1]['weight_orig']
for edge in self.G.edges_iter(data=True):
if 'weight_orig' in edge[2]:
del edge[2]['weight_orig']
# Freeze Graph from further modification
self.G = nx.freeze(self.G)
def main():
seed(0) #set seed
#get graph info
G = nx.read_gpickle("input/graphMTC_CentroidsLength6.gpickle") #noCentroidsLength15.gpickle") #does not have centroidal links. There is also the choice of a proper multidigraph: nx.read_gpickle("input/graphMTC_CentroidsLength5.gpickle")
G = nx.freeze(G) #prevents edges or nodes to be added or deleted
#get od info. This is in format of a dict keyed by od, like demand[sd1][sd2] = 200000.
demand = bd.build_demand('input/BATS2000_34SuperD_TripTableData.csv', 'input/superdistricts_centroids.csv')
#get earthquake info
q = QuakeMaps('input/20130210_mtc_total_lnsas3.pkl', 'input/20130210_mtc_magnitudes3.pkl', 'input/20130210_mtc_faults3.pkl', 'input/20130210_mtc_weights3.pkl', 'input/20130210_mtc_scenarios3.pkl') #input/20130107_mtc_total_lnsas1.pkl', 'input/20130107_mtc_magnitudes1.pkl','input/20130107_mtc_faults1.pkl', 'input/20130107_mtc_weights1.pkl', 'input/20130107_mtc_scenarios1.pkl') #'input/20130210_mtc_total_lnsas3.pkl', 'input/20130210_mtc_magnitudes3.pkl', 'input/20130210_mtc_faults3.pkl', 'input/20130210_mtc_weights3.pkl', 'input/20130210_mtc_scenarios3.pkl') #('input/20130107_mtc_total_lnsas1.pkl', 'input/20130107_mtc_magnitudes1.pkl', #totalfilename=None, magfilename=None, faultfilename=None, weightsfilename=None, scenariofilename=None):
print 'weights: ', q.weights
q.num_sites = len(q.lnsas[0])
#determine which scenarios you want to run
good_indices = pick_scenarios(q.lnsas, q.weights)
travel_index_times = []
index = 0
#loop over scenarios
print 'size of lnsas: ', len(q.lnsas)
for scenario in q.lnsas: #each 'scenario' has 1557 values of lnsa, i.e. one per site
if index in good_indices:
print 'index: ', index
(bridges, flow, path, path2) = run_simple_iteration(G, scenario, demand, False)
travel_index_times.append((index, bridges, flow, path, path2))
# print 'new travel times: ', travel_index_times
if index%1000 ==0:
util.write_2dlist(time.strftime("%Y%m%d")+'_bridges_flow_paths4.txt',travel_index_times)
index += 1 #IMPORTANT
util.write_2dlist(time.strftime("%Y%m%d")+'_bridges_flow_paths4.txt',travel_index_times)
print 'the number of scenarios I considered doing: ', index
print 'the number of scenarios I actually did: ', len(travel_index_times)
def __init__(self, nodes, segments, points):
graph = nx.Graph()
nodes = self.parse_nodes_file(nodes)
for nid, row in nodes.iterrows():
coord = (row["Z Coord"], row["Y Coord"], row["X Coord"])
graph.add_node(nid, coord=coord)
segments = self.parse_segments_file(segments)
points = self.parse_points_file(points)
for _, row in segments.iterrows():
point_coords = []
for pid in row["Point IDs"]:
point_coords.append((
points["Z Coord"][pid],
points["Y Coord"][pid],
points["X Coord"][pid],
))
graph.add_edge(row["Node ID #1"],
row["Node ID #2"],
points=point_coords)
self.graph = nx.freeze(graph)
self._rebuild_mito_relationship()
def spec2graph(spec: ConcreteSpec, qdd=False, dprob=None) -> nx.DiGraph:
dfa = spec._as_dfa(qdd=qdd)
if dprob is None:
dprob = fn.constantly(None)
def is_sink(state) -> bool:
return state.node.var is None
def is_decision(state) -> bool:
lvl = state.node.level
if qdd:
lvl -= state.debt
return spec.order.is_decision(lvl)
def key(state):
return (state.ref, state.debt) if qdd else state.ref
sinks = set()
g = nx.DiGraph()
@fn.memoize
def _node(state):
decision = is_decision(state) and not is_sink(state)
lvl = state.node.level
var = state.label() if state.node.var is None else state.node.var
node = key(state)
g.add_node(node, lvl=lvl, var=var, decision=decision)
return node
stack = [dfa.start]
while len(stack) > 0:
state = stack.pop()
action2succ = {a: dfa._transition(state, a) for a in dfa.inputs}
for action, succ in action2succ.items():
if key(succ) not in g.nodes:
stack.append(succ)
if succ == state: # Sink
sinks.add(_node(succ))
continue
if qdd and state.debt > 0:
g.add_edge(_node(state), _node(succ), action=None, prob=1)
else:
if is_decision(state):
prob = dprob(key(state), action)
else:
prob = 1/2
g.add_edge(_node(state), _node(succ), action=action, prob=prob)
g.add_node("DUMMY", lvl=None, var=None, decision=False)
for sink in sinks:
g.add_edge(sink, "DUMMY", action=None, prob=1)
g = nx.freeze(g)
return g, _node(dfa.start), list(sinks)
def get_graph():
import networkx
'''loads full mtc highway graph with dummy links and then adds a few fake centroidal nodes for max flow and traffic assignment'''
G = networkx.read_gpickle("input/graphMTC_CentroidsLength3int.gpickle")
G = add_superdistrict_centroids(G)
assert not G.is_multigraph() # Directed! only one edge between nodes
G = networkx.freeze(G) #prevents edges or nodes to be added or deleted
return G
def __init__(self, G, theta, eps, max_comms=100):
self._G = nx.freeze(G)
self._theta = theta
self._max_comms = max_comms
self._log = []
self._fitness_list = []
self._eps = eps
def __init__(self, d):
super(Spec, self).__init__()
self.graph = nx.Graph()
self._load_switches(d)
self._load_hosts(d)
self._load_links(d)
self.graph = nx.freeze(self.graph)
self._check_sanity()
def get_graph():
import networkx
'''loads full mtc highway graph with dummy links and then adds a few fake centroidal nodes for max flow and traffic assignment'''
G = networkx.read_gpickle("input/graphMTC_CentroidsLength3int.gpickle")
G = add_superdistrict_centroids(G)
# Directed! only one edge between nodes
G = nx.freeze(G) #prevents edges or nodes to be added or deleted
return G
def create_test_nw(cls, req_cores=3, req_memory=3000, req_rate=15000):
"""create a random network."""
g = nx.Graph()
g.add_node("Node_0", cores=req_cores, memory=req_memory)
g.add_node("Node_1", cores=req_cores, memory=req_memory)
g.add_edge("Node_0", "Node_1", rate=req_rate)
return cls(nx.freeze(g))
def graph(self):
if self._subgraph is not None:
return self._subgraph
if self._target is None:
return self._graph
nodes = [self._target]
nodes.extend(dst for _src, dst in
traversal.dfs_edges(self._graph.reverse(), self._target))
self._subgraph = nx.freeze(self._graph.subgraph(nodes))
return self._subgraph
def flatten(self):
"""Flattens a item (a task or flow) into a single execution graph."""
if self._graph is not None:
return self._graph
self._pre_flatten()
graph = self._flatten(self._root)
self._post_flatten(graph)
if self._freeze:
self._graph = nx.freeze(graph)
else:
self._graph = graph
return self._graph
def test_freeze(self):
G=networkx.freeze(self.G)
assert_equal(G.frozen,True)
assert_raises(networkx.NetworkXError, G.add_node, 1)
assert_raises(networkx.NetworkXError, G.add_nodes_from, [1])
assert_raises(networkx.NetworkXError, G.remove_node, 1)
assert_raises(networkx.NetworkXError, G.remove_nodes_from, [1])
assert_raises(networkx.NetworkXError, G.add_edge, 1,2)
assert_raises(networkx.NetworkXError, G.add_edges_from, [(1,2)])
assert_raises(networkx.NetworkXError, G.remove_edge, 1,2)
assert_raises(networkx.NetworkXError, G.remove_edges_from, [(1,2)])
assert_raises(networkx.NetworkXError, G.clear)
def main():
'''can change the number of epsilons below'''
seed(0) #set seed
simple = False #simple is just %bridges out, which is computationally efficient
number_of_highway_bridges = 1743
numeps = 3 #the number of epsilons
tol = 0.00001 #the minimum annual rate that you care about in the original event set (the weight now is the original annual rate / number of epsilons per event)
demand = bd.build_demand('input/BATS2000_34SuperD_TripTableData.csv', 'input/superdistricts_centroids.csv') #we just take a percentage in ita.py, namely #to get morning flows, take 5.3% of daily driver values. 11.5/(4.5*6+11.5*10+14*4+4.5*4) from Figure S10 of http://www.nature.com/srep/2012/121220/srep01001/extref/srep01001-s1.pdf
#figure out ground motions
lnsas, weights = ground_motions(numeps, tol, '/Users/mahalia/Documents/matlab/Research/Herbst2011/output_data/SF2_mtc_total_3909scenarios_1743bridgesPlusBART_3eps.txt')
bart_dict = transit_to_damage.make_bart_dict()
muni_dict = transit_to_damage.make_muni_dict()
set_main_path('/Users/mahaliamiller/Desktop/trn/transit_lines/', None) #TODO: need to change THREE file paths (these plus bart)
print 'the number of ground motion events we are considering: ', len(lnsas)
index = 0
bridge_array = []
travel_index_times = []
# G = nx.read_gpickle("input/graphMTC_noCentroidsLength15.gpickle")
G = nx.read_gpickle("input/graphMTC_CentroidsLength6.gpickle")
# Directed! only one edge between nodes
G = nx.freeze(G) #prevents edges or nodes to be added or deleted
print 'am I a multi graph? ', G.is_multigraph()
no_damage_travel_time, no_damage_vmt = compute_tt_vmt(G, demand)
if not os.path.isdir(time.strftime("%Y%m%d")+'_filesForCube/'):
os.mkdir(time.strftime("%Y%m%d")+'_filesForCube/')
if not os.path.isdir(time.strftime("%Y%m%d")+'_filesForCube/transit/'):
os.mkdir(time.strftime("%Y%m%d")+'_filesForCube/transit/')
if not os.path.isdir(time.strftime("%Y%m%d")+'_filesForCube/modCapacities/'):
os.mkdir(time.strftime("%Y%m%d")+'_filesForCube/modCapacities/')
for scenario in lnsas:
print index
#figure out bridge damage for each scenario
damaged_bridges, num_bridges_out = damage_bridges(scenario) #e.g., [1, 89, 598] #num_bridges_out is highway bridges only
bridge_array.append(damaged_bridges)
#figure out network damage and output Cube files to this effect
G = damage_network(damaged_bridges, G, time.strftime("%Y%m%d")+'_filesForCube/', index)
#figure out impact (performance metrics)
flow, shortest_paths, travel_time, vmt = measure_performance(G, damaged_bridges, demand, no_damage_travel_time, no_damage_vmt)
travel_index_times.append((index, num_bridges_out, flow, shortest_paths, travel_time, vmt, num_bridges_out/float(number_of_highway_bridges)))
G = util.clean_up_graph(G)
index +=1
# if index%3909 == 0:
if index%100 == 0:
save_results(bridge_array, travel_index_times, int(index/float(3909)))
test(numeps, lnsas, damaged_bridges, damaged_graph, num_bridges_out, flow, shortest_paths, travel_time, vmt)
def flatten(item, freeze=True):
graph = _flatten(item, set())
if freeze:
# Frozen graph can't be modified...
return nx.freeze(graph)
return graph
def _freeze(self):
self._g = nx.freeze(self._g)
return self
def make_graph(loglines,
tag_map,
id_map,
time_weighting,
adjacent_logline_edge_weight=1.0,
logline_id_edge_weight=1.0,
logline_tag_edge_weight=1.0):
"""
Creates a digraph from the argument data.
The graph that is created has the following structure:
o LogLine nodes have one edge to their previous LogLine
and one to its next Logline. This is defined by their position
in the loglines array argument.
o LogLine nodes have one DATA_TO_META edge to every id node, based upon
the entry in the id_map argument.
o LogLine nodes have one DATA_TO_META edge to each tag node.
o Id nodes have one META_TO_DATA edge to each of their LogLine nodes.
o Tag nodes have one META_TO_DATA edge to each of their LogLine nodes.
o Tag nodes each have two META_TO_META edges -- one to the 'previous'
tag node and one to the 'next' tag node. 'next' and 'previous' are
defined by the TagVertex.time field.
o The graph is directed, but every directed edge has a corresponding
directed edge -- if an edge (u,v) exists then (v,u) (of some type)
exists.
TODO(trevor) once we're further along and we like this graph take a few
minutes and make a asciigraph example.
Args:
loglines see vinge.parser.parse_log return value
tag_map see vinge.parser.parse_log return value
id_map see vinge.parser.parse_log return value
time_weighting (fun (datetime.datetime, datetime.datetime) -> float)
function defining the weight between tag nodes
adjacent_logline_edge_weight (float)
logline_id_edge_weight (float)
logline_tag_edge_weight (float)
Returns:
networkx.DiGraph
"""
g = nx.DiGraph()
g.add_nodes_from(loglines)
oldll = None
for ll in loglines:
if oldll is not None:
g.add_edge(oldll, ll, weight=adjacent_logline_edge_weight,
edge_type=EdgeType.ADJACENT_NEXT)
g.add_edge(ll, oldll, weight=adjacent_logline_edge_weight,
edge_type=EdgeType.ADJACENT_PREV)
oldll = ll
for id in id_map:
v = UniqueIDVertex(id)
g.add_node(v)
for ll in id_map[id]:
g.add_edge(ll, v, weight=logline_id_edge_weight,
edge_type=EdgeType.DATA_TO_META)
g.add_edge(v, ll, weight=logline_id_edge_weight,
edge_type=EdgeType.META_TO_DATA)
for tag in tag_map:
v, oldv = None, None
the_tag_occurrences = sorted(list(tag_map[tag]))
for ll in the_tag_occurrences:
oldv = v
v = TagVertex(tag, ll.time)
g.add_node(v)
# add edges between adjacent tag vertices, with
# weight based on how far apart the times are
if oldv is not None:
wt = time_weighting(v.time, oldv.time)
g.add_edge(v, oldv, weight=wt, edge_type=EdgeType.META_TO_META)
g.add_edge(oldv, v, weight=wt, edge_type=EdgeType.META_TO_META)
g.add_edge(ll, v, weight=logline_tag_edge_weight,
edge_type=EdgeType.DATA_TO_META)
g.add_edge(v, ll, weight=logline_tag_edge_weight,
edge_type=EdgeType.META_TO_DATA)
# Normalize edge weights
normalize_graph(g)
# Add the vertex index to all nodes
for i, node in enumerate(g.nodes_iter()):
node._set_idx(i)
g = nx.freeze(g)
return g
howdeep(each_item,h)
else:
pass
reader=csv.reader(file('C:/nx/networkx/sing.csv','rb'))
#构图
for row in reader:
if reader.line_num ==1:
continue
G.add_edge(row[0].decode('utf-8'),row[1].decode('utf-8'))
#返回G中节点权重，并按排序输出结果
weight_g = sorted(G.degree().values())
for each_node in G.nodes():
#找到邻居数大于设定值的节点i
if nx.degree(G)[each_node] >= weight_g[-rang]:
#print G.neighbors(each_item)
howdeep(each_node,deep)
'''
#生成与i直接连接的图
for each_one in G.neighbors(each_node):
DG.add_edge(each_one,each_node)
for each_neighbor in G.neighbors(each_one):
DG.add_edge(each_neighbor,each_one)
'''
pos = nx.spring_layout(G)
nx.draw_networkx(DG,pos,node_size=1000,font_size=8)
nx.freeze(G)
plt.show()
def __init__(self, name):
super(Flow, self).__init__(name)
self._graph = nx.freeze(nx.DiGraph())
def _make_left_corner(self): g = nx.DiGraph() for r in self.grammar: g.add_edge(r.lhs,r.rhs[0]) return nx.freeze(g)
def main():
'''can change the number of epsilons below'''
seed(0) #set seed
simple = False #False #simple is just %bridges out, which is computationally efficient
#get graph info
# G = nx.read_gpickle("input/graphMTC_CentroidsLength6.gpickle") #noCentroidsLength15.gpickle") #does not have centroidal links. There is also the choice of a proper multidigraph: nx.read_gpickle("input/graphMTC_CentroidsLength5.gpickle")
G = nx.read_gpickle("input/graphMTC_CentroidsLength6highways.gpickle") #noCentroidsLength15.gpickle") #does not have centroidal links. Directed! only one edge between nodes
# G1 = nx.read_gpickle("input/graphMTC_CentroidsLength5.gpickle") #undirected, multiple edges. It is a little funky because it has two links between A and B and two between B and A so is that double-counting?
# '''a multigraph: An undirected graph class that can store multiedges.
# Multiedges are multiple edges between two nodes. Each edge
# can hold optional data or attributes.
# A MultiGraph holds undirected edges. Self loops are allowed.'''
print 'nodes: ', len(G.nodes())
G = nx.freeze(G) #prevents edges or nodes to be added or deleted
# G1 = nx.freeze(G1)
#get od info. This is in format of a dict keyed by od, like demand[sd1][sd2] = 200000.
demand = bd.build_demand('input/BATS2000_34SuperD_TripTableData.csv', 'input/superdistricts_centroids.csv') #we just take a percentage in ita.py, namely #to get morning flows, take 5.3% of daily driver values. 11.5/(4.5*6+11.5*10+14*4+4.5*4) from Figure S10 of http://www.nature.com/srep/2012/121220/srep01001/extref/srep01001-s1.pdf
#get path
#get earthquake info #UPDATED May 23, 2013
#TODO
q = QuakeMaps('input/20130612_mtc_total_lnsas5.pkl', 'input/20130612_mtc_magnitudes5.pkl', 'input/20130612_mtc_faults5.pkl', 'input/20130612_mtc_weights5.pkl', 'input/20130612_mtc_scenarios5.pkl') #input/20130107_mtc_total_lnsas1.pkl', 'input/20130107_mtc_magnitudes1.pkl','input/20130107_mtc_faults1.pkl', 'input/20130107_mtc_weights1.pkl', 'input/20130107_mtc_scenarios1.pkl') #'input/20130210_mtc_total_lnsas3.pkl', 'input/20130210_mtc_magnitudes3.pkl', 'input/20130210_mtc_faults3.pkl', 'input/20130210_mtc_weights3.pkl', 'input/20130210_mtc_scenarios3.pkl') #('input/20130107_mtc_total_lnsas1.pkl', 'input/20130107_mtc_magnitudes1.pkl', #totalfilename=None, magfilename=None, faultfilename=None, weightsfilename=None, scenariofilename=None):
q.num_sites = len(q.lnsas[0])
numeps = 5 #CAHNGE THIS CHANGE THIS!!!!!!!!
#determine which scenarios you want to run
good_indices = pick_scenarios(q.lnsas, q.weights,True, numeps)
targets = good_indices #[12, 35, 55, 71, 75, 82, 86, 87, 88, 106, 108, 115, 121, 231, 241, 247, 256, 258, 260, 261, 676, 730, 733, 1231, 1548] #indices between 0 and 2110. the scenarios for which you want to save the damaged bridge data
print 'the number of scenarios for which I want to save bridge info: ', len(targets)
travel_index_times = []
index = 0
good_index = 0
# pdb.set_trace()
#figure out what the travel time and vmt are if no damage to any bridges
no_damage_travel_time = -1
no_damage_vmt = -1
found_no_damage = False
for scenario in q.lnsas: #each 'scenario' has 1xxx values of lnsa, i.e. one per site
while found_no_damage == False:
(bridges, flow, path, path2, newG) = run_simple_iteration(G, scenario, demand, False, good_index, targets, True) #since looking for no damage case, it is ok to clean up
if bridges == 0:
found_no_damage = True
print 'found case with no damage so I will save those and save you work later on'
(no_damage_travel_time, no_damage_vmt) = run_iteration(G, scenario, demand, newG)
#loop over scenarios
print 'size of lnsas: ', len(q.lnsas)
for scenario in q.lnsas: #each 'scenario' has 1xxx values of lnsa, i.e. one per site
if index in good_indices:
print 'index: ', index
if simple == True:
(bridges, flow, path, path2, newG) = run_simple_iteration(G, scenario, demand, False, good_index, targets)
travel_index_times.append((index, bridges, flow, path, path2, -1, -1, bridges/float(q.num_sites), -1))
else:
(bridges, flow, path, path2, newG) = run_simple_iteration(G, scenario, demand, False, good_index, targets, False) #doesn't clean up the damage
print 'what i found for bridges: ', bridges
if bridges == 0:
travel_time = no_damage_travel_time;
vmt = no_damage_vmt;
else:
print 'attempting new'
(travel_time, vmt) = run_iteration(G, scenario, demand, newG, True)
print 'what i have for (tt, vmt): ', (travel_time, vmt)
travel_index_times.append((index, bridges, flow, path, path2, travel_time, vmt, bridges/float(q.num_sites), -1))
good_index += 1
# travel_index_times.append((index, travel_time, vmt))
# print 'new travel times: ', travel_index_times
if index%1000 ==0:
print 'index: ', index
util.write_2dlist(time.strftime("%Y%m%d")+'_bridges_flow_paths_5eps_extensive.txt',travel_index_times)
index += 1 #IMPORTANT
util.write_2dlist(time.strftime("%Y%m%d")+'_bridges_flow_paths_5eps_extensive.txt',travel_index_times)
print 'the number of scenarios I considered doing: ', index
print 'the number of scenarios I actually did: ', len(travel_index_times)
print 'i.e.: ', good_index
print 'and now, I will save a dataset of damaged bridges in each scenario'
util.write_2dlist(time.strftime("%Y%m%d")+'_damaged_bridges_5eps_extensive.txt',BRIDGE_DAMAGE_DATASET)
with open(time.strftime("%Y%m%d")+'_damaged_bridges_5eps_extensive.pkl', 'wb') as f:
pickle.dump(BRIDGE_DAMAGE_DATASET, f)
def freeze(self):
"""Freezes the graph so that no more mutations can occur."""
if not self.frozen:
nx.freeze(self)
return self
assignments = np.delete(assignments, virtual_nodes)
fixed = np.delete(fixed, virtual_nodes)
print("\nVirtual nodes removed:")
print("Nodes: {}".format(G.number_of_nodes()))
print("Edges: {}".format(G.number_of_edges()))
# In[10]:
# Add partition attribute to nodes
for i in range(0, len(assignments)):
G.add_nodes_from([i], partition=str(assignments[i]))
# Freeze Graph from further modification
G = nx.freeze(G)
# In[11]:
import os
import datetime
timestamp = datetime.datetime.now().strftime('%H%M%S')
data_filename,_ = os.path.splitext(os.path.basename(DATA_FILENAME))
data_filename += "-" + timestamp
graph_metrics = {
"file": timestamp,
"num_partitions": num_partitions,
"num_iterations": num_iterations,
def freeze(self):
nx.freeze(self)
def contour(m, levels, nest=False, degrees=False, simplify=True):
import pkg_resources
try:
pkg_resources.require('healpy >= 1.9.0')
except:
raise RuntimeError('This function requires healpy >= 1.9.0.')
try:
import networkx as nx
except:
raise RuntimeError('This function requires the networkx package.')
# Determine HEALPix resolution
npix = len(m)
nside = hp.npix2nside(npix)
min_area = 0.4 * hp.nside2pixarea(nside)
# Compute faces, vertices, and neighbors.
# vertices is an N X 3 array of the distinct vertices of the HEALPix faces.
# faces is an npix X 4 array mapping HEALPix faces to their vertices.
# neighbors is an npix X 4 array mapping faces to their nearest neighbors.
faces = np.ascontiguousarray(
np.rollaxis(hp.boundaries(nside, np.arange(npix), nest=nest), 2, 1))
dtype = faces.dtype
faces = faces.view(np.dtype((np.void, dtype.itemsize * 3)))
vertices, faces = np.unique(faces.ravel(), return_inverse=True)
faces = faces.reshape(-1, 4)
vertices = vertices.view(dtype).reshape(-1, 3)
neighbors = hp.get_all_neighbours(nside, np.arange(npix), nest=nest)[::2].T
# Loop over the requested contours.
paths = []
for level in levels:
# Find credible region
indicator = (m >= level)
# Construct a graph of the eges of the contour.
graph = nx.Graph()
face_pairs = set()
for ipix1, ipix2 in enumerate(neighbors):
for ipix2 in ipix2:
# Determine if we have already considered this pair of faces.
new_face_pair = frozenset((ipix1, ipix2))
if new_face_pair in face_pairs: continue
face_pairs.add(new_face_pair)
# Determine if this pair of faces are on a boundary of the
# credible level.
if indicator[ipix1] == indicator[ipix2]: continue
# Add all common edges of this pair of faces.
i1 = np.concatenate((faces[ipix1], [faces[ipix1][0]]))
i2 = np.concatenate((faces[ipix2], [faces[ipix2][0]]))
edges1 = frozenset(frozenset(_) for _ in zip(i1[:-1], i1[1:]))
edges2 = frozenset(frozenset(_) for _ in zip(i2[:-1], i2[1:]))
for edge in edges1 & edges2:
graph.add_edge(*edge)
graph = nx.freeze(graph)
# Record a closed path for each cycle in the graph.
cycles = [
np.take(vertices, cycle, axis=0) for cycle in nx.cycle_basis(graph)]
# Simplify paths if requested
if simplify:
cycles = [_simplify(cycle, min_area) for cycle in cycles]
cycles = [cycle for cycle in cycles if len(cycle) > 2]
# Convert to lists
cycles = [
_vec2radec(cycle, degrees=degrees).tolist() for cycle in cycles]
# Add to output paths
paths.append([cycle + [cycle[0]] for cycle in cycles])
return paths
def test_is_frozen(self):
assert_equal(networkx.is_frozen(self.G), False)
G=networkx.freeze(self.G)
assert_equal(G.frozen, networkx.is_frozen(self.G))
assert_equal(G.frozen,True)
