Chapter 17.1: SUMO Architecture

17.1.1 The SUMO Simulation Pipeline

SUMO (Simulation of Urban MObility) is an open-source, microscopic traffic simulation package developed by the German Aerospace Center (DLR). It simulates individual vehicles with sub-second time resolution on networks of arbitrary complexity. The full pipeline from real-world map data to simulation outputs is:

OSMnx (Python)        → download OpenStreetMap network as .osm.xml
  ↓
netconvert (SUMO)     → convert to SUMO .net.xml (topology + geometry)
  ↓
randomTrips.py (SUMO) → generate demand as .rou.xml (vehicle routes)
  ↓
sumo / sumo-gui       → run simulation
  ↓
TraCI (TCP)           → real-time control interface
  ↓
Outputs               → emission.xml, fcd.xml, queue.xml, tripinfo.xml

Each component is modular. The network can come from any source (OSM, Shapefile, VISUM). Demand can be generated from origin-destination matrices, count data, or real GPS traces. TraCI (Traffic Control Interface) provides a TCP socket through which external programs can query and modify the simulation state at every timestep.

Key File Formats

File	Extension	Contents
Network	.net.xml	Edges, lanes, junctions, connections, traffic lights
Routes	.rou.xml	Vehicle types, routes, departure times
Configuration	.sumocfg	Simulation parameters, input/output paths
Emissions	emission.xml	Per-vehicle CO2, NOx, PMx at each timestep
Floating Car Data	fcd.xml	Vehicle positions, speeds, angles at each timestep

17.1.2 Krauss Car-Following Model

SUMO’s default car-following model is the Krauss model, a stochastic extension of the Gipps model. At each simulation step, the vehicle computes a safe velocity $v_{\text{safe}}$ that prevents collision under worst-case deceleration of the leader:

$$v_{\text{safe}} = v_{\text{lead}} + \frac{g - v_{\text{lead}}\,\tau}{v/b + \tau}$$

where:

$v_{\text{lead}}$: speed of the leading vehicle
$g$: bumper-to-bumper gap
$\tau$: driver reaction time (default 1.0 s)
$b$: maximum deceleration (default 4.5 m/s²)
$v$: current speed of the following vehicle

The desired velocity is then:

$$v_{\text{des}} = \min(v_{\max}, v + a\,\Delta t, v_{\text{safe}})$$

The Krauss model adds stochastic dawdling: the actual velocity is $v_{\text{actual}} = \max(0, v_{\text{des}} - \eta)$, where $\eta \sim \text{Uniform}(0, \sigma\,a\,\Delta t)$ and $\sigma \in [0,1]$ is the imperfection parameter.

17.1.3 Intelligent Driver Model (IDM)

The IDM (Treiber, Hennecke & Helbing, 2000) is a continuous-time car-following model widely used in traffic research. The acceleration is:

$$\frac{dv}{dt} = a\left[1 - \left(\frac{v}{v_0}\right)^\delta - \left(\frac{s^*(v, \Delta v)}{s}\right)^2\right]$$

where the desired gap function is:

$$s^*(v, \Delta v) = s_0 + v\,T + \frac{v\,\Delta v}{2\sqrt{a\,b}}$$

IDM parameters and their typical values:

Parameter	Symbol	Typical Value	Meaning
Desired speed	$v_0$	33.3 m/s (120 km/h)	Free-flow desired speed
Time headway	$T$	1.5 s	Desired time gap to leader
Min gap	$s_0$	2.0 m	Jam distance
Acceleration	$a$	1.4 m/s²	Maximum comfortable acceleration
Deceleration	$b$	2.0 m/s²	Comfortable deceleration
Exponent	$\delta$	4	Free-flow acceleration exponent

17.1.4 HBEFA Emission Model

SUMO integrates the Handbook Emission Factors for Road Transport (HBEFA) through the PHEMlight engine. For each vehicle at each timestep, emissions are computed from the instantaneous speed $v$ and acceleration $a$:

$$P_{\text{norm}} = \frac{v \cdot (F_{\text{roll}} + F_{\text{air}} + F_{\text{accel}})}{P_{\text{rated}}}$$

where the forces are:

Rolling resistance: $F_{\text{roll}} = c_r \cdot m \cdot g$
Aerodynamic drag: $F_{\text{air}} = \tfrac{1}{2}\rho_a c_d A_f v^2$
Inertial force: $F_{\text{accel}} = m \cdot a$

Emission rates (g/s) are then interpolated from lookup tables indexed by $P_{\text{norm}}$ for each pollutant species (CO₂, NOₓ, PMₓ, CO, HC). The key insight: emissions peak during acceleration events (high $P_{\text{norm}}$), making stop-and-go traffic far dirtier than free flow.

