docs/schema-reference.md

Channels4World schema reference

Names, types, shapes and units of every file in release 1.0.0. The release's schema/ folder holds the authoritative versions (arrays.json, conventions.json, interaction-codes.json and release-profile.json); every record header refers to conventions.json by its SHA-256.

Numeric payloads

Each numeric NPZ has the listed arrays and a scalar string __meta__ containing JSON (schema="wireless.npz-meta", version=2). Use np.load(..., allow_pickle=False). NumPy dtype strings specify byte order: < = little endian; | = one-byte value. Dimensions below are per record: L retained links, P retained paths, I interactions, B BS positions, U UE positions. Every scene has B=32 and U=16384; L, P and I vary. Counts, IDs, ranks and offsets are unitless integers.

Core: one scene × carrier × BS

Exact name	NumPy dtype	Shape	Unit	Meaning
link_ue_index	<i4 (int32)	(L,)	UE row index	Strictly increasing unique retained UE IDs; indexes scene ue_positions
link_path_offsets	<i8 (int64)	(L+1,)	Path offset	Half-open path span per link
path_rank	|u1 (uint8)	(P,)	Rank	0-based position within its link, by decreasing float32 power (see below)
a_real	<f4 (float32)	(P,)	1	Real part of stored scalar passband coefficient
a_imag	<f4	(P,)	1	Imaginary part of stored scalar passband coefficient
tau	<f4	(P,)	s	Absolute propagation delay
theta_t	<f4	(P,)	rad	Departure zenith from +z at BS
phi_t	<f4	(P,)	rad	Departure azimuth from +x toward +y at BS
theta_r	<f4	(P,)	rad	Arrival zenith from +z at UE
phi_r	<f4	(P,)	rad	Arrival azimuth from +x toward +y at UE
interaction_count	|u1 (uint8)	(P,)	Count	Number of interactions on each retained path
interaction_flags	<u2 (uint16)	(P,)	Bit mask	OR of 1 << interaction_type, not OR of raw codes

a_real + 1j*a_imag excludes the carrier-delay phase. tau is not delay spread. Summed |a|² is relative to unit coefficient power, not dBm/RSRP. For baseband phase or a frequency response, see the library's optional transforms below; the card's examples inspect stored coefficients without synthesizing a response.

Retention, order and ranks. For each link, at most the 16 strongest candidate paths are kept, and only those with 10·log10|a|² > −150 dB. Paths within a link are ordered by decreasing power computed in single (float32) precision; recomputing power in double precision can swap near-equal neighbours (differences below 1e-6 dB). The conventions document defines path_rank as the rank before the −150 dB threshold, with gaps retained. Because the threshold removes only the weakest candidates, the kept ranks are always the first ones, so path_rank equals the path's 0-based position within its link. In all of Tiny, path_rank and interaction_rank are contiguous and 0-based.

Detail: same scene × carrier × BS and core path axis

Exact name	NumPy dtype	Shape	Unit	Meaning
path_interaction_offsets	<i8 (int64)	(P+1,)	Interaction offset	Half-open interaction span for each core path
interaction_rank	|u1 (uint8)	(I,)	Rank	0-based position along the path, BS to UE
interaction_type	|i1 (int8)	(I,)	Code	1 specular reflection, 8 diffraction (see below)
interaction_vertex	<f4 (float32)	(I,3)	m	Interaction (x,y,z), ordered BS→UE

The interaction codebook defines 1 specular reflection, 2 diffuse reflection, 4 refraction and 8 diffraction (0 means none). Channels4World models line of sight, specular reflection and diffraction, with up to four interactions per path, so stored rows use codes 1 and 8 and the matching flag bits 2 and 256. A line-of-sight path has zero interactions: an empty span and a zero flag. Detail and core must share path_axis_sha256, not merely array lengths.

Positions: one scene, shared by carriers

Exact name	NumPy dtype	Shape	Unit	Meaning
bs_positions	<f4 (float32)	(B,3)	m	BS row = zero-based BS ID
ue_positions	<f4 (float32)	(U,3)	m	UE row = zero-based UE ID

