Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Parameters

This page lists all the parameters that can be used in the Toml configuration file.

The parameters’ names are separated by dots representing the (potentially nested) tables in which they must be defined. For example, the parameter modes.car_driver.alpha must be defined as:

[modes]
[modes.car_driver]
alpha = 10.0

For each parameter, the documentation specifies the types of values allowed. These types mostly follows the Toml specification (String, Integer, Float, Boolean), with the following special types:

  • Time: time of the day. It can be specified either as a valid Toml time (e.g., 07:30:00), as a number of seconds after midnight (e.g., 27000), or as a string (e.g., "07:30", "07:30:00"). Only the two latter specifications allows to specify times past midnight (e.g., 113400 and "31:30:00" both represent 07:30 on the next day).
  • Duration: a time duration (e.g., 1 hour 30 minutes, 10 seconds). It can be specified either as a string with a valid ISO8601 duration (e.g., "PT1H30M10S") or as a number of seconds (e.g., 5410).
  • List: a Toml array (e.g., [1, 2, 3]). When specified, the array elements must be of a specific type. There can also be constraints on the number of elements. For example, the simulation_parameters.period parameter must be an array with exactly two elements of type Time.
  • Table: a Toml table. It can be specified either as a complete table or as an inline table.

For example, many parameters can take as input a special table representing a distribution. These parameters can be specified as

[modes]
[modes.car_driver]
[modes.car_driver.alpha]
mean = 10.0
std = 1.0
distribution = "Normal"

or as

[modes]
[modes.car_driver]
alpha = { mean = 10.0, std = 1.0, distribution = "Normal" }

The documentation also lists all the steps that uses the defined parameter as input.

Warning

For parameters specifying a distribution (e.g., modes.car_driver.alpha), the meaning of the std value depends on the selected distribution.

For "Uniform" distributions, the values are uniformly distributed in the interval [mean - std, mean + std], so the actual standard-deviation is std / √3.

For "Lognormal" distributions, mean and std represent the mean and standard-deviation of the underlying normal distribution.

main_directory

  • Description: Directory where all the generated MetroFiles are stored.
  • Allowed values: String representing a valid path
  • Example: “my_simulation/”
  • Note: If the directory does not exist, it will be automatically created when running Pymetropolis.
  • Steps: All

crs

gtfs_files

  • Description: List of GTFS files that form the public-transit network.
  • Allowed values: List of String representing a valid path to an existing file
  • Example: ["data/gtfs/madrid-gtfs.zip"]
  • Steps: TripsPublicTransitTravelTimeFromR5Step

nb_threads

osm_file

random_seed

simulation_ratio

  • Description: Ratio of the population that is being simulated.
  • Allowed values: Float between 0.0 and 1.0
  • Note: This value controls how road capacities and aggregate results are scaled when the simulated agents do not represent 100% of population. It does not affect the scaling of the input origin-destination matrix or synthetic population.
  • Steps: AggregateResultsStep, WriteMetroVehicleTypesStep

bicycle_network.ensure_connected

  • Description: Whether the network should be restricted to the largest strongly connected component of the underlying graph.
  • Allowed values: Boolean
  • Note: If False, it is the user’s responsibility to ensure that all origin-destination pairs are feasible.
  • Steps: PostprocessBicycleNetworkStep

bicycle_network.forbidden_types

  • Description: List of bicycle edges’ types that cannot be used as origin / destination edge.
  • Allowed values: List of String
  • Example: ["trunk", "trunk_link"]
  • Steps: BicycleODNodesFromCoordinatesStep

bicycle_network.reindex

  • Description: If true, the edges are re-index after the postprocessing so that they are indexed from 0 to n-1.
  • Allowed values: Boolean
  • Steps: PostprocessBicycleNetworkStep

bicycle_network.remove_duplicates

  • Description: Whether the duplicate edges (edges with same source and target) should be removed.
  • Allowed values: Boolean
  • Note: If True, the edge with the smallest travel time is kept.
  • Steps: PostprocessBicycleNetworkStep

bicycle_routing.output_path

  • Description: Whether the minimum-cost paths are stored.
  • Allowed values: Boolean
  • Steps: TripsBicycleCostStep

circular_network.entry_ramps_length

  • Description: Length of entry ramps, in meters.
  • Allowed values: Float
  • Steps: CircularNetworkStep

circular_network.exit_ramps_length

  • Description: Length of exit ramps, in meters.
  • Allowed values: Float
  • Steps: CircularNetworkStep

