Chapter 17.2: OSMnx → SUMO Pipeline

17.2.1 Complete Pipeline Architecture

Building a SUMO simulation from real-world data involves four stages: network acquisition, network conversion, demand generation, and simulation execution. Each stage transforms data from one representation to the next.

Stage 1: NETWORK ACQUISITION
  OSMnx.graph_from_place("City, Country")  →  graph G
  ox.save_graph_xml(G, "city.osm.xml")     →  city.osm.xml

Stage 2: NETWORK CONVERSION
  netconvert --osm-files city.osm.xml      →  city.net.xml
    --output-file city.net.xml
    --junctions.join
    --roundabouts.guess
    --tls.guess
    --geometry.remove
    --ramps.guess

Stage 3: DEMAND GENERATION
  randomTrips.py -n city.net.xml           →  city.rou.xml
    -r city.rou.xml
    -e 3600
    --period 2
    --fringe-factor 5
    --validate

Stage 4: SIMULATION
  sumo -c city.sumocfg                     →  outputs
    --emission-output emission.xml
    --fcd-output fcd.xml
    --queue-output queue.xml

17.2.2 netconvert: Critical Flags

The netconvert tool translates OpenStreetMap data into SUMO’s internal network format. Several flags are essential for producing a usable network:

Flag	Purpose	Why Needed
--junctions.join	Merge nearby junctions	OSM often has multiple nodes for one intersection
--roundabouts.guess	Detect roundabouts	Proper priority/right-of-way rules
--tls.guess	Infer traffic lights	OSM tagging is inconsistent
--geometry.remove	Simplify edge geometry	Reduces file size, speeds simulation
--ramps.guess	Detect highway ramps	Correct merge/diverge behaviour
--no-turnarounds	Disable U-turns	Often unrealistic at signalised intersections

17.2.3 Demand Generation

SUMO’s randomTrips.py generates vehicle departures with origin-destination pairs drawn from the network:

--period p: one vehicle every $p$ seconds (flow rate = 1/p veh/s)
--fringe-factor f: weight edges on the network boundary by factor $f$, simulating through-traffic
--weights-prefix w: load OD weights from files for realistic demand patterns
--validate: discard trips with no valid route

For more realistic demand, an origin-destination (OD) matrix can be used. The OD matrix $T_{ij}$ specifies the number of trips from zone $i$ to zone $j$ per time period:

$$Q_{\text{total}} = \sum_{i,j} T_{ij}, \qquad \text{period} = \frac{T_{\text{sim}}}{Q_{\text{total}}}$$

17.2.4 SUMO Output Files

SUMO produces several output formats, each serving a different analysis purpose:

Emission Output (emission.xml)

<emission-export>
  <timestep time="10.00">
    <vehicle id="veh_0" eclass="HBEFA3/PC_G_EU4"
             CO2="3456.78" CO="12.34" HC="0.56"
             NOx="1.23" PMx="0.045"
             speed="8.33" pos="83.3" lane="edge_0_0"/>
  </timestep>
</emission-export>

Floating Car Data (fcd.xml)

<fcd-export>
  <timestep time="10.00">
    <vehicle id="veh_0" x="456.78" y="123.45"
             angle="90.0" speed="8.33" pos="83.3"
             lane="edge_0_0" slope="0.00"/>
  </timestep>
</fcd-export>

Queue Output (queue.xml)

<queue-export>
  <data timestep="10.00">
    <lanes>
      <lane id="edge_0_0" queueing_time="12.5"
            queueing_length="45.0"
            queueing_length_experimental="42.3"/>
    </lanes>
  </data>
</queue-export>

17.2.5 TraCI Integration: Signal Control + Pollution

The following script demonstrates a ready-to-use TraCI connection that combines Module 13 signal control with Module 16 pollution estimation. It can be run directly with a SUMO installation, but the structure is shown here for reference.

#!/usr/bin/env python3
"""TraCI controller integrating signal control (Module 13) and OSPM (Module 16)."""
import traci
import numpy as np