The frame is right-handed scene Cartesian (x,y,z) with +z up. Coordinates are local to each scene and not georeferenced; the ground is flat at z=0, so z is height above ground. Scene assets have frequency_hz=null and bs_index=null in their identity. The two carriers reuse these scene assets.

UE → path → interaction offsets

All indices are zero-based. Offsets start at zero, are non-decreasing, and end at the length of the spanned axis. Slices are half-open:

i = 0                              # retained-link row, NOT a UE ID
ue_id = int(core["link_ue_index"][i])
xyz = positions["ue_positions"][ue_id]
p0, p1 = map(int, core["link_path_offsets"][i:i+2])
# Core path j is in [p0, p1).
j = p0                             # only if p0 < p1
k0, k1 = map(int, detail["path_interaction_offsets"][j:j+2])
vertices = detail["interaction_vertex"][k0:k1]

For every path j, interaction_count[j] equals path_interaction_offsets[j+1] - path_interaction_offsets[j] when both components are present. The three interaction arrays share row k. Path fields share row j; path_rank is a position within the link, not the flat path index. Preserve link_ue_index whenever filtering or joining records. A UE ID that is not listed has no retained link: do not renumber the remaining UEs or treat the missing ones as zero power.

Illustrative indexing only: UE IDs [2,9], link offsets [0,2,3] assign paths 0,1 to UE 2 and path 2 to UE 9. Interaction offsets [0,1,1,3] assign one, zero and two interactions to those three paths. Coordinates come from position rows 2 and 9, not rows 0 and 1.

Numeric record metadata and identity

Header field	Type / structure	Meaning
schema, version	string, integer	wireless.npz-meta, 2
identity	object	collection_id (string), scene_id (string), component (string), frequency_hz (integer Hz or null), bs_index (integer or null)
conventions	{ref, sha256}	Relative path and exact SHA-256 of interpretation document
dimensions	object of integers	Core {links,paths}; detail {paths,interactions}; positions {bs,ues}
path_axis_sha256	SHA-256 string, core/detail	Associates UE IDs, link offsets and path ranks across components
dependencies.positions	object, core	Positions record_id, content_sha256, conventions_sha256, bs, ues
dependencies.core_axis	object, detail	Core record_id, path_axis_sha256, conventions_sha256, and positions dependency
info	object	Supplementary metadata; not a replacement for identity or dependencies

A record_id is the SHA-256 of the identity serialized as JSON with sorted keys, compact separators and UTF-8. To associate components, match the full identity and dependency hashes. The group snapshot records the numeric manifests, content hashes and NPZ byte hashes; each hash has its own meaning, so do not substitute one for another. collection_id is channels4world-v1-20260714 for every record of this release.

Root manifest and catalogs

c4w-root.json: format="channels4world.root", format_version=1. Other fields are kind (release, subset, or cache), payload (tar, loose, or cache representation), collection_id, release, ordered tiers, frequencies_hz (integer Hz list), hf_repo, hf_path, tables and source. Each table reference has path, sha256 and bytes. Subsets, including Tiny, also record created_by; their source records the source release, its kind and the SHA-256 of its root manifest.

The reader opens all tables referenced by this manifest. Tiny therefore needs the manifest plus its scenes, files and records tables even when only one scene's payloads are downloaded. Group metadata and payloads load lazily afterward, so an explicit downloaded scene can be read from a partial Tiny root.

Every path inside a root is relative to that root. hf_repo and hf_path record where a published root lives: hf_path is "" for the release root at the top of Intelligence-Networking-Lab/Channels4World and "tiny" for Tiny. Only download planning (MissingReport.repo_files, local_dir, hf_command) adds hf_path. Subsets and caches made locally with extract/to_cache have both fields null, so the library never proposes downloading their loose files from the repository.

Root table	Exact columns and Arrow types
c4w-root/scenes.parquet	scene_id:string, split:string, profile:string, tier:string, group:string, group_order:int64, scene_order:int64
c4w-root/files.parquet	path:string, bytes:int64, sha256:string, group:string, kind:string, component:string, frequency_hz:int64, record_id:string
c4w-root/records.parquet	record_id:string; subsets and caches only (Tiny has one), listing the included records

