Batched Mode

Batched Mode is the simplest way to run a complete simulation through the AODT client. After the scenario is loaded, run_full_simulation() asks the worker to execute all batches and all time steps at once. Results are written to the database as Parquet files in S3 and can be queried from the catalog, according to the scenario configuration. This mode is best when your application wants the complete output dataset instead of step-by-step control.

For selective CIR requests, per-slot inspection, or direct NumPy access during a run, use Interactive Mode instead.

Batched EM and Batched RAN

Batched Mode supports two simulation modes:

• Batched EM runs the EM Solver and exports channel results, ray paths, and related setup data.
• Batched RAN runs the EM Solver and RAN components, including the L1/L2 stack and channel emulation. It exports the channel results plus RAN telemetry and RAN configuration tables.

Use the SimConfig builder API to select the mode. EM scenarios can use either a duration/interval timeline or a slot-based timeline. RAN scenarios use the slot-based timeline so the simulation follows the 5G slot structure.

1
from aodt_config import SimConfig, SimMode
2
3
# Batched EM, duration/interval timeline
4
config = SimConfig(scene, SimMode.EM, asset_config)
5
config.set_timeline(duration=1.0, interval=0.1)
6
7
# Batched RAN, slot timeline
8
config = SimConfig(scene, SimMode.RAN, asset_config)
9
config.set_timeline(slots_per_batch=100, realizations_per_slot=1)

When the builder exports YAML, it writes the corresponding scenario fields, including sim_is_full, sim_simulation_mode, and the selected timeline parameters.

Workflow

The typical Batched Mode workflow is:

1. Create a dt_client.DigitalTwinClient.
2. Load a scenario YAML string with client.start(...).
3. Inspect the loaded scenario with client.get_status().
4. Call client.run_full_simulation().
5. Read the exported results produced by the run.

run_full_simulation() is a blocking call. Progress updates appear in the client logs while it runs, and the Python method returns a summary with time_steps_completed and total_time_seconds when the run finishes.

For EM runs, Batched Mode works with either timeline style described in Interactive Mode: slot-based timelines or duration/interval timelines. RAN runs use slot-based timelines.

Example

Run the full simulation example:

$
python client/examples/example_full_sim.py \
>
  --server_address localhost:50051 \
>
  --s3_endpoint http://minio:9000

Use --import_option file --yaml_file <path> to run a specific scenario YAML, or let the example generate a YAML configuration programmatically.

The core pattern is:

1
import dt_client
2
3
client = dt_client.DigitalTwinClient("localhost:50051")
4
client.start(yaml_content)
5
6
status = client.get_status()
7
if not status["scenario_loaded"]:
8
    raise RuntimeError("Scenario failed to load")
9
10
result = client.run_full_simulation()
11
print(result["time_steps_completed"])
12
print(result["total_time_seconds"])

After completion, the configured outputs are available from the database or exported result files. See the Results Schemas page for the tables and columns produced by the simulation. See client/examples/example_query_tables.py for an example of inspecting and querying exported result tables.

To clean up a result database after a test run, remove both the catalog metadata and the S3 Parquet data. See client/examples/example_drop_database.py for an example script that can preview the deletion plan and execute the cleanup.

Advanced RAN Parameters

RAN protocol and scheduler parameters are configured in worker/config_ran.json. The worker container mounts this file at /opt/nvidia/aodt_sim/src_be/components/common/config_ran.json.

Only a subset of RAN internals is exposed through this JSON file. See Waveform Dumping for RX FT filename, and see Results Schemas for the exported ran_config and ran_telemetry tables.

When To Use

Use Batched Mode when:

• The application needs a complete simulation result for an EM, RAN, or calibration workflow.
• You do not need to inspect or modify intermediate time steps.
• You want the worker to manage simulation execution and result persistence.
• You are running calibration. See Calibration.

Use Interactive Mode when the application needs to request selected slots or time steps, retrieve CIR arrays into NumPy, or feed intermediate results into custom application logic.

API Reference

See the DigitalTwinClient API for start, get_status, run_full_simulation, cancel_simulation, and related client methods.

See Results Schemas for the Parquet tables and columns exported by a completed run.