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

Definitions and types

This page lists all the parameters that can be used in the Toml configuration file. For each parameter, the documentation also lists all the steps that uses this parameter as input.

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" }

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.

Secrets and environment variables

Pymetropolis supports a special syntax to read parameter values from a “secret” configuration file or from environment variables instead. This is useful when you want to share the main configuration TOML file, without sharing the value of some parameters (especially API keys).

Secrets

To tell Pymetropolis to read the value of a parameter from the secret configuration file, use:

# config.toml
[tomtom_requests]
api_key = "secret:tomtom_api_key"

# secrets.toml
tomtom_api_key = "MY_API_KEY"

Environment variables

To tell Pymetropolis to read the value of a parameter from an environment variable, use:

# config.toml
[tomtom_requests]
api_key = "env:TOMTOM_API_KEY"

Reference

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. A relative path is resolved against the directory of the main configuration file, not against the current working directory from which Pymetropolis is run.
  • Steps: All

secrets_file

  • Description: Path to the file where the secret configuration values are defined.
  • Allowed values: String representing a valid path
  • Default: “secrets.toml”
  • Note: If the file is defined but does not exist, Pymetropolis will raise an error. A relative path is resolved against the directory of the main configuration file, not against the current working directory from which Pymetropolis is run.
  • Steps: All

extra_populations

  • Description: List of paths to TOML configuration files, each one defining an additional demand population to be simulated alongside the main population (i.e., the population defined directly in the main configuration file).
  • Allowed values: List of strings representing valid paths
  • Example: ["persons.toml", "trucks.toml"]
  • Note: Paths are relative to the main configuration file. Each listed file is a standalone TOML configuration file with its own population_name key, using the exact same dotted parameter keys as the main configuration file (no renaming needed). See the Multiple-demand page for more details.
  • Steps: All

main_population

  • Description: Whether the main population (i.e., the population defined directly in the main configuration file, as opposed to the populations listed in extra_populations) should be simulated.
  • Allowed values: Boolean
  • Default: true
  • Note: Set to false if the main configuration file should not itself define a population (only the populations listed in extra_populations are then simulated). See the Multiple-demand page for more details.
  • Steps: All

population_name

  • Description: Name of the population defined by an extra-population configuration file (see extra_populations).
  • Allowed values: String
  • Note: Required in every extra-population configuration file; not used in the main configuration file. Population names must be unique across all populations, cannot contain the "-" character, and cannot be "population" (the name reserved for the main population) when main_population is true.
  • Steps: All

custom_steps

  • Description: List of paths to Python files, each one defining custom Step subclasses to be loaded alongside the built-in Steps.
  • Allowed values: List of strings representing valid paths
  • Example: ["my_steps.py"]
  • Note: Paths are relative to the main configuration file.
  • Steps: All

crs

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

calibration.free_flow_travel_time.additive_interaction_variables

  • Description: Name of variable pairs whose interaction is used as additive penalties in the Lasso regression.
  • Allowed values: List of List of String [exactly 2 elements]
  • Note: The listed variables must be available in RoadEdgesVariablesFile.
  • Steps: FreeFlowLassoStep

calibration.free_flow_travel_time.additive_variables

  • Description: Name of variables to be used as additive penalties in the Lasso regression.
  • Allowed values: List of String
  • Note: A constant is automatically included. The listed variables must be available in RoadEdgesVariablesFile.
  • Steps: FreeFlowLassoStep

calibration.free_flow_travel_time.multiplicative_interaction_variables

  • Description: Name of variable pairs whose interaction is used as multiplicative penalties in the Lasso regression.
  • Allowed values: List of List of String [exactly 2 elements]
  • Note: The listed variables must be available in RoadEdgesVariablesFile.
  • Steps: FreeFlowLassoStep

calibration.free_flow_travel_time.multiplicative_variables

  • Description: Name of variables to be used as multiplicative penalties in the Lasso regression.
  • Allowed values: List of String
  • Note: A constant is automatically included. The listed variables must be available in RoadEdgesVariablesFile.
  • Steps: FreeFlowLassoStep

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 'ContinuousLogit', 'Exogenous'
  • Steps: PrepareMetroAlternativesStep

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: PrepareMetroAlternativesStep

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

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

gtfs.date

gtfs.files

ign.admin_express_directory

  • Description: Path to the directory where the ADMIN EXPRESS database is stored.
  • Allowed values: String representing a valid path to an existing directory
  • Note: The database can be downloaded from cartes.gouv.fr.The ADMIN EXPRESS COG CARTO version and GPKG format are recommended. The 7z file needs to be extracted.
  • Steps: AdminExpressStep, FrenchZonesStep

