integrations

collections

class AssignmentResultCollection(ids: ArrayLike | None = None, passenger_flow: ArrayLike | None = None, cargo_flow: ArrayLike | None = None, congested_time: ArrayLike | None = None, delay_factor: ArrayLike | None = None, volume_to_capacity: ArrayLike | None = None, passenger_car_unit: ArrayLike | None = None)

Bases: object

cargo_flow: ndarray
congested_time: ndarray
delay_factor: ndarray
ids: ndarray
passenger_car_unit: ndarray
passenger_flow: ndarray
volume_to_capacity: ndarray
class GraphPath(nodes: numpy.ndarray, links: numpy.ndarray, path_results: aequilibrae.paths.results.path_results.PathResults)

Bases: object

nodes: ndarray
path_results: PathResults
class LinkCollection(ids: ArrayLike | None = None, from_nodes: ArrayLike | None = None, to_nodes: ArrayLike | None = None, directions: ArrayLike | None = None, max_speeds: ArrayLike | None = None, capacities: ArrayLike | None = None, geometries: movici_simulation_core.core.arrays.TrackedCSRArray | None = None)

Bases: object

capacities: ndarray
directions: ndarray
from_nodes: ndarray
geometries: TrackedCSRArray | None
ids: ndarray
max_speeds: ndarray
to_nodes: ndarray
class NodeCollection(ids: ArrayLike | None = None, is_centroids: ArrayLike | None = None, geometries: List[List[float]] | List[numpy.ndarray] | numpy.ndarray | NoneType = None)

Bases: object

geometries: List[List[float]] | List[ndarray] | ndarray | None
ids: ndarray
is_centroids: ndarray

id_generator

class IdGenerator

Bases: object

Since aequilibrae has a fixed structure for ids we have to be able to convert between our ids and aequilibrae ids

get_new_ids(original_ids: ArrayLike) → ndarray
query_new_ids(original_ids: ArrayLike) → ndarray
query_original_ids(new_ids: ArrayLike) → ndarray

patches

class AequilibraeMatrix

Bases: AequilibraeMatrix

get_matrix(core: str, copy=True)

Same as upstream get_matrix, but with default copy=True

point_generator

class PointGenerator(increment: float = 0.001)

Bases: object

Since aequilibrae can’t work with overlapping points we have to be able to generate unique points

add_point(point: Tuple[float, float] | List[float] | ndarray) → None
add_points(points: List[Tuple[float, float] | List[float] | ndarray] | ndarray) → None
generate_and_add(reference_point: Tuple[float, float] | List[float] | ndarray) → ndarray
property point_count: int

project

class AssignmentParameters(volume_delay_function: str = 'BPR', vdf_alpha: float = 0.64, vdf_beta: float = 4.0, cargo_pcu: float = 1.9, algorithm: str = 'bfw', max_iter: int = 1000, rgap_target: float = 0.001)

Bases: object

algorithm: str = 'bfw'
cargo_pcu: float = 1.9
max_iter: int = 1000
rgap_target: float = 0.001
vdf_alpha: float = 0.64
vdf_beta: float = 4.0
volume_delay_function: str = 'BPR'
class ProjectWrapper(project_path: str | Path | None = None, project_name: str | None = None, delete_on_close: bool = True)

Bases: object

This class wraps Aequilibrae methods with sensible methods and bugfixes

add_column(column_name: str, values: Sequence | None = None) → None
add_nodes(nodes: NodeCollection) → None
assign_traffic(od_matrix_passenger: ndarray, od_matrix_cargo: ndarray, parameters: AssignmentParameters | None = None) → AssignmentResultCollection
build_graph(cost_field: str, block_centroid_flows: bool = True) → Graph
calculate_free_flow_times() → ndarray

Aequilibrae calculates distances automatically but does not compute free flow time, so we have to calculate them manually

close() → None
convert_od_matrix(od_matrix: ndarray, matrix_name: str) → AequilibraeMatrix
exclude_segments(segment_ids: Sequence[int])
get_nodes() → NodeCollection
get_shortest_path(from_node: int, to_node: int, path_results: PathResults | None = None) → GraphPath | None
get_shortest_paths(from_node: int, to_nodes: List[int]) → List[GraphPath | None]
transformer = <Unknown Transformer: unknown> Description: unavailable until proj_trans is called Area of Use: - undefined
update_column(column_name: str, values: Sequence) → None
class TransportMode

Bases: object

CAR = 'c'