def test_copy_from_omx_long_name(self):
temp_file = AequilibraeMatrix().random_name()
a = AequilibraeMatrix()
with self.assertRaises(ValueError):
a.create_from_omx(temp_file, omx_example, robust=False)
def test_load(self):
self.new_matrix = AequilibraeMatrix()
# Cannot load OMX file with no indices
with self.assertRaises(LookupError):
self.new_matrix.load(no_index_omx)
self.new_matrix = AequilibraeMatrix()
self.new_matrix.load(name_test)
def setUp(self) -> None:
self.matrix = AequilibraeMatrix()
self.matrix.load(siouxfalls_demand)
self.matrix.computational_view()
self.project = Project(siouxfalls_project)
self.project.network.build_graphs()
self.car_graph = self.project.network.graphs['c'] # type: Graph
self.car_graph.set_graph('free_flow_time')
self.car_graph.set_blocked_centroid_flows(False)
self.assignment = TrafficAssignment()
self.assigclass = TrafficClass(self.car_graph, self.matrix)
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 new_record(self, name: str, file_name: str,
matrix=AequilibraeMatrix()) -> MatrixRecord:
"""Creates a new record for a matrix in disk, but does not save it
If the matrix file is not already on disk, it will fail
Args:
*name* (:obj:`str`): Name of the matrix
*file_name* (:obj:`str`): Name of the file on disk
Return:
*matrix_record* (:obj:`MatrixRecord`): A matrix record that can be manipulated in memory before saving
"""
if name in self.__items:
raise ValueError(
f"There is already a matrix of name ({name}). It must be unique."
)
for mat in self.__items.values():
if mat.file_name == file_name:
raise ValueError(
f"There is already a matrix record for file name ({file_name}). It must be unique."
)
if matrix.cores > 0:
if isfile(join(self.fldr, file_name)):
raise FileExistsError(
f"{file_name} already exists. Choose a different name or matrix format"
)
mat_format = file_name.split(".")[-1].lower()
if mat_format not in ["omx", "aem"]:
raise ValueError(
"Matrix needs to be either OMX or native AequilibraE")
matrix.export(join(self.fldr, file_name))
cores = matrix.cores
else:
if not isfile(join(self.fldr, file_name)):
raise FileExistsError(
f"{file_name} does not exist. Cannot create this matrix record"
)
mat = AequilibraeMatrix()
mat.load(join(self.fldr, file_name))
cores = mat.cores
mat.close()
del mat
tp = {key: None for key in self.__fields}
tp["name"] = name
tp["file_name"] = file_name
tp["cores"] = cores
mr = MatrixRecord(tp)
mr.save()
self.__items[name.lower()] = mr
logger.warning("Matrix Record has been saved to the database")
return mr
def test_computational_view_with_omx(self):
self.new_matrix = AequilibraeMatrix()
self.new_matrix.load(omx_example)
arrays = ["m1", "m2"]
self.new_matrix.computational_view(arrays)
total_mats = np.sum(self.new_matrix.matrix_view)
self.new_matrix.computational_view([arrays[0]])
total_m1 = np.sum(self.new_matrix.matrix_view)
self.new_matrix.close()
omx_file = omx.open_file(omx_example, "r")
m1 = np.array(omx_file["m1"]).sum()
m2 = np.array(omx_file["m2"]).sum()
self.assertEqual(m1 + m2, total_mats)
self.assertEqual(m1, total_m1)
omx_file.close()
def setUp(self) -> None:
if self.matrix is not None:
return
args = {
"file_name": name_test,
"zones": zones,
"matrix_names": ["mat", "seed", "dist"],
"index_names": ["my indices"],
}
self.matrix = AequilibraeMatrix()
self.matrix.create_empty(**args)
self.matrix.index[:] = np.arange(self.matrix.zones) + 100
self.matrix.mat[:, :] = np.random.rand(self.matrix.zones,
self.matrix.zones)[:, :]
self.matrix.mat[:, :] = self.matrix.mat[:, :] * (
1000 / np.sum(self.matrix.mat[:, :]))
self.matrix.setName("Test matrix - " + str(random.randint(1, 10)))
self.matrix.setDescription(
"Generated at " +
datetime.datetime.now().strftime("%I:%M%p on %B %d, %Y"))
self.new_matrix = self.matrix
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 update_database(self) -> None:
"""Adds records to the matrices database for matrix files found on disk"""
existing_files = os.listdir(self.fldr)
paths_for_existing = [mat.file_name for mat in self.__items.values()]
new_files = [x for x in existing_files if x not in paths_for_existing]
new_files = [
x for x in new_files
if os.path.splitext(x.lower())[1] in [".omx", ".aem"]
]
if new_files:
logger.warning(
f'New matrix found on disk. Added to the database: {",".join(new_files)}'
)
for fl in new_files:
mat = AequilibraeMatrix()
mat.load(join(self.fldr, fl))
name = None
if not mat.is_omx():
name = str(mat.name).lower()
if not name:
name = fl.lower()
name = name.replace(".", "_").replace(" ", "_")
if name in self.__items:
i = 0
while f"{name}_{i}" in self.__items:
i += 1
name = f"{name}_{i}"
rec = self.new_record(name, fl)
rec.save()
def test_execute(self):
# Loads and prepares the graph
g = Graph()
g.load_from_disk(test_graph)
g.set_graph(cost_field='distance', skim_fields=None)
# None implies that only the cost field will be skimmed
# Prepares the matrix for assignment
args = {'file_name': os.path.join(gettempdir(),'my_matrix.aem'),
'zones': g.num_zones,
'matrix_names': ['cars', 'trucks'],
'index_names': ['my indices']}
matrix = AequilibraeMatrix()
matrix.create_empty(**args)
matrix.index[:] = g.centroids[:]
matrix.cars.fill(1)
matrix.trucks.fill(2)
matrix.computational_view(['cars'])
# Performs assignment
res = AssignmentResults()
res.prepare(g, matrix)
assig = allOrNothing(matrix, g, res)
assig.execute()
res.save_to_disk(os.path.join(gettempdir(),'link_loads.aed'))
res.save_to_disk(os.path.join(gettempdir(),'link_loads.csv'))
matrix.computational_view()
# Performs assignment
res = AssignmentResults()
res.prepare(g, matrix)
assig = allOrNothing(matrix, g, res)
assig.execute()
res.save_to_disk(os.path.join(gettempdir(),'link_loads_2_classes.aed'))
res.save_to_disk(os.path.join(gettempdir(),'link_loads_2_classes.csv'))
def test_copy_from_omx(self):
temp_file = AequilibraeMatrix().random_name()
a = AequilibraeMatrix()
a.create_from_omx(temp_file, omx_example)
omxfile = omx.open_file(omx_example, "r")
# Check if matrices values are compatible
for m in ["m1", "m2", "m3"]:
sm = a.matrix[m].sum()
sm2 = np.array(omxfile[m]).sum()
if sm != sm2:
self.fail(
"Matrix {} was copied with the wrong value".format(m))
if np.any(a.index[:] != np.array(list(omxfile.mapping("taz").keys()))):
self.fail("Index was not created properly")
a.close()
column_vector = AequilibraEData()
column_vector.create_empty(**args)
column_vector.index[:] = np.arange(column_vector.entries) + 100
column_vector.columns[:] = column_vector.index[:] + np.random.rand(zones)[:]
# balance vectors
column_vector.columns[:] = column_vector.columns[:] * (row_vector.rows.sum() / column_vector.columns.sum())
# Impedance matrix_procedures
name_test = os.path.join(tempfile.gettempdir(), 'aequilibrae_matrix_test.aem')
args = {'file_name': name_test,
'zones': zones,
'matrix_names': ['impedance']}
matrix = AequilibraeMatrix()
matrix.create_empty(**args)
# randoms = np.random.randint(5, size=(2, 4))
matrix.impedance[:, :] = np.random.rand(zones, zones)[:, :]
matrix.index[:] = np.arange(matrix.zones) + 100
matrix.computational_view(['impedance'])
model_expo = SyntheticGravityModel()
model_expo.function = 'EXPO'
model_expo.beta = 0.1
model_gamma = SyntheticGravityModel()
model_gamma.function = 'GAMMA'
model_gamma.beta = 0.1
model_gamma.alpha = -0.2
from aequilibrae.matrix import AequilibraeMatrix
from aequilibrae.distribution import GravityCalibration
import numpy as np
import os, tempfile
zones = 100
# Impedance matrix_procedures
name_test = AequilibraeMatrix().random_name()
args = {'file_name': name_test,
'zones': zones,
'matrix_names': ['impedance']}
impedance = AequilibraeMatrix()
impedance.create_empty(**args)
impedance.impedance[:, :] = np.random.rand(zones, zones)[:,:] * 1000
impedance.index[:] = np.arange(impedance.zones) + 100
impedance.computational_view(['impedance'])
args['matrix_names'] = ['base_matrix']
args['file_name'] = AequilibraeMatrix().random_name()
matrix = AequilibraeMatrix()
matrix.create_empty(**args)
matrix.base_matrix[:, :] = np.random.rand(zones, zones)[:,:] * 1000
matrix.index[:] = np.arange(matrix.zones) + 100
matrix.computational_view(['base_matrix'])
# column vector
args['field_names'] = ['columns']
column_vector = AequilibraEData()
column_vector.create_empty(**args)
column_vector.columns[:] = np.random.rand(zones)[:] * 1000
column_vector.index[:] = np.arange(zones)[:]
# balance vectors
column_vector.columns[:] = column_vector.columns[:] * (row_vector.rows.sum()/column_vector.columns.sum())
# seed matrix_procedures
name_test = AequilibraeMatrix().random_name()
args = {'file_name': name_test,
'zones': zones,
'matrix_names': ['seed']}
matrix = AequilibraeMatrix()
matrix.create_empty(**args)
matrix.seed[:, :] = np.random.rand(zones, zones)[:,:]
matrix.computational_view(['seed'])
matrix.matrix_view[1,1] = np.nan
matrix.index[:] = np.arange(zones)[:]
class TestIpf(TestCase):
def test_fit(self):
# The IPF per se
args = {'matrix': matrix,
'rows': row_vector,
'row_field': 'rows',
'columns': column_vector,
'column_field': 'columns',
