aequilibrae.paths.AoN#

Functions

aggregate_link_costs(actual_costs, ...)

aggregate_link_costs_cython(double[, ...)

assign_link_loads(actual_links, ...)

assign_link_loads_cython(signatures, args, ...)

bpr(congested_times, link_flows, capacity, ...)

bpr2(congested_times, link_flows, capacity, ...)

bpr2_cython(double[, double[, double[, ...)

bpr_cython(double[, double[, double[, ...)

conical(congested_times, link_flows, ...)

conical_cython(double[, double[, double[, ...)

connectivity_multi_threaded(tester)

copy_one_dimension(target, source, cores)

copy_one_dimension_cython(double[, double[, ...)

copy_three_dimensions(target, source, cores)

copy_three_dimensions_cython(double[, , , ...)

copy_two_dimensions(target, source, cores)

copy_two_dimensions_cython(double[, , ...)

dbpr2_cython(double[, double[, double[, ...)

dbpr_cython(double[, double[, double[, ...)

dconical_cython(double[, double[, double[, ...)

delta_bpr(dbpr, link_flows, capacity, ...)

delta_bpr2(dbpr2, link_flows, capacity, ...)

delta_conical(dbpr, link_flows, capacity, ...)

delta_inrets(dbpr, link_flows, capacity, ...)

dfs(long origin, long long[, long long[, ...)

dinrets_cython(double[, double[, double[, ...)

inrets(congested_times, link_flows, ...)

inrets_cython(double[, double[, double[, ...)

linear_combination(results, array1, array2, ...)

linear_combination_1d(results, array1, ...)

linear_combination_cython(double stepsize, ...)

linear_combination_cython_1d(...)

linear_combination_skims(results, array1, ...)

linear_combination_skims_cython(...)

network_loading(long classes, double[, , ...)

one_to_all(origin, matrix, graph, result, ...)

path_computation(origin, destination, graph, ...)

path_finding(long origin, unsigned char[, ...)

path_finding_a_star(long origin, ...)

Based on the pseudocode presented at https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode The following variables have been renamed to be consistent with out Dijkstra's implementation - openSet: pqueue - cameFrom: pred - fScore: pqueue.Elements[idx].key, for some idx

put_path_file_on_disk(unsigned int orig, ...)

save_path_file(long origin_index, ...)

skim_multiple_fields(long origin, ...)

skimming_single_origin(origin, graph, ...)

sum_a_times_b_minus_c(array1, array2, ...)

sum_a_times_b_minus_c_cython(double[, ...)

sum_axis1(totals, multiples, cores)

sum_axis1_cython(double[, double[, , int cores)

triple_linear_combination(results, array1, ...)

triple_linear_combination_cython(double[, ...)

triple_linear_combination_cython_skims(...)

triple_linear_combination_skims(results, ...)

update_path_trace(results, destination, graph)

If results.early_exit is True, early exit will be enabled if the path is to be recomputed.
aequilibrae.paths.AoN.bpr(congested_times, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.bpr2(congested_times, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.bpr2_cython(double[:] congested_time, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.bpr_cython(double[:] congested_time, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.conical(congested_times, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.conical_cython(double[:] congested_time, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.connectivity_multi_threaded(tester)#
aequilibrae.paths.AoN.copy_one_dimension(target, source, cores)#
aequilibrae.paths.AoN.copy_one_dimension_cython(double[:] target, double[:] source, int cores) → void#
aequilibrae.paths.AoN.copy_three_dimensions(target, source, cores)#
aequilibrae.paths.AoN.copy_three_dimensions_cython(double[:, :, :] target, double[:, :, :] source, int cores) → void#
aequilibrae.paths.AoN.copy_two_dimensions(target, source, cores)#
aequilibrae.paths.AoN.copy_two_dimensions_cython(double[:, :] target, double[:, :] source, int cores) → void#
aequilibrae.paths.AoN.dbpr2_cython(double[:] deltaresult, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.dbpr_cython(double[:] deltaresult, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.dconical_cython(double[:] deltaresult, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.delta_bpr(dbpr, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.delta_bpr2(dbpr2, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.delta_conical(dbpr, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.delta_inrets(dbpr, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.dfs(long origin, long long[:] csr_indices, long long[:] graph_fs, long long[:] pred) → void#
aequilibrae.paths.AoN.dinrets_cython(double[:] deltaresult, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.inrets(congested_times, link_flows, capacity, fftime, alpha, beta, cores)#
aequilibrae.paths.AoN.inrets_cython(double[:] congested_time, double[:] link_flows, double[:] capacity, double[:] fftime, double[:] alpha, double[:] beta, int cores) → void#
aequilibrae.paths.AoN.linear_combination(results, array1, array2, stepsize, cores)#
aequilibrae.paths.AoN.linear_combination_1d(results, array1, array2, stepsize, cores)#
aequilibrae.paths.AoN.linear_combination_cython(double stepsize, double[:, :] results, double[:, :] array1, double[:, :] array2, int cores) → void#
aequilibrae.paths.AoN.linear_combination_cython_1d(double stepsize, double[:] results, double[:] array1, double[:] array2, int cores) → void#
aequilibrae.paths.AoN.linear_combination_skims(results, array1, array2, stepsize, cores)#
aequilibrae.paths.AoN.linear_combination_skims_cython(double stepsize, double[:, :, :] results, double[:, :, :] array1, double[:, :, :] array2, int cores) → void#
aequilibrae.paths.AoN.network_loading(long classes, double[:, :] demand, long long[:] pred, long long[:] conn, double[:, :] link_loads) → void#
aequilibrae.paths.AoN.one_to_all(origin, matrix, graph, result, aux_result, curr_thread)#
aequilibrae.paths.AoN.path_computation(origin, destination, graph, results)#
Parameters:

  • graph – AequilibraE graph. Needs to have been set with number of centroids and list of skims (if any)

  • results – AequilibraE Matrix properly set for computation using matrix.computational_view([matrix list])

  • skimming – if we will skim for all nodes or not

aequilibrae.paths.AoN.path_finding(long origin, unsigned char[:] destinations, long long destination_count, double[:] graph_costs, long long[:] csr_indices, long long[:] graph_fs, long long[:] pred, long long[:] ids, long long[:] connectors, long long[:] reached_first) → int#
aequilibrae.paths.AoN.path_finding_a_star(long origin, long destination, double[:] graph_costs, long long[:] csr_indices, long long[:] graph_fs, long long[:] nodes_to_indices, double[:] lats, double[:] lons, long long[:] pred, long long[:] ids, long long[:] connectors, Heuristic heuristic) → void#

Based on the pseudocode presented at https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode The following variables have been renamed to be consistent with out Dijkstra’s implementation

  • openSet: pqueue

  • cameFrom: pred

  • fScore: pqueue.Elements[idx].key, for some idx

aequilibrae.paths.AoN.put_path_file_on_disk(unsigned int orig, unsigned int[:] pred, long long[:] predecessors, unsigned int[:] conn, long long[:] connectors, long long[:] all_nodes, unsigned int[:] origins_to_write, unsigned int[:] nodes_to_write) → void#
aequilibrae.paths.AoN.save_path_file(long origin_index, long num_links, long zones, long long[:] pred, long long[:] conn, str path_file, str index_file, bool write_feather) → void#
aequilibrae.paths.AoN.skim_multiple_fields(long origin, long nodes, long zones, long skims, double[:, :] node_skims, long long[:] pred, long long[:] conn, double[:, :] graph_costs, long long[:] reached_first, long found, double[:, :] final_skims) → void#
aequilibrae.paths.AoN.skimming_single_origin(origin, graph, result, aux_result, curr_thread)#
Parameters:

  • origin

  • graph

  • results

Returns:

aequilibrae.paths.AoN.sum_a_times_b_minus_c(array1, array2, array3, cores)#
aequilibrae.paths.AoN.sum_a_times_b_minus_c_cython(double[:] array1, double[:] array2, double[:] array3, int cores) → double#
aequilibrae.paths.AoN.sum_axis1(totals, multiples, cores)#
aequilibrae.paths.AoN.sum_axis1_cython(double[:] totals, double[:, :] multiples, int cores) → void#
aequilibrae.paths.AoN.triple_linear_combination(results, array1, array2, array3, stepsizes, cores)#
aequilibrae.paths.AoN.triple_linear_combination_cython(double[:] stepsizes, double[:, :] results, double[:, :] array1, double[:, :] array2, double[:, :] array3, int cores) → void#
aequilibrae.paths.AoN.triple_linear_combination_cython_skims(double[:] stepsizes, double[:, :, :] results, double[:, :, :] array1, double[:, :, :] array2, double[:, :, :] array3, int cores) → void#
aequilibrae.paths.AoN.triple_linear_combination_skims(results, array1, array2, array3, stepsizes, cores)#
aequilibrae.paths.AoN.update_path_trace(results, destination, graph)#

If results.early_exit is True, early exit will be enabled if the path is to be recomputed. If results.a_star is True, A* will be used if the path is to be recomputed.

Parameters:

  • graph – AequilibraE graph. Needs to have been set with number of centroids and list of skims (if any)

  • results – AequilibraE Matrix properly set for computation using matrix.computational_view([matrix list])

  • skimming – if we will skim for all nodes or not

  • early_exit – Exit Dijkstra’s once the destination has been found if the shortest path tree must be reconstructed.