witwin-radar 0.0.1__tar.gz

witwin_radar-0.0.1/.github/workflows/publish-witwin-radar.yml

@@ -0,0 +1,92 @@
+name: Publish witwin-radar
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    if: startsWith(github.event.release.tag_name, 'witwin-radar-v') && !github.event.release.prerelease
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    environment:
+      name: pypi
+      url: https://pypi.org/project/witwin-radar/
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Resolve package directory
+        id: package_dir
+        shell: bash
+        run: |
+          if [ -f pyproject.toml ]; then
+            echo "path=." >> "$GITHUB_OUTPUT"
+          elif [ -f radar/pyproject.toml ]; then
+            echo "path=radar" >> "$GITHUB_OUTPUT"
+          else
+            echo "Unable to find pyproject.toml for the witwin-radar package." >&2
+            exit 1
+          fi
+
+      - name: Validate release tag and package version
+        shell: bash
+        env:
+          PACKAGE_DIR: ${{ steps.package_dir.outputs.path }}
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+        run: |
+          python - <<'PY'
+          import os
+          import re
+          import sys
+          import tomllib
+          from pathlib import Path
+
+          tag = os.environ["RELEASE_TAG"]
+          match = re.fullmatch(r"witwin-radar-v(?P<version>[0-9A-Za-z.+_-]+)", tag)
+          if match is None:
+              print(f"Release tag '{tag}' must match 'witwin-radar-v<version>'.", file=sys.stderr)
+              raise SystemExit(1)
+
+          expected_version = match.group("version")
+          pyproject_path = Path(os.environ["PACKAGE_DIR"]) / "pyproject.toml"
+          data = tomllib.loads(pyproject_path.read_text(encoding="utf-8"))
+
+          project = data["project"]
+          package_name = project["name"]
+          package_version = project["version"]
+
+          if package_name != "witwin-radar":
+              print(f"Expected package name 'witwin-radar', found '{package_name}'.", file=sys.stderr)
+              raise SystemExit(1)
+
+          if package_version != expected_version:
+              print(
+                  f"Release tag version '{expected_version}' does not match pyproject version '{package_version}'.",
+                  file=sys.stderr,
+              )
+              raise SystemExit(1)
+
+          print(f"Validated {package_name} {package_version} from {pyproject_path}.")
+          PY
+
+      - name: Build distributions
+        shell: bash
+        env:
+          PACKAGE_DIR: ${{ steps.package_dir.outputs.path }}
+        run: |
+          python -m pip install --upgrade pip build
+          python -m build "$PACKAGE_DIR"
+
+      - name: Publish distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: ${{ steps.package_dir.outputs.path }}/dist

witwin_radar-0.0.1/.gitignore

@@ -0,0 +1,229 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+*.lock
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+.slangtorch_cache/
+
+# RadarTwin project data
+data/
+output/
+models/
+*.tar.bz2
+*.tar.xz
+*.tar.gz
+activate.sh
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

witwin_radar-0.0.1/FEATURE_LIST.md