17.1.5 Python: Krauss vs IDM Car-Following

We implement both models from scratch and simulate a platoon of vehicles following a leader with a velocity perturbation. The spacing-velocity fundamental diagrams are compared.

Krauss vs IDM Car-Following Simulation

Python

script.py178 lines

import numpy as np
import matplotlib.pyplot as plt

# ─── Simulation Parameters ───
dt = 0.1        # time step (s)
T_sim = 120     # total time (s)
N_steps = int(T_sim / dt)
N_veh = 10      # vehicles in platoon
L_veh = 5.0     # vehicle length (m)

# ─── Krauss Parameters ───
krauss = {
    "v_max": 13.9,   # 50 km/h
    "a_max": 2.6,
    "b_max": 4.5,
    "tau": 1.0,
    "sigma": 0.5,    # imperfection
    "min_gap": 2.5
}

# ─── IDM Parameters ───
idm = {
    "v0": 13.9,     # desired speed
    "T": 1.5,       # time headway
    "s0": 2.0,      # min gap
    "a": 1.4,       # max accel
    "b": 2.0,       # comfortable decel
    "delta": 4
}

# ─── Leader trajectory (perturbation) ───
t = np.arange(N_steps) * dt
v_leader = np.ones(N_steps) * 10.0
# Braking event at t=20-30s, then recovery
v_leader[int(20/dt):int(25/dt)] = np.linspace(10, 3, int(5/dt))
v_leader[int(25/dt):int(35/dt)] = np.linspace(3, 10, int(10/dt))
x_leader = np.cumsum(v_leader) * dt

# ─── Krauss Simulation ───
x_k = np.zeros((N_veh, N_steps))
v_k = np.zeros((N_veh, N_steps))
# Initial positions (equally spaced)
for i in range(N_veh):
    x_k[i, 0] = -(i + 1) * (L_veh + krauss["min_gap"] + 10)
    v_k[i, 0] = 10.0

for step in range(1, N_steps):
    for i in range(N_veh):
        if i == 0:
            x_ahead = x_leader[step - 1]
            v_ahead = v_leader[step - 1]
        else:
            x_ahead = x_k[i-1, step-1]
            v_ahead = v_k[i-1, step-1]

gap = x_ahead - x_k[i, step-1] - L_veh
        gap = max(gap, 0.1)
        v_curr = v_k[i, step-1]

# Safe velocity
        denom = v_curr / krauss["b_max"] + krauss["tau"]
        if denom > 0:
            v_safe = v_ahead + (gap - v_ahead * krauss["tau"]) / denom
        else:
            v_safe = v_curr

v_des = min(krauss["v_max"], v_curr + krauss["a_max"] * dt, v_safe)

# Stochastic dawdling
        eta = np.random.uniform(0, krauss["sigma"] * krauss["a_max"] * dt)
        v_new = max(0, v_des - eta)
        v_k[i, step] = v_new
        x_k[i, step] = x_k[i, step-1] + v_new * dt

# ─── IDM Simulation ───
x_idm = np.zeros((N_veh, N_steps))
v_idm = np.zeros((N_veh, N_steps))
for i in range(N_veh):
    x_idm[i, 0] = -(i + 1) * (L_veh + idm["s0"] + 10)
    v_idm[i, 0] = 10.0

for step in range(1, N_steps):
    for i in range(N_veh):
        if i == 0:
            x_ahead = x_leader[step - 1]
            v_ahead = v_leader[step - 1]
        else:
            x_ahead = x_idm[i-1, step-1]
            v_ahead = v_idm[i-1, step-1]

gap = max(x_ahead - x_idm[i, step-1] - L_veh, 0.1)
        v_curr = v_idm[i, step-1]
        delta_v = v_curr - v_ahead

s_star = idm["s0"] + v_curr * idm["T"] + v_curr * delta_v / (2 * np.sqrt(idm["a"] * idm["b"]))
        s_star = max(s_star, idm["s0"])

accel = idm["a"] * (1 - (v_curr / idm["v0"])**idm["delta"] - (s_star / gap)**2)
        v_new = max(0, v_curr + accel * dt)
        v_idm[i, step] = v_new
        x_idm[i, step] = x_idm[i, step-1] + v_new * dt

# ─── Figure 1: Time-space trajectories ───
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))
fig.patch.set_facecolor("#0f172a")

# Krauss trajectories
ax1.plot(t, x_leader, color="white", linewidth=2, label="Leader")
for i in range(N_veh):
    ax1.plot(t, x_k[i], linewidth=1.2, alpha=0.8)