class TraCIController:
    def __init__(self, sumo_cfg, canyon_params):
        self.sumo_cfg = sumo_cfg
        self.canyon = canyon_params  # dict: edge_id -> {H, W, alpha}
        self.step = 0

    def connect(self):
        traci.start(["sumo", "-c", self.sumo_cfg])

    def get_edge_emissions(self, edge_id):
        """Get total NOx emissions on an edge (mg/s)."""
        vehicles = traci.edge.getLastStepVehicleIDs(edge_id)
        total_nox = sum(traci.vehicle.getNOxEmission(v) for v in vehicles)
        return total_nox

    def ospm_concentration(self, edge_id, nox_emission):
        """Compute OSPM concentration for a canyon edge."""
        p = self.canyon.get(edge_id, {"H": 15, "W": 20})
        alpha = p["H"] / p["W"]
        length = traci.edge.getLastStepLength(edge_id)

        q_L = nox_emission / max(length, 1.0)  # mg/m/s
        u_H = 5.0; kappa = 0.41; C_D = 0.005
        u_v = C_D * u_H / ((1 + alpha) * kappa)
        u_s = max(u_v * 0.5, 0.3)

        C_D_conc = q_L / (np.sqrt(2*np.pi) * 0.8 * u_s)
        L_R = min(p["W"], p["H"])
        C_R = q_L * L_R / (u_v * p["W"] * p["H"]) * 2.0
        return C_D_conc + C_R + 25.0

    def pmp_signal_update(self, tls_id, concentrations):
        """Pontryagin signal control (Module 13) with pollution penalty."""
        queues = []
        for phase_idx in range(4):
            controlled_lanes = traci.trafficlight.getControlledLanes(tls_id)
            q = sum(traci.lane.getLastStepHaltingNumber(l)
                    for l in controlled_lanes[phase_idx::4])
            queues.append(q)

        # Optimal phase: minimise queue + lambda * concentration
        lam = 0.1  # pollution weight
        best_phase = np.argmin(queues)  # simplified
        return best_phase

    def run(self, n_steps=3600):
        self.connect()
        for _ in range(n_steps):
            traci.simulationStep()
            # ... apply control logic each step
            self.step += 1
        traci.close()

17.2.6 Python: Build .net.xml and .rou.xml

This code generates valid SUMO network and route files programmatically without requiring a SUMO installation. It creates a simple grid network and random vehicle routes.

Build SUMO Network & Routes Programmatically

Python

script.py237 lines

import numpy as np
import matplotlib.pyplot as plt
import xml.etree.ElementTree as ET

# ─── Generate a grid network as .net.xml ───
def build_grid_network(rows=4, cols=4, block_size=200):
    """Build a SUMO-compatible grid network XML."""
    nodes = []
    edges = []

# Create nodes
    for r in range(rows):
        for c in range(cols):
            node_id = f"n_{r}_{c}"
            x = c * block_size
            y = r * block_size
            tl = "true" if (r > 0 and r < rows-1 and c > 0 and c < cols-1) else "false"
            nodes.append({"id": node_id, "x": x, "y": y, "tl": tl})

# Create edges (horizontal and vertical, bidirectional)
    edge_id = 0
    for r in range(rows):
        for c in range(cols):
            if c < cols - 1:  # horizontal
                edges.append({
                    "id": f"e_{edge_id}", "from": f"n_{r}_{c}", "to": f"n_{r}_{c+1}",
                    "numLanes": 2, "speed": 13.89, "length": block_size
                })
                edge_id += 1
                edges.append({
                    "id": f"e_{edge_id}", "from": f"n_{r}_{c+1}", "to": f"n_{r}_{c}",
                    "numLanes": 2, "speed": 13.89, "length": block_size
                })
                edge_id += 1
            if r < rows - 1:  # vertical
                edges.append({
                    "id": f"e_{edge_id}", "from": f"n_{r}_{c}", "to": f"n_{r+1}_{c}",
                    "numLanes": 2, "speed": 13.89, "length": block_size
                })
                edge_id += 1
                edges.append({
                    "id": f"e_{edge_id}", "from": f"n_{r+1}_{c}", "to": f"n_{r}_{c}",
                    "numLanes": 2, "speed": 13.89, "length": block_size
                })
                edge_id += 1

