Registered antennas as Sionna transmitters#

A geographic scene gives Sionna RT the environment. This tutorial takes the transmitters from an antenna source as well: the register of the French frequency agency (ANFR) around the Opéra in Paris, whose antennas carry their real position, height and azimuth. owrt.antennas returns them as records that go straight into sionna.rt.Transmitter; the arrays, the solver and the viewers stay the upstream Sionna API.

Outline

  1. Setup

  2. Load a geographic scene

  3. The antennas inside the scene

  4. Values the source does not give

  5. Add the antennas as native transmitters

  6. Solve and inspect the radio map

  7. Registered sites versus crowdsourced cells

  8. Provenance

1. Setup#

One simulation has one carrier: a Sionna scene has one frequency, bandwidth and tx_array for all its transmitters. The selection below therefore takes one downlink channel, with every antenna that transmits on it. QUALITY trades run time for fidelity; the stored outputs use "draft", computed on a CPU.

import json
from collections import Counter
from pathlib import Path

import matplotlib.pyplot as plt
import numpy as np

from openworld_radio_twin import rt as owrt

DEVICE = "auto"  # "auto" | "cuda" | "cpu"
CACHE_DIR = Path(".cache/owrt-antennas")

# Paris, the Opéra and the grands boulevards: rooftop antennas of four mobile networks.
LOCATION = dict(latitude=48.8719, longitude=2.3316, radius_m=300)
CHANNEL = (1805, 1825)  # MHz: Orange's LTE 1800 downlink block in the register
OPERATOR = "208-01"  # PLMN of Orange France, for the comparison with OpenCelliD
RX_HEIGHT_M = 1.5

QUALITY = "draft"  # "draft" | "high" | "ultra"
QUALITY_PRESETS = {
    "draft": dict(terrain_resolution_m=5.0, cell_size=5.0, samples_per_tx=1_000_000, max_depth=5),
    "high": dict(terrain_resolution_m=2.0, cell_size=2.0, samples_per_tx=10_000_000, max_depth=6),
    "ultra": dict(terrain_resolution_m=1.0, cell_size=1.0, samples_per_tx=100_000_000, max_depth=8),
}
quality = QUALITY_PRESETS[QUALITY]
SEED = 42

2. Load a geographic scene#

The environment is compiled as in any OWRT notebook. Antennas are not a load_scene option: they are radio devices, and the carrier, which decides which antennas apply, the arrays and the powers are Sionna settings chosen afterwards. The compiled scene is therefore reused for any antenna selection.

scene = owrt.load_scene(
    **LOCATION,
    terrain_resolution_m=quality["terrain_resolution_m"],
    cache_dir=CACHE_DIR,
    device=DEVICE,
)

import sionna.rt as rt  # noqa: E402 - the Mitsuba variant is now fixed

compilation = json.loads((owrt.scene_path(scene) / "scene_info.json").read_text())["provenance"]
print(
    f"{compilation['exported_building_count']} buildings from {compilation['building_provider']} "
    f"{compilation['building_release'] or ''}".rstrip()
)
355 buildings from Overture Maps 2026-09-23.1

3. The antennas inside the scene#

owrt.antennas(scene) queries the source that auto selects for the scene centre, ANFR in France, keeps the antennas inside the scene square and places them in scene coordinates. The source is read from a local snapshot of its published export; the first call downloads it once.

everything = owrt.antennas(scene)
print(f"{len(everything.antennas)} antennas from {everything.provider}, release {everything.release}")
print(f"{everything.attribution}; {everything.license}\n")

operators = Counter(
    f"{antenna.operator} ({antenna.plmn})" if antenna.plmn else antenna.operator
    for antenna in everything.antennas
)
print("Antennas per operator:")
for name, count in operators.most_common():
    print(f"  {name:<32}{count:>4}")
