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:

```python
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

```text
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](../README.md)