Sionna–SUMO 3D Ray‑Tracing V2X Simulation

Code availability (for paper reuse): operational code + scenario assets for reproducing the SUMO↔Sionna RT trace-generation pipeline are available in this repository.

This repository provides an operational research pipeline for generating 3D ray‑tracing link metrics (e.g., RSSI / path-loss style traces, depending on the post‑processing implemented in the scripts) by coupling:

SUMO — microscopic traffic simulator (mobility + traffic flows), and
Sionna RT — 3D ray tracing for wireless propagation (scene + terrain meshes).

The repository is structured for reproducibility: scenarios are stored under scenarios/, and Python dependencies are pinned in requirements.txt.

What this repo is for

The intended usage is:

Select / prepare a scenario (SUMO configuration + 3D scene meshes).
Run the main orchestration script that:
- starts SUMO,
- queries vehicle states via TraCI,
- runs Sionna RT ray tracing for the link(s) of interest,
- logs metrics over time,
- optionally renders frames.
Use the included plotting helpers to produce publication-ready figures.

Important note: This repository focuses on ray-tracing propagation + mobility coupling. Higher‑layer PHY/MAC or decoding is not the target here unless explicitly implemented in the scripts.

Repository layout

At the repository root you will find (names as committed):

scenarios/ — scenario folders (each scenario should be self-contained).
signal_propagation_3d_RT.py — main script: orchestrates SUMO + Sionna RT and produces trace logs.
requirements.txt — pinned Python dependencies for reproducibility.
test.ipynb — exploratory notebook.
blender_auto.py / blender_projection.py — helper scripts for Blender-based scenario preparation and geometry projection.
path_loss_graphs.py / graphs_handler.py — plotting utilities for trace logs.
frames2video.py — helper to stitch rendered frames to video (if you render frames).
Protected — repository artifact file (as committed).

Prerequisites

System prerequisites

Python 3.x (recommended: match the Python version you used in experiments).
SUMO installed and accessible from terminal as sumo.
(Recommended) NVIDIA GPU with CUDA drivers compatible with your installed TensorFlow/Sionna RT stack.

Optional prerequisites (scenario building)

Blender (version depends on your pipeline; ensure compatibility with your add-ons).
The Blender add-on you use to import map/OSM data (e.g., Blosm), if your scenario pipeline relies on it.

Installation

1) Create a virtual environment

python -m venv .venv
# Linux/macOS
source .venv/bin/activate
# Windows (PowerShell)
# .\.venv\Scripts\Activate.ps1

2) Install pinned dependencies

pip install --upgrade pip
pip install -r requirements.txt

Why pinned deps matter: Sionna RT depends on a specific stack (TensorFlow + Mitsuba + Dr.Jit). Using pinned versions from requirements.txt helps avoid “works on my machine” issues.

3) Verify SUMO works

Check that SUMO is installed and visible:

sumo --version

If sumo is not found, install SUMO and ensure it is on your PATH.

Scenarios

Each scenario should live under:

scenarios/<scenario_name>/

A scenario is expected to include at least:

sumo_dir/ containing your SUMO config (commonly osm.sumocfg)
scenario.xml — Sionna RT scene description (geometry + materials)
terrain.xml — terrain mesh / geometry description used by the scene (if your pipeline separates it)

If your repo uses different naming per scenario, keep the scenario folder self-contained and update the main script to match.

Scenario checklist (recommended)

SUMO:
- road network and routes defined
- simulation duration / step length defined
- stable and reproducible route generation (if you use randomness, fix seeds where possible)
Sionna RT:
- all referenced meshes exist in the scenario folder
- coordinate system is consistent with SUMO positions (same units, same origin convention)
- material settings are defined and documented (if you tune materials, record values)

How to run

1) Run the main pipeline

python signal_propagation_3d_RT.py

The script typically:

launches SUMO with the selected scenario config,
connects via TraCI,
loads the Sionna RT scene,
iterates time steps and logs link metrics.

Configuration: If you need to change scenario selection, SUMO port, ray-tracing depth, rendering flags, logging output paths, etc., open signal_propagation_3d_RT.py and adjust the constants/parameters documented in its header or main section.

2) Headless / server execution

If you run on a remote server:

use headless SUMO (no GUI) → sumo (not sumo-gui)
ensure rendering options do not require a display (or disable rendering)

3) CPU-only execution (if no GPU)