names = {antenna.operator_id: antenna.operator for antenna in everything.antennas}
print("\nDownlink channels (MHz):")
for channel in everything.channels:
    note = "" if channel.sionna_supported else "  below 1 GHz: CPU preview only"
    print(
        f"  {channel.low_mhz:>7g}-{channel.high_mhz:<7g}{', '.join(channel.labels):<30}"
        f"{', '.join(names[item] for item in channel.operators):<20}{channel.antenna_count:>4}{note}"
    )
85 antennas from ANFR installations > 5 W, release 2026-08-31:9909cfcefc86
Agence nationale des fréquences (ANFR), via data.gouv.fr; Licence Ouverte 2.0

Antennas per operator:
  FREE MOBILE (208-15)              29
  BOUYGUES TELECOM (208-20)         22
  SFR (208-10)                      19
  ORANGE (208-01)                   15

Downlink channels (MHz):
      758-763    LTE 700                       SFR                    3  below 1 GHz: CPU preview only
      763-773    5G NR 700, LTE 700            ORANGE                 7  below 1 GHz: CPU preview only
      773-778    LTE 700                       BOUYGUES TELECOM      15  below 1 GHz: CPU preview only
      778-788    5G NR 700, LTE 700            FREE MOBILE           19  below 1 GHz: CPU preview only
      791-801    LTE 800                       BOUYGUES TELECOM      15  below 1 GHz: CPU preview only
      801-811    LTE 800                       SFR                    8  below 1 GHz: CPU preview only
      811-821    LTE 800                       ORANGE                 8  below 1 GHz: CPU preview only
    925.1-933.8  GSM 900, UMTS 900             BOUYGUES TELECOM      12  below 1 GHz: CPU preview only
    925.1-934.9  GSM 900, UMTS 900             BOUYGUES TELECOM       6  below 1 GHz: CPU preview only
    934.9-943.6  GSM 900, UMTS 900             ORANGE                 6  below 1 GHz: CPU preview only
    942.5-951.2  LTE 900                       FREE MOBILE           19  below 1 GHz: CPU preview only
    951.2-959.9  GSM 900, UMTS 900             SFR                    8  below 1 GHz: CPU preview only
     1805-1825   LTE 1800                      ORANGE                10
     1825-1845   LTE 1800                      SFR                   12
     1845-1860   LTE 1800                      FREE MOBILE           19
     1860-1880   LTE 1800                      BOUYGUES TELECOM      15
   1915.1-1920.1 UMTS 2100                     SFR                    6
   2110.5-2125.3 LTE 2100, UMTS 2100           SFR                   12
   2125.3-2140.1 5G NR 2100, LTE 2100          BOUYGUES TELECOM      15
   2140.1-2154.9 LTE 2100                      FREE MOBILE           13
   2149.9-2154.9 LTE 2100, UMTS 2100           SFR, FREE MOBILE      19
   2154.9-2169.7 LTE 2100                      ORANGE                10
     2620-2635   LTE 2600                      SFR                   11
     2635-2655   LTE 2600                      ORANGE                 9
     2655-2670   LTE 2600                      BOUYGUES TELECOM      15
     2670-2690   LTE 2600                      FREE MOBILE           19
     3490-3570   5G NR 3500                    SFR                    6
     3570-3640   5G NR 3500                    BOUYGUES TELECOM      13
     3640-3710   5G NR 3500                    FREE MOBILE           16
     3710-3800   5G NR 3500                    ORANGE                 7

An antenna usually carries several systems, and the register lists each one’s uplink and downlink ranges. OWRT classifies every range against the 3GPP operating bands and lists the distinct downlink ranges as channels. channel keeps every antenna that transmits on the channel, whatever operator or technology its record names, so every co-channel interferer in the scene is present. An antenna transmits on the channel when one of its downlink ranges contains it, at its own power. operator and radio also filter; the selection happens before placement, so the notes below concern only the selected antennas.