@@ -0,0 +1,55 @@
+# Radar Feature List
+
+## Public API
+
+- Declarative simulation flow: `Scene -> Simulation -> Result`
+- Radar pose can be controlled explicitly with `Sensor(...)` on `Radar`, `Renderer`, or `Simulation`
+- Scene assembly uses `Scene.set_sensor(...)`, `Scene.add_structure(...)`, `Scene.add_mesh(...)`, `Scene.add_smpl(...)`, and `Scene.add_structure_motion(...)`
+- Multi-radar orchestration is available via `Simulation.mimo_group(...)`, `RadarSpec`, and `MultiResult`
+- Optional per-structure motion is available through `Scene.add_structure_motion(...)`, `Scene.update_structure_motion(...)`, and `Scene.clear_structure_motion(...)`
+- Public string-literal API types: `SolverBackend`, `DetectorType`, `SamplingMode`, and `MotionSampling`
+- Low-level radar solver entrypoint: `Radar.chirp()`, `Radar.frame()`, `Radar.mimo()`, and `Radar.apply_noise()`
+- Ray-tracing entrypoint: `Renderer.trace()` returns `TraceResult(points, intensities)` and also carries `entry_points`, `fixed_path_lengths`, and `depths` for generalized path tracing
+- `Result.signal()`, `Result.trace_points()`, `Result.trace_intensities()`, `Result.trace_entry_points()`, `Result.trace_fixed_path_lengths()`, and `Result.trace_depths()` provide semantic tensor access, with `Result.tensor(...)` retained as a generic fallback
+
+## Configuration
+
+- `RadarConfig` frozen schema validates required radar fields and antenna layouts
+- Optional `antenna_pattern` config defaults to a broadside dipole and also supports separable `x/y` 1D gain curves or a direct 2D gain map
+- Optional `noise_model` config supports thermal noise, quantization noise, and phase noise with optional deterministic seeding
+- Optional `polarization` config supports simplified TX/RX polarization vectors with alias strings (`horizontal` / `vertical`) or per-element 3D vectors
+- Optional `receiver_chain` config supports `lna`, `agc`, and `adc` stages plus absolute TX-power scaling via `config["power"]`
+- `Radar` accepts `RadarConfig`, `dict`, or JSON config path
+- `Simulation` accepts the same validated config inputs as `Radar`
+- `Renderer(...)` and `Simulation.mimo(...)` accept `multipath`, `max_reflections`, and `ray_batch_size`
+- `Simulation.mimo(...)` and `Simulation.mimo_group(...)` accept `motion_sampling="frame" | "chirp"` for dynamic scenes
+
+## Backend Execution
+
+- Three solver backends: `pytorch`, `slang`, `dirichlet`
+- Backend-specific runtime state lives on `radar.solver`, including Dirichlet FFT metadata such as `pad_factor` and `N_fft`
+- `Radar(device=...)` validates CUDA availability explicitly; `slang` and `dirichlet` require CUDA, while `pytorch` honors the selected device
+- Time-domain outputs from `Radar.chirp()`, `Radar.frame()`, and `Radar.mimo()` automatically apply `noise_model` when configured; `radar.mimo(..., freq_domain=True)` rejects built-in noise injection
+- Time-domain outputs from `Radar.chirp()`, `Radar.frame()`, and `Radar.mimo()` automatically apply `receiver_chain` when configured; enabling it also moves `Radar.gain` onto an absolute transmit-voltage scale
+- `receiver_chain.adc` and `noise_model.quantization` are mutually exclusive so only one ADC quantizer is active
+
+## Rendering And Dynamics
+
+- `Renderer.trace()` has a single public signature with no ignored `spp` parameter
+- `Scene.compile_renderables(time=...)` and `Renderer.trace(time=...)` expose time-dependent geometry for dynamic scenes
+- Multipath tracing is available for `sampling="pixel"` and uses radar-center path tracing with configurable maximum specular reflection depth
+- Solver backends consume generalized path samples and apply FSPL from the total `tx -> bounces -> scatter -> rx` distance
+- When `polarization` is configured, traced path normals are propagated through the runtime and used for simplified reflection/projection coupling
+- Shared core geometry constructors default to `device=None`, while radar `Scene(...)` owns device placement and defaults to CUDA
+- `Timeline.from_motion()` uses the renderer trace contract directly
+- Dynamic structure motion supports rigid `translation`, `rotation`, and `parent` inheritance so rotational Doppler can be modeled directly from the scene
+- `radar.mimo(..., freq_domain=True)` remains available for Dirichlet frequency-domain output
+
+## Signal Processing
+
+- `process_pc(..., detector=...)` accepts the validated detector set `{"cfar", "topk"}`
+- `frame2pointcloud(...)` requires a `radar` argument so TDM-MIMO compensation is never skipped silently
+- `PointCloudProcessConfig` provides the normalized point-cloud extraction config surface
+- `range_fft(...)`, `doppler_fft(...)`, `clutter_removal(...)`, `process_pc(...)`, and `process_rd(...)` keep tensor inputs on the PyTorch path and use `torch.fft` for GPU-native DSP
+- `ca_cfar_2d(...)`, `ca_cfar_2d_fast(...)`, and `os_cfar_2d(...)` return `(detections, threshold_map)` with a consistent CFAR contract
+- `ca_cfar_2d(...)`, `ca_cfar_2d_fast(...)`, and `os_cfar_2d(...)` all accept NumPy arrays and PyTorch tensors; the reference CA/OS paths now stay on the torch device instead of falling back to CPU

witwin_radar-0.0.1/PERFORMANCE.md