Root table fields are nullable in the Arrow schemas; which apply depends on the row's kind. bytes is file size in bytes. path is relative to the root. tier is the smallest containing tier; group_order and scene_order fix iteration order (scene_order is also the member order inside each archive). split is train or test. profile is urban, metropolitan or suburban; metro appears only in group names, archive names and scene IDs. Take scene and BS IDs from the catalogs.

For a TAR payload row, record_id is null because one file holds many records. For loose payload rows it identifies the single included record. group, component and frequency_hz are null where they do not apply. kind is payload, snapshot, members, catalog or schema; the format also defines cache_index and cache_array for local caches. The root files themselves (c4w-root.json, c4w-root/) are not listed.

Group metadata

File	Fields / role
groups/<group>/catalog/members.parquet	record_id:string, object_path:string, member_path:string, data_offset:int64, member_bytes:int64, member_sha256:string
groups/<group>/catalog/objects.parquet	object_path, object_bytes, object_sha256: each archive's size and byte hash
groups/<group>/catalog/scenes.parquet	The group's scenes, including scene_id, scene_order, split and profile
groups/<group>/catalog/records.parquet, geometry.parquet	Per-record and per-geometry descriptions used by the library
groups/<group>/snapshot.json	wireless.numeric-snapshot v1: conventions reference and each numeric record's declarations and content proofs

data_offset is the byte offset of member data in an uncompressed TAR, not the TAR header offset. member_bytes is the embedded NPZ/ZIP byte length. Together they locate one record's bytes inside an archive, so a byte-range read can fetch it without the rest of the archive. member_path is also the file's path after extraction. Subset roots keep the original group metadata and shared schemas; only the subset root's records table defines what the subset contains, and other group catalogs can remain present.

Archives are plain, uncompressed POSIX ustar TARs with regular-file members only and normalized member metadata (mode 0644, uid and gid 0, mtime 0). A channel archive has 800 members (25 scenes × 32 BSs), ordered by scene_order and then by BS; a scene-asset archive has 25.

Geometry

Geometry is a ZIP rather than a numeric NPZ. scene.json identifies an entrypoint XML; the archive also contains Mitsuba XML and OBJ meshes in metres. Preserve their relative paths when extracting. Its identity uses null carrier and BS, like positions.

Library API used on the card

open(path) -> Dataset
Dataset.select(*, split=None, tier=None, profile=None, scene_ids=None,
               frequencies_hz=None, bs_ids=None,
               components=("core", "positions", "geometry")) -> Selection
Dataset.profiles; Dataset.scene(scene_id) -> Scene
Scene.profile; Scene.frequencies[integer_Hz].base_stations[integer_BS]
BaseStation.read(detail=False, verify="basic") -> Record
Scene.read_positions(verify="basic") -> Positions
Record.ue_ids; Record.core; Record.detail; Record.get_link(ue_id)
extract(selection, dest, *, verify="basic", check_space=True,
        skip_existing=False, confirm=None) -> Path
to_cache(selection, dest, *, verify="basic", check_space=True, confirm=None) -> Path

Selections are lazy; read() performs payload I/O and returns read-only arrays. Use copies for manipulation. Selection.missing() distinguishes requested missing files from unpublished components. verify="basic" checks published bytes and declared structure; verify="full" additionally checks scientific rules and content proofs. Core/detail association is checked together on a full read of both components.

Optional channels4world.transforms functions operate on a loaded record and return new writable arrays: complex_gain(rec), path_power_db(rec), delay_spread(rec), baseband_coefficients(rec, delay_reference="absolute"), and frequency_response(rec, offsets_hz, delay_reference="absolute", max_elements=1<<22). These describe retained paths only. frequency_response takes offsets from the record's carrier, not absolute carrier frequencies. A local NPY cache stores parts by group/component/carrier, with one NPY per array and an index; numeric arrays can then be memory-mapped. This changes the local representation, not the scene tier.

Return to dataset card