found = owrt.antennas(scene, channel=CHANNEL)
print(f"{len(found.antennas)} antennas on {CHANNEL[0]}-{CHANNEL[1]} MHz, operators {sorted({a.operator for a in found.antennas})}\n")
print(f"{'antenna':<18}{'height (m)':>12}  {'basis':<9}{'azimuth':>9}  {'basis':<9}{'power':>7}  basis")
for antenna in found.antennas:
    basis = antenna.basis
    print(
        f"{antenna.feature_id:<18}{antenna.height_agl_m:>12.1f}  {basis['height_agl_m']:<9}"
        f"{antenna.azimuth_deg:>9.0f}  {basis['azimuth_deg']:<9}{antenna.power_dbm:>7.0f}  "
        f"{basis['power_dbm']}"
    )
print()
for warning in found.warnings:
    print("-", warning)
10 antennas on 1805-1825 MHz, operators ['ORANGE']

antenna             height (m)  basis      azimuth  basis      power  basis
anfr:1271307              40.0  source           6  source        44  default
anfr:1271309              45.5  source         155  source        44  default
anfr:1271311              44.6  source         245  source        44  default
anfr:1930671              33.6  source          30  source        44  default
anfr:1930673              33.6  source         150  source        44  default
anfr:1930675              29.0  source         280  source        44  default
anfr:3916522              28.3  source          90  source        44  default
anfr:3916524              28.3  source         350  source        44  default
anfr:6114003              23.2  adjusted       345  source        44  default
anfr:6850532              23.2  adjusted        90  default       44  default

- Excluded 9 antenna records outside the square scene; interference from sites beyond the scene boundary is not modelled.
- Default values used where the source gives none: azimuth for 1, downtilt for 10, power for 10.
- Raised 2 antennas that would sit inside a building to 1 m above its roof.

4. Values the source does not give#

Sionna needs a position, an orientation and a power for every transmitter. The register gives position, height above ground, and the azimuth of directional antennas; it records no downtilt and no power. Every value a source does not give takes a default, marked "default" in the record’s basis. Where Sionna defines a default, it is Sionna’s:

Value

Sionna parameter

Default when missing

Height above ground

position (z)

25 m, the OWRT transmitter default; Sionna has none

Azimuth

orientation (alpha)

Sionna’s zero orientation: boresight towards east

Downtilt

orientation (beta)

Sionna’s zero orientation: horizontal

Transmit power of each emission

power_dbm

44 dBm, sionna.rt.constants.DEFAULT_TRANSMIT_POWER_DBM

basis also shows "adjusted": an antenna that would sit inside a building of this scene is raised 1 m above its roof, because the register and the building source disagree on heights and a transmitter inside a closed shell reaches no receiver. defaults replaces any entry. Here the macro cells get a common 6° downtilt; the values the register gives are kept.

found = owrt.antennas(scene, channel=CHANNEL, defaults={"downtilt_deg": 6.0})
tilts = Counter((antenna.downtilt_deg, antenna.basis["downtilt_deg"]) for antenna in found.antennas)
print("Downtilt and its basis:", dict(tilts))
print("Height basis:", dict(Counter(antenna.basis["height_agl_m"] for antenna in found.antennas)))
print("Azimuth basis:", dict(Counter(antenna.basis["azimuth_deg"] for antenna in found.antennas)))
Downtilt and its basis: {(6.0, 'default'): 10}
Height basis: {'source': 8, 'adjusted': 2}
Azimuth basis: {'source': 9, 'default': 1}

5. Add the antennas as native transmitters#

Each record carries position (scene metres, terrain included), orientation (Sionna’s rotation angles, converted from the compass azimuth and the downtilt) and its transmit power. The channel’s centre is the carrier and its width the noise bandwidth. The 3GPP TR 38.901 pattern gives the panels their direction. Antennas without a registered azimuth keep the default orientation; for a source that records no azimuth at all, an isotropic array fits.

scene.frequency = found.channel.centre_hz
scene.bandwidth = found.channel.bandwidth_hz
scene.tx_array = rt.PlanarArray(num_rows=4, num_cols=2, pattern="tr38901", polarization="V")
scene.rx_array = rt.PlanarArray(num_rows=1, num_cols=1, pattern="iso", polarization="V")

