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])