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
Setup
Load a geographic scene
The antennas inside the scene
Values the source does not give
Add the antennas as native transmitters
Solve and inspect the radio map
Registered sites versus crowdsourced cells
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 |
|
25 m, the OWRT transmitter default; Sionna has none |
Azimuth |
|
Sionna’s zero orientation: boresight towards east |
Downtilt |
|
Sionna’s zero orientation: horizontal |
Transmit power of each emission |
|
44 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")
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.")
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/sourcesunder the checkout), pinned by export date and SHA-256.owrt sources refresh anfrinstalls a newer export; until then every call reads the same data.Defaults. The values a source does not give are listed in
basisand in the result’s warnings; change them withdefaults.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
antennasselection 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.