ax1.set_xlabel("Time (s)", color="white", fontsize=12)
ax1.set_ylabel("Position (m)", color="white", fontsize=12)
ax1.set_title("Krauss Model Trajectories", color="white", fontsize=13, fontweight="bold")
ax1.set_facecolor("#0f172a")
ax1.tick_params(colors="gray")
ax1.grid(True, alpha=0.2, color="#334155")
for spine in ax1.spines.values():
    spine.set_color("#334155")

# IDM trajectories
ax2.plot(t, x_leader, color="white", linewidth=2, label="Leader")
for i in range(N_veh):
    ax2.plot(t, x_idm[i], linewidth=1.2, alpha=0.8)
ax2.set_xlabel("Time (s)", color="white", fontsize=12)
ax2.set_ylabel("Position (m)", color="white", fontsize=12)
ax2.set_title("IDM Trajectories", color="white", fontsize=13, fontweight="bold")
ax2.set_facecolor("#0f172a")
ax2.tick_params(colors="gray")
ax2.grid(True, alpha=0.2, color="#334155")
for spine in ax2.spines.values():
    spine.set_color("#334155")

plt.tight_layout()
plt.savefig("output.png", dpi=120, bbox_inches="tight", facecolor="#0f172a")
plt.close()

# ─── Figure 2: Spacing-Velocity Fundamental Diagram ───
fig2, (ax3, ax4) = plt.subplots(1, 2, figsize=(14, 6))
fig2.patch.set_facecolor("#0f172a")

# Compute spacings
for ax, x_data, v_data, title, color in [
    (ax3, x_k, v_k, "Krauss", "#10b981"),
    (ax4, x_idm, v_idm, "IDM", "#06b6d4")
]:
    all_gaps = []
    all_speeds = []
    for i in range(1, N_veh):
        gaps = x_data[i-1, :] - x_data[i, :] - L_veh
        speeds = v_data[i, :]
        all_gaps.extend(gaps[::10])
        all_speeds.extend(speeds[::10])

ax.scatter(all_gaps, all_speeds, s=2, alpha=0.3, color=color)
    ax.set_xlabel("Gap (m)", color="white", fontsize=12)
    ax.set_ylabel("Speed (m/s)", color="white", fontsize=12)
    ax.set_title(f"{title}: Spacing-Velocity Diagram", color="white", fontsize=13, fontweight="bold")
    ax.set_facecolor("#0f172a")
    ax.tick_params(colors="gray")
    ax.grid(True, alpha=0.2, color="#334155")
    ax.set_xlim(0, 80)
    ax.set_ylim(0, 15)
    for spine in ax.spines.values():
        spine.set_color("#334155")

plt.tight_layout()
plt.savefig("output.png", dpi=120, bbox_inches="tight", facecolor="#0f172a")
plt.close()

print("=== Car-Following Model Comparison ===")
print(f"Simulation: {N_veh} vehicles, {T_sim}s, dt = {dt}s")
print()
for name, v_data in [("Krauss", v_k), ("IDM", v_idm)]:
    print(f"─── {name} ───")
    print(f"  Mean speed (all vehicles): {v_data[:, N_steps//2:].mean():.2f} m/s")
    print(f"  Speed std (vehicle 5):     {v_data[4, :].std():.3f} m/s")
    print(f"  Min speed (vehicle 9):     {v_data[-1, :].min():.2f} m/s")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

17.1.6 Key Takeaways

SUMO simulates individual vehicles with Krauss (default) or IDM car-following, providing per-vehicle speed, position, and acceleration at sub-second resolution.
The Krauss safe velocity prevents collisions under reaction time delay; its stochastic dawdling reproduces realistic capacity drop.
IDM provides smooth, deterministic dynamics with physically interpretable parameters; the desired gap function $s^*$ depends on both speed and relative speed.
HBEFA/PHEMlight converts instantaneous (v, a) into emission rates, showing that stop-and-go driving produces far more pollution than steady-state flow.
The pipeline OSMnx → netconvert → SUMO → TraCI provides a complete, controllable simulation environment for urban traffic.

← Module 17 Overview OSMnx → SUMO Pipeline →

Parameter	Symbol	Typical Value	Meaning
Desired speed	\(v_0\)	33.3 m/s (120 km/h)	Free-flow desired speed
Time headway	\(T\)	1.5 s	Desired time gap to leader
Min gap	\(s_0\)	2.0 m	Jam distance
Acceleration	\(a\)	1.4 m/s²	Maximum comfortable acceleration
Deceleration	\(b\)	2.0 m/s²	Comfortable deceleration
Exponent	\(\delta\)	4	Free-flow acceleration exponent