circular_network.nb_radials

circular_network.nb_rings

circular_network.radial_inter_ramp_length

  • Description: Length of the radial road segments (tunnels) between the clockwise and counter-clockwise ramps, in meters.
  • Allowed values: Float
  • Steps: CircularNetworkStep

circular_network.radius

  • Description: Radius of each ring, in meters.
  • Allowed values: float or list of floats
  • Note: If a scalar, the distance between each ring. If a list, the (cumulative) distance of each ring to the center.
  • Steps: CircularNetworkStep

circular_network.resolution

  • Description: The number of points in the geometry of the ring roads.
  • Allowed values: Integer
  • Steps: CircularNetworkStep

circular_network.ring_inter_ramp_length

  • Description: Length of the ring road segments (bridges) between the left and right ramps, in meters.
  • Allowed values: Float
  • Steps: CircularNetworkStep

circular_network.with_ramps

  • Description: Whether entry / exit ramps to the ring roads should be added.
  • Allowed values: Boolean
  • Steps: CircularNetworkStep

custom_road_import.edges_file

  • Description: Path to the geospatial file containing the edges definition.
  • Allowed values: String representing a valid path to an existing file
  • Example: "data/my_edges.geojson"
  • Steps: CustomRoadImportStep

departure_time.linear_schedule.beta

  • Description: Penalty for starting an activity earlier than the desired time (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: LinearScheduleStep

departure_time.linear_schedule.delta

  • Description: Length of the desired time window.
  • Allowed values: Duration or a table with keys mean (Duration), std (Duration), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: LinearScheduleStep

departure_time.linear_schedule.gamma

  • Description: Penalty for starting an activity later than the desired time (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: LinearScheduleStep

departure_time.linear_schedule.preferences_file

  • Description: Path to a Parquet or CSV file with the beta, gamma and delta values for different activity purposes.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: purpose, beta, gamma, delta.
  • Steps: LinearScheduleFromPurposeStep

departure_time.linear_schedule.tstar

  • Description: Desired start time of the following activity.
  • Allowed values: Time or a table with keys mean (Time), std (Duration), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: HomogeneousTstarStep

departure_time.linear_schedule.tstar_type

departure_time_choice.model

  • Description: Type of choice model for departure-time choice
  • Allowed values: Either 'Exogenous', 'ContinuousLogit'
  • Steps: WriteMetroAlternativesStep

departure_time_choice.mu

  • Description: Value of mu for the Continuous Logit departure-time choice model
  • Allowed values: Float
  • Note: Only required when departure-time choice model is ContinuousLogit
  • Steps: WriteMetroAlternativesStep

fuel.consumption_factor

  • Description: Fuel consumption, in liters per km.
  • Allowed values: Float
  • Steps: CarFuelStep

fuel.price

  • Description: Price of fuel, in € per liter.
  • Allowed values: Float
  • Steps: CarFuelStep

gravity_od_matrix.exponential_decay

  • Description: Exponential decay rate of flows as a function of free-flow travel times (rate per minute)
  • Allowed values: Float
  • Steps: GravityODMatrixStep

gravity_od_matrix.nodes_regex

  • Description: Regular expression specifying the nodes to be selected as possible origin / destination.
  • Allowed values: String
  • Note: If not specified, any node can be an origin / destination.
  • Steps: GravityODMatrixStep

gravity_od_matrix.trips_per_node

  • Description: Number of trips to be generated originating from each node
  • Allowed values: Integer or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: GravityODMatrixStep

grid_network.bottom_to_top

  • Description: Whether edges going from bottom to top should be generated.
  • Allowed values: Boolean
  • Steps: GridNetworkStep

grid_network.left_to_right

  • Description: Whether edges going from left to right should be generated.
  • Allowed values: Boolean
  • Steps: GridNetworkStep

grid_network.length

  • Description: Length of an edge, in meters.
  • Allowed values: Float
  • Steps: GridNetworkStep

grid_network.nb_columns

  • Description: Number of columns (i.e., number of nodes on each row).
  • Allowed values: Integer
  • Steps: GridNetworkStep

grid_network.nb_rows

  • Description: Number of rows (i.e., number of nodes on each column).
  • Allowed values: Integer
  • Steps: GridNetworkStep

grid_network.right_to_left

  • Description: Whether edges going from right to left should be generated.
  • Allowed values: Boolean
  • Steps: GridNetworkStep

grid_network.top_to_bottom

  • Description: Whether edges going from top to bottom should be generated.
  • Allowed values: Boolean
  • Steps: GridNetworkStep

ign.admin_express_directory

ign.api_communes_service_name

ign.api_iris_service_name

ign.api_wfs_url

ign.contours_iris_directory

metropolis_core.exec_path

  • Description: Path to the metropolis_cli executable.
  • Allowed values: String representing a valid path to an executable
  • Note: On Windows, you can omit the “.exe” extension
  • Steps: RunSimulationStep

metropolis_core.routing_exec_path

mode_choice.model

  • Description: Type of choice model for mode choice
  • Allowed values: Either 'Logit', 'DrawnLogit', 'DrawnNestedLogit', 'Deterministic'
  • Steps: WriteMetroAgentsStep

mode_choice.modes

mode_choice.mu

  • Description: Value of mu for the Logit choice model
  • Allowed values: Float
  • Note: Only required when mode choice model is Logit
  • Steps: WriteMetroAgentsStep

modes.bicycle.alpha

  • Description: Value of time by bicycle (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: BicyclePreferencesStep

modes.bicycle.constant

  • Description: Constant penalty for each bicycle trip (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: BicyclePreferencesStep

modes.bicycle.distance.type

modes.bicycle.distance.with_snap

  • Description: (“Whether snap distances at origin and destination should be added to the trips’ total distances.”,)
  • Allowed values: Boolean
  • Steps: BicycleTravelTimesFromDistanceStep

modes.bicycle.preferences_file

  • Description: Path to a Parquet or CSV file with the constant and alpha values for different population segments.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: mode, constant, alpha, value_of_time, any persons’ characteristics column from PersonsFile.
  • Steps: BicyclePreferencesFromPopulationStep

modes.bicycle.snap_speed

  • Description: Bicycle speed on the snap part of the trip, in km/h.
  • Allowed values: Float
  • Note: Default is to use modes.bicycle.speed as snap speed.
  • Steps: BicycleTravelTimesFromDistanceStep

modes.bicycle.speed

modes.car_driver.alpha

  • Description: Value of time by car_driver (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarDriverPreferencesStep

modes.car_driver.constant

  • Description: Constant penalty for each car_driver trip (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarDriverPreferencesStep

modes.car_driver.preferences_file

  • Description: Path to a Parquet or CSV file with the constant and alpha values for different population segments.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: mode, constant, alpha, value_of_time, any persons’ characteristics column from PersonsFile.
  • Steps: CarDriverPreferencesFromPopulationStep

modes.car_driver_with_passengers.alpha

  • Description: Value of time by car_driver_with_passengers (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarDriverWithPassengersPreferencesStep

modes.car_driver_with_passengers.constant

  • Description: Constant penalty for each car_driver_with_passengers trip (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarDriverWithPassengersPreferencesStep

modes.car_driver_with_passengers.preferences_file

  • Description: Path to a Parquet or CSV file with the constant and alpha values for different population segments.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: mode, constant, alpha, value_of_time, any persons’ characteristics column from PersonsFile.
  • Steps: CarDriverWithPassengersPreferencesFromPopulationStep

modes.car_passenger.alpha

  • Description: Value of time by car_passenger (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarPassengerPreferencesStep

modes.car_passenger.constant

  • Description: Constant penalty for each car_passenger trip (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarPassengerPreferencesStep

modes.car_passenger.preferences_file

  • Description: Path to a Parquet or CSV file with the constant and alpha values for different population segments.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: mode, constant, alpha, value_of_time, any persons’ characteristics column from PersonsFile.
  • Steps: CarPassengerPreferencesFromPopulationStep

modes.car_ridesharing.alpha

  • Description: Value of time by car_ridesharing (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarRidesharingPreferencesStep

modes.car_ridesharing.constant

  • Description: Constant penalty for each car_ridesharing trip (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: CarRidesharingPreferencesStep

modes.car_ridesharing.preferences_file

  • Description: Path to a Parquet or CSV file with the constant and alpha values for different population segments.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: mode, constant, alpha, value_of_time, any persons’ characteristics column from PersonsFile.
  • Steps: CarRidesharingPreferencesFromPopulationStep

modes.outside_option.alpha

  • Description: Value of time for the outside option (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Note: This is usually not relevant as the outside option does not imply traveling.
  • Steps: OutsideOptionPreferencesStep

modes.outside_option.constant

  • Description: Constant penalty of the outside option (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Note: Use negative values to represent benefits (i.e., a positive utility).
  • Steps: OutsideOptionPreferencesStep

modes.outside_option.road_network_speed

modes.public_transit.alpha

  • Description: Value of time by public_transit (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: PublicTransitPreferencesStep

modes.public_transit.constant

  • Description: Constant penalty for each public_transit trip (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: PublicTransitPreferencesStep

modes.public_transit.preferences_file

  • Description: Path to a Parquet or CSV file with the constant and alpha values for different population segments.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: mode, constant, alpha, value_of_time, any persons’ characteristics column from PersonsFile.
  • Steps: PublicTransitPreferencesFromPopulationStep

modes.public_transit.road_network_speed

modes.walking.alpha

  • Description: Value of time by walking (€/h).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: WalkingPreferencesStep

modes.walking.constant

  • Description: Constant penalty for each walking trip (€).
  • Allowed values: Float or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: WalkingPreferencesStep

modes.walking.distance.type

modes.walking.distance.with_snap

  • Description: (“Whether snap distances at origin and destination should be added to the trips’ total distances.”,)
  • Allowed values: Boolean
  • Steps: WalkingTravelTimesFromDistanceStep

modes.walking.preferences_file

  • Description: Path to a Parquet or CSV file with the constant and alpha values for different population segments.
  • Allowed values: String representing a valid path to an existing file
  • Note: Possible columns: mode, constant, alpha, value_of_time, any persons’ characteristics column from PersonsFile.
  • Steps: WalkingPreferencesFromPopulationStep

modes.walking.snap_speed

  • Description: Walking speed on the snap part of the trip, in km/h.
  • Allowed values: Float
  • Note: Default is to use modes.walking.speed as snap speed.
  • Steps: WalkingTravelTimesFromDistanceStep

modes.walking.speed

node_od_matrix.each

  • Description: Number of trips to generate for each origin-destination pair.
  • Allowed values: Integer or a table with keys mean (Float), std (Float), and distribution (one of 'Uniform', 'Gaussian', 'Normal', 'Lognormal')
  • Steps: ODMatrixEachStep

od_matrix.file

  • Description: Path to the CSV or Parquet file containing the origin-destination matrix.
  • Allowed values: String representing a valid path to an existing file
  • Note: Required columns are: origin (id of origin node), destination (id of destination node), and size (int or float, number of trips).
  • Steps: CustomODMatrixStep

opentripplanner.batch_size

  • Description: How many trips should be processed in each batch.
  • Allowed values: Integer
  • Note: Default is to process all trips in a single batch. Use a lower value if you are running out of memory.
  • Steps: TripsOpenTripPlannerStep

opentripplanner.date

  • Description: Date to be used for the requests.
  • Allowed values: Date
  • Note: Ensure that the GTFS file read by OpenTripPlanner has active services for this date.
  • Steps: TripsOpenTripPlannerStep

opentripplanner.multipliers.bus

opentripplanner.multipliers.rail

  • Description: Multiplier for the value of time for rail transport.
  • Allowed values: Float
  • Steps: TripsOpenTripPlannerStep

opentripplanner.multipliers.subway

opentripplanner.multipliers.tram

opentripplanner.multipliers.wait

opentripplanner.multipliers.walk

opentripplanner.time

  • Description: Departure / arrival time of the requests.
  • Allowed values: Time
  • Note: If time_type is "custom_departure", this is the departure time used for all requests. If time_type is "custom_arrival", this is the arrival time used for all requests. Otherwise, the value is only used as a default for missing departure / arrival time.
  • Steps: TripsOpenTripPlannerStep

opentripplanner.time_type

  • Description: How the departure / arrival time of the requests is defined.
  • Allowed values: Either 'tstar', 'custom_arrival', 'departure', 'custom_departure', 'arrival'
  • Note: If "departure", trips’ departure times are read from the trips’ ex-ante departure times. If "arrival", trips’ arrival times are read from the trips’ ex-ante arrival times. If "tstar", trips’ arrival times are read from the trips’ desired arrival times. If "custom_departure", the departure times are equal to the value of opentripplanner.time for all trips. If "custom_arrival", the arrival times are equal to the value of opentripplanner.time for all trips.
  • Steps: TripsOpenTripPlannerStep

opentripplanner.transfer_cost

opentripplanner.url

  • Description: URL from which the OpenTripPlanner API can be accessed.
  • Allowed values: String
  • Steps: TripsOpenTripPlannerStep

opentripplanner.walking_speed

osm_bicycle_import.highways

  • Description: List of highway=* OpenStreetMap tags to be considered as valid bicycle ways.
  • Allowed values: List of String [at least 1 elements]
  • Example: ["tertiary", "tertiary_link", "residential", "cycleway", "path"]
  • Note: A list of highway tags with description is available on the OpenStreetMap wiki.
  • Steps: OpenStreetMapBicycleImportStep

osm_bicycle_import.simulation_area_buffer

  • Description: Distance by which the polygon of the simulation area must be extended or shrinked when importing the bicycle network.
  • Allowed values: Float
  • Note: The value is expressed in the unit of measure of the CRS (usually meter). Positive values extend the area, while negative values shrink it.
  • Steps: OpenStreetMapBicycleImportStep

osm_bicycle_import.simulation_area_filter

  • Description: Whether the bicycle network must be restricted to the edges within the simulation area.
  • Allowed values: Boolean
  • Steps: OpenStreetMapBicycleImportStep

osm_pedestrian_import.highways

  • Description: List of highway=* OpenStreetMap tags to be considered as valid pedetrian ways.
  • Allowed values: List of String [at least 1 elements]
  • Example: ["track", "footway", "path", "pedestrian"]
  • Note: A list of highway tags with description is available on the OpenStreetMap wiki.
  • Steps: OpenStreetMapPedestrianImportStep

osm_pedestrian_import.simulation_area_buffer

  • Description: Distance by which the polygon of the simulation area must be extended or shrinked when importing the pedestrian network.
  • Allowed values: Float
  • Note: The value is expressed in the unit of measure of the CRS (usually meter). Positive values extend the area, while negative values shrink it.
  • Steps: OpenStreetMapPedestrianImportStep

osm_pedestrian_import.simulation_area_filter

  • Description: Whether the pedestrian network must be restricted to the edges within the simulation area.
  • Allowed values: Boolean
  • Steps: OpenStreetMapPedestrianImportStep

osm_road_import.allowed_access

  • Description: List of access=* OpenStreetMap tags defining ways accessible to road vehicles.
  • Allowed values: List of String
  • Note: Any way with an access value that is not in the given list will be considered as not accessible to road vehicles and thus will not be imported. A list of access tags with description is available on the OpenStreetMap wiki.
  • Steps: OpenStreetMapRoadImportStep

osm_road_import.highways

  • Description: List of highway=* OpenStreetMap tags to be considered as valid road ways.
  • Allowed values: List of String [at least 1 elements]
  • Example: ["motorway", "motorway_link", "trunk", "trunk_link", "primary", "primary_link"]
  • Note: A list of highway tags with description is available on the OpenStreetMap wiki.
  • Steps: OpenStreetMapRoadImportStep

osm_road_import.simulation_area_buffer

  • Description: Distance by which the polygon of the simulation area must be extended or shrinked when importing the road network.
  • Allowed values: Float
  • Note: The value is expressed in the unit of measure of the CRS (usually meter). Positive values extend the area, while negative values shrink it.
  • Steps: OpenStreetMapRoadImportStep

osm_road_import.simulation_area_filter

  • Description: Whether the road network must be restricted to the edges within the simulation area.
  • Allowed values: Boolean
  • Steps: OpenStreetMapRoadImportStep

osm_urban_areas.buffer

  • Description: Distance by which the polygons of the urban areas are buffered.
  • Allowed values: Float
  • Note: The value is expressed in the unit of measure of the CRS (usually meter). Positive values extend the area, while negative values shrink it.
  • Steps: OpenStreetMapUrbanAreasStep

osm_urban_areas.urban_landuse_tags

  • Description: List of landuse=* OpenStreetMap tags that define urban areas.
  • Allowed values: List of String [at least 1 elements]
  • Example: ["residential", "industrial", "commercial", "retail"]
  • Note: A list of landuse tags with description is available on the OpenStreetMap wiki.
  • Steps: OpenStreetMapUrbanAreasStep

pedestrian_network.ensure_connected

  • Description: Whether the network should be restricted to the largest strongly connected component of the underlying graph.
  • Allowed values: Boolean
  • Note: If False, it is the user’s responsibility to ensure that all origin-destination pairs are feasible.
  • Steps: PostprocessPedestrianNetworkStep

pedestrian_network.forbidden_types

  • Description: List of pedestrian edges’ types that cannot be used as origin / destination edge.
  • Allowed values: List of String
  • Example: ["trunk", "trunk_link"]
  • Steps: PedestrianODNodesFromCoordinatesStep

pedestrian_network.reindex

  • Description: If true, the edges are re-index after the postprocessing so that they are indexed from 0 to n-1.
  • Allowed values: Boolean
  • Steps: PostprocessPedestrianNetworkStep

pedestrian_network.remove_duplicates

  • Description: Whether the duplicate edges (edges with same source and target) should be removed.
  • Allowed values: Boolean
  • Note: If True, the edge with the smallest travel time is kept.
  • Steps: PostprocessPedestrianNetworkStep

pedestrian_routing.output_path

population.trip_coordinates_file

  • Description: Path to a Parquet / CSV file with coordinates of each trip.
  • Allowed values: String representing a valid path to an existing file
  • Steps: PopulationFromTripCoordinatesStep

r5.coordinates_rounding

  • Description: By how many meters trip origin / destination coordinates should be rounded.
  • Allowed values: Float
  • Note: Smaller values mean that the travel times will be more accurate, but it can result in a very long running time for the step.
  • Steps: TripsPublicTransitTravelTimeFromR5Step

r5.date

  • Description: Date to be used for the requests.
  • Allowed values: Date
  • Note: Ensure that the GTFS file read by OpenTripPlanner has active services for this date.
  • Steps: TripsPublicTransitTravelTimeFromR5Step

r5.time

  • Description: Departure time of the requests.
  • Allowed values: Time
  • Note: If time_type is "custom", this is the departure time used for all requests. Otherwise, the value is only used as a default for missing departure times.
  • Steps: TripsPublicTransitTravelTimeFromR5Step

r5.time_rounding

  • Description: By how much time trips’ departure time should be rounded.
  • Allowed values: Duration
  • Note: Smaller values mean that the travel times will be more accurate, but it can result in a very long running time for the step.
  • Steps: TripsPublicTransitTravelTimeFromR5Step

r5.time_type

  • Description: How the departure time of the requests is defined.
  • Allowed values: Either 'custom', 'departure'
  • Note: If "departure", trips’ departure times are read from the trips’ ex-ante departure times. If "custom", the departure times are equal to the value of r5.time for all trips.
  • Steps: TripsPublicTransitTravelTimeFromR5Step

road_network.calibration_variables

  • Description: (‘Definition of the variables (type and modalities) available for road network calibration.’,)
  • Allowed values: Table variable->definition, where variable is the name of a valid edge column and definition is a table with key type. Four types are possible: "boolean", "continuous", "intervals", "categories". See the example for configuration options.
  • Example:
[road_network.calibration_variables]
[road_network.calibration_variables.urban]
type = "boolean"

[road_network.calibration_variables.lanes]
type = "continuous"
min = 1  # Optional lower bound to constrain the values.
max = 3  # Optional upper bound to constrain the values.

[road_network.calibration_variables.speed_limit]
type = "intervals"
cuts = [30, 50, 70, 90, 110, 130]  # Breakpoints of the intervals.
left_closed = true  # Set the intervals to be left-closed instead of right-closed.

[road_network.calibration_variables.edge_type]
type = "categories"
# Optionally, group categories together with `map` (all original modalities must be defined).
map = {"motorway": "motorway", "motorway_link": "motorway", ...}

road_network.capacities

  • Description: Bottleneck capacity (in PCE/h) of edges.
  • Allowed values: float (constant capacity for all edges), table with edge types as keys and capacities as values, or table with “urban” and “rural” as keys and edge_type->value tables as values (see example)
  • Example:
[road_network.capacities]
[road_network.capacities.urban]
motorway = 2000
road = 1000
[road_network.capacities.rural]
motorway = 2000
road = 1500

road_network.default_lanes

  • Description: Default number of lanes to use for edges with no specified value.
  • Allowed values: float (constant number of lanes for all edges), table with edge types as keys and number of lanes as values, or table with “urban” and “rural” as keys and edge_type->value tables as values (see example)
  • Example:
[road_network.default_lanes]
[road_network.default_lanes.urban]
motorway = 2
road = 1
[road_network.default_lanes.rural]
motorway = 3
road = 1

road_network.default_speed_limit

  • Description: Default speed limit (in km/h) to use for edges with no specified value.
  • Allowed values: float (constant speed limit for all edges), table with edge types as keys and speed limits as values, or table with “urban” and “rural” as keys and edge_type->value tables as values (see example)
  • Example:
[road_network.default_speed_limit]
[road_network.default_speed_limit.urban]
motorway = 110
road = 50
[road_network.default_speed_limit.rural]
motorway = 110
road = 80
  • Note: The value is either a scalar value to be applied to all edges with no specified value, a table edge_type -> speed_limit or two tables edge_type -> speed_limit, for urban and rural edges.
  • Steps: PostprocessRoadNetworkStep

road_network.ensure_connected

  • Description: Whether the network should be restricted to the largest strongly connected component of the underlying graph.
  • Allowed values: Boolean
  • Note: If False, it is the user’s responsibility to ensure that all origin-destination pairs are feasible.
  • Steps: PostprocessRoadNetworkStep

road_network.ensure_primary_connected

  • Description: When true, add some secondary edges to the primary network to ensure that free-flow routes are primary-connected.
  • Allowed values: Boolean
  • Note: A free-flow route is “primary-connected” if there are no “secondary” edges which are both after the first occurrence of a “primary” edge and before the last occurrence of a “primary” edge.
  • Steps: RoadNetworkPrimaryEdgesStep

road_network.forbidden_types

  • Description: List of road edges’ types that cannot be used as origin / destination edge.
  • Allowed values: List of String
  • Example: ["motorway", "motorway_link", "trunk", "trunk_link"]
  • Steps: RoadODNodesFromCoordinatesStep

road_network.hov_lanes

  • Description: Number of HOV lanes on edges.
  • Allowed values: float (constant number of HOV lanes for all edges), table with edge types as keys and number of lanes as values, or table with “urban” and “rural” as keys and edge_type->value tables as values (see example)
  • Example:
[road_network.default_lanes]
[road_network.default_lanes.urban]
motorway = 2
road = 1
[road_network.default_lanes.rural]
motorway = 3
road = 1
  • Note: The HOV lanes are included in the total number of lanes on the edges so there cannot be more HOV lanes than there are lanes.
  • Steps: PostprocessRoadNetworkStep

road_network.min_lanes

road_network.min_length

road_network.min_speed_limit

road_network.penalties

  • Description: Constant time penalty (in seconds) of edges.
  • Allowed values: float (constant penalty for all edges), table with edge types as keys and penalties as values, or table with “urban” and “rural” as keys and edge_type->value tables as values (see example)
  • Example:
[road_network.penalties]
[road_network.penalties.urban]
motorway = 0
road = 5
[road_network.penalties.rural]
motorway = 0
road = 2

road_network.reindex

  • Description: If true, the edges are re-index after the postprocessing so that they are indexed from 0 to n-1.
  • Allowed values: Boolean
  • Steps: PostprocessRoadNetworkStep

road_network.remove_duplicates

  • Description: Whether the duplicate edges (edges with same source and target) should be removed.
  • Allowed values: Boolean
  • Note: If True, the edge with the smallest travel time is kept.
  • Steps: PostprocessRoadNetworkStep

road_network.secondary_types

  • Description: List of edges’ types that are part of the “secondary” road network.
  • Allowed values: List of String
  • Note: By default, all edges are part of the “primary” road network.
  • Steps: RoadNetworkPrimaryEdgesStep

simulation.backward_wave_speed

  • Description: Speed at which the holes created by a vehicle leaving a road is propagating backward (in km/h).
  • Allowed values: Float
  • Steps: WriteMetroParametersStep

simulation.departure_time_interval

  • Description: Interval between two breakpoints in the utility function for departure-time choice.
  • Allowed values: Duration
  • Note: Smaller values make the simulation faster but can lead to approximations in the departure-time choice.
  • Steps: WriteMetroParametersStep

simulation.learning_factor

  • Description: Value of the smoothing factor for the exponential learning model.
  • Allowed values: Float
  • Note: Value must be between 0 and 1. Smaller values lead to slower but steadier convergences.
  • Steps: WriteMetroParametersStep

simulation.max_pending_duration

  • Description: Maximum amount of time that a vehicle can spend waiting to enter the next road, in case of spillback.
  • Allowed values: Duration
  • Steps: WriteMetroParametersStep

simulation.nb_iterations

simulation.period

  • Description: Time window to be simulated.
  • Allowed values: List of Time [exactly 2 elements]
  • Example: [06:00:00, 10:00:00]
  • Note: The window can span multiple days.
  • Steps: WriteMetroParametersStep

simulation.recording_interval

  • Description: Time interval between two breakpoints for the travel-time functions.
  • Allowed values: Duration
  • Steps: WriteMetroParametersStep

simulation.routing_algorithm

  • Description: Algorithm type to use when computing the origin-destination travel-time functions.
  • Allowed values: Either 'TCH', 'Intersect', 'Best'
  • Note: Possible values: “Best”, “Intersect”, “TCH”
  • Steps: WriteMetroParametersStep

simulation.spillback

  • Description: Whether the number of vehicles on a road should be limited by the total road length.
  • Allowed values: Boolean
  • Steps: WriteMetroParametersStep

simulation_area.aav_filename

  • Description: Path to the shapefile of the French’s Aires d’attraction des villes.
  • Allowed values: String representing a valid path to an existing file [possible extensions: .zip, .shp]
  • Example: "data/aav2020_2024.zip"
  • Note: When the value is not specified, pymetropolis will attempt to automatically download the shapefile.
  • Steps: SimulationAreaFromAAVStep

simulation_area.aav_name

  • Description: Name of the Aire d’attraction des villes to be selected.
  • Allowed values: String
  • Example: Paris
  • Note: The value must appears in the column libaav20xx of the aav_filename file.
  • Steps: SimulationAreaFromAAVStep

simulation_area.bbox

  • Description: Bounding box to be used as simulation area.
  • Allowed values: List of Float [exactly 4 elements]
  • Example: [1.4777, 48.3955, 3.6200, 49.2032]
  • Note: Note: The values need to be specified as [minx, miny, maxx, maxy], in the simulation’s CRS. If bbox_wgs = true, the values need to be specified in WGS 84 (longitude, latitude).
  • Steps: SimulationAreaFromBboxStep

simulation_area.bbox_wgs

  • Description: Whether the bbox values are specified in the simulation CRS (false) or in WGS84 (true)
  • Allowed values: Boolean
  • Steps: SimulationAreaFromBboxStep

simulation_area.buffer

simulation_area.osm_admin_level

  • Description: Administrative level to be considered when reading administrative boundaries.
  • Allowed values: Integer
  • Note: See https://wiki.openstreetmap.org/wiki/Tag:boundary%3Dadministrative#Table_:_Admin_level_for_all_countries for a table with the meaning of all possible value for each country.
  • Steps: SimulationAreaFromOSMStep

simulation_area.osm_name

  • Description: List of subdivision names to be considered when reading administrative boundaries.
  • Allowed values: string or list of strings
  • Example: "Madrid"
  • Note: The values are compared with the name=* tag of the OpenStreetMap features. Be careful, the name can sometimes be in the local language.
  • Steps: SimulationAreaFromOSMStep

simulation_area.polygon_file

  • Description: Path to the geospatial file containing polygon(s) of the simulation area.
  • Allowed values: String representing a valid path to an existing file
  • Example: "data/my_area.geojson"
  • Steps: SimulationAreaFromPolygonsStep

synthetic_population.eqasim_output

  • Description: Path to the output directory of the Eqasim synthetic population pipeline.
  • Allowed values: String representing a valid path to an existing directory
  • Steps: EqasimImportStep

synthetic_population.fraction

  • Description: Fraction of the synthetic population to be selected for simulations.
  • Allowed values: Float between 0.0 and 1.0
  • Note: If the synthetic population already represents a part of the total population (with Eqasim’s sampling_rate parameter), you probably want to keep this parameter to 1. You will also need to set the simulation_ratio parameter to the actual share of the population being simulated. For example, when you generated 10% of the population (sampling_rate = 0.1) and you set fraction = 0.1, then only 1% of the population is actually being simulated with Pymetropolis, so simulation_ratio needs to be set to 0.01.
  • Steps: EqasimImportStep

vehicle_types.car.headway

  • Description: Typical length between two cars, from head to head, in meters
  • Allowed values: Float
  • Steps: WriteMetroVehicleTypesStep

vehicle_types.car.pce

vehicle_types.car.ridesharing_passenger_count

  • Description: Average number of passengers in the car (excluding the driver).
  • Allowed values: Float
  • Note: This is only relevant for the car_ridesharing mode. Larger values increase probability to select this mode (fuel cost is shared between more persons) and decrease congestion generated (more persons are traveling in each car).
  • Steps: WriteMetroTripsStep, WriteMetroVehicleTypesStep

zones.custom_zones

  • Description: Path to the geospatial file containing the zones definition.
  • Allowed values: String representing a valid path to an existing file
  • Example: "data/my_zones.geojson"
  • Steps: CustomZonesStep