@@ -0,0 +1,146 @@
+# Radar Signal Processing Performance Analysis
+
+## Overview
+
+This report compares different parallelization strategies for FMCW radar signal processing:
+- **Slang+FFT**: Compute time-domain chirp signal, then apply FFT
+- **Dirichlet**: Direct frequency-domain computation using Dirichlet kernel (skips FFT)
+
+Each method has three variants:
+- **Internal (_i)**: Per-output-bin parallel, each thread loops through ALL targets
+- **Chunked (_c)**: Per-output-bin parallel, targets split into chunks, no atomics
+- **Per-target (_t)**: Per-target parallel, each thread loops through ALL output bins, chunked atomics
+
+## Benchmark Results
+
+Hardware: NVIDIA GPU with CUDA
+Parameters: `adc_samples=400`, `pad_factor=16`, `N_fft=6400`, `num_bins=3200`
+
+| Targets | PyTorch | Slang_i | Slang_c | Slang_t | Dir_i | Dir_c | Dir_t |
+|---------|---------|---------|---------|---------|-------|-------|-------|
+| 4 | 0.20 | 0.15 | 0.50 | 0.23 | 0.07 | 0.08 | 0.16 |
+| 16 | 0.21 | 0.14 | 0.15 | 0.17 | 0.07 | 0.08 | 0.14 |
+| 64 | 0.19 | 0.27 | 0.27 | 0.17 | 0.07 | 0.08 | 0.68 |
+| 256 | 0.21 | 0.74 | 0.74 | 0.24 | 0.08 | 0.12 | 1.46 |
+| 1024 | 0.27 | 2.99 | 0.75 | 0.34 | 0.16 | 0.13 | 1.65 |
+| 4096 | 0.64 | 11.34 | 0.84 | 0.58 | 0.87 | 0.31 | 2.11 |
+| 16384 | 3.69 | 45.86 | 1.91 | 1.25 | 1.77 | 1.33 | 3.79 |
+| 65536 | 15.17 | 177.90 | 5.23 | 5.87 | 7.44 | 4.68 | 12.55 |
+| 262144 | 54.28 | 677.15 | 21.04 | 19.09 | 28.44 | 14.50 | 42.31 |
+| 1048576 | OOM | 2719.41 | 79.22 | 76.41 | 112.38 | **58.12** | 175.29 |
+
+*Times in milliseconds (ms). OOM = Out of Memory.*
+
+## Method Comparison
+
+### 1. PyTorch (Batched Tensor Operations)
+- **Pros**: Simple implementation, fast for small N
+- **Cons**: O(N × T) memory, OOM for N > 262144
+- **Memory**: ~6.7 GB for N=1M (N × T × 16 bytes for complex128)
+
+### 2. Slang Internal (Slang_i)
+- **Strategy**: Each thread handles one time sample, loops through ALL targets
+- **Parallelism**: T threads (400)
+- **Pros**: Minimal memory O(T)
+- **Cons**: Poor parallelism, very slow for large N
+- **Bottleneck**: Serial loop over N targets per thread
+
+### 3. Slang Chunked (Slang_c)
+- **Strategy**: 2D grid (time_blocks × target_chunks), each thread handles one time sample, loops through targets in its chunk
+- **Parallelism**: T × num_chunks threads
+- **Memory**: O(num_chunks × T) ≈ 26 MB for N=1M
+- **Pros**: Good parallelism, no atomics needed
+- **Performance**: 79.22ms @ 1M targets
+
+### 4. Slang Per-target (Slang_t)
+- **Strategy**: Each thread handles one target, loops through ALL time samples
+- **Parallelism**: N threads (chunked)
+- **Memory**: O(num_chunks × T)
+- **Atomics**: Required within each chunk (multiple targets write to same time index)
+- **Performance**: 76.41ms @ 1M targets
+
+### 5. Dirichlet Internal (Dir_i)
+- **Strategy**: Each thread handles one frequency bin, loops through ALL targets
+- **Parallelism**: num_bins threads (3200)
+- **Memory**: O(num_bins) ≈ 25 KB
+- **Pros**: Minimal memory, skips FFT
+- **Cons**: Poor parallelism for large N
+
+### 6. Dirichlet Chunked (Dir_c) - FASTEST
+- **Strategy**: 2D grid (bin_blocks × target_chunks), each thread handles one bin, loops through targets in its chunk
+- **Parallelism**: num_bins × num_chunks threads
+- **Memory**: O(num_chunks × num_bins) ≈ 105 MB for N=1M
+- **Pros**: Best parallelism, no atomics, skips FFT
+- **Performance**: **58.12ms @ 1M targets**
+
+### 7. Dirichlet Per-target (Dir_t)
+- **Strategy**: Each thread handles one target, loops through ALL frequency bins
+- **Parallelism**: N threads (chunked)
+- **Memory**: O(num_chunks × num_bins)
+- **Atomics**: Required within each chunk (multiple targets write to same bin)
+- **Performance**: 175.29ms @ 1M targets
+
+## Key Insights
+
+### Why Dirichlet is Faster than Slang+FFT
+1. **Skips FFT**: Dirichlet computes frequency-domain result directly
+2. **Same complexity**: Both are O(N × M) where M = num_bins or T
+3. **FFT overhead**: cuFFT adds ~20ms constant overhead
+
+### Why Chunked is Faster than Per-target
+1. **No atomics**: Chunked per-bin writes to separate memory locations
+2. **Cache locality**: Sequential bin iteration has better memory access patterns
+3. **Atomic contention**: Per-target has multiple threads writing to same bin indices
+
+### Why Per-target Chunked Improved Over Global Atomics
+Previous per-target with global atomics: 132.58ms (Slang_t), 293.73ms (Dir_t)
+Current per-target with chunked atomics: 76.41ms (Slang_t), 175.29ms (Dir_t)
+
+**Improvement: ~1.7x faster** by reducing atomic contention scope from global to per-chunk.
+
+## Memory vs Performance Trade-off
+
+| Method | Memory (N=1M) | Time (ms) | Notes |
+|--------|---------------|-----------|-------|
+| PyTorch | ~6.7 GB | OOM | N × T × 16 bytes |
+| Slang_i | ~6 KB | 2719 | T × 8 bytes |
+| Slang_c | ~26 MB | 79 | chunks × T × 8 bytes |
+| Slang_t | ~26 MB | 76 | chunks × T × 8 bytes |
+| Dir_i | ~25 KB | 112 | bins × 8 bytes |
+| Dir_c | ~105 MB | **58** | chunks × bins × 8 bytes |
+| Dir_t | ~105 MB | 175 | chunks × bins × 8 bytes |
+
+## Recommendations
+
+1. **For large N (>10K targets)**: Use **Dir_c** (Dirichlet Chunked)
+   - Best performance: 58ms @ 1M targets
+   - Reasonable memory: ~105 MB
+   - No atomic contention
+
+2. **For small N (<1K targets)**: Use **Dir_i** (Dirichlet Internal)
+   - Minimal memory overhead
+   - Fast enough for small N
+
+3. **When FFT is required**: Use **Slang_c** or **Slang_t**
+   - Similar performance (~76-79ms @ 1M)
+   - Slang_t slightly faster for very large N
+
+4. **Avoid**: Slang_i for large N (poor parallelism)
+
+## Parallelization Strategy Summary
+
+```
+Per-bin (loop targets):          Per-target (loop bins):
+┌─────────────────────┐          ┌─────────────────────┐
+│ Thread 0: bin 0     │          │ Thread 0: target 0  │
+│   for t in targets: │          │   for b in bins:    │
+│     accumulate      │          │     atomic_add[b]   │
+├─────────────────────┤          ├─────────────────────┤
+│ Thread 1: bin 1     │          │ Thread 1: target 1  │
+│   for t in targets: │          │   for b in bins:    │
+│     accumulate      │          │     atomic_add[b]   │
+└─────────────────────┘          └─────────────────────┘
+     No atomics!                  Atomics required!
+```
+
+The per-bin approach naturally avoids atomics because each thread writes to a unique output location.

