> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/aerial/aodt/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/aerial/aodt/_mcp/server.

# Config Builder API

This page documents the public classes and enums in the `_config` module
(C++ with pybind11 bindings).

## Enums

### SimMode

```python showLineNumbers={false}
class _config.SimMode
```

Simulation mode.

#### EM

```python showLineNumbers={false}
attribute _config.SimMode.EM
```

Electromagnetic mode (duration/interval based).

#### RAN

```python showLineNumbers={false}
attribute _config.SimMode.RAN
```

RAN mode (slot/symbol based).

### DBTable

```python showLineNumbers={false}
class _config.DBTable
```

Result tables that can be persisted to the database.

#### CIRS

```python showLineNumbers={false}
attribute _config.DBTable.CIRS
```

Channel Impulse Response.

#### CFRS

```python showLineNumbers={false}
attribute _config.DBTable.CFRS
```

Channel Frequency Response. Adding this table automatically
enables wideband simulation.

#### RAYPATHS

```python showLineNumbers={false}
attribute _config.DBTable.RAYPATHS
```

Ray path data.

#### TELEMETRY

```python showLineNumbers={false}
attribute _config.DBTable.TELEMETRY
```

Telemetry data (RAN mode only).

### GeoTargets

```python showLineNumbers={false}
class _config.GeoTargets
```

Target geometry type for material calibration operations.

#### BLDG

```python showLineNumbers={false}
attribute _config.GeoTargets.BLDG
```

Building materials (`sim.Materials` section).

#### VEG

```python showLineNumbers={false}
attribute _config.GeoTargets.VEG
```

Vegetation materials (`sim.VegetationMaterials` section).

### DiffusionModel

```python showLineNumbers={false}
class _config.DiffusionModel
```

EM diffusion model for ray tracing.

#### LAMBERTIAN

```python showLineNumbers={false}
attribute _config.DiffusionModel.LAMBERTIAN
```

Lambertian diffusion.

#### DIRECTIONAL

```python showLineNumbers={false}
attribute _config.DiffusionModel.DIRECTIONAL
```

Directional diffusion.

## Data Classes

### Position

```python showLineNumbers={false}
class _config.Position
```

A geographic or Cartesian position.

#### georef

```python showLineNumbers={false}
staticmethod _config.Position.georef(
    lat: float,
    lon: float,
    alt: Optional[float] = None,
) -> Position
```

Create a georeferenced position from latitude and longitude.
*alt* is an altitude offset above terrain in meters. When *alt*
is set, the point is 3D and AODT projects `z = terrain_z + alt`.
When *alt* is `None`, the point is 2D and AODT
projects `z` to the terrain+buildings surface.

#### cartesian

```python showLineNumbers={false}
staticmethod _config.Position.cartesian(
    x: float,
    y: float,
    z: Optional[float] = None,
) -> Position
```

Create a Cartesian position. *z* is the vertical coordinate in
meters. When *z* is `None`, the point is 2D and AODT
projects `z` to the terrain+buildings surface.

### Waypoint

```python showLineNumbers={false}
class _config.Waypoint
```

UE waypoint with position and mobility parameters.

#### position

```python showLineNumbers={false}
attribute _config.Waypoint.position
```

<dl>
  <dt>
    Return type
  </dt>

  <dd>
    <code>Position</code>
  </dd>
</dl>

#### speed

```python showLineNumbers={false}
attribute _config.Waypoint.speed
```

<dl>
  <dt>
    Return type
  </dt>

  <dd>
    <code>float</code>
  </dd>
</dl>

Speed in m/s.

#### pauseDuration

```python showLineNumbers={false}
attribute _config.Waypoint.pauseDuration
```

<dl>
  <dt>
    Return type
  </dt>

  <dd>
    <code>float</code>
  </dd>
</dl>

Pause duration in seconds.

#### azimuthOffset

```python showLineNumbers={false}
attribute _config.Waypoint.azimuthOffset
```

<dl>
  <dt>
    Return type
  </dt>

  <dd>
    <code>float</code>
  </dd>
</dl>

Azimuth offset in degrees.

### S3Config

```python showLineNumbers={false}
class _config.S3Config(
    bucket="",
    provider="",
    endpoint_url="",
    access_key="",
    secret_key="",
    region="us-east-1",
)
```

Reusable S3 connection credentials. Used by
`SimConfig.set_s3_config()` and
`SimConfig.add_parquet_s3_config()`.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>bucket</code> (<code>str</code>) - S3 bucket name.

    •<code>provider</code> (<code>str</code>) - <code>"minio"</code> or <code>"aws"</code>.

    •<code>endpoint\_url</code> (<code>str</code>) - S3 endpoint URL (not required for AWS).

    •<code>access\_key</code> (<code>str</code>) - Access key.

    •<code>secret\_key</code> (<code>str</code>) - Secret key.

    •<code>region</code> (<code>str</code>) - AWS region (default <code>"us-east-1"</code>).
  </dd>