for antenna in found.antennas:
    scene.add(
        rt.Transmitter(
            name=antenna.feature_id,
            position=antenna.position,
            orientation=antenna.orientation,
            power_dbm=antenna.power_dbm,
        )
    )
print(f"{len(scene.transmitters)} transmitters at {found.channel.centre_hz / 1e9:.3f} GHz, {found.channel.bandwidth_hz / 1e6:g} MHz")
10 transmitters at 1.815 GHz, 20 MHz

The scene in Sionna’s interactive viewer, with the transmitters as Sionna draws them. Drag to orbit, scroll to zoom.

scene.preview(resolution=(1400, 900))

6. Solve and inspect the radio map#

The receivers follow the terrain on OWRT’s measurement surface; the solver call is unchanged Sionna.

surface = owrt.measurement_surface(scene, cell_size=quality["cell_size"], height=RX_HEIGHT_M)
radio_map = rt.RadioMapSolver()(
    scene,
    measurement_surface=surface,
    samples_per_tx=quality["samples_per_tx"],
    max_depth=quality["max_depth"],
    seed=SEED,
)
print(f"{type(radio_map).__name__}: {radio_map.cells_count:,} triangles, {len(scene.transmitters)} transmitters")
MeshRadioMap: 28,800 triangles, 10 transmitters
scene.preview(radio_map=radio_map, rm_metric="path_gain", rm_vmin=-140, rm_vmax=-60, resolution=(1400, 900))

The top-down view: received power of the strongest antenna per cell, and which antenna serves each cell. Arrows show the registered azimuths; the downtilt of each antenna is the 6° default.

mesh = radio_map.measurement_surface
vertices = np.asarray(mesh.vertex_positions_buffer()).reshape(-1, 3)
faces = np.asarray(mesh.faces_buffer()).reshape(-1, 3)
rss = radio_map.rss.numpy()  # (transmitters, triangles), watts
strongest = rss.max(axis=0)
with np.errstate(divide="ignore"):
    rss_dbm = np.where(strongest > 0, 10 * np.log10(strongest) + 30, np.nan)
serving = np.where(strongest > 0, rss.argmax(axis=0), -1).astype(float)
serving[serving < 0] = np.nan


def draw_antennas(ax, antennas, color="white"):
    for antenna in antennas:
        east, north, _ = antenna.position
        ax.plot(east, north, "^", color=color, markersize=8, markeredgecolor="black")
        if antenna.basis["azimuth_deg"] == "source":
            azimuth = np.radians(antenna.azimuth_deg)
            ax.annotate(
                "", xy=(east + 40 * np.sin(azimuth), north + 40 * np.cos(azimuth)), xytext=(east, north),
                arrowprops=dict(arrowstyle="->", color=color, lw=1.4),
            )


fig, axes = plt.subplots(1, 2, figsize=(13, 5.8), constrained_layout=True)
for ax in axes:
    ax.set_facecolor("#e6e8eb")
    ax.set_aspect("equal")
    ax.set_xlabel("East (m)")
    ax.set_ylabel("North (m)")
image = axes[0].tripcolor(vertices[:, 0], vertices[:, 1], faces, facecolors=rss_dbm, cmap="inferno", vmin=-110, vmax=-20)
fig.colorbar(image, ax=axes[0], label="RSS of the strongest antenna (dBm)", shrink=0.85)
axes[0].set_title(f"{CHANNEL[0]}-{CHANNEL[1]} MHz: received power")
axes[1].tripcolor(vertices[:, 0], vertices[:, 1], faces, facecolors=serving, cmap="tab20")
axes[1].set_title("Serving antenna")
for ax in axes:
    draw_antennas(ax, found.antennas)
plt.show()

print(f"Covered cells: {np.isfinite(rss_dbm).mean():.1%}; median RSS {np.nanmedian(rss_dbm):.1f} dBm")
../_images/15a4e66d73122d8ca41087d75f3260749799b090a6d25642867f51eb7618d1cf.png
Covered cells: 93.2%; median RSS -37.7 dBm

7. Registered sites versus crowdsourced cells#

