def test_skimming_single_origin(self):
origin = 1
# graph
g = Graph()
g.load_from_disk(test_graph)
g.set_graph(cost_field="distance", skim_fields=None)
# g.block_centroid_flows = False
# None implies that only the cost field will be skimmed
# skimming results
res = SkimResults()
res.prepare(g)
aux_result = MultiThreadedNetworkSkimming()
aux_result.prepare(g, res)
a = skimming_single_origin(origin, g, res, aux_result, 0)
tot = np.sum(res.skims.distance[origin, :])
if tot > 10e10:
self.fail(
"Skimming was not successful. At least one np.inf returned.")
if a != origin:
self.fail("Skimming returned an error: " + a)
def execute(self):
"""Runs the skimming process as specified in the graph"""
if pyqt:
self.skimming.emit(["zones finalized", 0])
self.results.prepare(self.graph)
self.aux_res = MultiThreadedNetworkSkimming()
self.aux_res.prepare(self.graph, self.results)
pool = ThreadPool(self.results.cores)
all_threads = {"count": 0}
for orig in list(self.graph.centroids):
i = int(self.graph.nodes_to_indices[orig])
if i >= self.graph.nodes_to_indices.shape[0]:
self.report.append(
f"Centroid {orig} is beyond the domain of the graph")
elif self.graph.fs[int(i)] == self.graph.fs[int(i) + 1]:
self.report.append(
f"Centroid {orig} does not exist in the graph")
else:
pool.apply_async(self.__func_skim_thread,
args=(orig, all_threads))
pool.close()
pool.join()
self.aux_res = None
self.procedure_id = uuid4().hex
self.procedure_date = str(datetime.today())
if pyqt:
self.skimming.emit(["text skimming", "Saving Outputs"])
self.skimming.emit(["finished_threaded_procedure", None])
def test_network_skimming(self):
# graph
g = Graph()
g.load_from_disk(test_graph)
g.set_graph(cost_field="distance")
g.set_skimming("distance")
# skimming results
res = SkimResults()
res.prepare(g)
aux_res = MultiThreadedNetworkSkimming()
aux_res.prepare(g, res)
_ = skimming_single_origin(26, g, res, aux_res, 0)
skm = NetworkSkimming(g, res)
skm.execute()
tot = np.nanmax(res.skims.distance[:, :])
if tot > 10e10:
self.fail("Skimming was not successful. At least one np.inf returned.")
if skm.report:
self.fail("Skimming returned an error:" + str(skm.report))
def test_skimming_single_origin(self):
g = Graph()
g.load_from_disk(test_graph)
g.set_graph(cost_field="distance")
g.set_skimming("distance")
origin = np.random.choice(g.centroids[:-1], 1)[0]
# skimming results
res = SkimResults()
res.prepare(g)
aux_result = MultiThreadedNetworkSkimming()
aux_result.prepare(g, res)
a = skimming_single_origin(origin, g, res, aux_result, 0)
tot = np.sum(res.skims.distance[origin, :])
if tot > 10e10:
self.fail(
"Skimming was not successful. At least one np.inf returned for origin {}."
.format(origin))
if a != origin:
self.fail("Skimming returned an error: {} for origin {}".format(
a, origin))
def __init__(self, graph, origins=None):
WorkerThread.__init__(self, None)
self.origins = origins
self.graph = graph
self.results = SkimResults()
self.aux_res = MultiThreadedNetworkSkimming()
self.report = []
self.procedure_id = ""
self.procedure_date = ""
self.cumulative = 0
def test_network_skimming(self):
self.network.build_graphs()
graph = self.network.graphs['c']
graph.set_graph(cost_field="distance")
graph.set_skimming("distance")
graph.set_blocked_centroid_flows(False)
# skimming results
res = SkimResults()
res.prepare(graph)
aux_res = MultiThreadedNetworkSkimming()
aux_res.prepare(graph, res)
_ = skimming_single_origin(12, graph, res, aux_res, 0)
skm = NetworkSkimming(graph)
skm.execute()
tot = np.nanmax(skm.results.skims.distance[:, :])
if tot > np.sum(graph.cost):
self.fail(
"Skimming was not successful. At least one np.inf returned.")
if skm.report:
self.fail("Skimming returned an error:" + str(skm.report))
skm.save_to_project('tEst_Skimming')
if not os.path.isfile(
os.path.join(self.proj_dir, 'matrices', 'test_skimming.omx')):
self.fail('Did not save project to project')
matrices = self.project.matrices
mat = matrices.get_record('TEsT_Skimming')
self.assertEqual(mat.name, 'tEst_Skimming',
'Matrix record name saved wrong')
self.assertEqual(mat.file_name, 'tEst_Skimming.omx',
'matrix file_name saved wrong')
self.assertEqual(mat.cores, 1,
'matrix saved number of matrix cores wrong')
self.assertEqual(mat.procedure, 'Network skimming',
'Matrix saved wrong procedure name')
self.assertEqual(mat.procedure_id, skm.procedure_id,
'Procedure ID saved wrong')
self.assertEqual(mat.timestamp, skm.procedure_date,
'Procedure ID saved wrong')
class NetworkSkimming(WorkerThread):
"""
::
from aequilibrae.paths.network_skimming import NetworkSkimming
from aequilibrae.project import Project
project = Project()
project.open(self.proj_dir)
network = self.project.network
network.build_graphs()
graph = network.graphs['c']
graph.set_graph(cost_field="distance")
graph.set_skimming("distance")
skm = NetworkSkimming(graph)
skm.execute()
# The skim report (if any error generated) is available here
skm.report
# To access the skim matrix directly from its temporary file
matrix = skm.results.skims
# Or you can save the results to disk
skm.save_to_project('skimming result')
# Or specify the AequilibraE's matrix file format
skm.save_to_project('skimming result', 'aem')
project.close()
"""
if pyqt:
skimming = pyqtSignal(object)
def __init__(self, graph, origins=None):
WorkerThread.__init__(self, None)
self.origins = origins
self.graph = graph
self.results = SkimResults()
self.aux_res = MultiThreadedNetworkSkimming()
self.report = []
self.procedure_id = ""
self.procedure_date = ""
self.cumulative = 0
def doWork(self):
self.execute()
def execute(self):
"""Runs the skimming process as specified in the graph"""
if pyqt:
self.skimming.emit(["zones finalized", 0])
self.results.prepare(self.graph)
self.aux_res = MultiThreadedNetworkSkimming()
self.aux_res.prepare(self.graph, self.results)
pool = ThreadPool(self.results.cores)
all_threads = {"count": 0}
for orig in list(self.graph.centroids):
i = int(self.graph.nodes_to_indices[orig])
if i >= self.graph.nodes_to_indices.shape[0]:
self.report.append(
f"Centroid {orig} is beyond the domain of the graph")
elif self.graph.fs[int(i)] == self.graph.fs[int(i) + 1]:
self.report.append(
f"Centroid {orig} does not exist in the graph")
else:
pool.apply_async(self.__func_skim_thread,
args=(orig, all_threads))
pool.close()
pool.join()
self.aux_res = None
self.procedure_id = uuid4().hex
self.procedure_date = str(datetime.today())
if pyqt:
self.skimming.emit(["text skimming", "Saving Outputs"])
self.skimming.emit(["finished_threaded_procedure", None])
def save_to_project(self, name: str, format="omx") -> None:
"""Saves skim results to the project folder and creates record in the database
Args:
*name* (:obj:`str`): Name of the matrix. Same value for matrix record name and file (plus extension)
*format* (:obj:`str`, `Optional`): File format ('aem' or 'omx'). Default is 'omx'
"""
file_name = f"{name}.{format.lower()}"
mats = Matrices()
record = mats.new_record(name, file_name, self.results.skims)
record.procedure_id = self.procedure_id
record.timestamp = self.procedure_date
record.procedure = "Network skimming"
record.save()
def __func_skim_thread(self, origin, all_threads):
if threading.get_ident() in all_threads:
th = all_threads[threading.get_ident()]
else:
all_threads[threading.get_ident()] = all_threads["count"]
th = all_threads["count"]
all_threads["count"] += 1
x = skimming_single_origin(origin, self.graph, self.results,
self.aux_res, th)
self.cumulative += 1
if x != origin:
self.report.append(x)
if pyqt:
self.skimming.emit(["zones finalized", self.cumulative])
txt = str(self.cumulative) + " / " + str(self.matrix.zones)
self.skimming.emit(["text skimming", txt])