San Pablo Dam

This tutorial describes the execution of the simulation in a loop using a control script. The aim is to calibrate the simulation to a given real-world dataset. This tutorial may be used for further research on car-following models or optimization algorithms.

It is assumed that road network building and routes definition is known from other tutorials, as Tutorials/Hello SUMO, Tutorials/quick start or Tutorials/Quick Start old style.

All files mentioned here can be found in the repository at <SUMO_HOME>/tests/complex/tutorial/san_pablo_dam/.

# Description#

Models for vehicle movement usually have several parameters which control the behavior of the vehicle. Their default values are usually set based on assumptions or measures or by adapting them to a given data set. When moving to a different scenario, they often have to be re-adapted so as to be valid. Due to this, calibration is a crucial step in preparing a traffic simulation scenario.

This tutorial shows one possibility to calibrate a car-following model to match a set of data gained from the real world. The data set we use was collected on the San Pablo Dam Road "from 6:45 a.m. to 9:00 a.m. on Tuesday, November 18 and again on Thursday, November 20, 1997" ([Smilowitz1999]). Please look here (OpenStreetMap) or here (GoogleMaps) for the location. The data set's pages are here. It was also used for benchmarking car-following models, see [Brockfeld2003a]. The data set consists of times at which vehicles pass count points and is assumed to be quite clean.

Having the passing times of vehicles, we want to calibrate our car-following model so that the difference between real and simulated travel times across all vehicles is minimized.

In order to obtain the passing times from the simulation, we use induction loops with a frequency of 1s. They are defined in "input_det.add.xml". Additionally, we use a variable speed sign for constraining the outflow velocity so that the original (real world) network's outflow condition is preserved.

## Prerequisites#

In order to execute this tutorial, you need

• a runnable SUMO simulation
• Python 2.x (tested with Python 2.7)
• SciPy

# Network Preparation#

Optimization requires several - many - iterations, and sumo's execution speed highly depends on the number of edges a network is made of. Due to this we model the San Pablo Dam Road using two edges only. We build an edge file, and a node file as already discussed in previous (Tutorials/Hello SUMO, Tutorials/Quick Start) tutorials.

# Demand Preparation#

We use the function genDemand in "runner.py" for building the demand. Here, times at observation point 1 are used as our vehicle departure times. The route consists of the two edges the network consists of. All vehicles have the same type. The values for this type - the car-following parameter to optimize - are documented in the function gof in "runner.py". Please note that we keep "minGap" at 2.5m constantly - this should be changed for other models than the used SUMO-Krauß-model. If desired, they may be set to the default parameter values before performing the calibration (see the end of runner.py).

# Simulation Settings#

Our configuration looks like this:

``````<configuration>
<input>
</input>
<time>
<begin value="24420"/>
</time>
<processing>
<time-to-teleport value="0"/>
</processing>
<report>
<no-duration-log value="true"/>
<no-step-log value="true"/>
</report>
</configuration>
``````

This means: we load the network from "spd-road.net.xml", routes from "spd-road.rou.xml", and three additional files, "input_vss.add.xml" including the variable speed sign, "input_det.add.xml" containing definitions of induction loops to simulate, and "input_types.add.xml" containing the definition of our current vehicle type. The begin time is set to the departure time of the first vehicle. We ignore possible waiting times by setting time-to-teleport to 0 and disable simulation outputs.

Please note that "spd-road.rou.xml" is created from the input measurements on the start of runner.py, "input_types.add.xml" is created on every simulation loop with the new parameters and all the other files are completely static.

# Calibration#

We use SciPy's "COBYLA" implementation. It requires callbacks for determining the error which we have to supply. Our callback (function `gof` in "runner.py") works as follows:

1. Write the current vehicle type with the parameters supported by the optimizer into a file named "input_types.add.xml"
2. Start the validation script "validate.py" and return the error value computed by it

The validation step, implemented in "validate.py" is not much more complicated:

1. Execute the simulation
2. Read the real-world observations and the vehicle crossing times from the simulation
3. Convert both from observation times to travel times
4. Compute the RMSE (root mean square error) between both for all vehicles and observation points and return it

# Execution#

In order to perform the calibration, you need to call only:

``````python runner.py
``````

This is what it is doing:

• calls the function buildVSS

Build the speed limits for the end boundary; generates "spd-road.vss.xml" which is referenced by "input_vss.add.xml"

• Starts the calibration

For each calibration step, the following output should appear:

``````# simulation with: vMax:22.000 aMax:2.000 bMax:2.000 lCar:5.000 sigA:0.500 tTau:1.500