Outside France, the Netherlands and Poland, auto falls back to OpenCelliD when a token (OWRT_OPENCELLID_TOKEN) or an installed snapshot makes it available. OpenCelliD records where phones observed a cell: its positions are centroids of measurements, and it gives no height, azimuth, tilt, power or band. Plotting both sources for the same operator shows what that means for a transmitter layout.

from openworld_radio_twin.config import get_settings  # noqa: E402
from openworld_radio_twin.providers.opencellid import configured  # noqa: E402

if configured(get_settings()):
    cells = owrt.antennas(scene, source="opencellid", operator=OPERATOR, radio="LTE")
    lte = owrt.antennas(scene, operator=OPERATOR, radio="LTE")
    supports = {antenna.site_id: antenna.position[:2] for antenna in lte.antennas}
    fig, ax = plt.subplots(figsize=(6.4, 6), constrained_layout=True)
    registered = np.array(list(supports.values()))
    observed = np.array([antenna.position[:2] for antenna in cells.antennas])
    ax.scatter(*registered.T, marker="^", s=70, color="crimson", label=f"ANFR LTE supports ({len(registered)})")
    ax.scatter(*observed.T, marker="o", s=30, color="steelblue", label=f"OpenCelliD LTE sites ({len(observed)})")
    limit = LOCATION["radius_m"]
    ax.set(xlim=(-limit, limit), ylim=(-limit, limit), xlabel="East (m)", ylabel="North (m)")
    ax.set_aspect("equal")
    ax.legend(loc="upper right")
    ax.set_title(f"{OPERATOR}: registered LTE supports and crowdsourced LTE sites")
    plt.show()
    print(cells.attribution, "·", cells.license)
else:
    print("OpenCelliD is not configured; set OWRT_OPENCELLID_TOKEN to download its export.")
../_images/3cfc974a2d1c05ec11d5ab2aa78e8b6f338b0d1dda71681c19c67f0f9eff4055.png
Cell tower data from OpenCelliD (https://opencellid.org) · CC BY-SA 4.0

8. Provenance#

Every call records its selection in the scene directory under antennas/: the query, the resolved source and its release, the licence, the warnings and the placed records. The compiled geometry and its cache key do not change.

scene_dir = owrt.scene_path(scene)
records = json.loads((scene_dir / "scene_info.json").read_text())["shared_assets"]["antenna_records"]
latest = json.loads((scene_dir / records[-1]).read_text())
print("Records:", *records, sep="\n  ")
print("\nLast query:", latest["query"])
print("Source:", latest["source_selection"]["resolved"], latest["release"], "·", latest["license"])
Records:
  antennas/anfr-671c3a691725b42e.json
  antennas/anfr-37d14c5065f47521.json
  antennas/anfr-099b8d33e657c705.json
  antennas/opencellid-c3bbeb6e64109bc5.json
  antennas/anfr-30f7c7747dd3c56a.json

Last query: {'source': 'auto', 'operator': '208-01', 'radio': 'LTE', 'channel': None, 'defaults': {'height_agl_m': 25.0, 'azimuth_deg': 90.0, 'downtilt_deg': 0.0, 'power_dbm': 44.0, 'sectors': None, 'roof_clearance_m': 1.0}}
Source: anfr 2026-08-31:9909cfcefc86 · Licence Ouverte 2.0

Reproducibility notes#

  • Snapshots. Sources are read from local snapshots under OWRT_SOURCE_CACHE_ROOT (default .cache/sources under the checkout), pinned by export date and SHA-256. owrt sources refresh anfr installs a newer export; until then every call reads the same data.

  • Defaults. The values a source does not give are listed in basis and in the result’s warnings; change them with defaults.

  • Licences. ANFR data is under Licence Ouverte 2.0. Data adapted from OpenCelliD is shared under CC BY-SA 4.0 with the credit “Cell tower data from OpenCelliD (https://opencellid.org)”.

  • Datasets. A dataset scene with an antennas selection acquires its antennas once; each radio map takes a downlink channel, uses the antennas on it and samples the values the source does not give from its ranges; see the dataset guide.