</dl>

## Domain Objects

### Panel

```python showLineNumbers={false}
class _config.Panel
```

Antenna panel configuration. Create via the static factory methods
below -- do not instantiate directly.

#### create\_panel

```python showLineNumbers={false}
staticmethod _config.Panel.create_panel(
    antenna_elements: list[str],
    frequency_mhz: float,
    vertical_spacing: float = 0.5,
    vertical_num: int = 1,
    horizontal_spacing: float = 0.5,
    horizontal_num: int = 2,
    dual_polarized: bool = True,
    roll_first: float = 0.0,
    roll_second: float = 90.0,
) -> Panel
```

Create a panel from antenna element names.

*antenna\_elements* accepts built-in pattern name constants
(e.g. `Panel.THREE_GPP_38901`, `Panel.ISOTROPIC`) or custom
file paths (e.g. `"path/to/pattern.csv"`).

Built-in constants: `Panel.ISOTROPIC`,
`Panel.INFINITESIMAL_DIPOLE`, `Panel.HALFWAVE_DIPOLE`,
`Panel.REC_MICROSTRIP_PATCH`, `Panel.THREE_GPP_38901`,
`Panel.POLARIZED_ISOTROPIC`.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>antenna\_elements</code> (<code>list\[str]</code>) - Antenna element names or file paths.

    •<code>frequency\_mhz</code> (<code>float</code>) - Reference frequency in MHz.

    •<code>vertical\_spacing</code> (<code>float</code>) - Vertical spacing in wavelengths.

    •<code>vertical\_num</code> (<code>int</code>) - Number of vertical elements.

    •<code>horizontal\_spacing</code> (<code>float</code>) - Horizontal spacing in wavelengths.

    •<code>horizontal\_num</code> (<code>int</code>) - Number of horizontal elements.

    •<code>dual\_polarized</code> (<code>bool</code>) - Whether the panel is dual-polarized.

    •<code>roll\_first</code> (<code>float</code>) - First polarization roll angle (degrees).

    •<code>roll\_second</code> (<code>float</code>) - Second polarization roll angle (degrees).
  </dd>

  <dt>
    Return type
  </dt>

  <dd>
    <code>Panel</code>
  </dd>
</dl>

#### create\_panel\_from\_file

```python showLineNumbers={false}
staticmethod _config.Panel.create_panel_from_file(
    panel_file_path: str,
) -> Panel
```

Create a file-based panel from a CSV or FFD file. The panel
configuration is entirely defined by the file.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>panel\_file\_path</code> (<code>str</code>) - Path to the panel definition file.
  </dd>

  <dt>
    Return type
  </dt>

  <dd>
    <code>Panel</code>
  </dd>
</dl>

#### id

```python showLineNumbers={false}
_config.Panel.id() -> int
```

Return the panel ID (assigned when added to a config).

The setters below mutate an existing `Panel`. They are intended
for editing a config loaded via `SimConfig.from_yaml_file()`.

For example:

Examples

```python
panel = config.get_panel(config.get_default_ru_panel_id())
panel.set_antenna_elements([AntennaElement.Isotropic])

```

None of the setters are valid on a file-based panel (one created via
`Panel.create_panel_from_file()`); calling any of them on such
a panel raises `RuntimeError`. Setters that re-run the panel
invariant check (`set_antenna_elements`, `set_panel_size`)
provide a strong exception guarantee: if validation fails, the panel
reverts to its previous state.

#### set\_antenna\_elements

```python showLineNumbers={false}
_config.Panel.set_antenna_elements(
    elements: list[AntennaElement],
)
```

set\_antenna\_elements(names: list\[str])

Replace the antenna element list. Two forms are accepted:

* A list of :class:`AntennaElement` enum values.
* A list of strings: built-in pattern name constants
  (`Panel.THREE_GPP_38901`, `Panel.ISOTROPIC`, ...) or custom
  pattern file paths. Empty strings are rejected.

Re-runs the full panel invariant check, so the new list must be
consistent with the current array shape: either a single element
(broadcast to every antenna) or exactly
`vertical_num * horizontal_num * (2 if dual_polarized else 1)`
entries.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>elements</code> (<code>list\[AntennaElement]</code>) - Antenna element enum values.

    •<code>names</code> (<code>list\[str]</code>) - Antenna element names or file paths.
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>RuntimeError</code>

     \- If the panel is file-based, or the list
  </dd>
</dl>