Sionna RT / Dr.Jit can run in CPU mode via an LLVM backend, but it is much slower.
If you plan to report CPU-vs-GPU timings in your paper, run the same scenario with GPU enabled and disabled and record:

wall-clock per simulation step
total run time
hardware + software versions

Outputs

Depending on script configuration, outputs are typically written under the scenario directory, e.g.:

output_data/ — trace data (CSV / NPY / NPZ / etc., depending on script)
render_frames/ — rendered frames (if enabled)

Because exact filenames depend on your implementation, treat the scenario folder as the canonical storage location:

input assets live under scenarios/<scenario>/...
outputs go to scenarios/<scenario>/(output_data|render_frames)/...

Post-processing and plots

Two plotting helpers exist in this repository:

path_loss_graphs.py — plot path-loss / RSSI style traces
graphs_handler.py — orchestration / utilities for plotting

Typical flow:

run signal_propagation_3d_RT.py to generate traces
run plotting scripts to produce figures
optionally convert frames to video with frames2video.py

If your plotting scripts expect a specific folder structure or filenames, document it in comments at the top of those scripts and keep naming stable.

Reproducibility checklist

For a reviewer-friendly reproducibility statement, record the following in your paper / README:

Software versions

OS (e.g., Ubuntu 22.04)
Python version
SUMO version
CUDA version + GPU driver (if GPU is used)
pinned Python package versions (use requirements.txt)

Determinism

fix random seeds used by:
- mobility generation (SUMO route generation, if applicable)
- ray tracing (PathSolver / sampling)
keep scenario assets identical between runs
note that JIT compilation can affect the first iteration timing (warm up before benchmarking)

Hardware

GPU model + VRAM
CPU model
RAM

Trace generation protocol (recommendation)

Run one “warm-up” pass (for JIT compilation) before measuring performance.
Then run the measured pass with identical configuration.

Troubleshooting

SUMO is not found

Install SUMO and ensure the sumo executable is on PATH.
Verify with sumo --version.

TraCI connection errors

Common causes:

SUMO did not start
wrong remote port
firewall / container networking issues

Fix:

confirm the SUMO process is running
ensure the port in your script matches the SUMO launch arguments

Missing GPU / CUDA issues

ensure nvidia-smi works
ensure TensorFlow sees the GPU
validate that your CUDA driver/toolkit matches your pinned TF stack

Scene loading errors

missing mesh files referenced by scenario.xml / terrain.xml
wrong relative paths
inconsistent coordinate system

Fix:

keep all meshes inside the scenario folder
use relative paths in XML when possible
validate that vehicle coordinates match scene units

Citation

If you use this repository, its code, or simulation scenarios in academic work, please cite the following peer-reviewed publication:

Stepanyants, V. G., Fizulin, A. V., Chibirov, A. R., Amerikanov, A. A., & Romanov, A. Y. (2026). Effects of Elevation Changes and Multilevel Structures on Vehicular Signal Propagation. Future Transportation, 6(5), 225.

DOI: https://doi.org/10.3390/futuretransp6050225

Paper: https://www.mdpi.com/2673-7590/6/5/225

Source code: https://github.com/CAVISE-RnD/Sionna_SUMO_simulation

BibTeX

@article{Stepanyants2026Elevation,
  title   = {Effects of Elevation Changes and Multilevel Structures on Vehicular Signal Propagation},
  author  = {Stepanyants, Vitaly G. and Fizulin, Andrey V. and Chibirov, Artem R. and Amerikanov, Aleksandr A. and Romanov, Aleksandr Y.},
  journal = {Future Transportation},
  volume  = {6},
  number  = {5},
  pages   = {225},
  year    = {2026},
  doi     = {10.3390/futuretransp6050225},
  url     = {https://doi.org/10.3390/futuretransp6050225},
  note    = {Source code available at https://github.com/CAVISE-RnD/Sionna_SUMO_simulation}
}

Name		Name	Last commit message	Last commit date
Sionna_SUMO_simu		Sionna_SUMO_simu
docs		docs
scenarios		scenarios
.gitignore		.gitignore
Protected		Protected
README.md		README.md
blender_auto.py		blender_auto.py
blender_projection.py		blender_projection.py
frames2video.py		frames2video.py
graphs_handler.py		graphs_handler.py
path_loss_graphs.py		path_loss_graphs.py
requirements.txt		requirements.txt
signal_propagation_3d_RT.py		signal_propagation_3d_RT.py
test.ipynb		test.ipynb

Latest commit

History

Folders and files

Repository files navigation