return nodes, edges

rows, cols = 5, 5
block_size = 200
nodes, edges = build_grid_network(rows, cols, block_size)

print(f"Generated grid network: {len(nodes)} nodes, {len(edges)} edges")
print(f"Grid: {rows}x{cols}, block size: {block_size}m")
print()

# ─── Generate .net.xml content (simplified) ───
net_xml = '<?xml version="1.0" encoding="UTF-8"?>\n'
net_xml += '<net version="1.16">\n'
for n in nodes:
    tl_attr = f' type="traffic_light"' if n["tl"] == "true" else ' type="priority"'
    net_xml += f'  <junction id="{n["id"]}" x="{n["x"]}" y="{n["y"]}"{tl_attr}/>\n'
for e in edges:
    net_xml += f'  <edge id="{e["id"]}" from="{e["from"]}" to="{e["to"]}" '
    net_xml += f'numLanes="{e["numLanes"]}" speed="{e["speed"]}"/>\n'
net_xml += '</net>\n'

print("─── .net.xml (first 500 chars) ───")
print(net_xml[:500])
print()

# ─── Generate routes ───
np.random.seed(42)
n_vehicles = 200
departure_times = sorted(np.random.uniform(0, 3600, n_vehicles))

# Build adjacency for path finding
from collections import defaultdict
adj = defaultdict(list)
edge_lookup = {}
for e in edges:
    adj[e["from"]].append((e["to"], e["id"]))
    edge_lookup[(e["from"], e["to"])] = e["id"]