size does not match the panel shape.

#### set\_frequency

```python showLineNumbers={false}
_config.Panel.set_frequency(mhz: float)
```

Set the panel reference frequency in MHz.

Does not change the stored mm spacing: a real panel has a fixed
physical element spacing and only its wavelength ratio changes
with frequency. To re-derive the spacing at the new frequency,
call `set_spacing_wavelengths()` afterwards.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>mhz</code> (<code>float</code>) - Reference frequency in MHz (must be > 0).
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>RuntimeError</code>

     \- If the panel is file-based, or 

    <em>mhz</em>

     is
  </dd>
</dl>

not positive.

#### set\_spacing\_wavelengths

```python showLineNumbers={false}
_config.Panel.set_spacing_wavelengths(
    vertical_wavelengths: float,
    horizontal_wavelengths: float,
)
```

Set the element spacings in wavelengths at the current reference
frequency. Stored internally as millimeters.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>vertical\_wavelengths</code> (<code>float</code>) - Vertical spacing in wavelengths.

    •<code>horizontal\_wavelengths</code> (<code>float</code>) - Horizontal spacing in wavelengths.
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>RuntimeError</code>

     \- If the panel is file-based, or either
  </dd>
</dl>

spacing is not positive.

#### set\_panel\_size

```python showLineNumbers={false}
_config.Panel.set_panel_size(
    vertical_num: int,
    horizontal_num: int,
    dual_polarized: bool,
)
```

Set the array shape (vertical x horizontal element counts) and
whether the panel is dual-polarized.

Re-runs the full panel invariant check, so the current antenna
element list must still be size-compatible with the new shape.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>vertical\_num</code> (<code>int</code>) - Number of vertical elements (must be > 0).

    •<code>horizontal\_num</code> (<code>int</code>) - Number of horizontal elements (must be > 0).

    •<code>dual\_polarized</code> (<code>bool</code>) - Whether the panel is dual-polarized.
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>RuntimeError</code>

     \- If the panel is file-based, the counts are
  </dd>
</dl>

non-positive, or the antenna element list does not match the
new shape.

#### set\_roll\_angles

```python showLineNumbers={false}
_config.Panel.set_roll_angles(
    first_deg: float,
    second_deg: float,
)
```

Set the polarization roll angles in degrees.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>first\_deg</code> (<code>float</code>) - First polarization roll angle (degrees).

    •<code>second\_deg</code> (<code>float</code>) - Second polarization roll angle (degrees).
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>RuntimeError</code>

     \- If the panel is file-based.
  </dd>
</dl>

### DU (Distributed Unit)

```python showLineNumbers={false}
class _config.DU
```

Distributed Unit. Create via `Nodes.create_du()`.

#### id

```python showLineNumbers={false}
_config.DU.id() -> int
```

Return the DU ID.

#### frequency

```python showLineNumbers={false}
_config.DU.frequency() -> float
```

Return carrier frequency in MHz.

#### set\_position

```python showLineNumbers={false}
_config.DU.set_position(position: Position)
```

Set the DU position.

#### set\_frequency

```python showLineNumbers={false}
_config.DU.set_frequency(mhz: float)
```

Set the DU reference frequency in MHz.

Only this DU's emitted `aerial_du_reference_freq` is updated;
the frequencies of associated RUs are independent and must be
adjusted separately with `RU.set_frequency()` if the
deployment expects them to track.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>mhz</code> (<code>float</code>) - Reference frequency in MHz (must be > 0).
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>ValueError</code>

     \- If 

    <em>mhz</em>

     is not positive.
  </dd>
</dl>

#### set\_fft\_size

```python showLineNumbers={false}
_config.DU.set_fft_size(size: int)
```

Set FFT size.

#### set\_max\_channel\_bandwidth

```python showLineNumbers={false}
_config.DU.set_max_channel_bandwidth(bw: float)
```

Set maximum channel bandwidth in MHz.

#### set\_num\_antennas

```python showLineNumbers={false}
_config.DU.set_num_antennas(num: int)
```

Override the number of antennas (normally auto-derived from the
default RU panel).

### RU (Radio Unit)

```python showLineNumbers={false}
class _config.RU
```

Radio Unit. Create via `Nodes.create_ru()`.

#### id

```python showLineNumbers={false}
_config.RU.id() -> int
```

Return the RU ID.

#### frequency

```python showLineNumbers={false}
_config.RU.frequency() -> float
```

Return carrier frequency in MHz.

#### du\_id

```python showLineNumbers={false}
_config.RU.du_id() -> int
```

Return the associated DU ID.

#### panel\_id

```python showLineNumbers={false}
_config.RU.panel_id() -> int
```