ign.api_communes_service_name

  • Description: Name of the API service from which to request communes data.
  • Allowed values: String
  • Note: For faster but less accurate queries, you can use the “COG-CARTO-PE” version.
  • Steps: AdminExpressStep, FrenchZonesStep

ign.api_departements_service_name

  • Description: Name of the API service from which to request départements data.
  • Allowed values: String
  • Note: For faster but less accurate queries, you can use the “COG-CARTO-PE” version.
  • Steps: AdminExpressStep, FrenchZonesStep

ign.api_iris_service_name

  • Description: Name of the API service from which to request IRIS data.
  • Allowed values: String
  • Note: For faster but less accurate queries, you can use the “STATISTICALUNITS.IRIS.PE” version.
  • Steps: FrenchZonesStep, IRISStep

ign.api_regions_service_name

  • Description: Name of the API service from which to request régions data.
  • Allowed values: String
  • Note: For faster but less accurate queries, you can use the “COG-CARTO-PE” version.
  • Steps: AdminExpressStep, FrenchZonesStep

ign.api_wfs_url

ign.contours_iris_directory

  • Description: Path to the directory where the Contours IRIS database is stored.
  • Allowed values: String representing a valid path to an existing directory
  • Note: The database can be downloaded from cartes.gouv.fr.The GPKG format is recommended. The 7z file needs to be extracted.
  • Steps: FrenchZonesStep, IRISStep

joint_travel.external_model

  • Description: Path to a .joblib file with the classifier for joint tours.
  • Allowed values: String representing a valid path to an existing file
  • Steps: ExternalJointToursClassifierStep

joint_travel.features

  • Description: List of variables to use in the model.
  • Allowed values: List of String
  • Note: Variables should be available in SurveyedToursFile.
  • Steps: EstimateJointToursClassifierStep

joint_travel.model

  • Description: ML model to use as classifier.
  • Allowed values: String
  • Note: If no model is specified, multiple classifiers are run and the best one is selected.
  • Steps: EstimateJointToursClassifierStep

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 'DrawnNestedLogit', 'Deterministic', 'DrawnLogit', 'Logit'
  • Steps: PrepareMetroAgentsStep

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: PrepareMetroAgentsStep

mode_classifier.external_model

  • Description: Path to a .joblib file with the classifier for modes.
  • Allowed values: String representing a valid path to an existing file
  • Steps: ExternalModeClassifierStep

mode_classifier.features

  • Description: List of variables to use in the model.
  • Allowed values: List of String
  • Note: Variables should be available in SurveyedToursFile.
  • Steps: EstimateModeClassifierStep

mode_classifier.group_car_driver_modes

  • Description: If true, all car-driver modes are grouped in a single category.
  • Allowed values: Boolean
  • Steps: EstimateModeClassifierStep

mode_classifier.model

  • Description: ML model to use as classifier.
  • Allowed values: String
  • Note: If no model is specified, multiple classifiers are run and the best one is selected.
  • Steps: EstimateModeClassifierStep

mode_classifier.modes

  • Description: Valid modes to be used in the model.
  • Allowed values: List of String
  • Note: If not specified, all modes are used.
  • Steps: EstimateModeClassifierStep

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

od_matrix.edge_weights

  • Description: Probability weights of edges when drawing origins / destinations.
  • Allowed values: a number (constant weight for all edges), a table with edge types as keys and weights as values, or a table with “urban” and “rural” as keys and edge_type->value tables as values (see example)
  • Example:
[od_matrix.edge_weights]
[od_matrix.edge_weights.urban]
motorway = 4
road = 2
[od_matrix.edge_weights.rural]
motorway = 4
road = 3
  • Note: Only used when origins / destinations are drawn along road edges (i.e., zone_level is set and use_centroid is false). The probability that an edge is used as origin / destination for a trip is proportional to weight * length_in_zone where length_in_zone is the length of the edge within the current zone. Edges with larger weights are more likely to be selected as origin / destination. Actual origins / destinations are then set to a random point drawn along the selected edge. Edges with 0 weight cannot be selected as origin / destination, unless all edges in the zone have zero-weight, in which case all edges in the zone are equally likely to be selected. Default is to use a weight of 1 for all edges.
  • Steps: CustomODMatrixStep, GravityODMatrixStep, 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 zone / node), destination (id of destination zone / node), and size (int or float, number of trips).
  • Steps: CustomODMatrixStep