witwin_radar-0.0.1/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: witwin-radar
+Version: 0.0.1
+Summary: Witwin Radar - Radar signal simulation
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: torch>=2.0
+Requires-Dist: witwin>=0.0.1
+Description-Content-Type: text/markdown
+
+# WiTwin Radar
+
+A GPU-accelerated, differentiable FMCW radar simulator for generating synthetic radar data from 3D scenes. It combines Mitsuba ray tracing with custom CUDA kernels and exposes a single public workflow:
+
+`Scene -> Simulation -> Result`
+
+## Quick Start
+
+```python
+import numpy as np
+import torch
+
+from witwin.radar import Radar
+from witwin.radar.sigproc import process_pc, process_rd
+
+config = {
+    "num_tx": 3,
+    "num_rx": 4,
+    "fc": 77e9,
+    "slope": 60.012,
+    "adc_samples": 256,
+    "adc_start_time": 6,
+    "sample_rate": 4400,
+    "idle_time": 7,
+    "ramp_end_time": 65,
+    "chirp_per_frame": 128,
+    "frame_per_second": 10,
+    "num_doppler_bins": 128,
+    "num_range_bins": 256,
+    "num_angle_bins": 64,
+    "power": 15,
+    "tx_loc": [[0, 0, 0], [4, 0, 0], [2, 1, 0]],
+    "rx_loc": [[-6, 0, 0], [-5, 0, 0], [-4, 0, 0], [-3, 0, 0]],
+}
+
+radar = Radar(config, backend="pytorch", device="cpu")
+
+point = np.array([[0.0, 0.0, -3.0]], dtype=np.float32)
+velocity = np.array([[0.0, 0.0, 0.01]], dtype=np.float32)
+
+
+def interp(t):
+    positions = torch.tensor(point + velocity * t, dtype=torch.float32, device=radar.device)
+    intensities = torch.ones((positions.shape[0],), dtype=torch.float32, device=radar.device)
+    return intensities, positions
+
+
+frame = radar.mimo(interp, t0=0)
+pc = process_pc(radar, frame)
+rd, _, ranges, vels = process_rd(radar, frame)
+```
+
+## Scene API
+
+Use `Sensor(...)` to define the radar pose, `Scene.set_sensor(...)` to configure the default scene sensor, and `Scene.add_*` methods for scene assembly.
+
+```python
+from witwin.core import Material, Structure
+from witwin.radar import Scene, Sensor, Simulation
+
+scene = Scene(device="cpu").set_sensor(
+    origin=(0.0, 0.0, 0.0),
+    target=(0.0, 0.0, -1.0),
+    up=(0.0, 1.0, 0.0),
+)
+
+scene.add_structure(
+    Structure(
+        name="car_body",
+        geometry=car_body_mesh,
+        material=Material(eps_r=3.0),
+    )
+)
+scene.add_mesh(name="wheel_fl", vertices=wheel_vertices, faces=wheel_faces, dynamic=True)
+scene.add_structure_motion(
+    "wheel_fl",
+    rotation={
+        "axis": (0.0, 1.0, 0.0),
+        "angular_velocity": 32.0,
+        "origin": (0.0, 0.0, 0.0),
+        "space": "local",
+    },
+)
+
+result = Simulation.mimo(
+    scene,
+    config=config,
+    backend="pytorch",
+    sampling="triangle",
+    motion_sampling="chirp",
+    device="cpu",
+).run()
+```
+
+Available mutating scene methods:
+
+- `Scene.set_sensor(...)`
+- `Scene.add_structure(...)`
+- `Scene.add_mesh(...)`
+- `Scene.add_smpl(...)`
+- `Scene.add_structure_motion(...)`
+- `Scene.update_structure(...)`
+- `Scene.update_structure_motion(...)`
+- `Scene.clear_structure_motion(...)`
+
+## Features
+
+- Three solver backends: `pytorch`, `slang`, `dirichlet`
+- Ray tracing through Mitsuba with differentiable scene support
+- Shared-core geometry and structure primitives
+- SMPL body support through `Scene.add_smpl(...)`
+- Optional per-structure rigid motion with parent inheritance
+- Multi-radar orchestration through `Simulation.mimo_group(...)`
+- Torch-native DSP pipeline for range/Doppler processing and point-cloud extraction
+- Optional antenna pattern, polarization, noise-model, and receiver-chain configuration
+
+## Running Tests
+
+```bash
+cd radar
+pytest tests/
+pytest tests/ --gpu
+```
+
+## Installation
+
+Requires Python 3.10+ and a CUDA-capable environment for the CUDA backends.
+
+```bash
+pip install -r requirements.txt
+```
+
+Core dependencies include `torch`, `numpy`, `slangtorch`, `tqdm`, `matplotlib`, and `scipy`. Optional rendering dependencies are `mitsuba` and `drjit`.