Return the ID of the panel assigned to this RU.

For an RU retrieved via `SimConfig.get_ru()` this is
always non-zero: `SimConfig.add_ru()` resolves an unset
(`0`) value to the current default RU panel before storing the
RU. The accessor only returns `0` on a freshly constructed RU
that has not yet been added to a config.

#### set\_position

```python showLineNumbers={false}
_config.RU.set_position(position: Position)
```

Set the RU position (georeferenced or Cartesian).

#### set\_height

```python showLineNumbers={false}
_config.RU.set_height(height_m: float)
```

Set height in meters above ground.

#### set\_radiated\_power

```python showLineNumbers={false}
_config.RU.set_radiated_power(power_dbm: float)
```

Set radiated power in dBm.

#### set\_mech\_azimuth

```python showLineNumbers={false}
_config.RU.set_mech_azimuth(deg: float)
```

Set mechanical azimuth in degrees.

#### set\_mech\_tilt

```python showLineNumbers={false}
_config.RU.set_mech_tilt(deg: float)
```

Set mechanical tilt in degrees.

#### set\_frequency

```python showLineNumbers={false}
_config.RU.set_frequency(mhz: float)
```

Set the RU carrier frequency in MHz.

Only this RU's emitted `aerial_gnb_carrier_freq` is updated;
the associated DU's frequency is not modified.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>mhz</code> (<code>float</code>) - Carrier frequency in MHz (must be > 0).
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>ValueError</code>

     \- If 

    <em>mhz</em>

     is not positive.
  </dd>
</dl>

#### assign\_panel

```python showLineNumbers={false}
_config.RU.assign_panel(panel: Panel)
```

Assign a specific panel to this RU, overriding the default.

### UE (User Equipment)

```python showLineNumbers={false}
class _config.UE
```

User Equipment. Create via `Nodes.create_ue()`.

#### id

```python showLineNumbers={false}
_config.UE.id() -> int
```

Return the UE ID.

#### add\_waypoint

```python showLineNumbers={false}
_config.UE.add_waypoint(
    position: Position,
    speed: float = 0.0,
    pause_duration: float = 0.0,
    azimuth_offset: float = 0.0,
)
```

Add a waypoint. At least one waypoint is required before calling
`SimConfig.add_ue()` (unless using a GPX source).
Waypoints for the same UE must all have the same dimensionality;
adding a 2D waypoint to a 3D UE, or a 3D waypoint to a 2D UE,
raises.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>position</code> (<code>Position</code>) - Waypoint position.

    •<code>speed</code> (<code>float</code>) - Speed in m/s.

    •<code>pause\_duration</code> (<code>float</code>) - Pause duration in seconds.

    •<code>azimuth\_offset</code> (<code>float</code>) - Azimuth offset in degrees.
  </dd>
</dl>

#### clear\_waypoints

```python showLineNumbers={false}
_config.UE.clear_waypoints()
```

Remove all waypoints from this UE.

#### set\_radiated\_power

```python showLineNumbers={false}
_config.UE.set_radiated_power(power_dbm: float)
```

Set UE radiated power in dBm.

#### assign\_panel

```python showLineNumbers={false}
_config.UE.assign_panel(panel: Panel)
```

Assign a specific panel to this UE, overriding the default.

#### set\_bler\_target

```python showLineNumbers={false}
_config.UE.set_bler_target(target: float)
```

Set the BLER target.

#### set\_manual

```python showLineNumbers={false}
_config.UE.set_manual(manual: bool)
```

Set manual mode for this UE.

## Factory

### Nodes

```python showLineNumbers={false}
class _config.Nodes
```

Factory for creating DU, RU, and UE objects.

#### create\_du

```python showLineNumbers={false}
staticmethod _config.Nodes.create_du(
    du_id: int,
    frequency_mhz: float = 3600.0,
    scs_khz: float = 30.0,
) -> DU
```

Create a Distributed Unit.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>du\_id</code> (<code>int</code>) - DU identifier (must be > 0).

    •<code>frequency\_mhz</code> (<code>float</code>) - Carrier frequency in MHz.

    •<code>scs\_khz</code> (<code>float</code>) - Subcarrier spacing in kHz.
  </dd>

  <dt>
    Return type
  </dt>

  <dd>
    <code>DU</code>
  </dd>
</dl>

#### create\_ru

```python showLineNumbers={false}
staticmethod _config.Nodes.create_ru(
    ru_id: int,
    frequency_mhz: float = 3600.0,
    radiated_power_dbm: float = 43.0,
    du_id: int = 1,
) -> RU
```

