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))
class TestGraph(TestCase): def test_create_from_geography(self): self.graph = Graph() self.graph.create_from_geography( test_network, "link_id", "dir", "distance", centroids=centroids, skim_fields=[], anode="A_NODE", bnode="B_NODE", ) self.graph.set_graph(cost_field="distance") self.graph.set_blocked_centroid_flows(block_centroid_flows=True) self.graph.set_skimming("distance") def test_prepare_graph(self): self.test_create_from_geography() self.graph.prepare_graph(centroids) reference_graph = Graph() reference_graph.load_from_disk(test_graph) if not np.array_equal(self.graph.graph, reference_graph.graph): self.fail("Reference graph and newly-prepared graph are not equal") def test_set_graph(self): self.test_prepare_graph() self.graph.set_graph(cost_field="distance") self.graph.set_blocked_centroid_flows(block_centroid_flows=True) if self.graph.num_zones != centroids.shape[0]: self.fail("Number of centroids not properly set") if self.graph.num_links != 222: self.fail("Number of links not properly set") if self.graph.num_nodes != 93: self.fail("Number of nodes not properly set - " + str(self.graph.num_nodes)) def test_save_to_disk(self): self.test_create_from_geography() self.graph.save_to_disk(join(path_test, "aequilibrae_test_graph.aeg")) self.graph_id = self.graph.__id__ self.graph_version = self.graph.__version__ def test_load_from_disk(self): self.test_save_to_disk() reference_graph = Graph() reference_graph.load_from_disk(test_graph) new_graph = Graph() new_graph.load_from_disk(join(path_test, "aequilibrae_test_graph.aeg")) comparisons = [ ("Graph", new_graph.graph, reference_graph.graph), ("b_nodes", new_graph.b_node, reference_graph.b_node), ("Forward-Star", new_graph.fs, reference_graph.fs), ("cost", new_graph.cost, reference_graph.cost), ("centroids", new_graph.centroids, reference_graph.centroids), ("skims", new_graph.skims, reference_graph.skims), ("link ids", new_graph.ids, reference_graph.ids), ("Network", new_graph.network, reference_graph.network), ("All Nodes", new_graph.all_nodes, reference_graph.all_nodes), ("Nodes to indices", new_graph.nodes_to_indices, reference_graph.nodes_to_indices), ] for comparison, newg, refg in comparisons: if not np.array_equal(newg, refg): self.fail( "Reference %s and %s created and saved to disk are not equal" % (comparison, comparison)) comparisons = [ ("nodes", new_graph.num_nodes, reference_graph.num_nodes), ("links", new_graph.num_links, reference_graph.num_links), ("zones", new_graph.num_zones, reference_graph.num_zones), ("block through centroids", new_graph.block_centroid_flows, reference_graph.block_centroid_flows), ("Graph ID", new_graph.__id__, self.graph_id), ("Graph Version", new_graph.__version__, self.graph_version), ] for comparison, newg, refg in comparisons: if newg != refg: self.fail( "Reference %s and %s created and saved to disk are not equal" % (comparison, comparison)) def test_available_skims(self): self.test_set_graph() if self.graph.available_skims() != ["distance"]: self.fail("Skim availability with problems") def test_exclude_links(self): p = Project() p.load(siouxfalls_project) p.network.build_graphs() g = p.network.graphs['c'] # type: Graph # excludes a link before any setting or preparation g.exclude_links([12]) g.set_graph('distance') r1 = PathResults() r1.prepare(g) r1.compute_path(1, 14) self.assertEqual(list(r1.path), [2, 6, 10, 34]) # We exclude one link that we know was part of the last shortest path g.exclude_links([10]) r2 = PathResults() r2.prepare(g) r2.compute_path(1, 14) self.assertEqual(list(r2.path), [2, 7, 36, 34]) p.conn.close()
class TestAllOrNothing(TestCase): def setUp(self) -> None: self.mat_name = AequilibraeMatrix().random_name() self.g = Graph() self.g.load_from_disk(test_graph) self.g.set_graph(cost_field="distance") # Creates the matrix for assignment args = { "file_name": os.path.join(gettempdir(), self.mat_name), "zones": self.g.num_zones, "matrix_names": ["cars", "trucks"], "index_names": ["my indices"], } matrix = AequilibraeMatrix() matrix.create_empty(**args) matrix.index[:] = self.g.centroids[:] matrix.cars.fill(1.1) matrix.trucks.fill(2.2) # Exports matrix to OMX in order to have two matrices to work with matrix.export(os.path.join(gettempdir(), "my_matrix.omx")) matrix.close() def test_skimming_on_assignment(self): matrix = AequilibraeMatrix() matrix.load(os.path.join(gettempdir(), self.mat_name)) matrix.computational_view(["cars"]) res = AssignmentResults() res.prepare(self.g, matrix) self.g.set_skimming([]) self.g.set_blocked_centroid_flows(True) assig = allOrNothing(matrix, self.g, res) assig.execute() if res.skims.distance.sum() > 0: self.fail( "skimming for nothing during assignment returned something different than zero" ) self.g.set_skimming("distance") res.prepare(self.g, matrix) assig = allOrNothing(matrix, self.g, res) assig.execute() if res.skims.distance.sum() != 2914644.0: self.fail("skimming during assignment returned the wrong value") matrix.close() def test_execute(self): # Loads and prepares the graph car_loads = [] two_class_loads = [] for extension in ["omx", "aem"]: matrix = AequilibraeMatrix() if extension == 'omx': mat_name = os.path.join(gettempdir(), "my_matrix." + extension) else: mat_name = self.mat_name matrix.load(mat_name) matrix.computational_view(["cars"]) # Performs assignment res = AssignmentResults() res.prepare(self.g, matrix) assig = allOrNothing(matrix, self.g, res) assig.execute() car_loads.append(res.link_loads) res.save_to_disk( os.path.join(gettempdir(), "link_loads_{}.aed".format(extension))) res.save_to_disk( os.path.join(gettempdir(), "link_loads_{}.csv".format(extension))) matrix.computational_view() # Performs assignment res = AssignmentResults() res.prepare(self.g, matrix) assig = allOrNothing(matrix, self.g, res) assig.execute() two_class_loads.append(res.link_loads) res.save_to_disk( os.path.join(gettempdir(), "link_loads_2_classes_{}.aed".format(extension))) res.save_to_disk( os.path.join(gettempdir(), "link_loads_2_classes_{}.csv".format(extension))) matrix.close() load_diff = two_class_loads[0] - two_class_loads[1] if load_diff.max() > 0.0000000001 or load_diff.max() < -0.0000000001: self.fail( "Loads for two classes differ for OMX and AEM matrix types") load_diff = car_loads[0] - car_loads[1] if load_diff.max() > 0.0000000001 or load_diff.max() < -0.0000000001: self.fail( "Loads for a single class differ for OMX and AEM matrix types")
class TestGraph(TestCase): def test_create_from_geography(self): self.graph = Graph() self.graph.create_from_geography( test_network, "link_id", "dir", "distance", centroids=centroids, skim_fields=[], anode="A_NODE", bnode="B_NODE", ) self.graph.set_graph(cost_field="distance") self.graph.set_blocked_centroid_flows(block_centroid_flows=True) self.graph.set_skimming("distance") def test_prepare_graph(self): self.test_create_from_geography() self.graph.prepare_graph(centroids) reference_graph = Graph() reference_graph.load_from_disk(test_graph) if not np.array_equal(self.graph.graph, reference_graph.graph): self.fail("Reference graph and newly-prepared graph are not equal") def test_set_graph(self): self.test_prepare_graph() self.graph.set_graph(cost_field="distance") self.graph.set_blocked_centroid_flows(block_centroid_flows=True) if self.graph.num_zones != centroids.shape[0]: self.fail("Number of centroids not properly set") if self.graph.num_links != 222: self.fail("Number of links not properly set") if self.graph.num_nodes != 93: self.fail("Number of nodes not properly set - " + str(self.graph.num_nodes)) def test_save_to_disk(self): self.test_create_from_geography() self.graph.save_to_disk(join(path_test, "aequilibrae_test_graph.aeg")) self.graph_id = self.graph.__id__ self.graph_version = self.graph.__version__ def test_load_from_disk(self): self.test_save_to_disk() reference_graph = Graph() reference_graph.load_from_disk(test_graph) new_graph = Graph() new_graph.load_from_disk(join(path_test, "aequilibrae_test_graph.aeg")) comparisons = [ ("Graph", new_graph.graph, reference_graph.graph), ("b_nodes", new_graph.b_node, reference_graph.b_node), ("Forward-Star", new_graph.fs, reference_graph.fs), ("cost", new_graph.cost, reference_graph.cost), ("centroids", new_graph.centroids, reference_graph.centroids), ("skims", new_graph.skims, reference_graph.skims), ("link ids", new_graph.ids, reference_graph.ids), ("Network", new_graph.network, reference_graph.network), ("All Nodes", new_graph.all_nodes, reference_graph.all_nodes), ("Nodes to indices", new_graph.nodes_to_indices, reference_graph.nodes_to_indices), ] for comparison, newg, refg in comparisons: if not np.array_equal(newg, refg): self.fail( "Reference %s and %s created and saved to disk are not equal" % (comparison, comparison)) comparisons = [ ("nodes", new_graph.num_nodes, reference_graph.num_nodes), ("links", new_graph.num_links, reference_graph.num_links), ("zones", new_graph.num_zones, reference_graph.num_zones), ("block through centroids", new_graph.block_centroid_flows, reference_graph.block_centroid_flows), ("Graph ID", new_graph.__id__, self.graph_id), ("Graph Version", new_graph.__version__, self.graph_version), ] for comparison, newg, refg in comparisons: if newg != refg: self.fail( "Reference %s and %s created and saved to disk are not equal" % (comparison, comparison)) def test_available_skims(self): self.test_set_graph() if self.graph.available_skims() != ["distance"]: self.fail("Skim availability with problems")