od_matrix.gravity.exponential_decay

  • Description: Exponential decay rate of flows as a function of distance (rate per kilometers).
  • Allowed values: Float
  • Steps: GravityODMatrixStep

od_matrix.gravity.trips_per_origin

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

od_matrix.max_edges_per_zone

  • Description: Maximum number of edges that can be used as origin / destination in each zone.
  • Allowed values: Integer not smaller than 1
  • Note: Only used when origins / destinations are drawn along road edges (i.e., zone_level is set and use_centroid is false). Default is to allow an unlimited number of edges per zone.
  • Steps: CustomODMatrixStep, GravityODMatrixStep, ODMatrixEachStep

od_matrix.trips_per_pair

  • 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.use_centroid

  • Description: If true, origin / destination coordinates are set to the centroid of the zone.
  • Allowed values: Boolean
  • Note: Ignored when zone_level is NULL, in which case origin / destination coordinates are always the road nodes’ coordinates.
  • Steps: CustomODMatrixStep, GravityODMatrixStep, ODMatrixEachStep

od_matrix.zone_level

  • Description: Zone level (1-5) used by the origin-destination matrix.
  • Allowed values: Integer between 1 and 5
  • Note: When set to NULL (default), one zone is defined for each node of the road network. It is discouraged to do so with a large network (> 10k nodes). Similarly, it is recommended to use a zone level with fewer than 10k nodes.
  • Steps: CustomODMatrixStep, GravityODMatrixStep, ODMatrixEachStep

od_matrix.zone_regex

  • Description: Regular expression specifying the zones to be selected as possible origin / destination.
  • Allowed values: String
  • Note: If not specified, any zone can be an origin / destination. If zone_level is NULL, the regex applies to the road nodes instead.
  • Steps: CustomODMatrixStep, GravityODMatrixStep, ODMatrixEachStep

od_matrix_travel_times.congested_zones_levels

  • Description: Zones levels for which OD congested travel times are computed.
  • Allowed values: List of Integer [at most 5 elements]
  • Example: [3, 4]
  • Steps: ZonesODCongestedTravelTimesStep

od_matrix_travel_times.free_flow_zones_levels

  • Description: Zones levels for which OD free-flow travel times are computed.
  • Allowed values: List of Integer between 1 and 5 [at most 5 elements]
  • Example: [3, 4]
  • Steps: ZonesODFreeFlowTravelTimesStep

od_matrix_travel_times.time_window

  • Description: Time window over which the congested travel time is aggregated.
  • Allowed values: List of Time [exactly 2 elements]
  • Example: [06:00:00, 09:00:00]
  • Steps: ZonesODCongestedTravelTimesStep

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.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 'custom_arrival', 'arrival', 'tstar', 'departure', 'custom_departure'
  • 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.reindex

  • Description: If true, the edges are re-index from 1 to n. If false, edge ids match the OpenStreetMap way ids.
  • Allowed values: Boolean
  • 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.reindex

  • Description: If true, the edges are re-index from 1 to n. If false, edge ids match the OpenStreetMap way ids.
  • Allowed values: Boolean
  • 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.reindex

  • Description: If true, the edges are re-index from 1 to n. If false, edge ids match the OpenStreetMap way ids.
  • Allowed values: Boolean
  • 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: ImportTripCoordinatesStep

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.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 'departure', 'custom'
  • 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

road_network.free_flow_penalties.additive_lower_bound

road_network.free_flow_penalties.additive_upper_bound

road_network.free_flow_penalties.multiplicative_lower_bound

  • Description: Lower bound (inclusive) to the multiplicative penalty for each edge.
  • Allowed values: Float not smaller than 0.0
  • Steps: EdgePenaltiesFromCoefficientsStep

road_network.free_flow_penalties.multiplicative_upper_bound

  • Description: Upper bound (inclusive) to the multiplicative penalty for each edge.
  • Allowed values: Float not smaller than 0.0
  • Steps: EdgePenaltiesFromCoefficientsStep

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.max_effective_speed

  • Description: Upper bound to the effective speed (in km/h) of edges, after application of multiplicative penalties.
  • Allowed values: Float not smaller than 1e-08
  • Steps: EdgesFreeFlowTravelTimesStep

road_network.min_effective_speed

  • Description: Lower bound to the effective speed (in km/h) of edges, after application of multiplicative penalties.
  • Allowed values: Float not smaller than 1e-08
  • Steps: EdgesFreeFlowTravelTimesStep

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.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