Create a Radio Unit.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>ru\_id</code> (<code>int</code>) - RU identifier (must be > 0).

    •<code>frequency\_mhz</code> (<code>float</code>) - Carrier frequency in MHz.

    •<code>radiated\_power\_dbm</code> (<code>float</code>) - Radiated power in dBm.

    •<code>du\_id</code> (<code>int</code>) - Associated DU identifier.
  </dd>

  <dt>
    Return type
  </dt>

  <dd>
    <code>RU</code>
  </dd>
</dl>

#### create\_ue

```python showLineNumbers={false}
staticmethod _config.Nodes.create_ue(
    ue_id: int,
    radiated_power_dbm: float = 26.0,
) -> UE
```

Create a User Equipment.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>ue\_id</code> (<code>int</code>) - UE identifier (must be in \[1, 10000]).

    •<code>radiated\_power\_dbm</code> (<code>float</code>) - Radiated power in dBm.
  </dd>

  <dt>
    Return type
  </dt>

  <dd>
    <code>UE</code>
  </dd>
</dl>

## Configuration Builder

### SimConfig

```python showLineNumbers={false}
class _config.SimConfig(
    scene_url: str,
    mode: SimMode = SimMode.EM,
    asset_config_path: str = "",
)
```

High-level configuration builder for AODT simulations.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>scene\_url</code> (<code>str</code>) - Scene URL -- S3 key prefix or local path.

    •<code>mode</code> (<code>SimMode</code>) - Simulation mode (default <code>EM</code>).

    •<code>asset\_config\_path</code> (<code>str</code>) - Path to <code>assets.yml</code> (*<em>required</em>*).
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>RuntimeError</code>

     \- If 

    <em>asset_config_path</em>

     is empty or cannot be loaded.
  </dd>
</dl>

#### SimConfig.from\_yaml\_file

```python showLineNumbers={false}
staticmethod _config.SimConfig.from_yaml_file(
    file_path: str,
) -> SimConfig
```

Load an existing complete YAML config file into an editable
:class:`SimConfig`.

The import path reads asset defaults from the YAML `sim.*.default` keys
and does not require an `assets.yml` path. The returned object can be
edited with the normal builder API, for example `get_ru()`,
`get_ue()`, `add_ue()`, etc.

Import is semantic rather than byte preserving: comments, YAML scalar
style, anchors, duplicate keys, and original ordering are not preserved.

Import assumes the YAML file is generated by this client library.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>file\_path</code> (<code>str</code>) - Path to the YAML config file.
  </dd>

  <dt>
    Raises
  </dt>

  <dd>
    <code>RuntimeError</code>

     \- If the file cannot be opened, parsed, or imported.
  </dd>
</dl>

#### SimConfig.set\_simulation\_id

```python showLineNumbers={false}
_config.SimConfig.set_simulation_id(simulation_id: str)
```

Set the simulation ID (used as DB name and identifier).

#### SimConfig.set\_db

```python showLineNumbers={false}
_config.SimConfig.set_db(
    db_host: str = "localhost",
    db_port: int = 9000,
    db_author: str = "aerial",
    db_notes: str = "",
)
```

Set database connection parameters.

#### SimConfig.set\_num\_batches

```python showLineNumbers={false}
_config.SimConfig.set_num_batches(batches: int)
```

Set number of simulation batches (must be > 0).

#### SimConfig.set\_timeline

```python showLineNumbers={false}
_config.SimConfig.set_timeline(
    duration: float = None,
    interval: float = None,
    slots_per_batch: int = None,
    realizations_per_slot: int = None,
)
```

Set simulation timeline. Provide **either** *duration*/*interval*
(EM mode) **or** *slots\_per\_batch*/*realizations\_per\_slot* (RAN /
slot mode) -- not both.

#### SimConfig.set\_seed

```python showLineNumbers={false}
_config.SimConfig.set_seed(seed: int = 0)
```

Enable deterministic seeding for mobility.

#### SimConfig.add\_tables\_to\_db

```python showLineNumbers={false}
_config.SimConfig.add_tables_to_db(table: DBTable)
```

Add a result table to persist in the database.

#### SimConfig.add\_table\_option

```python showLineNumbers={false}
_config.SimConfig.add_table_option(
    table_name: str,
    option: str,
)
```

Set an option for an opt-in table (e.g.
`add_table_option("raypaths", "full")`).

#### SimConfig.set\_s3\_config

```python showLineNumbers={false}
_config.SimConfig.set_s3_config(s3_config: S3Config)
```

Set the global S3 config (**required**). Emitted as
`db.s3_config` in the YAML output.

#### SimConfig.enable\_parquet\_export

```python showLineNumbers={false}
_config.SimConfig.enable_parquet_export(
    timesteps_per_file: int = 100,
    compression: str = "zstd",
    max_workers: int = 2,
    verify_exports: bool = True,
)
```