def bfs_path(start, end):
    """Find a path from start to end node."""
    from collections import deque
    queue = deque([(start, [start])])
    visited = {start}
    while queue:
        node, path = queue.popleft()
        if node == end:
            return path
        for neighbor, eid in adj[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append((neighbor, path + [neighbor]))
    return None

# Generate random trips
node_ids = [n["id"] for n in nodes]
boundary_nodes = [n["id"] for n in nodes
                  if "0" in n["id"].split("_")[1:] or
                  str(rows-1) in n["id"].split("_")[1:] or
                  str(cols-1) in n["id"].split("_")[1:]]

routes = []
for i in range(n_vehicles):
    origin = np.random.choice(boundary_nodes)
    dest = np.random.choice(boundary_nodes)
    while dest == origin:
        dest = np.random.choice(boundary_nodes)

path = bfs_path(origin, dest)
    if path and len(path) > 1:
        edge_ids = []
        for j in range(len(path) - 1):
            eid = edge_lookup.get((path[j], path[j+1]))
            if eid:
                edge_ids.append(eid)
        if edge_ids:
            routes.append({
                "id": f"veh_{i}",
                "depart": f"{departure_times[i]:.2f}",
                "edges": " ".join(edge_ids)
            })

# Build .rou.xml
rou_xml = '<?xml version="1.0" encoding="UTF-8"?>\n<routes>\n'
rou_xml += '  <vType id="car" accel="2.6" decel="4.5" sigma="0.5" length="5" maxSpeed="13.89"/>\n'
for r in routes:
    rou_xml += f'  <vehicle id="{r["id"]}" type="car" depart="{r["depart"]}">\n'
    rou_xml += f'    <route edges="{r["edges"]}"/>\n'
    rou_xml += f'  </vehicle>\n'
rou_xml += '</routes>\n'

print(f"Generated {len(routes)} valid routes out of {n_vehicles} attempts")
print()
print("─── .rou.xml (first 500 chars) ───")
print(rou_xml[:500])
print()

# ─── Generate .sumocfg ───
sumocfg = """<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <input>
        <net-file value="grid.net.xml"/>
        <route-files value="grid.rou.xml"/>
    </input>
    <time>
        <begin value="0"/>
        <end value="3600"/>
        <step-length value="0.5"/>
    </time>
    <output>
        <emission-output value="emission.xml"/>
        <fcd-output value="fcd.xml"/>
        <queue-output value="queue.xml"/>
    </output>
</configuration>"""
print("─── .sumocfg ───")
print(sumocfg)
print()

# ─── Visualise network ───
fig, ax = plt.subplots(1, 1, figsize=(10, 10))
fig.patch.set_facecolor("#0f172a")

# Draw edges
for e in edges:
    n_from = next(n for n in nodes if n["id"] == e["from"])
    n_to = next(n for n in nodes if n["id"] == e["to"])
    ax.plot([n_from["x"], n_to["x"]], [n_from["y"], n_to["y"]],
            color="#334155", linewidth=2, alpha=0.5)

# Draw nodes
for n in nodes:
    color = "#10b981" if n["tl"] == "true" else "#64748b"
    size = 80 if n["tl"] == "true" else 40
    ax.scatter(n["x"], n["y"], color=color, s=size, zorder=5)

# Draw some routes
np.random.seed(0)
colors = plt.cm.cool(np.linspace(0, 1, min(20, len(routes))))
for idx, r in enumerate(routes[:20]):
    edge_ids = r["edges"].split()
    xs, ys = [], []
    for eid in edge_ids:
        e = next(e for e in edges if e["id"] == eid)
        n_from = next(n for n in nodes if n["id"] == e["from"])
        n_to = next(n for n in nodes if n["id"] == e["to"])
        if not xs:
            xs.append(n_from["x"])
            ys.append(n_from["y"])
        xs.append(n_to["x"])
        ys.append(n_to["y"])
    # Offset for visibility
    offset = (idx - 10) * 2
    ax.plot([x + offset for x in xs], [y + offset for y in ys],
            color=colors[idx], linewidth=1.5, alpha=0.7)

ax.set_title("Generated Grid Network + Sample Routes", color="white", fontsize=14, fontweight="bold")
ax.set_xlabel("x (m)", color="white")
ax.set_ylabel("y (m)", color="white")
ax.set_facecolor("#0f172a")
ax.tick_params(colors="gray")
ax.set_aspect("equal")
for spine in ax.spines.values():
    spine.set_color("#334155")

# Legend
ax.scatter([], [], color="#10b981", s=80, label="Traffic Light")
ax.scatter([], [], color="#64748b", s=40, label="Priority Junction")
ax.legend(fontsize=10, facecolor="#1e293b", edgecolor="#334155", labelcolor="white")

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

# ─── netconvert command reference ───
print("─── netconvert Command Sequence ───")
print("# Step 1: Download network with OSMnx")
print("# python3 script: import osmnx as ox")
print("#   G = ox.graph_from_place('Manhattan, NYC')")
print("#   ox.save_graph_xml(G, 'manhattan.osm.xml')")
print()
print("# Step 2: Convert to SUMO network")
print("netconvert --osm-files manhattan.osm.xml \\")
print("  --output-file manhattan.net.xml \\")
print("  --junctions.join --roundabouts.guess --tls.guess \\")
print("  --geometry.remove --ramps.guess --no-turnarounds")
print()
print("# Step 3: Generate demand")
print("python3 $SUMO_HOME/tools/randomTrips.py \\")
print("  -n manhattan.net.xml -r manhattan.rou.xml \\")
print("  -e 3600 --period 2 --fringe-factor 5 --validate")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

17.2.7 Key Takeaways

The pipeline OSMnx → netconvert → randomTrips.py → SUMO provides a complete path from real-world maps to microscopic simulation.
Critical netconvert flags (--junctions.join, --tls.guess, --roundabouts.guess) are essential for converting noisy OSM data into a valid simulation network.
Demand generation via randomTrips.py with --fringe-factor produces realistic through-traffic patterns; OD matrices provide higher fidelity.
TraCI enables real-time coupling between SUMO and external controllers, including Module 13 signal optimisation and Module 16 pollution estimation.
All SUMO input/output files are XML-based, making them straightforward to generate and parse programmatically.

← SUMO Architecture SUMO-Canyon Coupling →