road_network.speed_multiplier

  • Description: By how much edge speed limit must be multiplied to get edge free-flow speed.
  • Allowed values: float (constant multiplier for all edges), table with edge types as keys and multiplier as values, or table with “urban” and “rural” as keys and edge_type->value` tables as values (see example)
  • Example:
[road_network.speed_multiplier]
[road_network.speed_multiplier.urban]
motorway = 0.9
road = 0.8
[road_network.speed_multiplier.rural]
motorway = 1.0
road = 0.9

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.node_order_reuse_threshold

  • Description: Threshold for expected edge TTFs RMSE above which node ordering is recomputed at next iteration.
  • Allowed values: Duration
  • Note: Edge TTFs RMSE is the RMSE of the difference between expected edge-level road travel times at the previous and current iteration.
  • Steps: WriteMetroParametersStep

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 'Intersect', 'Best', 'TCH'
  • 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

survey.mobisurvstd.bulk

  • Description: If true, all surveys in the provided directory are read in bulk and concatenated.
  • Allowed values: Boolean
  • Steps: MobiSurvStdImportStep

survey.mobisurvstd.path

  • Description: Path to a directory or zipfile containing a survey supported by MobiSurvStd.
  • Allowed values: String representing a valid path
  • Steps: MobiSurvStdImportStep

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

tomtom_requests.api_key

  • Description: Key for the TomTom API.
  • Allowed values: String
  • Note: You need to generate your own API key on the my.tomtom.com portal. You can use the "secret:tomtom_api_key" syntax to keep the key secret when sharing your configuration TOML file.
  • Steps: TomTomRequestsStep

tomtom_requests.date

  • Description: Date to be used for the requests.
  • Allowed values: Date
  • Note: It is recommended to set a date a few months in the future, on a weekday, so that TomTom does not rely of real time data and roadworks.
  • Steps: TomTomRequestsStep

tomtom_requests.departure_time

  • Description: Departure time to be used for the requests.
  • Allowed values: Time
  • Note: This parameter only controls the departure time from origin, not from the intermediate stops. When not specified, a random departure time is chosen for each request.
  • Steps: TomTomRequestsStep

tomtom_requests.excluded_edge_types

  • Description: List of edge types that are excluded from the network when selecting origin-destination pairs.
  • Allowed values: List of String
  • Example: ["motorway", "motorway_link", "trunk", "trunk_link"]
  • Note: It is recommended to exclude major highways so that minor roads are more likely to beobserved (major highways will be part of most fastest paths anyway).
  • Steps: TomTomRequestsStep

tomtom_requests.map_matching.relative_length_threshold

  • Description: Maximum relative difference allowed between TomTom route’s length and actual length on network.
  • Allowed values: Float
  • Note: A value of 0.01 means that routes for which the length of the matched path on the road-network differs by more than 1% compared to the length of the TomTom route will be excluded.
  • Steps: MapMatchingStep

tomtom_requests.map_matching.search_radius

  • Description: Search radius, in meters.
  • Allowed values: Float
  • Note: Larger values are more likely to result in a positive match but increase running time.Recommended value is between 30 and 200.
  • Steps: MapMatchingStep

tomtom_requests.nb_batches

  • Description: Number of batches to be computed in parallel.
  • Allowed values: Integer
  • Note: Ideally, the value should be the number of threads that you want to use. If the value is too large, TomTom API might complain about exceeding the number of requests per second.
  • Steps: TomTomRequestsStep

tomtom_requests.nb_routes

  • Description: Number of routes to request.
  • Allowed values: Integer
  • Example: 2000
  • Note: Free TomTom API is limiting the daily number of requests to 2500.
  • Steps: TomTomRequestsStep

tomtom_requests.nb_waypoints

  • Description: Number of waypoints (intermediate stops) to use for each request.
  • Allowed values: Integer not larger than 148
  • Note: The number of OD pairs per route is equal to the number of waypoints plus 1, so that the total number of OD pairs is equal to nb_routes * (nb_waypoints + 1). TomTom API is limiting the number of waypoints to 148.
  • Steps: TomTomRequestsStep

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: PrepareMetroTripsStep, WriteMetroVehicleTypesStep

zones.custom_files.level1

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

zones.custom_files.level2

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

zones.custom_files.level3

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

zones.custom_files.level4

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

zones.custom_files.level5

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

zones.france

zones.weiszfeld.max_iter

zones.weiszfeld.threshold