Enable Parquet export to S3.

#### SimConfig.disable\_parquet\_export

```python showLineNumbers={false}
_config.SimConfig.disable_parquet_export()
```

Disable Parquet export.

#### SimConfig.add\_parquet\_s3\_config

```python showLineNumbers={false}
_config.SimConfig.add_parquet_s3_config(
    s3_config: S3Config,
    nodes: list[str] = ["node1"],
    use_ssl: bool = False,
)
```

Add an S3 storage config for Parquet export.

#### SimConfig.set\_parquet\_iceberg

```python showLineNumbers={false}
_config.SimConfig.set_parquet_iceberg(
    catalog_type: str = "rest",
    catalog_uri: str = "http://nessie:19120/iceberg",
    catalog_name: str = "default",
    aws_region: str = "",
    nessie_ref: str = "main",
)
```

Configure an Apache Iceberg catalog for Parquet export.

#### SimConfig.set\_ray\_tracing\_model

```python showLineNumbers={false}
_config.SimConfig.set_ray_tracing_model(
    diffuse_type: DiffusionModel = DiffusionModel.LAMBERTIAN,
    interactions: int = 5,
    max_num_paths_per_ant_pair: int = 500,
    emitted_rays_in_thousands: int = 500,
    fast_mode: bool = False,
)
```

Set EM ray tracing solver parameters.

#### SimConfig.enable\_wideband

```python showLineNumbers={false}
_config.SimConfig.enable_wideband()
```

Enable wideband simulation (automatically enabled when adding
`DBTable.CFRS`).

#### SimConfig.set\_default\_panel\_ru

```python showLineNumbers={false}
_config.SimConfig.set_default_panel_ru(panel: Panel)
```

Set the default RU panel (assigns ID 2). Must be called before
adding any DU, RU, or UE.

#### SimConfig.set\_default\_panel\_ue

```python showLineNumbers={false}
_config.SimConfig.set_default_panel_ue(panel: Panel)
```

Set the default UE panel (assigns ID 1). Must be called before
adding any DU, RU, or UE.

#### SimConfig.add\_panel

```python showLineNumbers={false}
_config.SimConfig.add_panel(panel: Panel)
```

Add an additional panel (auto-assigns an ID).

#### SimConfig.get\_default\_ru\_panel\_id

```python showLineNumbers={false}
_config.SimConfig.get_default_ru_panel_id() -> int
```

Return the ID of the panel registered as the default RU panel
(the YAML field `sim_gnb_panel_type`). Useful when re-editing a
config loaded via `SimConfig.from_yaml_file()`::

panel = config.get\_panel(config.get\_default\_ru\_panel\_id())
panel.set\_antenna\_elements(\[AntennaElement.Isotropic])

The underlying field is value-initialized (`2`), so a non-zero
return value does not by itself imply that a Panel with that ID
has been added to the config yet. This is safe on configs loaded
via `SimConfig.from_yaml_file()` (the import populates real
panels and defaults), but a brand-new `SimConfig()` may report
an ID that does not yet correspond to any registered panel.

#### SimConfig.get\_default\_ue\_panel\_id

```python showLineNumbers={false}
_config.SimConfig.get_default_ue_panel_id() -> int
```

Return the ID of the panel registered as the default UE panel
(the YAML field `sim_ue_panel_type`). See
`get_default_ru_panel_id()` for caveats on default
initialization.

#### SimConfig.add\_du

```python showLineNumbers={false}
_config.SimConfig.add_du(du: DU)
```

Add a DU to the configuration.

#### SimConfig.add\_ru

```python showLineNumbers={false}
_config.SimConfig.add_ru(ru: RU)
```

Add an RU to the configuration. The referenced DU must already
exist.

#### SimConfig.add\_ue

```python showLineNumbers={false}
_config.SimConfig.add_ue(ue: UE)
```

Add a UE to the configuration. At least one waypoint or GPX
source must be set.

#### SimConfig.get\_du

```python showLineNumbers={false}
_config.SimConfig.get_du(du_id: int) -> DU
```

Get a mutable reference to a DU by ID.

#### SimConfig.get\_ru

```python showLineNumbers={false}
_config.SimConfig.get_ru(ru_id: int) -> RU
```

Get a mutable reference to an RU by ID.

#### SimConfig.get\_ue

```python showLineNumbers={false}
_config.SimConfig.get_ue(ue_id: int) -> UE
```

Get a mutable reference to a UE by ID.

#### SimConfig.get\_panel

```python showLineNumbers={false}
_config.SimConfig.get_panel(panel_id: int) -> Panel
```

Get a mutable reference to a Panel by ID.

#### SimConfig.get\_ru\_ids

```python showLineNumbers={false}
_config.SimConfig.get_ru_ids() -> list[int]
```

Return the IDs of all RUs currently added to the config. The order
reflects the underlying hash map and must be treated as
unspecified.

#### SimConfig.get\_ue\_ids

```python showLineNumbers={false}
_config.SimConfig.get_ue_ids() -> list[int]
```

Return the IDs of all UEs currently added to the config (order
unspecified).

#### SimConfig.get\_du\_ids

```python showLineNumbers={false}
_config.SimConfig.get_du_ids() -> list[int]
```

Return the IDs of all DUs currently added to the config (order
unspecified).

#### SimConfig.get\_panel\_ids

```python showLineNumbers={false}
_config.SimConfig.get_panel_ids() -> list[int]
```

Return the IDs of all Panels currently added to the config (order
unspecified).

#### SimConfig.remove\_ue

```python showLineNumbers={false}
_config.SimConfig.remove_ue(ue_id: int)
```

Remove a UE from the configuration.

#### SimConfig.clear\_waypoints

```python showLineNumbers={false}
_config.SimConfig.clear_waypoints(ue_id: int)
```

Clear all waypoints for a given UE.

#### SimConfig.add\_ues\_from\_gpx

```python showLineNumbers={false}
_config.SimConfig.add_ues_from_gpx(
    gpx_src: str,
    ue_ids: list[int],
    use_pathfinding: bool = True,
)
```

Create UEs driven by a GPX file. Use `SimConfig.get_ue()`
to customize individual UEs afterwards.

#### SimConfig.add\_spawn\_zone

```python showLineNumbers={false}
_config.SimConfig.add_spawn_zone(points_ccw: list[Position])
```

Add a spawn zone for procedural UEs as a counter-clockwise
polygon. `SimConfig.add_spawn_zone` accepts only 2D points and
raises on 3D `Position` values.

#### SimConfig.set\_num\_procedural\_ues

```python showLineNumbers={false}
_config.SimConfig.set_num_procedural_ues(num: int)
```

Set number of procedural UEs.

#### SimConfig.set\_perc\_indoor\_procedural\_ues

```python showLineNumbers={false}
_config.SimConfig.set_perc_indoor_procedural_ues(
    perc: float,
)
```

Set percentage of indoor procedural UEs (0--100).

#### SimConfig.set\_ue\_speed

```python showLineNumbers={false}
_config.SimConfig.set_ue_speed(
    min_speed: float,
    max_speed: float,
)
```

Set speed range for procedural UEs in m/s.

#### SimConfig.enable\_urban\_mobility

```python showLineNumbers={false}
_config.SimConfig.enable_urban_mobility(vehicles: int)
```

Enable urban mobility simulation with the given number of
vehicles.

#### SimConfig.enable\_vegetation

```python showLineNumbers={false}
_config.SimConfig.enable_vegetation(geojson_path: str = "")
```

Enable vegetation rendering from GeoJSON data. If *geojson\_path*
is omitted, a default is derived from the scene URL as
`<scene_url>/sim/vegetation.geojson`. Enabled vegetation also emits
`gis.vegetation.vegetation_asset_path` from the required
`vegetation_assets` entry in `assets.yml`.

#### SimConfig.add\_material\_definition

```python showLineNumbers={false}
_config.SimConfig.add_material_definition(
    file: str,
    target: GeoTargets,
)
```

Add a material calibration definition file.

#### SimConfig.add\_material\_assignment

```python showLineNumbers={false}
_config.SimConfig.add_material_assignment(
    file: str,
    target: GeoTargets,
)
```

Add a material calibration assignment file.

#### SimConfig.set\_calibration\_targets

```python showLineNumbers={false}
_config.SimConfig.set_calibration_targets(
    materials: bool,
    veg_materials: bool,
    rus: bool,
    rus_beams: bool,
    ues: bool,
)
```

Set the calibration target flags. Call this before the other
calibration run configuration methods.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>materials</code> (<code>bool</code>) - Calibrate building materials.

    •<code>veg\_materials</code> (<code>bool</code>) - Calibrate vegetation materials.

    •<code>rus</code> (<code>bool</code>) - Calibrate RU angles.

    •<code>rus\_beams</code> (<code>bool</code>) - Calibrate RU beam settings.

    •<code>ues</code> (<code>bool</code>) - Calibrate UE angles.
  </dd>
</dl>

#### SimConfig.add\_calibration\_measurement

```python showLineNumbers={false}
_config.SimConfig.add_calibration_measurement(
    ru_id: int,
    ue_id: int,
    measurement_file: str,
)
```

Add one measured RU/UE link used as a calibration reference.
*measurement\_file* must be non-empty. At least one measurement is
required before exporting a calibration YAML.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>ru\_id</code> (<code>int</code>) - RU ID for the measured link.

    •<code>ue\_id</code> (<code>int</code>) - UE ID for the measured link.

    •<code>measurement\_file</code> (<code>str</code>) - Measurement CSV path.
  </dd>
</dl>

#### SimConfig.set\_calibration\_timeline

```python showLineNumbers={false}
_config.SimConfig.set_calibration_timeline(
    start: int = 0,
    step: int = 1,
    end: int = None,
)
```

Set the time indices used for calibration. *step* must be positive.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>start</code> (<code>int</code>) - First time index.

    •<code>step</code> (<code>int</code>) - Time index stride.

    •<code>end</code> (<code>int</code>) - Optional final time index.
  </dd>
</dl>

#### SimConfig.set\_calibration\_output

```python showLineNumbers={false}
_config.SimConfig.set_calibration_output(folder_key: str)
```

Set the calibration output S3 folder key under the configured bucket.
The folder key must be non-empty and is required before exporting a
calibration YAML.

#### SimConfig.set\_calibration\_execution\_mode

```python showLineNumbers={false}
_config.SimConfig.set_calibration_execution_mode(
    execution_mode: str,
)
```

Override the calibration execution mode. Typical calibration configs
should leave this unset; when omitted, the calibration pipeline derives
the execution mode from `SimConfig.set_calibration_targets()`.

Use this only when an explicit training bitmask or calibration pipeline
debug mode is required. For example, `"0"` means debug forward pass;
positive values are calibration-group bitmasks.

#### SimConfig.set\_calibration\_keep\_local\_output

```python showLineNumbers={false}
_config.SimConfig.set_calibration_keep_local_output(
    keep_local_output: bool,
)
```

Set whether calibration keeps local output files.

#### SimConfig.set\_bldg\_exterior\_attr

```python showLineNumbers={false}
_config.SimConfig.set_bldg_exterior_attr(
    activate_rf: bool,
    activate_diffraction: bool,
    activate_diffusion: bool,
    activate_transmission: bool,
    diffuse_surface_element_area: float = None,
    building_ids: list[str] = [],
)
```

Convenience wrapper to set RF attributes for exterior buildings.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>activate\_rf</code> (<code>bool</code>) - Enable RF mesh for exterior surfaces.

    •<code>activate\_diffraction</code> (<code>bool</code>) - Enable diffraction.

    •<code>activate\_diffusion</code> (<code>bool</code>) - Enable diffusion.

    •<code>activate\_transmission</code> (<code>bool</code>) - Enable transmission.

    •<code>diffuse\_surface\_element\_area</code> (<code>float</code>) - Diffuse surface element area in m^2.

    •<code>building\_ids</code> (<code>list\[str]</code>) - Building IDs to target. Empty list = all buildings.
  </dd>
</dl>

#### SimConfig.set\_bldg\_interior\_attr

```python showLineNumbers={false}
_config.SimConfig.set_bldg_interior_attr(
    activate_rf: bool,
    activate_diffraction: bool,
    activate_transmission: bool,
    building_ids: list[str] = [],
)
```

Convenience wrapper to set RF attributes for interior buildings.

<dl>
  <dt>
    Parameters
  </dt>

  <dd>
    •<code>activate\_rf</code> (<code>bool</code>) - Enable RF mesh for interior surfaces.

    •<code>activate\_diffraction</code> (<code>bool</code>) - Enable diffraction.

    •<code>activate\_transmission</code> (<code>bool</code>) - Enable transmission.

    •<code>building\_ids</code> (<code>list\[str]</code>) - Building IDs to target. Empty list = all buildings.
  </dd>
</dl>

#### SimConfig.set\_ues\_height

```python showLineNumbers={false}
_config.SimConfig.set_ues_height(
    height_m: float,
    ids: list[int] = [],
)
```

Set UE height for selected UEs. Empty *ids* = all UEs.

#### SimConfig.set\_ues\_power

```python showLineNumbers={false}
_config.SimConfig.set_ues_power(
    radiated_power_dbm: float,
    ids: list[int] = [],
)
```

Set UE radiated power for selected UEs.

#### SimConfig.set\_rus\_power

```python showLineNumbers={false}
_config.SimConfig.set_rus_power(
    radiated_power_dbm: float,
    ids: list[int] = [],
)
```

Set RU radiated power for selected RUs.

#### SimConfig.to\_dict

```python showLineNumbers={false}
_config.SimConfig.to_dict() -> dict
```

Convert the configuration to a nested Python dictionary,
compatible with `OmegaConf.save()`.