1.0.0 release

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,526 @@
+---
+pretty_name: Channels4World
+license: cc-by-4.0
+language:
+  - en
+tags:
+  - wireless
+  - ray-tracing
+  - sionna
+  - channel-modeling
+  - radio-propagation
+  - synthetic
+size_categories:
+  - 100K<n<1M
+configs:
+  - config_name: scenes
+    default: true
+    data_files:
+      - split: catalog
+        path: c4w-root/scenes.parquet
+  - config_name: files
+    data_files:
+      - split: catalog
+        path: c4w-root/files.parquet
+  - config_name: tiny_scenes
+    data_files:
+      - split: catalog
+        path: tiny/c4w-root/scenes.parquet
+---
+
+# Channels4World
+
+**An environment-scale foundation for wireless AI.** Channels4World is a ray-traced
+wireless channel dataset for learning across many environments, from wireless foundation
+models to channel prediction and localization: **100,000 synthetic outdoor scenes**, each
+with **32 base stations (BSs) and 16,384 UE positions**, simulated at **3.5 and 7 GHz** with
+Sionna RT. Scenes come from three generation profiles (urban, metropolitan and suburban).
+Train and test are split by scene, and nested tiers from 200 to 100,000 scenes let you scale
+the number of environments separately from the data in each.
+
+**Get data:** [Choose a subset and get download commands](https://cbchae.yonsei.ac.kr/channels4world/download.html) ([Space](https://huggingface.co/spaces/Intelligence-Networking-Lab/channels4world-download)) ·
+[Try one scene](#download)
+
+![Example scenes across the urban, metropolitan and suburban profiles](docs/scenes.png)
+
+*Example scenes from the three profiles. Building colours show material classes.*
+
+| Release 1.0.0 | Coverage |
+|---|---|
+| Geometry and positions | All 100,000 scenes |
+| Core channels | All 100,000 scenes, both carriers |
+| Detail (interactions) | The 10,000 Medium-tier scenes, both carriers |
+| Total | About **20.8 TB**: the Full tier, the loose Tiny copy and metadata |
+
+Start with plain NumPy, use the `channels4world` library to select larger subsets, or
+read the TAR archives with 🤗 Datasets. Numeric records are standard NPZ files;
+geometry is ZIP. Every example follows one link: BS 0 and UE 14 of `urban_scene_019234`
+at 3.5 GHz, the link the project website shows.
+
+[Project website](https://cbchae.yonsei.ac.kr/channels4world/) ·
+[Library source on GitHub](https://github.com/JoonkyuJang/channels4world) ·
+[Paper (submitted; arXiv preprint pending)](#license-and-citation) ·
+[Tutorials](#tutorials) ·
+[Schema reference](docs/schema-reference.md) ·
+[Library guide](docs/library-guide.md) ·
+[Without the library](docs/without-library.md)
+
+## Contents
+
+Each scene is divided into four **components**, which you can download separately.
+
+![A scene, one channel record and four paths from urban_scene_019234](docs/overview.png)
+
+*`urban_scene_019234` at 3.5 GHz, top view (heights not shown). UE positions are a sample
+of the 16,384. Each path segment takes the colour of the interaction it leaves.*
+
+| Component | What it holds | One file per | Files per scene |
+|---|---|---|---|
+| **geometry** | The 3-D scene: Mitsuba XML and OBJ meshes | scene | 1 |
+| **positions** | Coordinates of the 32 BSs and 16,384 UEs | scene | 1 |
+| **core** | Every retained path from one BS to each UE it reaches: gain, delay, angles, interaction count and type flags | scene × carrier × BS | 64 |
+| **detail** | Each path's interactions in order: type and location | scene × carrier × BS | 64 |
+
+Geometry and positions are shared by both carriers; core and detail are frequency-specific.
+Most channel work needs only positions and core.
+
+**What a record keeps.** Each link keeps at most the 16 strongest paths whose power exceeds
+−150 dB, ordered by decreasing power (computed in float32). Paths combine line of sight, specular reflection and
+diffraction, with up to four interactions per path; diffuse reflection and refraction are
+not modeled. A UE with no stored link to a BS has no retained path to it; that is not a
+zero-power channel. The scenes are synthetic and the channels are simulated, not measured;
+the paper describes how they were generated.
+
+Gains are the passband coefficients without the carrier-delay phase, relative to unit
+power. Angles: zenith from +z, azimuth from +x toward +y. Each BS and UE has one isotropic,
+vertically polarized antenna, already included in the gains. Details: [schema reference](docs/schema-reference.md).
+
+<details>
+<summary><b>How the files connect</b></summary>
+
+![How the geometry, positions, core and detail files connect, with illustrative values](docs/files.png)
+
+*Illustrative values: link 0 is UE 2 and owns paths 0–1; link 1 is UE 9 and owns path 2.*
+
+- **One frame:** geometry, positions and interaction vertices share scene coordinates in metres.
+- **BS:** the number in a file name (`bs00000`) is its row in `bs_positions`.
+- **UE:** each value of `link_ue_index` is a row in `ue_positions`. A UE that isn't listed
+  has no retained link to this BS (not a zero-power channel).
+- **Paths:** link ℓ owns paths `link_path_offsets[ℓ]` to `link_path_offsets[ℓ+1]` (end excluded).
+- **Interactions:** detail lists paths in core's order; path *p* owns interactions
+  `path_interaction_offsets[p]` to `[p+1]`.
+
+</details>
+
+<details>
+<summary><b>Arrays in each file</b></summary>
+
+*L* links, *P* paths and *I* interactions vary per record. For example, BS 0 of
+`urban_scene_019234` at 3.5 GHz has *L* = 15,873 retained links and *P* = 214,443 paths.
+
+**geometry** · `geometry.zip`: `scene.json` names the entry XML, which references OBJ
+meshes in metres.
+
+**positions** · `positions.npz`
+
+| Array | Shape | Type | Meaning |
+|---|---|---|---|
+| `bs_positions` | 32 × 3 | float32 | BS coordinates, m |
+| `ue_positions` | 16,384 × 3 | float32 | UE coordinates, m |
+
+**core** · `band_hz=<Hz>/component=core/bs<NNNNN>.npz`
+
+| Array | Shape | Type | Meaning |
+|---|---|---|---|
+| `link_ue_index` | *L* | int32 | UE ID of each link, ascending |
+| `link_path_offsets` | *L* + 1 | int64 | Where each link's paths start and end |
+| `a_real`, `a_imag` | *P* | float32 | Complex path gain |
+| `tau` | *P* | float32 | Delay, s |
+| `theta_t`, `phi_t` | *P* | float32 | Departure angles at the BS, rad |
+| `theta_r`, `phi_r` | *P* | float32 | Arrival angles at the UE, rad |
+| `interaction_count` | *P* | uint8 | Number of interactions |
+| `interaction_flags` | *P* | uint16 | Interaction types present, one bit per type |
+| `path_rank` | *P* | uint8 | 0-based position within its link, by decreasing float32 power |
+
+**detail** · same name under `component=detail`
+
+| Array | Shape | Type | Meaning |
+|---|---|---|---|
+| `path_interaction_offsets` | *P* + 1 | int64 | Where each path's interactions start and end |
+| `interaction_type` | *I* | int8 | 1 specular reflection, 8 diffraction (2 diffuse reflection and 4 refraction are defined but not modeled) |
+| `interaction_rank` | *I* | uint8 | 0-based position along the path |
+| `interaction_vertex` | *I* × 3 | float32 | Location, m |
+
+</details>
+
+## Organization
+
+Every scene belongs to one **split** (train or test) and one **profile** (urban,
+metropolitan or suburban). Scenes are offered in nested **tiers**, so a larger tier keeps
+every scene of the smaller ones. Every tier is 90% train and 10% test, and within each
+split 50% urban, 25% metropolitan and 25% suburban.
+
+| Tier | Train urban | Train metropolitan | Train suburban | Test urban | Test metropolitan | Test suburban | Total |
+|---|---:|---:|---:|---:|---:|---:|---:|
+| Tiny | 90 | 45 | 45 | 10 | 5 | 5 | 200 |
+| Small | 450 | 225 | 225 | 50 | 25 | 25 | 1,000 |
+| Medium | 4,500 | 2,250 | 2,250 | 500 | 250 | 250 | 10,000 |
+| Large | 22,500 | 11,250 | 11,250 | 2,500 | 1,250 | 1,250 | 50,000 |
+| Full | 45,000 | 22,500 | 22,500 | 5,000 | 2,500 | 2,500 | 100,000 |
+
+- A scene is in exactly one split. Both carriers and all four components of a scene share it.
+- There is no validation split. Hold out training scenes by scene, not by link or UE.
+- In the catalog, `tier` is the **smallest** tier that contains a scene. Medium is therefore
+  `tier in {"tiny", "small", "medium"}`.
+
+| Tier | Core | Detail | Geometry + positions | Total |
+|---|---:|---:|---:|---:|
+| Tiny | 38.9 GB | 26.7 GB | 41 MB | 65.6 GB |
+| Small | 194 GB | 133 GB | 207 MB | 327 GB |
+| Medium | 1.93 TB | 1.32 TB | 2.07 GB | 3.26 TB |
+| Large | 9.66 TB | 1.32 TB (Medium only) | 10.3 GB | 10.99 TB |
+| Full | 19.32 TB | 1.32 TB (Medium only) | 20.7 GB | 20.66 TB |
+
+*Sizes cover both carriers (GB = 10⁹ bytes, TB = 10¹² bytes); catalogs and group metadata
+add under 0.2%. Tiny is published as loose files (65.7 GB with its metadata), and its
+scenes are also part of Small.*
+
+Tiers choose scenes; components and carriers are chosen separately. Tiny needs no unpacking.
+
+## Download
+
+Try one scene from Tiny to get loose files without unpacking. For Small or larger,
+download TAR archives and use the catalog to select scenes, carriers and components.
+Each example below leaves files under `c4w/`. Commands use the release tag `v1.0.0`; the
+`hf` command comes with `huggingface_hub` (`pip install huggingface_hub`).
+The [download helper](https://cbchae.yonsei.ac.kr/channels4world/download.html) (also a [Space](https://huggingface.co/spaces/Intelligence-Networking-Lab/channels4world-download)) sizes any
+tier, split, profile, carrier and component choice and writes these commands for it.
+
+<details>
+<summary><b>Try one scene from Tiny</b></summary>
+
+Download base station 0 of one scene (**26.0 MB** in 16 files, including the metadata the
+library needs):
+
+```bash
+hf download Intelligence-Networking-Lab/Channels4World --repo-type dataset \
+  --revision v1.0.0 --local-dir c4w \
+  --include 'tiny/c4w-root.json' --include 'tiny/c4w-root/*' --include 'tiny/schema/*' \
+  --include 'tiny/groups/test-urban-g00000/catalog/members.parquet' \
+  --include 'tiny/groups/test-urban-g00000/snapshot.json' \
+  --include 'tiny/records/scene=urban_scene_019234/positions.npz' \
+  --include 'tiny/records/scene=urban_scene_019234/geometry.zip' \
+  --include 'tiny/records/scene=urban_scene_019234/band_hz=*/component=*/bs00000.npz'
+```
+
+For NumPy alone, the last three `--include` patterns are enough (15.2 MB). For all 32 BSs
+of the scene, replace them with `--include 'tiny/records/scene=urban_scene_019234/*'`
+(418.0 MB with the metadata). For all of Tiny, use `--include 'tiny/*'` (65.7 GB). For
+another Tiny scene, take its `group` from the `tiny_scenes` catalog. The three scenes shown
+on the project website, `urban_scene_019234`, `metro_scene_054046` and
+`suburban_scene_096016`, are Tiny test scenes.
+Then [read the data](#read-the-data) below.
+
+</details>
+
+<details>
+<summary><b>Download a tier</b></summary>
+
+Install the optional library with `pip install channels4world` (Python ≥3.11).
+Download the release catalog, then select Small, positions and core at 3.5 GHz:
+
+```bash
+hf download Intelligence-Networking-Lab/Channels4World --repo-type dataset \
+  --revision v1.0.0 --local-dir c4w \
+  --include 'c4w-root.json' --include 'c4w-root/*'
+```
+
+```python
+import channels4world as c4w
+from huggingface_hub import snapshot_download
+
+ds = c4w.open("c4w")
+selection = ds.select(tier="small", frequencies_hz=[3_500_000_000],
+                      components=("positions", "core"))
+report = selection.missing()
+print(report)                         # planned files and total size
+if report.files:
+    snapshot_download(
+        "Intelligence-Networking-Lab/Channels4World", repo_type="dataset",
+        revision="v1.0.0", local_dir=report.local_dir,
+        allow_patterns=report.repo_files,
+    )
+assert selection.missing().complete
+```
+
+`select()` also takes `split=` and `profile=` (catalog spelling: `urban`, `metropolitan`,
+`suburban`). Each archive holds one group: 25 scenes of one split and profile, from one
+tier, with all 32 BSs. Tier, split and profile selections therefore download exactly their
+scenes; a list of scene IDs downloads the whole groups that contain them.
+`selection.to_recipe()` saves a selection as a small JSON recipe that others can replay
+with `ds.select_recipe(...)` or `c4w missing c4w --recipe FILE`; the download helper
+writes the same recipes.
+The [library guide](docs/library-guide.md) covers larger download plans, subsets and
+caching; [without the library](docs/without-library.md) covers glob downloads and ordinary
+TAR extraction.
+
+</details>
+
+<details>
+<summary><b>Select scenes and components</b></summary>
+
+With the release catalog from the tier example local, choose exact scene IDs and the
+components you need. The catalog finds the containing archives:
+
+```python
+import channels4world as c4w
+from huggingface_hub import snapshot_download
+
+ds = c4w.open("c4w")
+selection = ds.select(scene_ids=["urban_scene_019234"],
+                      frequencies_hz=[3_500_000_000], components=("positions", "core"))
+report = selection.missing()
+print(report)
+if report.files:
+    snapshot_download(
+        "Intelligence-Networking-Lab/Channels4World", repo_type="dataset",
+        revision="v1.0.0", local_dir=report.local_dir,
+        allow_patterns=report.repo_files,
+    )
+assert selection.missing().complete
+```
+
+</details>
+
+HF Datasets can also [stream archives](#streaming-archives) without downloading the
+entire selection first.
+
+## Read the data
+
+We recommend the `channels4world` library for selection, verification and repeated reads;
+standard NumPy works directly with loose files. Both examples read the same link, BS 0 →
+UE 14 of `urban_scene_019234` at 3.5 GHz: its delays, complex gains and BS–UE distance.
+Change the IDs at the top to read any other link you have downloaded.
+
+<details>
+<summary><b>Read with the library</b></summary>
+
+```python
+from pathlib import Path
+import numpy as np
+import channels4world as c4w
+
+TINY_ROOT = Path("c4w/tiny")
+SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14
+ds = c4w.open(TINY_ROOT)
+scene = ds.scene(SCENE_ID)
+record = scene.frequencies[CARRIER_HZ].base_stations[BS_ID].read()
+positions = scene.read_positions()
+
+link = record.get_link(UE_ID)      # None when this UE has no retained link to this BS
+print(link.n_paths, link.core["tau"])                        # 16 retained paths, delays in s
+print(link.core["a_real"] + 1j * link.core["a_imag"])
+print(np.linalg.norm(positions.ue[UE_ID] - positions.bs[BS_ID]))
+```
+
+The library's arrays keep the stored dtypes and are read-only. For downloaded TARs, open the
+release root (`c4w/`) and iterate your selection directly; extraction is optional.
+See [iteration and extraction](docs/library-guide.md#iterate-extract-or-cache).
+
+</details>
+
+<details>
+<summary><b>Read loose files with NumPy</b></summary>
+
+The same code works after ordinary TAR extraction: change `TINY_ROOT` to the extracted
+folder.
+
+```python
+from pathlib import Path
+import numpy as np
+
+TINY_ROOT = Path("c4w/tiny")
+SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14
+scene_dir = TINY_ROOT / "records" / f"scene={SCENE_ID}"
+core_path = scene_dir / f"band_hz={CARRIER_HZ}" / "component=core" / f"bs{BS_ID:05d}.npz"
+
+with np.load(core_path, allow_pickle=False) as core, np.load(
+    scene_dir / "positions.npz", allow_pickle=False
+) as positions:
+    ue_ids = core["link_ue_index"]             # retained UE IDs, ascending
+    row = int(np.searchsorted(ue_ids, UE_ID))  # this UE's link row
+    assert row < ue_ids.size and ue_ids[row] == UE_ID, "No retained link to this UE."
+    start, stop = map(int, core["link_path_offsets"][row:row + 2])
+    print(stop - start, core["tau"][start:stop])
+    print(core["a_real"][start:stop] + 1j * core["a_imag"][start:stop])
+    print(np.linalg.norm(positions["ue_positions"][UE_ID] - positions["bs_positions"][BS_ID]))
+```
+
+NumPy preserves the NPZ's stored dtypes and shapes. `UE_ID` indexes positions; `row`
+indexes retained links. Keep that mapping when filtering. Ordinary TAR extraction writes
+these payload paths; library extraction also creates a navigable subset root.
+
+</details>
+
+<details>
+<summary><b>Pad paths to fixed-size arrays</b></summary>
+
+Each link has at most 16 paths, so any per-path array becomes an `(L, 16)` array plus a
+mask. Row *i* belongs to UE `link_ue_index[i]`:
+
+```python
+import numpy as np
+
+def pad_paths(core, name, max_paths=16):
+    """Per-path array -> (links, max_paths) array and a mask of stored paths."""
+    offsets = np.asarray(core["link_path_offsets"])
+    values = np.asarray(core[name])
+    counts = np.diff(offsets)                                # paths per link
+    rows = np.repeat(np.arange(counts.size), counts)
+    cols = np.arange(offsets[-1]) - np.repeat(offsets[:-1], counts)
+    padded = np.zeros((counts.size, max_paths), values.dtype)
+    padded[rows, cols] = values
+    mask = np.arange(max_paths) < counts[:, None]
+    return padded, mask
+
+with np.load(core_path, allow_pickle=False) as core:     # core_path from the example above
+    tau, mask = pad_paths(core, "tau")                    # (L, 16) float32, (L, 16) bool
+    gain = pad_paths(core, "a_real")[0] + 1j * pad_paths(core, "a_imag")[0]
+    ue_ids = core["link_ue_index"]                        # (L,) row i <-> UE ue_ids[i]
+```
+
+Padded entries are zero; use the mask, not the value, to tell them apart. The same works
+on library records and on HF Datasets rows after
+[restoring their shapes](docs/hf-datasets.md#decoding-and-array-representation). The
+library has the same function, with a per-path version for interactions:
+`from channels4world.transforms import pad_paths, pad_interactions`.
+
+</details>
+
+### Streaming archives
+
+Stream remote TARs on demand, or iterate the same TARs saved locally without a network
+read. Each HF Datasets example is one BS record, not one UE or a joined scene. Archives
+stream in order: to reach one record, stream only the group archive that holds it.
+
+<details>
+<summary><b>Stream archives with 🤗 Datasets</b></summary>
+
+```python
+import numpy as np
+from datasets import load_dataset
+
+SCENE_ID, BS_ID, UE_ID = "urban_scene_019234", 0, 14
+archive = ("hf://datasets/Intelligence-Networking-Lab/Channels4World@v1.0.0/payload/"
+           "3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar")   # this scene's group
+# For a downloaded copy: archive = "c4w/payload/3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar"
+member = f"records/scene={SCENE_ID}/band_hz=3500000000/component=core/bs{BS_ID:05d}"
+core = load_dataset("webdataset", streaming=True, data_files={"test": archive})["test"]
+record = next(r for r in core.with_format("numpy") if r["__key__"] == member)
+arrays = record["npz"]                        # HF has already decoded the NPZ
+row = int(np.searchsorted(arrays["link_ue_index"], UE_ID))
+start, stop = map(int, arrays["link_path_offsets"][row:row + 2])
+print(arrays["tau"][start:stop])              # UE 14's delays (s)
+```
+
+The group comes from the `scenes` catalog. Streaming reads the archive from its start, so
+the members before this record are read too (at most one group's archive). `streaming=True`
+iterates on demand; without it, HF Datasets downloads the archives and builds an Arrow
+dataset on disk, from remote or local input. HF formatting can change dtypes. See the
+[HF guide](docs/hf-datasets.md) for explicit features, shape and dtype restoration, and
+joining positions. To read one record without the rest of its archive, use a byte-range
+read ([file guide](docs/without-library.md#find-the-byte-location-of-one-record)). Tiny
+stays loose.
+
+</details>
+
+## Tutorials
+
+Each tutorial is a page and a notebook that runs top to bottom. The two reading tutorials
+follow the same link, BS 0 → UE 14 of `urban_scene_019234`.
+
+| Tutorial | Reads with | Covers |
+|---|---|---|
+| [Read one scene](docs/tutorial-library.md) ([notebook](docs/notebooks/01-read-one-scene-library.ipynb)) | the library | catalog → scene → carrier → BS → UE link → paths; geometry and positions; the stored arrays; the same link at 7 GHz |
+| [Read one scene without the library](docs/tutorial-numpy.md) ([notebook](docs/notebooks/02-read-one-scene-numpy.ipynb)) | NumPy | the same steps on the loose files |
+| [From channel records to a DataLoader](docs/ml-guide.md) ([notebook](docs/notebooks/03-dataloader.ipynb)) | the library, PyTorch | link samples, train/validation/test by scene, padded arrays, preprocessing, a cache and batches |
+
+## Files and catalogs
+
+The catalogs list scenes and files so you can choose downloads and locate records;
+metadata supplies their identities and checksums. The dataset viewer shows three catalog
+configs: `scenes` (default; one row per scene), `files` (every archive, group metadata and schema file with its size
+and SHA-256; the root catalog files and this card are not listed) and `tiny_scenes` (Tiny's 200 scenes). Their split is named `catalog`; it is
+not the train/test split, which is the `split` column. The viewer shows catalog rows, not
+channel arrays. The [file guide](docs/without-library.md) explains how to use them.
+
+<details>
+<summary><b>File reference</b></summary>
+
+| Path | What it is |
+|---|---|
+| `c4w-root.json`, `c4w-root/` | Release catalog: every scene (split, profile, tier, group) and every archive, metadata and schema file (path, size, checksum) |
+| `groups/<group>/` | Group metadata: where each record sits inside the archives, and its identity and checksums |
+| `schema/` | Interpretation documents (units, conventions, interaction codes) |
+
+```text
+c4w-root.json, c4w-root/        release catalog
+schema/, groups/                interpretation documents, group metadata
+payload/                        TAR archives (paths below)
+tiny/                           Tiny: its own catalog, schema/, groups/ and
+  records/scene=<id>/               loose files per scene:
+    geometry.zip, positions.npz
+    band_hz=<3500000000|7000000000>/component=<core|detail>/bs00000.npz … bs00031.npz
+```
+
+Archive path templates:
+
+```text
+payload/scene/<geometry|positions>/inc<N>-<tier>/<group>-<component>.tar
+payload/<3.5ghz|7ghz>/<core|detail>/inc<N>-<tier>/<group>-<band>-<component>.tar
+```
+
+- **Groups** are named `<split>-<profile code>-g<NNNNN>`, with profile code `urban`, `metro`
+  or `suburban` (the catalog spells `metro` as `metropolitan`). Each holds exactly 25 scenes.
+- **Increments** are `inc1-small`, `inc2-medium`, `inc3-large` and `inc4-full`. A tier is
+  its own increment plus all smaller ones, so in every component folder Small is `inc1-*`,
+  Medium `inc[1-2]-*`, Large `inc[1-3]-*` and Full `inc*`.
+- **Detail** is hosted in `inc1-small` and `inc2-medium` only.
+
+</details>
+
+<details>
+<summary><b>Query the catalogs</b></summary>
+
+```python
+from datasets import load_dataset
+
+REPO, REV = "Intelligence-Networking-Lab/Channels4World", "v1.0.0"
+scenes = load_dataset(REPO, "scenes", split="catalog", revision=REV)
+files = load_dataset(REPO, "files", split="catalog", revision=REV)
+print(scenes.filter(lambda row: row["split"] == "test")[:3])
+print(files.filter(lambda row: row["kind"] == "payload")[:3])
+```
+
+</details>
+
+## License and citation
+
+Channels4World: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). If you share or
+adapt it, credit **Joonkyu Jang**, link the license and indicate changes.
+channels4world library: [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0).
+
+If Channels4World is useful in your research, please cite the dataset paper:
+
+> J. Jang, H.-J. Moon, K. S. Kim, S.-L. Kim, J. Hoydis, R. W. Heath Jr. and C.-B. Chae,
+> "Channels4World: An Environment-Scale Dataset for Wireless Foundation Models,"
+> submitted to *IEEE Transactions on Communications*.
+
+The arXiv preprint and a BibTeX entry will be added here when the preprint is available.
+
+| Item | Version |
+|---|---|
+| Channels4World release | 1.0.0: tag `v1.0.0` (the tag pins the exact repository commit) |
+| Collection ID | `channels4world-v1-20260714`, in every record header; it names the generated collection, while `1.0.0` names this release |
+| Library | `channels4world` 1.0.0, Python ≥3.11 |
+| Catalog format | `channels4world.root` version 1 |

c4w-root.json

@@ -0,0 +1,34 @@
+{
+ "collection_id": "channels4world-v1-20260714",
+ "format": "channels4world.root",
+ "format_version": 1,
+ "frequencies_hz": [
+  3500000000,
+  7000000000
+ ],
+ "hf_path": "",
+ "hf_repo": "Intelligence-Networking-Lab/Channels4World",
+ "kind": "release",
+ "payload": "tar",
+ "release": "1.0.0",
+ "source": null,
+ "tables": {
+  "files": {
+   "bytes": 1637414,
+   "path": "c4w-root/files.parquet",
+   "sha256": "77a971c31f048162e595b88218daca355e64119f2bfdd4902d9b104d0201c102"
+  },
+  "scenes": {
+   "bytes": 427119,
+   "path": "c4w-root/scenes.parquet",
+   "sha256": "cf6c74f3ff96f755b8dbfa178547a73756a1dfe1c2053c76059add0c7f1763c9"
+  }
+ },
+ "tiers": [
+  "tiny",
+  "small",
+  "medium",
+  "large",
+  "full"
+ ]
+}

c4w-root/files.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77a971c31f048162e595b88218daca355e64119f2bfdd4902d9b104d0201c102
+size 1637414

c4w-root/scenes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf6c74f3ff96f755b8dbfa178547a73756a1dfe1c2053c76059add0c7f1763c9
+size 427119

docs/hf-datasets.md

@@ -0,0 +1,153 @@
+# TAR records with HF Datasets
+
+HF Datasets can read the existing TAR member names with its `webdataset` loader. The
+examples need `pip install datasets`; `hf://` paths are read through `huggingface_hub`,
+which `datasets` installs.
+Each core/detail NPZ is one scene × carrier × BS record; each positions NPZ is one
+scene record. These are ragged records, not preassembled UE training samples.
+Choose and join components before defining samples or batching them.
+
+The [card](../README.md#streaming-archives) shows a short remote/local iteration example.
+`streaming=True` returns an iterable; omitting it downloads remote input as needed and
+builds an Arrow dataset on disk, even when the TARs are already local. Neither route
+extracts a subset root for the channels4world library. Tiny can remain loose throughout.
+
+## Decoding and array representation
+
+HF's loader already decodes `record["npz"]`; do not pass that mapping to `np.load`.
+Its feature inference and NumPy formatting are separate steps: integer widths can
+change, and empty arrays need their declared dimensions restored. Direct NumPy NPZ
+reads and the channels4world library retain the stored numeric dtypes and shapes; HF's formatted
+rows do not promise that representation unchanged.
+
+The explicit features and restoration below follow the release's array schema
+(`schema/arrays.json`, summarized in the [schema reference](schema-reference.md)). The
+shape comes from each NPZ's embedded JSON `__meta__`.
+
+```python
+import json
+import numpy as np
+from datasets import Array2D, Features, Sequence, Value, load_dataset
+
+SCHEMAS = {
+    "core": {
+        "link_ue_index": ("int32", ("links",)),
+        "link_path_offsets": ("int64", ("links+1",)),
+        "path_rank": ("uint8", ("paths",)),
+        "a_real": ("float32", ("paths",)), "a_imag": ("float32", ("paths",)),
+        "tau": ("float32", ("paths",)),
+        "theta_t": ("float32", ("paths",)), "phi_t": ("float32", ("paths",)),
+        "theta_r": ("float32", ("paths",)), "phi_r": ("float32", ("paths",)),
+        "interaction_count": ("uint8", ("paths",)),
+        "interaction_flags": ("uint16", ("paths",)),
+    },
+    "detail": {
+        "path_interaction_offsets": ("int64", ("paths+1",)),
+        "interaction_rank": ("uint8", ("interactions",)),
+        "interaction_type": ("int8", ("interactions",)),
+        "interaction_vertex": ("float32", ("interactions", 3)),
+    },
+    "positions": {
+        "bs_positions": ("float32", ("bs", 3)),
+        "ue_positions": ("float32", ("ues", 3)),
+    },
+}
+
+def features_for(component):
+    fields = {"__meta__": Value("string")}
+    for name, (dtype, axes) in SCHEMAS[component].items():
+        fields[name] = (Array2D(shape=(None, 3), dtype=dtype) if len(axes) == 2
+                        else Sequence(Value(dtype)))
+    return Features({"__key__": Value("string"), "__url__": Value("string"), "npz": fields})
+
+def restore_npz(record):
+    raw = record["npz"]
+    meta = json.loads(str(raw["__meta__"]))
+    def size(axis):
+        if isinstance(axis, int):
+            return axis
+        name, _, extra = axis.partition("+")
+        return meta["dimensions"][name] + (int(extra) if extra else 0)
+    arrays = {
+        name: np.asarray(raw[name], dtype=dtype).reshape(tuple(size(a) for a in axes))
+        for name, (dtype, axes) in SCHEMAS[meta["identity"]["component"]].items()
+    }
+    return meta, arrays
+```
+
+For example, zero interactions restore `interaction_vertex` to `(0, 3)` rather than
+an ambiguous empty vector. Core and detail offsets still have their final sentinel:
+an empty core has `link_path_offsets.shape == (1,)`.
+
+## One chosen link, with remote or local TARs
+
+Stream only the archives of the group that holds the chosen scene (the `group` column of
+the `scenes` catalog), then pick records by identity:
+
+```python
+SCENE_ID, BS_ID, UE_ID = "urban_scene_019234", 0, 14
+GROUP = "test-urban-g00000"                          # from the scenes catalog
+base = "hf://datasets/Intelligence-Networking-Lab/Channels4World@v1.0.0/payload"
+# For downloaded copies: base = "c4w/payload"
+
+def records(component):
+    archive = (f"{base}/3.5ghz/core/inc1-small/{GROUP}-3.5ghz-core.tar" if component == "core"
+               else f"{base}/scene/positions/inc1-small/{GROUP}-positions.tar")
+    return load_dataset(
+        "webdataset", streaming=True, features=features_for(component),
+        data_files={"test": archive},
+    )["test"].with_format("numpy")
+
+def identity_of(meta):
+    i = meta["identity"]
+    return i["scene_id"], i["bs_index"]
+
+meta, core = next((m, a) for m, a in map(restore_npz, records("core"))
+                  if identity_of(m) == (SCENE_ID, BS_ID))
+positions = next(a for m, a in map(restore_npz, records("positions"))
+                 if m["identity"]["scene_id"] == SCENE_ID)
+
+row = int(np.searchsorted(core["link_ue_index"], UE_ID))   # UE 14's link row
+assert row < core["link_ue_index"].size and core["link_ue_index"][row] == UE_ID
+start, stop = map(int, core["link_path_offsets"][row:row + 2])
+print(core["tau"][start:stop])
+print(core["a_real"][start:stop] + 1j * core["a_imag"][start:stop])
+print(np.linalg.norm(positions["ue_positions"][UE_ID] - positions["bs_positions"][BS_ID]))
+```
+
+Archives stream in order, so each iterator reads until it reaches the matching record:
+at most one group's archive (800 channel records or 25 scene records). This scene is the
+first in its group, so both stop almost at once. To fetch one record without reading the
+rest of its archive, use a byte-range read
+([file guide](without-library.md#find-the-byte-location-of-one-record)). For repeated
+workloads, index or cache positions rather than rescanning them for every BS.
+Core and detail additionally join by carrier and BS and must share `path_axis_sha256`;
+their `__key__` values differ by component. Use the identity and dependency metadata, not
+only equal array lengths. Restoration itself does not verify content hashes.
+
+## Optional: stock WebDataset and NumPy
+
+Stock `webdataset`, without calling its decoder, yields NPZ **bytes**. For a downloaded
+core TAR, standard NumPy opens those bytes with their stored dtypes and shapes:
+
+```python
+import io
+import webdataset as wds
+
+archive = "c4w/payload/3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar"
+key = "records/scene=urban_scene_019234/band_hz=3500000000/component=core/bs00000"
+record = next(r for r in wds.WebDataset(archive, shardshuffle=False) if r["__key__"] == key)
+with np.load(io.BytesIO(record["npz"]), allow_pickle=False) as npz:
+    core = {name: npz[name] for name in npz.files if name != "__meta__"}
+    meta = json.loads(npz["__meta__"].item())
+```
+
+Each WebDataset sample is one member: `__key__` is the member path without its `.npz`
+extension. Keep the same UE, scene and component associations as above.
+
+Explicit features avoid relying on types inferred from the first examples, and
+restoration makes the stored dtypes and shapes explicit again. Reference behavior:
+[HF WebDataset loader](https://github.com/huggingface/datasets/blob/5.1.0/src/datasets/packaged_modules/webdataset/webdataset.py)
+and [NumPy formatter](https://github.com/huggingface/datasets/blob/5.1.0/src/datasets/formatting/np_formatter.py).
+
+[Return to card](../README.md) · [Without the library](without-library.md) · [Schema](schema-reference.md)

docs/library-guide.md

@@ -0,0 +1,186 @@
+# Library guide
+
+The `channels4world` library (1.0.0) requires Python ≥3.11, NumPy and PyArrow. Install it
+with `pip install channels4world`; its full documentation is at <https://github.com/JoonkyuJang/channels4world#readme>. It reads local
+files and never downloads them. A download into the Hugging Face cache
+(`snapshot_download` without `local_dir`) works too: open the snapshot folder it returns.
+
+## Partial Tiny and direct reads
+
+Opening a root reads `c4w-root.json` and **every table referenced by that manifest**.
+For Tiny these include scenes, files and included records. Payloads and group
+metadata load later. Downloading those root tables, shared schemas, the chosen
+scene's group metadata and its payloads permits direct access to that explicit
+scene even when the other Tiny payloads are absent. Do not select an arbitrary first
+scene when only one known scene has been downloaded.
+
+```python
+from pathlib import Path
+import channels4world as c4w
+
+TINY_ROOT = Path("c4w/tiny")
+SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14
+
+ds = c4w.open(TINY_ROOT)
+scene = ds.scene(SCENE_ID)
+record = scene.frequencies[CARRIER_HZ].base_stations[BS_ID].read()
+positions = scene.read_positions()
+link = record.get_link(UE_ID)        # BS 0 → UE 14: 16 retained paths
+```
+
+A loaded record's absent UE IDs mean no retained link; missing files and unpublished
+components raise separate availability errors. Selecting across partially downloaded
+**loose** Tiny before group metadata is available can conservatively plan other files
+in a touched group. For the first scene, use the card's narrow include command and
+explicit scene read; direct reads do not require every scene's payload.
+
+## Root-first planning for TAR releases
+
+Download the release catalog (`c4w-root.json` and `c4w-root/`) at the release revision.
+`missing()` can then plan from the catalog alone.
+For groups whose members/snapshot are absent, it lists matching component/carrier
+TARs and requested scene assets, plus required metadata and schemas. Once metadata
+is local, it maps selected records to their TARs. Because a TAR contains the group's
+records for one component/carrier, either route uses archives as download units.
+Rerun after downloading to resolve unpublished requests and confirm completeness.
+
+```python
+import channels4world as c4w
+
+ds = c4w.open("c4w")                 # the release root is the repository top level
+selection = ds.select(
+    tier="small", frequencies_hz=[3_500_000_000], components=("positions", "core"),
+)
+report = selection.missing()
+print(report)                        # files and total bytes
+if report.files:
+    print(report.hf_command(revision="v1.0.0"))
+```
+
+`report.files` are paths inside the opened root. `report.repo_files` are the same files
+as repository paths (identical for the release root; prefixed with `tiny/` for Tiny), and
+`report.local_dir` is the folder that corresponds to the repository's top level.
+`hf_command(revision=...)` uses both and quotes every argument. It refuses an empty plan
+and roots that are not published as-is, such as a subset you extracted yourself, whose
+loose files exist only on your disk.
+
+For long plans, avoid putting thousands of paths on a shell command line:
+
+```python
+from huggingface_hub import snapshot_download
+
+if report.files:
+    snapshot_download(
+        repo_id="Intelligence-Networking-Lab/Channels4World", repo_type="dataset",
+        revision="v1.0.0", local_dir=report.local_dir,
+        allow_patterns=report.repo_files,
+    )
+report = selection.missing()
+if report.files:
+    raise RuntimeError("Files are still missing; re-plan the download.")
+if report.unpublished:
+    raise RuntimeError(f"Requested components are not published: {report.unpublished}")
+```
+
+The published catalogs at that revision are the source of truth for paths, sizes and
+hashes. Without the library, the increment-folder patterns in the
+[file guide](without-library.md#download-a-tiers-archives) select a whole tier.
+
+Selections combine filters. `ds.profiles` lists the catalog's profile names:
+
+```python
+metro_train = ds.select(tier="medium", split="train", profile="metropolitan",
+                        frequencies_hz=[7_000_000_000], components=("positions", "core"))
+```
+
+### Share a selection as a recipe
+
+A recipe is a small JSON file that records a selection (tier, split, profiles, scene IDs,
+carriers, BS IDs and components) and the release it refers to. It holds no paths or
+commands, so whoever replays it plans the download from their own catalog:
+
+```python
+with open("selection.json", "w") as fh:
+    fh.write(c4w.recipe.dumps(selection.to_recipe(revision="v1.0.0")))
+
+same = c4w.open("c4w").select_recipe("selection.json")
+```
+
+The command line does the same. `c4w recipe` never overwrites a file, so choose a new name:
+
+```bash
+c4w recipe c4w --tier small --frequency 3500000000 --components positions,core \
+  --revision v1.0.0 -o small-core.json
+c4w missing c4w --recipe small-core.json     # prints the hf download command, pinned to v1.0.0
+```
+
+The [download helper](https://cbchae.yonsei.ac.kr/channels4world/download.html) on the
+project website writes the same recipes. A recipe for another release is refused, and every
+filter is checked against the catalog exactly as `select()` checks it.
+
+The examples below continue with the Small selection from above.
+
+## Iterate, extract or cache
+
+```python
+for scene in selection.scenes():
+    positions = scene.read_positions()
+    for record in scene.records():  # selected scene preserves carrier/BS/component filters
+        print(record.scene_id, record.frequency_hz, record.bs_id, record.n_links)
+
+# Use new destinations after missing()/coverage checks have passed.
+c4w.extract(selection, "small-loose", verify="basic", check_space=True)
+c4w.to_cache(selection, "small-npy", verify="basic", check_space=True)
+```
+
+Packed TARs preserve original NPZ/ZIP records. `extract` preserves selected
+`member_path` values and original payload bytes and writes a common loose subset
+root. The optional NPY cache instead stores arrays plus indexes for memory-mapped
+repeated access; values, IDs, dtypes and ragged associations stay the same. Geometry
+remains ZIP. A cache is not another scene tier.
+
+## Arrays are read-only
+
+Arrays returned by the library are read-only views of the stored data. Arithmetic such as
+`record.core["tau"] * 1e9` creates a new array; to modify values in place, copy first
+(`record.copy()` or `np.array(...)`).
+
+## Reads, file handles and disk writes
+
+| Verb | Meaning | Examples |
+|---|---|---|
+| `read` / `read_*` | Load data into memory | `bs.read()`, `scene.read_positions()` |
+| `open_*` | Return a handle to close | `scene.open_geometry()` returns `ZipFile` |
+| `extract` / `extract_*` | Write files and return a path | `c4w.extract(selection, dest)`, `scene.extract_geometry(dest)` |
+
+Geometry extraction requires a destination because renderers load XML and referenced
+meshes from disk. Positions are arrays. No hidden temporary geometry location is
+assumed.
+
+`verify="basic"` checks declared bytes and array structure. `verify="full"` adds
+scientific/content-proof checks for loaded components. A full core+detail read checks
+their association together. Extraction/cache conversion does not replace that
+pairwise read check. See the [schema reference](schema-reference.md).
+
+## Optional transforms
+
+```python
+import numpy as np
+from channels4world import transforms as T
+
+rms_delay_s = T.delay_spread(record)
+response = T.frequency_response(
+    record, np.array([-1e6, 0.0, 1e6]), delay_reference="absolute",
+)
+```
+
+These return new writable arrays describing retained paths. Frequency inputs above
+are **offsets from the record's carrier**, not absolute frequencies. `T.pad_paths(record.core,
+"tau")` gives one row per link, `(links, 16)`, with a mask of stored paths, and
+`T.pad_interactions(record.detail, "interaction_vertex")` one row per path, `(paths, 4, 3)`;
+both match the card's padding snippet. Stored
+`a_real + 1j*a_imag` is a scalar passband coefficient excluding carrier-delay phase;
+`tau` is absolute propagation delay. Do not add antenna effects twice. The
+[conventions reference](schema-reference.md) provides the details.
+
+[Return to card](../README.md) · [Without the library](without-library.md)

docs/ml-guide.md

@@ -0,0 +1,220 @@
+# From channel records to a DataLoader
+
+This guide turns Channels4World records into fixed-size arrays and a PyTorch `DataLoader`,
+with train, validation and test sets split by scene. It ends at one batch whose contents
+are explained, so you can adapt the inputs and targets to your model, or swap these
+batches into an existing training loop. The [notebook version](notebooks/03-dataloader.ipynb)
+runs top to bottom.
+
+The example uses the 100 urban scenes of Tiny (90 train, 10 test), BS 0 at 3.5 GHz. Change the
+selection to scale up; the steps stay the same. Install the library with `pip install channels4world`
+(Python 3.11+), then `pip install torch huggingface_hub`.
+
+```python
+from pathlib import Path
+import hashlib
+import json
+
+import numpy as np
+import torch
+from huggingface_hub import snapshot_download
+from torch.utils.data import DataLoader, Dataset
+
+import channels4world as c4w
+from channels4world import transforms as T
+
+REPO, REVISION = "Intelligence-Networking-Lab/Channels4World", "v1.0.0"
+DATA = Path("c4w")
+```
+
+## 1. Choose the records
+
+One **sample** here is one retained link: a (scene, carrier, BS, UE) channel. A record holds
+every retained link of one BS at one carrier, so records are read whole and split into
+links. First download Tiny's catalog and the metadata of the five groups that hold its urban
+scenes (about 42 MB), so the library can plan exactly which record files the selection needs:
+here about 0.4 GB.
+
+```python
+snapshot_download(REPO, repo_type="dataset", revision=REVISION, local_dir=DATA, allow_patterns=[
+    "tiny/c4w-root.json", "tiny/c4w-root/*", "tiny/schema/*",
+    "tiny/groups/*-urban-g*/catalog/members.parquet", "tiny/groups/*-urban-g*/snapshot.json"])
+
+ds = c4w.open(DATA / "tiny")
+selection = ds.select(profile="urban", frequencies_hz=[3_500_000_000], bs_ids=[0],
+                      components=("core", "positions"))
+report = selection.missing()
+print(report)
+if report.files:
+    snapshot_download(REPO, repo_type="dataset", revision=REVISION, local_dir=report.local_dir,
+                      allow_patterns=report.repo_files)
+assert selection.missing().complete
+```
+
+## 2. Split by scene
+
+Keep the release's train and test split: test scenes are places no training scene shows.
+Take validation scenes from the training split, by scene and never by link, so links of one
+place never sit on both sides. Hashing the scene ID makes the choice reproducible, and
+saving the lists records it.
+
+```python
+def is_validation(scene_id, fraction=0.1):
+    return int(hashlib.sha256(scene_id.encode()).hexdigest(), 16) % 1000 < fraction * 1000
+
+splits = {"train": [], "validation": [], "test": []}
+for scene in selection.scenes():
+    part = "test" if scene.split == "test" else ("validation" if is_validation(scene.id) else "train")
+    splits[part].append(scene.id)
+print({k: len(v) for k, v in splits.items()})
+Path("splits.json").write_text(json.dumps(splits, indent=1))
+```
+
+## 3. From a record to arrays
+
+Each record becomes arrays with one row per link. This is where your own preprocessing goes:
+`inputs` here are the UE position relative to the BS and the BS height; `targets` are the
+strongest 16 paths' delays (ns), powers (dB) and arrival angles, padded to fixed size with a
+mask that marks stored paths. Replace either function to fit your task. `LINKS_PER_RECORD`
+bounds memory by sampling links reproducibly.
+
+```python
+LINKS_PER_RECORD = 512
+PREPROCESSING = "v1: dxyz+bs_z -> 16 x (delay ns, power dB, cos/sin AoA az, AoA zenith)"
+
+def inputs(record, positions):
+    ue = positions.ue[record.ue_ids].astype(np.float32)
+    bs = positions.bs[record.bs_id].astype(np.float32)
+    return np.concatenate([ue - bs, np.full((len(ue), 1), bs[2], np.float32)], axis=1)   # (links, 4)
+
+def targets(record):
+    core = record.core
+    power = 10 * np.log10(core["a_real"].astype(np.float64) ** 2 + core["a_imag"].astype(np.float64) ** 2)
+    per_path = np.stack([core["tau"] * 1e9, power, np.cos(core["phi_r"]), np.sin(core["phi_r"]),
+                         core["theta_r"]], axis=1).astype(np.float32)           # (paths, 5)
+    padded, mask = T.pad_paths(core, per_path)                                   # (links, 16, 5), (links, 16)
+    return padded, mask
+
+def arrays(scene_ids):
+    rng = np.random.default_rng(0)
+    x, y, m, ids = [], [], [], []
+    for scene in selection.scenes():
+        if scene.id not in scene_ids:
+            continue
+        positions = scene.read_positions()
+        for record in scene.records():
+            keep = np.sort(rng.permutation(record.n_links)[:LINKS_PER_RECORD])
+            padded, mask = targets(record)
+            x.append(inputs(record, positions)[keep]); y.append(padded[keep]); m.append(mask[keep])
+            ids += [(scene.id, record.frequency_hz, record.bs_id, int(u)) for u in record.ue_ids[keep]]
+    return {"x": np.concatenate(x), "y": np.concatenate(y), "mask": np.concatenate(m),
+            "ids": np.array(ids, dtype=object)}
+```
+
+## 4. Cache, then normalize with training statistics only
+
+Converting records takes a while, so save the arrays once. The cache key covers the release,
+the selection, the scene lists of the split and the preprocessing version: change any of them
+(including the validation fraction) and a new cache is built. Loading checks that every cached
+row comes from a scene of its part.
+Normalization is fitted on the training split and then applied unchanged to validation and
+test, so no information leaks from held-out scenes. Target statistics use stored paths only,
+and padded entries stay zero. Keep the statistics to turn predictions back into units.
+
+```python
+recipe = c4w.recipe.dumps(selection.to_recipe(revision=REVISION))
+split_lists = json.dumps(splits, sort_keys=True)
+key = hashlib.sha256(
+    f"{ds.release}|{recipe}|{split_lists}|{PREPROCESSING}|{LINKS_PER_RECORD}".encode()).hexdigest()[:16]
+cache = Path("cache") / key
+data = {}
+for part, scene_ids in splits.items():
+    path = cache / f"{part}.npz"
+    if not path.exists():
+        cache.mkdir(parents=True, exist_ok=True)
+        a = arrays(set(scene_ids))
+        np.savez(path, x=a["x"], y=a["y"], mask=a["mask"], ids=a["ids"].astype(str))
+    with np.load(path) as z:
+        data[part] = {k: z[k] for k in z.files}
+    assert set(data[part]["ids"][:, 0]) <= set(scene_ids), f"cached {part} rows from other scenes"
+    print(part, data[part]["x"].shape, data[part]["y"].shape)
+
+train = data["train"]
+stored = train["y"][train["mask"]]                                  # (stored paths, 5)
+stats = {"x_mean": train["x"].mean(axis=0), "x_std": train["x"].std(axis=0) + 1e-6,
+         "y_mean": stored.mean(axis=0), "y_std": stored.std(axis=0) + 1e-6}
+np.savez(cache / "normalization.npz", **stats)
+for part in data.values():
+    part["x"] = ((part["x"] - stats["x_mean"]) / stats["x_std"]).astype(np.float32)
+    y = (part["y"] - stats["y_mean"]) / stats["y_std"]
+    part["y"] = np.where(part["mask"][..., None], y, 0).astype(np.float32)
+```
+
+## 5. A Dataset and a DataLoader
+
+Every sample has the same shape, so PyTorch's default collate function batches them. Shuffle
+the training set; keep validation and test in order.
+
+```python
+class LinkDataset(Dataset):
+    def __init__(self, part):
+        self.x = torch.from_numpy(part["x"])
+        self.y = torch.from_numpy(part["y"])
+        self.mask = torch.from_numpy(part["mask"])
+
+    def __len__(self):
+        return len(self.x)
+
+    def __getitem__(self, i):
+        return {"x": self.x[i], "y": self.y[i], "mask": self.mask[i]}
+
+loaders = {part: DataLoader(LinkDataset(data[part]), batch_size=256, shuffle=(part == "train"))
+           for part in data}
+batch = next(iter(loaders["train"]))
+for name, value in batch.items():
+    print(f"{name:5s} {tuple(value.shape)} {value.dtype}")
+```
+
+## 6. What a batch holds
+
+- `x` (batch, 4): the UE position relative to the BS, in metres, and the BS height,
+  normalized with training statistics.
+- `y` (batch, 16, 5): up to 16 paths per link, strongest first; per path the delay in ns, the
+  power in dB relative to unit power, the cosine and sine of the arrival azimuth and the
+  arrival zenith in radians, each normalized with the training split's stored paths.
+- `mask` (batch, 16): true where a path is stored. Padded paths are zeros: use the mask in
+  every loss and metric so they never count as weak paths.
+
+The saved `ids` (scene, carrier, BS, UE) tie each row back to its record.
+
+```python
+paths = data["train"]["mask"].sum(axis=1)
+print("stored paths per link: min", paths.min(), "mean", round(float(paths.mean()), 1), "max", paths.max())
+
+def masked_mse(prediction, target, mask):
+    error = ((prediction - target) ** 2).mean(dim=-1)          # (batch, 16)
+    return (error * mask).sum() / mask.sum().clamp(min=1)
+
+# Predicting the training mean (zero after normalization) gives a masked MSE near 1.
+print("masked MSE of predicting the mean:",
+      round(float(masked_mse(torch.zeros_like(batch["y"]), batch["y"], batch["mask"])), 3))
+```
+
+## Adapt it
+
+- **Other inputs:** add the carrier, the scene geometry (`scene.open_geometry()`), or the
+  channel at the other carrier for cross-band tasks; keep them per link.
+- **Other targets:** use the complex coefficients, departure angles, the frequency response
+  (`T.frequency_response`) or the interaction detail (`components=("core", "detail")`,
+  `T.pad_interactions`).
+- **More data:** widen the selection (`tier="small"` on the release catalog, other profiles or
+  BSs) and raise `LINKS_PER_RECORD`; the [library guide](library-guide.md) plans TAR
+  downloads, and `c4w.to_cache` keeps records memory-mapped for repeated reads.
+- **Shuffling at scale:** records are stored in groups of 25 scenes; shuffle groups or scenes
+  and read each one's records together, as above.
+- **Records instead of links:** `channels4world.torch.RecordDataset(selection, transform=...)`
+  yields one record per item and reopens the dataset in each worker process.
+
+*Notebook: [03-dataloader.ipynb](notebooks/03-dataloader.ipynb). The page and the notebook hold the same code.*
+
+[Return to card](../README.md)

docs/notebooks/01-read-one-scene-library.ipynb

@@ -0,0 +1,345 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cell-00",
+   "metadata": {},
+   "source": [
+    "# Read one scene with the channels4world library\n",
+    "\n",
+    "This tutorial follows one link of Channels4World from the catalog down to its paths:\n",
+    "**BS 0 → UE 14 of `urban_scene_019234` at 3.5 GHz**, the link the project website shows.\n",
+    "It downloads about 26 MB of one Tiny scene, walks the hierarchy, reads the geometry, the\n",
+    "positions and the channel record, explains the stored arrays, and ends with the same link\n",
+    "at 7 GHz. [The same tutorial without the library](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/tutorial-numpy.md) reads the same link\n",
+    "with NumPy alone.\n",
+    "\n",
+    "Install the library with `pip install channels4world` (Python 3.11+), then\n",
+    "`pip install huggingface_hub matplotlib`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import json\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from huggingface_hub import snapshot_download\n",
+    "from matplotlib.collections import PolyCollection\n",
+    "\n",
+    "import channels4world as c4w"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-02",
+   "metadata": {},
+   "source": [
+    "## 1. Choose the link\n",
+    "\n",
+    "Change these to read any other link. `GROUP` is the scene's `group` in the `tiny_scenes`\n",
+    "catalog. BS IDs run from 0 to 31 and UE IDs from 0 to 16,383; both are rows\n",
+    "of the scene's positions. Carriers are integers in Hz."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-03",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "REPO, REVISION = \"Intelligence-Networking-Lab/Channels4World\", \"v1.0.0\"\n",
+    "SCENE_ID, GROUP = \"urban_scene_019234\", \"test-urban-g00000\"  # GROUP: from the tiny_scenes catalog\n",
+    "CARRIER_HZ, BS_ID, UE_ID = 3_500_000_000, 0, 14\n",
+    "OTHER_HZ = 7_000_000_000\n",
+    "DATA = Path(\"c4w\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-04",
+   "metadata": {},
+   "source": [
+    "## 2. Download what this tutorial reads\n",
+    "\n",
+    "Tiny is published as loose files under `tiny/`. The library needs Tiny's catalog, the shared\n",
+    "schemas and the scene's group metadata (about 11 MB); the records are the scene's positions\n",
+    "and geometry and BS 0's core and detail at both carriers (about 15 MB)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scene_dir = f\"tiny/records/scene={SCENE_ID}\"\n",
+    "patterns = [\n",
+    "    \"tiny/c4w-root.json\", \"tiny/c4w-root/*\", \"tiny/schema/*\",\n",
+    "    f\"tiny/groups/{GROUP}/catalog/members.parquet\", f\"tiny/groups/{GROUP}/snapshot.json\",\n",
+    "    f\"{scene_dir}/positions.npz\", f\"{scene_dir}/geometry.zip\",\n",
+    "    f\"{scene_dir}/band_hz=*/component=*/bs{BS_ID:05d}.npz\",\n",
+    "]\n",
+    "snapshot_download(REPO, repo_type=\"dataset\", revision=REVISION, local_dir=DATA, allow_patterns=patterns)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-06",
+   "metadata": {},
+   "source": [
+    "## 3. Walk the hierarchy\n",
+    "\n",
+    "The dataset is organized as **dataset → scene → carrier → base station → UE link → paths**.\n",
+    "Opening reads only the small catalog; group metadata and records load when first needed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds = c4w.open(DATA / \"tiny\")\n",
+    "print(ds)\n",
+    "scene = ds.scene(SCENE_ID)\n",
+    "print(scene)                                        # split, profile and smallest tier\n",
+    "print(\"carriers (Hz):\", scene.frequencies.ids)\n",
+    "print(\"base stations:\", scene.frequencies[CARRIER_HZ].base_stations.ids)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-08",
+   "metadata": {},
+   "source": [
+    "`urban_scene_019234` is a **test** scene: every link and both carriers of a scene stay in\n",
+    "one split, so a model trained on the training split has never seen this place.\n",
+    "\n",
+    "## 4. Geometry and positions\n",
+    "\n",
+    "Geometry, positions and interaction points share one frame: scene metres, z up. Positions\n",
+    "hold all 32 BS and 16,384 UE coordinates of the scene; the geometry is a Mitsuba XML file\n",
+    "with OBJ meshes in a ZIP."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-09",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "positions = scene.read_positions()\n",
+    "bs_positions, ue_positions = positions.bs, positions.ue\n",
+    "bs_xyz, ue_xyz = bs_positions[BS_ID], ue_positions[UE_ID]\n",
+    "print(positions)\n",
+    "print(\"BS\", bs_xyz, \"UE\", ue_xyz, f\"distance {np.linalg.norm(ue_xyz - bs_xyz):.1f} m\")\n",
+    "\n",
+    "def top_view(read, names):\n",
+    "    \"\"\"Building triangles projected onto the ground (x, y), from OBJ meshes.\"\"\"\n",
+    "    triangles = []\n",
+    "    for name in names:\n",
+    "        verts, faces = [], []\n",
+    "        for line in read(name).decode().splitlines():\n",
+    "            if line.startswith(\"v \"):\n",
+    "                verts.append([float(v) for v in line.split()[1:4]])\n",
+    "            elif line.startswith(\"f \"):\n",
+    "                idx = [int(t.split(\"/\")[0]) for t in line.split()[1:]]\n",
+    "                faces += [[idx[0], idx[k], idx[k + 1]] for k in range(1, len(idx) - 1)]\n",
+    "        v = np.array(verts)\n",
+    "        triangles += [v[[i - 1 for i in f], :2] for f in faces]   # OBJ indices start at 1\n",
+    "    return triangles\n",
+    "\n",
+    "with scene.open_geometry() as geometry:\n",
+    "    print(\"entry point:\", json.loads(geometry.read(\"scene.json\"))[\"entrypoint\"])\n",
+    "    meshes = [n for n in geometry.namelist() if n.endswith(\".obj\") and \"ground\" not in n]\n",
+    "    triangles = top_view(geometry.read, meshes)\n",
+    "print(len(meshes), \"building meshes\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(6, 6))\n",
+    "ax.add_collection(PolyCollection(triangles, facecolor=\"#c3cbc2\", edgecolor=\"none\"))\n",
+    "ax.scatter(ue_positions[:, 0], ue_positions[:, 1], s=0.2, color=\"#4d9688\", label=f\"{len(ue_positions):,} UEs\")\n",
+    "ax.scatter(bs_positions[:, 0], bs_positions[:, 1], marker=\"^\", s=30, color=\"k\", label=f\"{len(bs_positions)} BSs\")\n",
+    "ax.plot(*zip(bs_xyz[:2], ue_xyz[:2]), color=\"#e2733d\", lw=2, label=f\"BS {BS_ID} → UE {UE_ID}\")\n",
+    "ax.set(xlim=(-250, 250), ylim=(-250, 250), aspect=\"equal\", xlabel=\"x (m)\", ylabel=\"y (m)\", title=SCENE_ID)\n",
+    "ax.legend(loc=\"upper right\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-11",
+   "metadata": {},
+   "source": [
+    "## 5. One channel record\n",
+    "\n",
+    "A record holds every retained link from one BS at one carrier. `get_link(UE_ID)` returns\n",
+    "that UE's link, or `None` when the UE has no retained link to this BS (which is not a\n",
+    "zero-valued channel). A UE ID is a row of the positions; the link's row inside the record\n",
+    "is a different index."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "record = scene.frequencies[CARRIER_HZ].base_stations[BS_ID].read(detail=True)\n",
+    "print(record)\n",
+    "link = record.get_link(UE_ID)\n",
+    "print(link, f\"- row {link.index} of the record's {record.n_links} links\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-13",
+   "metadata": {},
+   "source": [
+    "## 6. What each path stores\n",
+    "\n",
+    "For every retained path the core record stores the complex coefficient `a_real + 1j*a_imag`\n",
+    "(passband, without the carrier-delay phase, antennas included), the delay `tau` in seconds,\n",
+    "departure and arrival angles in radians, and its interaction count and type flags; the detail\n",
+    "record adds each interaction's type and location in order. Paths are stored strongest first,\n",
+    "and each link keeps at most its 16 strongest paths above −150 dB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NAMES = {1: \"specular reflection\", 2: \"diffuse reflection\", 4: \"refraction\", 8: \"diffraction\"}\n",
+    "\n",
+    "def describe(core, detail):\n",
+    "    \"\"\"One line per retained path, strongest first.\"\"\"\n",
+    "    re, im = core[\"a_real\"].astype(np.float64), core[\"a_imag\"].astype(np.float64)\n",
+    "    power_db = 10 * np.log10(re**2 + im**2)\n",
+    "    off = detail[\"path_interaction_offsets\"]\n",
+    "    for p in range(len(core[\"tau\"])):\n",
+    "        kinds = [NAMES.get(int(t), str(t)) for t in detail[\"interaction_type\"][off[p]:off[p + 1]]]\n",
+    "        print(f\"rank {int(core['path_rank'][p]):2d}  {core['tau'][p] * 1e9:8.2f} ns  {power_db[p]:7.2f} dB  \"\n",
+    "              f\"AoD az {np.degrees(core['phi_t'][p]):6.1f}°  AoA az {np.degrees(core['phi_r'][p]):6.1f}°  \"\n",
+    "              f\"{' → '.join(kinds) or 'line of sight'}\")\n",
+    "\n",
+    "describe(link.core, link.detail)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-15",
+   "metadata": {},
+   "source": [
+    "## 7. A power–delay profile\n",
+    "\n",
+    "Placing each path by delay and power gives the link's power–delay profile: a path-based view\n",
+    "of the stored channel. It is not a sampled impulse response; for a channel at a given\n",
+    "bandwidth, `channels4world.transforms` provides baseband coefficients and frequency\n",
+    "responses."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stems(ax, tau, a_real, a_imag, label, marker, color):\n",
+    "    power_db = 10 * np.log10(a_real.astype(np.float64)**2 + a_imag.astype(np.float64)**2)\n",
+    "    ax.vlines(tau * 1e9, -150, power_db, color=color, lw=1.2)\n",
+    "    ax.scatter(tau * 1e9, power_db, marker=marker, color=color, zorder=3, label=label)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7, 3))\n",
+    "stems(ax, link.core[\"tau\"], link.core[\"a_real\"], link.core[\"a_imag\"], \"3.5 GHz\", \"o\", \"#e2733d\")\n",
+    "ax.set(xlabel=\"delay (ns)\", ylabel=\"path power (dB)\", ylim=(-150, None),\n",
+    "       title=f\"{SCENE_ID} · BS {BS_ID} → UE {UE_ID}\")\n",
+    "ax.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-17",
+   "metadata": {},
+   "source": [
+    "## 8. The same link at 7 GHz\n",
+    "\n",
+    "Every scene is simulated at both carriers with the same BS and UE positions. Read the same\n",
+    "BS and UE at 7 GHz and compare on shared axes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "link7 = scene.frequencies[OTHER_HZ].base_stations[BS_ID].read(detail=True).get_link(UE_ID)\n",
+    "fig, ax = plt.subplots(figsize=(7, 3))\n",
+    "stems(ax, link.core[\"tau\"], link.core[\"a_real\"], link.core[\"a_imag\"], \"3.5 GHz\", \"o\", \"#e2733d\")\n",
+    "if link7 is None:\n",
+    "    print(\"UE\", UE_ID, \"has no retained link at 7 GHz\")\n",
+    "else:\n",
+    "    stems(ax, link7.core[\"tau\"], link7.core[\"a_real\"], link7.core[\"a_imag\"], \"7 GHz\", \"s\", \"#4d9688\")\n",
+    "    for l, label in ((link, \"3.5 GHz\"), (link7, \"7 GHz\")):\n",
+    "        a = l.core[\"a_real\"].astype(np.float64) + 1j * l.core[\"a_imag\"].astype(np.float64)\n",
+    "        print(f\"{label}: {l.n_paths} paths, link power {10 * np.log10(np.sum(np.abs(a) ** 2)):.2f} dB\")\n",
+    "ax.set(xlabel=\"delay (ns)\", ylabel=\"path power (dB)\", ylim=(-150, None))\n",
+    "ax.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-19",
+   "metadata": {},
+   "source": [
+    "Ranks order the paths within one record: rank 0 at 7 GHz need not be the route of rank 0\n",
+    "at 3.5 GHz. To match routes across carriers, compare delays, interaction sequences or\n",
+    "interaction points (`link7.detail`), not ranks.\n",
+    "\n",
+    "## Next\n",
+    "\n",
+    "- [From channel records to a DataLoader](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/ml-guide.md): link samples, splits, padding and batches.\n",
+    "- [Library guide](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/library-guide.md): download plans for larger tiers, recipes, extraction and caches.\n",
+    "- [Schema reference](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/schema-reference.md): every array and its meaning."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/notebooks/02-read-one-scene-numpy.ipynb

@@ -0,0 +1,342 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cell-00",
+   "metadata": {},
+   "source": [
+    "# Read one scene without the library\n",
+    "\n",
+    "The same link as the [library tutorial](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/tutorial-library.md), **BS 0 → UE 14 of\n",
+    "`urban_scene_019234` at 3.5 GHz**, read with NumPy and the standard library from Tiny's loose\n",
+    "files: about 15 MB. Archives from larger tiers hold the same files; see\n",
+    "[without the library](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/without-library.md) for TAR access.\n",
+    "\n",
+    "Install with `pip install numpy huggingface_hub matplotlib`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import json\n",
+    "import zipfile\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from huggingface_hub import snapshot_download\n",
+    "from matplotlib.collections import PolyCollection"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-02",
+   "metadata": {},
+   "source": [
+    "## 1. Choose the link\n",
+    "\n",
+    "The same identifiers as the library tutorial. A UE ID is a row of `ue_positions`, and the BS\n",
+    "ID is both a row of `bs_positions` and the number in the record's file name."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-03",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "REPO, REVISION = \"Intelligence-Networking-Lab/Channels4World\", \"v1.0.0\"\n",
+    "SCENE_ID, GROUP = \"urban_scene_019234\", \"test-urban-g00000\"  # GROUP: from the tiny_scenes catalog\n",
+    "CARRIER_HZ, BS_ID, UE_ID = 3_500_000_000, 0, 14\n",
+    "OTHER_HZ = 7_000_000_000\n",
+    "DATA = Path(\"c4w\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-04",
+   "metadata": {},
+   "source": [
+    "## 2. Download the scene's files\n",
+    "\n",
+    "NumPy needs only the record files: positions, geometry, and BS 0's core and detail at both\n",
+    "carriers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scene_dir = DATA / \"tiny\" / \"records\" / f\"scene={SCENE_ID}\"\n",
+    "remote = f\"tiny/records/scene={SCENE_ID}\"\n",
+    "snapshot_download(REPO, repo_type=\"dataset\", revision=REVISION, local_dir=DATA, allow_patterns=[\n",
+    "    f\"{remote}/positions.npz\", f\"{remote}/geometry.zip\", f\"{remote}/band_hz=*/component=*/bs{BS_ID:05d}.npz\"])\n",
+    "\n",
+    "def record_path(carrier_hz, component):\n",
+    "    return scene_dir / f\"band_hz={carrier_hz}\" / f\"component={component}\" / f\"bs{BS_ID:05d}.npz\"\n",
+    "\n",
+    "print(sorted(p.relative_to(scene_dir).as_posix() for p in scene_dir.rglob(\"*\") if p.is_file()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-06",
+   "metadata": {},
+   "source": [
+    "## 3. The hierarchy on disk\n",
+    "\n",
+    "Each scene folder holds `positions.npz` and `geometry.zip`, shared by both carriers, and one\n",
+    "file per carrier, component and BS: `band_hz=<Hz>/component=<core|detail>/bs<NNNNN>.npz`.\n",
+    "Every NPZ carries its identity in a JSON `__meta__` entry:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with np.load(record_path(CARRIER_HZ, \"core\"), allow_pickle=False) as npz:\n",
+    "    meta = json.loads(npz[\"__meta__\"].item())\n",
+    "print(json.dumps(meta[\"identity\"], indent=1))\n",
+    "print(meta[\"dimensions\"])                      # retained links and paths in this record"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-08",
+   "metadata": {},
+   "source": [
+    "## 4. Geometry and positions\n",
+    "\n",
+    "Geometry, positions and interaction points share one frame: scene metres, z up."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-09",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with np.load(scene_dir / \"positions.npz\", allow_pickle=False) as positions:\n",
+    "    bs_positions, ue_positions = positions[\"bs_positions\"], positions[\"ue_positions\"]\n",
+    "bs_xyz, ue_xyz = bs_positions[BS_ID], ue_positions[UE_ID]\n",
+    "print(bs_positions.shape, ue_positions.shape)\n",
+    "print(\"BS\", bs_xyz, \"UE\", ue_xyz, f\"distance {np.linalg.norm(ue_xyz - bs_xyz):.1f} m\")\n",
+    "\n",
+    "def top_view(read, names):\n",
+    "    \"\"\"Building triangles projected onto the ground (x, y), from OBJ meshes.\"\"\"\n",
+    "    triangles = []\n",
+    "    for name in names:\n",
+    "        verts, faces = [], []\n",
+    "        for line in read(name).decode().splitlines():\n",
+    "            if line.startswith(\"v \"):\n",
+    "                verts.append([float(v) for v in line.split()[1:4]])\n",
+    "            elif line.startswith(\"f \"):\n",
+    "                idx = [int(t.split(\"/\")[0]) for t in line.split()[1:]]\n",
+    "                faces += [[idx[0], idx[k], idx[k + 1]] for k in range(1, len(idx) - 1)]\n",
+    "        v = np.array(verts)\n",
+    "        triangles += [v[[i - 1 for i in f], :2] for f in faces]   # OBJ indices start at 1\n",
+    "    return triangles\n",
+    "\n",
+    "with zipfile.ZipFile(scene_dir / \"geometry.zip\") as geometry:\n",
+    "    print(\"entry point:\", json.loads(geometry.read(\"scene.json\"))[\"entrypoint\"])\n",
+    "    meshes = [n for n in geometry.namelist() if n.endswith(\".obj\") and \"ground\" not in n]\n",
+    "    triangles = top_view(geometry.read, meshes)\n",
+    "print(len(meshes), \"building meshes\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(6, 6))\n",
+    "ax.add_collection(PolyCollection(triangles, facecolor=\"#c3cbc2\", edgecolor=\"none\"))\n",
+    "ax.scatter(ue_positions[:, 0], ue_positions[:, 1], s=0.2, color=\"#4d9688\", label=f\"{len(ue_positions):,} UEs\")\n",
+    "ax.scatter(bs_positions[:, 0], bs_positions[:, 1], marker=\"^\", s=30, color=\"k\", label=f\"{len(bs_positions)} BSs\")\n",
+    "ax.plot(*zip(bs_xyz[:2], ue_xyz[:2]), color=\"#e2733d\", lw=2, label=f\"BS {BS_ID} → UE {UE_ID}\")\n",
+    "ax.set(xlim=(-250, 250), ylim=(-250, 250), aspect=\"equal\", xlabel=\"x (m)\", ylabel=\"y (m)\", title=SCENE_ID)\n",
+    "ax.legend(loc=\"upper right\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-11",
+   "metadata": {},
+   "source": [
+    "## 5. Find the link\n",
+    "\n",
+    "`link_ue_index` lists the UEs this BS reaches, in ascending order; the link's row is where\n",
+    "`UE_ID` sits in that list. Link `row` owns paths `link_path_offsets[row]` to\n",
+    "`link_path_offsets[row + 1]`. A UE that is not listed has no retained link to this BS (not a\n",
+    "zero-valued channel)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load(carrier_hz, component):\n",
+    "    with np.load(record_path(carrier_hz, component), allow_pickle=False) as npz:\n",
+    "        return {name: npz[name] for name in npz.files if name != \"__meta__\"}\n",
+    "\n",
+    "def link_of(core, detail, ue_id):\n",
+    "    ue_ids = core[\"link_ue_index\"]\n",
+    "    row = int(np.searchsorted(ue_ids, ue_id))\n",
+    "    if row == ue_ids.size or ue_ids[row] != ue_id:\n",
+    "        return None                                        # no retained link to this UE\n",
+    "    p0, p1 = map(int, core[\"link_path_offsets\"][row:row + 2])\n",
+    "    link_core = {k: v[p0:p1] for k, v in core.items() if k not in (\"link_ue_index\", \"link_path_offsets\")}\n",
+    "    i0, i1 = map(int, detail[\"path_interaction_offsets\"][[p0, p1]])\n",
+    "    link_detail = {k: detail[k][i0:i1] for k in (\"interaction_rank\", \"interaction_type\", \"interaction_vertex\")}\n",
+    "    link_detail[\"path_interaction_offsets\"] = detail[\"path_interaction_offsets\"][p0:p1 + 1] - i0\n",
+    "    return row, link_core, link_detail\n",
+    "\n",
+    "core, detail = load(CARRIER_HZ, \"core\"), load(CARRIER_HZ, \"detail\")\n",
+    "row, link_core, link_detail = link_of(core, detail, UE_ID)\n",
+    "print(f\"UE {UE_ID}: link row {row} of {core['link_ue_index'].size}, {link_core['tau'].size} paths\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-13",
+   "metadata": {},
+   "source": [
+    "## 6. What each path stores\n",
+    "\n",
+    "The same arrays as in the library tutorial: the complex coefficient `a_real + 1j*a_imag`\n",
+    "(passband, without the carrier-delay phase, antennas included), the delay `tau` in seconds,\n",
+    "departure and arrival angles in radians and, in detail, each interaction's type and location\n",
+    "in order. Paths are stored strongest first, at most 16 per link above −150 dB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NAMES = {1: \"specular reflection\", 2: \"diffuse reflection\", 4: \"refraction\", 8: \"diffraction\"}\n",
+    "\n",
+    "def describe(core, detail):\n",
+    "    \"\"\"One line per retained path, strongest first.\"\"\"\n",
+    "    re, im = core[\"a_real\"].astype(np.float64), core[\"a_imag\"].astype(np.float64)\n",
+    "    power_db = 10 * np.log10(re**2 + im**2)\n",
+    "    off = detail[\"path_interaction_offsets\"]\n",
+    "    for p in range(len(core[\"tau\"])):\n",
+    "        kinds = [NAMES.get(int(t), str(t)) for t in detail[\"interaction_type\"][off[p]:off[p + 1]]]\n",
+    "        print(f\"rank {int(core['path_rank'][p]):2d}  {core['tau'][p] * 1e9:8.2f} ns  {power_db[p]:7.2f} dB  \"\n",
+    "              f\"AoD az {np.degrees(core['phi_t'][p]):6.1f}°  AoA az {np.degrees(core['phi_r'][p]):6.1f}°  \"\n",
+    "              f\"{' → '.join(kinds) or 'line of sight'}\")\n",
+    "\n",
+    "describe(link_core, link_detail)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-15",
+   "metadata": {},
+   "source": [
+    "## 7. A power–delay profile\n",
+    "\n",
+    "Placing each path by delay and power gives the link's power–delay profile: a path-based view\n",
+    "of the stored channel, not a sampled impulse response."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stems(ax, tau, a_real, a_imag, label, marker, color):\n",
+    "    power_db = 10 * np.log10(a_real.astype(np.float64)**2 + a_imag.astype(np.float64)**2)\n",
+    "    ax.vlines(tau * 1e9, -150, power_db, color=color, lw=1.2)\n",
+    "    ax.scatter(tau * 1e9, power_db, marker=marker, color=color, zorder=3, label=label)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7, 3))\n",
+    "stems(ax, link_core[\"tau\"], link_core[\"a_real\"], link_core[\"a_imag\"], \"3.5 GHz\", \"o\", \"#e2733d\")\n",
+    "ax.set(xlabel=\"delay (ns)\", ylabel=\"path power (dB)\", ylim=(-150, None),\n",
+    "       title=f\"{SCENE_ID} · BS {BS_ID} → UE {UE_ID}\")\n",
+    "ax.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-17",
+   "metadata": {},
+   "source": [
+    "## 8. The same link at 7 GHz"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "other = link_of(load(OTHER_HZ, \"core\"), load(OTHER_HZ, \"detail\"), UE_ID)\n",
+    "fig, ax = plt.subplots(figsize=(7, 3))\n",
+    "stems(ax, link_core[\"tau\"], link_core[\"a_real\"], link_core[\"a_imag\"], \"3.5 GHz\", \"o\", \"#e2733d\")\n",
+    "if other is None:\n",
+    "    print(\"UE\", UE_ID, \"has no retained link at 7 GHz\")\n",
+    "else:\n",
+    "    _, core7, _ = other\n",
+    "    stems(ax, core7[\"tau\"], core7[\"a_real\"], core7[\"a_imag\"], \"7 GHz\", \"s\", \"#4d9688\")\n",
+    "    for c, label in ((link_core, \"3.5 GHz\"), (core7, \"7 GHz\")):\n",
+    "        power = np.sum(c[\"a_real\"].astype(np.float64) ** 2 + c[\"a_imag\"].astype(np.float64) ** 2)\n",
+    "        print(f\"{label}: {c['tau'].size} paths, link power {10 * np.log10(power):.2f} dB\")\n",
+    "ax.set(xlabel=\"delay (ns)\", ylabel=\"path power (dB)\", ylim=(-150, None))\n",
+    "ax.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-19",
+   "metadata": {},
+   "source": [
+    "Ranks order the paths within one record, so the same rank at 3.5 and 7 GHz need not be\n",
+    "the same route. Compare delays, interaction sequences or interaction points instead.\n",
+    "\n",
+    "## Next\n",
+    "\n",
+    "- [Without the library](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/without-library.md): TAR archives, catalogs and byte-range reads.\n",
+    "- [Schema reference](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/schema-reference.md): every array, its dtype and its meaning."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/notebooks/03-dataloader.ipynb

@@ -0,0 +1,322 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cell-00",
+   "metadata": {},
+   "source": [
+    "# From channel records to a DataLoader\n",
+    "\n",
+    "This guide turns Channels4World records into fixed-size arrays and a PyTorch `DataLoader`,\n",
+    "with train, validation and test sets split by scene. It ends at one batch whose contents\n",
+    "are explained, so you can adapt the inputs and targets to your model, or swap these\n",
+    "batches into an existing training loop.\n",
+    "\n",
+    "The example uses the 100 urban scenes of Tiny (90 train, 10 test), BS 0 at 3.5 GHz. Change the\n",
+    "selection to scale up; the steps stay the same. Install the library with `pip install channels4world`\n",
+    "(Python 3.11+), then `pip install torch huggingface_hub`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import hashlib\n",
+    "import json\n",
+    "\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from huggingface_hub import snapshot_download\n",
+    "from torch.utils.data import DataLoader, Dataset\n",
+    "\n",
+    "import channels4world as c4w\n",
+    "from channels4world import transforms as T\n",
+    "\n",
+    "REPO, REVISION = \"Intelligence-Networking-Lab/Channels4World\", \"v1.0.0\"\n",
+    "DATA = Path(\"c4w\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-02",
+   "metadata": {},
+   "source": [
+    "## 1. Choose the records\n",
+    "\n",
+    "One **sample** here is one retained link: a (scene, carrier, BS, UE) channel. A record holds\n",
+    "every retained link of one BS at one carrier, so records are read whole and split into\n",
+    "links. First download Tiny's catalog and the metadata of the five groups that hold its urban\n",
+    "scenes (about 42 MB), so the library can plan exactly which record files the selection needs:\n",
+    "here about 0.4 GB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-03",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "snapshot_download(REPO, repo_type=\"dataset\", revision=REVISION, local_dir=DATA, allow_patterns=[\n",
+    "    \"tiny/c4w-root.json\", \"tiny/c4w-root/*\", \"tiny/schema/*\",\n",
+    "    \"tiny/groups/*-urban-g*/catalog/members.parquet\", \"tiny/groups/*-urban-g*/snapshot.json\"])\n",
+    "\n",
+    "ds = c4w.open(DATA / \"tiny\")\n",
+    "selection = ds.select(profile=\"urban\", frequencies_hz=[3_500_000_000], bs_ids=[0],\n",
+    "                      components=(\"core\", \"positions\"))\n",
+    "report = selection.missing()\n",
+    "print(report)\n",
+    "if report.files:\n",
+    "    snapshot_download(REPO, repo_type=\"dataset\", revision=REVISION, local_dir=report.local_dir,\n",
+    "                      allow_patterns=report.repo_files)\n",
+    "assert selection.missing().complete"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-04",
+   "metadata": {},
+   "source": [
+    "## 2. Split by scene\n",
+    "\n",
+    "Keep the release's train and test split: test scenes are places no training scene shows.\n",
+    "Take validation scenes from the training split, by scene and never by link, so links of one\n",
+    "place never sit on both sides. Hashing the scene ID makes the choice reproducible, and\n",
+    "saving the lists records it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def is_validation(scene_id, fraction=0.1):\n",
+    "    return int(hashlib.sha256(scene_id.encode()).hexdigest(), 16) % 1000 < fraction * 1000\n",
+    "\n",
+    "splits = {\"train\": [], \"validation\": [], \"test\": []}\n",
+    "for scene in selection.scenes():\n",
+    "    part = \"test\" if scene.split == \"test\" else (\"validation\" if is_validation(scene.id) else \"train\")\n",
+    "    splits[part].append(scene.id)\n",
+    "print({k: len(v) for k, v in splits.items()})\n",
+    "Path(\"splits.json\").write_text(json.dumps(splits, indent=1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-06",
+   "metadata": {},
+   "source": [
+    "## 3. From a record to arrays\n",
+    "\n",
+    "Each record becomes arrays with one row per link. This is where your own preprocessing goes:\n",
+    "`inputs` here are the UE position relative to the BS and the BS height; `targets` are the\n",
+    "strongest 16 paths' delays (ns), powers (dB) and arrival angles, padded to fixed size with a\n",
+    "mask that marks stored paths. Replace either function to fit your task. `LINKS_PER_RECORD`\n",
+    "bounds memory by sampling links reproducibly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "LINKS_PER_RECORD = 512\n",
+    "PREPROCESSING = \"v1: dxyz+bs_z -> 16 x (delay ns, power dB, cos/sin AoA az, AoA zenith)\"\n",
+    "\n",
+    "def inputs(record, positions):\n",
+    "    ue = positions.ue[record.ue_ids].astype(np.float32)\n",
+    "    bs = positions.bs[record.bs_id].astype(np.float32)\n",
+    "    return np.concatenate([ue - bs, np.full((len(ue), 1), bs[2], np.float32)], axis=1)   # (links, 4)\n",
+    "\n",
+    "def targets(record):\n",
+    "    core = record.core\n",
+    "    power = 10 * np.log10(core[\"a_real\"].astype(np.float64) ** 2 + core[\"a_imag\"].astype(np.float64) ** 2)\n",
+    "    per_path = np.stack([core[\"tau\"] * 1e9, power, np.cos(core[\"phi_r\"]), np.sin(core[\"phi_r\"]),\n",
+    "                         core[\"theta_r\"]], axis=1).astype(np.float32)           # (paths, 5)\n",
+    "    padded, mask = T.pad_paths(core, per_path)                                   # (links, 16, 5), (links, 16)\n",
+    "    return padded, mask\n",
+    "\n",
+    "def arrays(scene_ids):\n",
+    "    rng = np.random.default_rng(0)\n",
+    "    x, y, m, ids = [], [], [], []\n",
+    "    for scene in selection.scenes():\n",
+    "        if scene.id not in scene_ids:\n",
+    "            continue\n",
+    "        positions = scene.read_positions()\n",
+    "        for record in scene.records():\n",
+    "            keep = np.sort(rng.permutation(record.n_links)[:LINKS_PER_RECORD])\n",
+    "            padded, mask = targets(record)\n",
+    "            x.append(inputs(record, positions)[keep]); y.append(padded[keep]); m.append(mask[keep])\n",
+    "            ids += [(scene.id, record.frequency_hz, record.bs_id, int(u)) for u in record.ue_ids[keep]]\n",
+    "    return {\"x\": np.concatenate(x), \"y\": np.concatenate(y), \"mask\": np.concatenate(m),\n",
+    "            \"ids\": np.array(ids, dtype=object)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-08",
+   "metadata": {},
+   "source": [
+    "## 4. Cache, then normalize with training statistics only\n",
+    "\n",
+    "Converting records takes a while, so save the arrays once. The cache key covers the release,\n",
+    "the selection, the scene lists of the split and the preprocessing version: change any of them\n",
+    "(including the validation fraction) and a new cache is built. Loading checks that every cached\n",
+    "row comes from a scene of its part.\n",
+    "Normalization is fitted on the training split and then applied unchanged to validation and\n",
+    "test, so no information leaks from held-out scenes. Target statistics use stored paths only,\n",
+    "and padded entries stay zero. Keep the statistics to turn predictions back into units."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-09",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "recipe = c4w.recipe.dumps(selection.to_recipe(revision=REVISION))\n",
+    "split_lists = json.dumps(splits, sort_keys=True)\n",
+    "key = hashlib.sha256(\n",
+    "    f\"{ds.release}|{recipe}|{split_lists}|{PREPROCESSING}|{LINKS_PER_RECORD}\".encode()).hexdigest()[:16]\n",
+    "cache = Path(\"cache\") / key\n",
+    "data = {}\n",
+    "for part, scene_ids in splits.items():\n",
+    "    path = cache / f\"{part}.npz\"\n",
+    "    if not path.exists():\n",
+    "        cache.mkdir(parents=True, exist_ok=True)\n",
+    "        a = arrays(set(scene_ids))\n",
+    "        np.savez(path, x=a[\"x\"], y=a[\"y\"], mask=a[\"mask\"], ids=a[\"ids\"].astype(str))\n",
+    "    with np.load(path) as z:\n",
+    "        data[part] = {k: z[k] for k in z.files}\n",
+    "    assert set(data[part][\"ids\"][:, 0]) <= set(scene_ids), f\"cached {part} rows from other scenes\"\n",
+    "    print(part, data[part][\"x\"].shape, data[part][\"y\"].shape)\n",
+    "\n",
+    "train = data[\"train\"]\n",
+    "stored = train[\"y\"][train[\"mask\"]]                                  # (stored paths, 5)\n",
+    "stats = {\"x_mean\": train[\"x\"].mean(axis=0), \"x_std\": train[\"x\"].std(axis=0) + 1e-6,\n",
+    "         \"y_mean\": stored.mean(axis=0), \"y_std\": stored.std(axis=0) + 1e-6}\n",
+    "np.savez(cache / \"normalization.npz\", **stats)\n",
+    "for part in data.values():\n",
+    "    part[\"x\"] = ((part[\"x\"] - stats[\"x_mean\"]) / stats[\"x_std\"]).astype(np.float32)\n",
+    "    y = (part[\"y\"] - stats[\"y_mean\"]) / stats[\"y_std\"]\n",
+    "    part[\"y\"] = np.where(part[\"mask\"][..., None], y, 0).astype(np.float32)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-10",
+   "metadata": {},
+   "source": [
+    "## 5. A Dataset and a DataLoader\n",
+    "\n",
+    "Every sample has the same shape, so PyTorch's default collate function batches them. Shuffle\n",
+    "the training set; keep validation and test in order."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LinkDataset(Dataset):\n",
+    "    def __init__(self, part):\n",
+    "        self.x = torch.from_numpy(part[\"x\"])\n",
+    "        self.y = torch.from_numpy(part[\"y\"])\n",
+    "        self.mask = torch.from_numpy(part[\"mask\"])\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.x)\n",
+    "\n",
+    "    def __getitem__(self, i):\n",
+    "        return {\"x\": self.x[i], \"y\": self.y[i], \"mask\": self.mask[i]}\n",
+    "\n",
+    "loaders = {part: DataLoader(LinkDataset(data[part]), batch_size=256, shuffle=(part == \"train\"))\n",
+    "           for part in data}\n",
+    "batch = next(iter(loaders[\"train\"]))\n",
+    "for name, value in batch.items():\n",
+    "    print(f\"{name:5s} {tuple(value.shape)} {value.dtype}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-12",
+   "metadata": {},
+   "source": [
+    "## 6. What a batch holds\n",
+    "\n",
+    "- `x` (batch, 4): the UE position relative to the BS, in metres, and the BS height,\n",
+    "  normalized with training statistics.\n",
+    "- `y` (batch, 16, 5): up to 16 paths per link, strongest first; per path the delay in ns, the\n",
+    "  power in dB relative to unit power, the cosine and sine of the arrival azimuth and the\n",
+    "  arrival zenith in radians, each normalized with the training split's stored paths.\n",
+    "- `mask` (batch, 16): true where a path is stored. Padded paths are zeros: use the mask in\n",
+    "  every loss and metric so they never count as weak paths.\n",
+    "\n",
+    "The saved `ids` (scene, carrier, BS, UE) tie each row back to its record."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "paths = data[\"train\"][\"mask\"].sum(axis=1)\n",
+    "print(\"stored paths per link: min\", paths.min(), \"mean\", round(float(paths.mean()), 1), \"max\", paths.max())\n",
+    "\n",
+    "def masked_mse(prediction, target, mask):\n",
+    "    error = ((prediction - target) ** 2).mean(dim=-1)          # (batch, 16)\n",
+    "    return (error * mask).sum() / mask.sum().clamp(min=1)\n",
+    "\n",
+    "# Predicting the training mean (zero after normalization) gives a masked MSE near 1.\n",
+    "print(\"masked MSE of predicting the mean:\",\n",
+    "      round(float(masked_mse(torch.zeros_like(batch[\"y\"]), batch[\"y\"], batch[\"mask\"])), 3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-14",
+   "metadata": {},
+   "source": [
+    "## Adapt it\n",
+    "\n",
+    "- **Other inputs:** add the carrier, the scene geometry (`scene.open_geometry()`), or the\n",
+    "  channel at the other carrier for cross-band tasks; keep them per link.\n",
+    "- **Other targets:** use the complex coefficients, departure angles, the frequency response\n",
+    "  (`T.frequency_response`) or the interaction detail (`components=(\"core\", \"detail\")`,\n",
+    "  `T.pad_interactions`).\n",
+    "- **More data:** widen the selection (`tier=\"small\"` on the release catalog, other profiles or\n",
+    "  BSs) and raise `LINKS_PER_RECORD`; the [library guide](https://huggingface.co/datasets/Intelligence-Networking-Lab/Channels4World/blob/v1.0.0/docs/library-guide.md) plans TAR\n",
+    "  downloads, and `c4w.to_cache` keeps records memory-mapped for repeated reads.\n",
+    "- **Shuffling at scale:** records are stored in groups of 25 scenes; shuffle groups or scenes\n",
+    "  and read each one's records together, as above.\n",
+    "- **Records instead of links:** `channels4world.torch.RecordDataset(selection, transform=...)`\n",
+    "  yields one record per item and reopens the dataset in each worker process."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/read_archives.py

@@ -0,0 +1,108 @@
+"""Read Channels4World channel archives with only NumPy and the standard library.
+
+Usage:  python read_archives.py RELEASE_DIR [--band 3.5ghz] [--scenes ID ...] [--limit N]
+
+RELEASE_DIR is the folder you downloaded the release into (it contains payload/).
+The script finds every archive under RELEASE_DIR/payload, pairs each channel archive
+with its group's positions archive, joins UE IDs to UE positions, and prints the first
+retained link of each record it shows. It works with any folder layout, because archive
+file names are unique.
+"""
+
+import argparse
+import io
+import tarfile
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+
+
+def find_archives(release_dir):
+    """Map archive file name -> path for every .tar under RELEASE_DIR/payload."""
+    payload = Path(release_dir) / "payload"
+    if not payload.is_dir():
+        raise SystemExit(f"{payload} not found: pass the folder you downloaded the release into")
+    found = defaultdict(list)
+    for path in payload.rglob("*.tar"):
+        found[path.name].append(path)
+    duplicates = {name: paths for name, paths in found.items() if len(paths) > 1}
+    if duplicates:
+        lines = [f"  {name}: {', '.join(str(p) for p in paths)}" for name, paths in sorted(duplicates.items())]
+        raise SystemExit("The same archive appears more than once (mixed downloads or layouts?):\n"
+                         + "\n".join(lines))
+    return {name: paths[0] for name, paths in found.items()}
+
+
+def scene_of(member_path):
+    """'records/scene=<id>/...' -> '<id>'"""
+    return member_path.split("/")[1].removeprefix("scene=")
+
+
+def npz_members(tar_path, scenes=None):
+    """Yield (member_path, arrays) for NPZ members, optionally only for the given scenes."""
+    with tarfile.open(tar_path) as tar:
+        for member in tar:
+            if not (member.isfile() and member.name.endswith(".npz")):
+                continue
+            if scenes is not None and scene_of(member.name) not in scenes:
+                continue                      # skip without reading the member's bytes
+            with np.load(io.BytesIO(tar.extractfile(member).read())) as npz:
+                yield member.name, {k: npz[k] for k in npz.files if k != "__meta__"}
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("release_dir")
+    ap.add_argument("--band", default="3.5ghz", help="3.5ghz or 7ghz (default: 3.5ghz)")
+    ap.add_argument("--scenes", nargs="*", help="only these scene IDs (their archives must be downloaded)")
+    ap.add_argument("--limit", type=int, default=5,
+                    help="stop after printing this many records (default: 5; 0 reads every record)")
+    args = ap.parse_args()
+    scenes = set(args.scenes) if args.scenes else None
+
+    archives = find_archives(args.release_dir)
+    suffix = f"-{args.band}-core.tar"
+    core_archives = sorted(name for name in archives if name.endswith(suffix))
+    groups = [name.removesuffix(suffix) for name in core_archives]
+    missing = [f"{g}-positions.tar" for g in groups if f"{g}-positions.tar" not in archives]
+    if missing:
+        print(f"Skipping {len(missing)} group(s) whose positions archive is not downloaded:")
+        print("\n".join(f"  {name}" for name in missing))
+    if not core_archives:
+        raise SystemExit(f"No *{suffix} archives under {args.release_dir}/payload")
+
+    printed = seen = 0
+    for group in groups:
+        if f"{group}-positions.tar" in missing:
+            continue
+        if args.limit and printed >= args.limit:
+            break                                          # stop reading once enough is printed
+        positions = {scene_of(m): a for m, a in npz_members(archives[f"{group}-positions.tar"], scenes)}
+        records = npz_members(archives[f"{group}{suffix}"], scenes)
+        for member, core in records:
+            seen += 1
+            scene = scene_of(member)
+            bs_id = int(member.rsplit("/bs", 1)[1].removesuffix(".npz"))
+            pos = positions[scene]
+            ue_ids = core["link_ue_index"]                 # retained UE IDs (rows of ue_positions)
+            offsets = core["link_path_offsets"]            # link i owns paths offsets[i]:offsets[i+1]
+            if ue_ids.size == 0:
+                continue
+            i = 0                                          # first retained link
+            start, stop = offsets[i], offsets[i + 1]
+            gain = core["a_real"][start:stop] + 1j * core["a_imag"][start:stop]
+            distance = np.linalg.norm(pos["ue_positions"][ue_ids[i]] - pos["bs_positions"][bs_id])
+            print(f"{scene} BS {bs_id}: {ue_ids.size} links, {offsets[-1]} paths; "
+                  f"UE {ue_ids[i]} at {distance:.1f} m has {stop - start} paths, "
+                  f"first delay {core['tau'][start]:.3e} s, |gain| {abs(gain[0]):.3e}")
+            printed += 1
+            if args.limit and printed >= args.limit:
+                records.close()                            # closes the archive
+                break
+    note = f" (stopped at --limit {args.limit})" if args.limit and printed >= args.limit else ""
+    print(f"Read {seen} channel records{note}.")
+
+
+if __name__ == "__main__":
+    main()

docs/schema-reference.md

@@ -0,0 +1,226 @@
+# 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)

docs/tutorial-library.md

@@ -0,0 +1,213 @@
+# Read one scene with the channels4world library
+
+This tutorial follows one link of Channels4World from the catalog down to its paths:
+**BS 0 → UE 14 of `urban_scene_019234` at 3.5 GHz**, the link the project website shows.
+It downloads about 26 MB of one Tiny scene, walks the hierarchy, reads the geometry, the
+positions and the channel record, explains the stored arrays, and ends with the same link
+at 7 GHz. The [notebook version](notebooks/01-read-one-scene-library.ipynb) runs top to
+bottom; [the same tutorial without the library](tutorial-numpy.md) reads the same link with
+NumPy alone.
+
+Install the library with `pip install channels4world` (Python 3.11+), then
+`pip install huggingface_hub matplotlib`.
+
+```python
+from pathlib import Path
+import json
+
+import matplotlib.pyplot as plt
+import numpy as np
+from huggingface_hub import snapshot_download
+from matplotlib.collections import PolyCollection
+
+import channels4world as c4w
+```
+
+## 1. Choose the link
+
+Change these to read any other link. `GROUP` is the scene's `group` in the `tiny_scenes`
+catalog. BS IDs run from 0 to 31 and UE IDs from 0 to 16,383; both are rows
+of the scene's positions. Carriers are integers in Hz.
+
+```python
+REPO, REVISION = "Intelligence-Networking-Lab/Channels4World", "v1.0.0"
+SCENE_ID, GROUP = "urban_scene_019234", "test-urban-g00000"  # GROUP: from the tiny_scenes catalog
+CARRIER_HZ, BS_ID, UE_ID = 3_500_000_000, 0, 14
+OTHER_HZ = 7_000_000_000
+DATA = Path("c4w")
+```
+
+## 2. Download what this tutorial reads
+
+Tiny is published as loose files under `tiny/`. The library needs Tiny's catalog, the shared
+schemas and the scene's group metadata (about 11 MB); the records are the scene's positions
+and geometry and BS 0's core and detail at both carriers (about 15 MB).
+
+```python
+scene_dir = f"tiny/records/scene={SCENE_ID}"
+patterns = [
+    "tiny/c4w-root.json", "tiny/c4w-root/*", "tiny/schema/*",
+    f"tiny/groups/{GROUP}/catalog/members.parquet", f"tiny/groups/{GROUP}/snapshot.json",
+    f"{scene_dir}/positions.npz", f"{scene_dir}/geometry.zip",
+    f"{scene_dir}/band_hz=*/component=*/bs{BS_ID:05d}.npz",
+]
+snapshot_download(REPO, repo_type="dataset", revision=REVISION, local_dir=DATA, allow_patterns=patterns)
+```
+
+## 3. Walk the hierarchy
+
+The dataset is organized as **dataset → scene → carrier → base station → UE link → paths**.
+Opening reads only the small catalog; group metadata and records load when first needed.
+
+```python
+ds = c4w.open(DATA / "tiny")
+print(ds)
+scene = ds.scene(SCENE_ID)
+print(scene)                                        # split, profile and smallest tier
+print("carriers (Hz):", scene.frequencies.ids)
+print("base stations:", scene.frequencies[CARRIER_HZ].base_stations.ids)
+```
+
+`urban_scene_019234` is a **test** scene: every link and both carriers of a scene stay in
+one split, so a model trained on the training split has never seen this place.
+
+## 4. Geometry and positions
+
+Geometry, positions and interaction points share one frame: scene metres, z up. Positions
+hold all 32 BS and 16,384 UE coordinates of the scene; the geometry is a Mitsuba XML file
+with OBJ meshes in a ZIP.
+
+```python
+positions = scene.read_positions()
+bs_positions, ue_positions = positions.bs, positions.ue
+bs_xyz, ue_xyz = bs_positions[BS_ID], ue_positions[UE_ID]
+print(positions)
+print("BS", bs_xyz, "UE", ue_xyz, f"distance {np.linalg.norm(ue_xyz - bs_xyz):.1f} m")
+
+def top_view(read, names):
+    """Building triangles projected onto the ground (x, y), from OBJ meshes."""
+    triangles = []
+    for name in names:
+        verts, faces = [], []
+        for line in read(name).decode().splitlines():
+            if line.startswith("v "):
+                verts.append([float(v) for v in line.split()[1:4]])
+            elif line.startswith("f "):
+                idx = [int(t.split("/")[0]) for t in line.split()[1:]]
+                faces += [[idx[0], idx[k], idx[k + 1]] for k in range(1, len(idx) - 1)]
+        v = np.array(verts)
+        triangles += [v[[i - 1 for i in f], :2] for f in faces]   # OBJ indices start at 1
+    return triangles
+
+with scene.open_geometry() as geometry:
+    print("entry point:", json.loads(geometry.read("scene.json"))["entrypoint"])
+    meshes = [n for n in geometry.namelist() if n.endswith(".obj") and "ground" not in n]
+    triangles = top_view(geometry.read, meshes)
+print(len(meshes), "building meshes")
+```
+
+```python
+fig, ax = plt.subplots(figsize=(6, 6))
+ax.add_collection(PolyCollection(triangles, facecolor="#c3cbc2", edgecolor="none"))
+ax.scatter(ue_positions[:, 0], ue_positions[:, 1], s=0.2, color="#4d9688", label=f"{len(ue_positions):,} UEs")
+ax.scatter(bs_positions[:, 0], bs_positions[:, 1], marker="^", s=30, color="k", label=f"{len(bs_positions)} BSs")
+ax.plot(*zip(bs_xyz[:2], ue_xyz[:2]), color="#e2733d", lw=2, label=f"BS {BS_ID} → UE {UE_ID}")
+ax.set(xlim=(-250, 250), ylim=(-250, 250), aspect="equal", xlabel="x (m)", ylabel="y (m)", title=SCENE_ID)
+ax.legend(loc="upper right")
+plt.show()
+```
+
+## 5. One channel record
+
+A record holds every retained link from one BS at one carrier. `get_link(UE_ID)` returns
+that UE's link, or `None` when the UE has no retained link to this BS (which is not a
+zero-valued channel). A UE ID is a row of the positions; the link's row inside the record
+is a different index.
+
+```python
+record = scene.frequencies[CARRIER_HZ].base_stations[BS_ID].read(detail=True)
+print(record)
+link = record.get_link(UE_ID)
+print(link, f"- row {link.index} of the record's {record.n_links} links")
+```
+
+## 6. What each path stores
+
+For every retained path the core record stores the complex coefficient `a_real + 1j*a_imag`
+(passband, without the carrier-delay phase, antennas included), the delay `tau` in seconds,
+departure and arrival angles in radians, and its interaction count and type flags; the detail
+record adds each interaction's type and location in order. Paths are stored strongest first,
+and each link keeps at most its 16 strongest paths above −150 dB.
+
+```python
+NAMES = {1: "specular reflection", 2: "diffuse reflection", 4: "refraction", 8: "diffraction"}
+
+def describe(core, detail):
+    """One line per retained path, strongest first."""
+    re, im = core["a_real"].astype(np.float64), core["a_imag"].astype(np.float64)
+    power_db = 10 * np.log10(re**2 + im**2)
+    off = detail["path_interaction_offsets"]
+    for p in range(len(core["tau"])):
+        kinds = [NAMES.get(int(t), str(t)) for t in detail["interaction_type"][off[p]:off[p + 1]]]
+        print(f"rank {int(core['path_rank'][p]):2d}  {core['tau'][p] * 1e9:8.2f} ns  {power_db[p]:7.2f} dB  "
+              f"AoD az {np.degrees(core['phi_t'][p]):6.1f}°  AoA az {np.degrees(core['phi_r'][p]):6.1f}°  "
+              f"{' → '.join(kinds) or 'line of sight'}")
+
+describe(link.core, link.detail)
+```
+
+## 7. A power–delay profile
+
+Placing each path by delay and power gives the link's power–delay profile: a path-based view
+of the stored channel. It is not a sampled impulse response; for a channel at a given
+bandwidth, `channels4world.transforms` provides baseband coefficients and frequency
+responses.
+
+```python
+def stems(ax, tau, a_real, a_imag, label, marker, color):
+    power_db = 10 * np.log10(a_real.astype(np.float64)**2 + a_imag.astype(np.float64)**2)
+    ax.vlines(tau * 1e9, -150, power_db, color=color, lw=1.2)
+    ax.scatter(tau * 1e9, power_db, marker=marker, color=color, zorder=3, label=label)
+
+fig, ax = plt.subplots(figsize=(7, 3))
+stems(ax, link.core["tau"], link.core["a_real"], link.core["a_imag"], "3.5 GHz", "o", "#e2733d")
+ax.set(xlabel="delay (ns)", ylabel="path power (dB)", ylim=(-150, None),
+       title=f"{SCENE_ID} · BS {BS_ID} → UE {UE_ID}")
+ax.legend()
+plt.show()
+```
+
+## 8. The same link at 7 GHz
+
+Every scene is simulated at both carriers with the same BS and UE positions. Read the same
+BS and UE at 7 GHz and compare on shared axes:
+
+```python
+link7 = scene.frequencies[OTHER_HZ].base_stations[BS_ID].read(detail=True).get_link(UE_ID)
+fig, ax = plt.subplots(figsize=(7, 3))
+stems(ax, link.core["tau"], link.core["a_real"], link.core["a_imag"], "3.5 GHz", "o", "#e2733d")
+if link7 is None:
+    print("UE", UE_ID, "has no retained link at 7 GHz")
+else:
+    stems(ax, link7.core["tau"], link7.core["a_real"], link7.core["a_imag"], "7 GHz", "s", "#4d9688")
+    for l, label in ((link, "3.5 GHz"), (link7, "7 GHz")):
+        a = l.core["a_real"].astype(np.float64) + 1j * l.core["a_imag"].astype(np.float64)
+        print(f"{label}: {l.n_paths} paths, link power {10 * np.log10(np.sum(np.abs(a) ** 2)):.2f} dB")
+ax.set(xlabel="delay (ns)", ylabel="path power (dB)", ylim=(-150, None))
+ax.legend()
+plt.show()
+```
+
+Ranks order the paths within one record: rank 0 at 7 GHz need not be the route of rank 0
+at 3.5 GHz. To match routes across carriers, compare delays, interaction sequences or
+interaction points (`link7.detail`), not ranks.
+
+## Next
+
+- [From channel records to a DataLoader](ml-guide.md): link samples, splits, padding and batches.
+- [Library guide](library-guide.md): download plans for larger tiers, recipes, extraction and caches.
+- [Schema reference](schema-reference.md): every array and its meaning.
+
+*Notebook: [01-read-one-scene-library.ipynb](notebooks/01-read-one-scene-library.ipynb). The page and the notebook hold the same code.*
+
+[Return to card](../README.md)

docs/tutorial-numpy.md

@@ -0,0 +1,210 @@
+# Read one scene without the library
+
+The same link as the [library tutorial](tutorial-library.md), **BS 0 → UE 14 of
+`urban_scene_019234` at 3.5 GHz**, read with NumPy and the standard library from Tiny's loose
+files: about 15 MB. The [notebook version](notebooks/02-read-one-scene-numpy.ipynb) runs top
+to bottom. Archives from larger tiers hold the same files; see
+[without the library](without-library.md) for TAR access.
+
+Install with `pip install numpy huggingface_hub matplotlib`.
+
+```python
+from pathlib import Path
+import json
+import zipfile
+
+import matplotlib.pyplot as plt
+import numpy as np
+from huggingface_hub import snapshot_download
+from matplotlib.collections import PolyCollection
+```
+
+## 1. Choose the link
+
+The same identifiers as the library tutorial. A UE ID is a row of `ue_positions`, and the BS
+ID is both a row of `bs_positions` and the number in the record's file name.
+
+```python
+REPO, REVISION = "Intelligence-Networking-Lab/Channels4World", "v1.0.0"
+SCENE_ID, GROUP = "urban_scene_019234", "test-urban-g00000"  # GROUP: from the tiny_scenes catalog
+CARRIER_HZ, BS_ID, UE_ID = 3_500_000_000, 0, 14
+OTHER_HZ = 7_000_000_000
+DATA = Path("c4w")
+```
+
+## 2. Download the scene's files
+
+NumPy needs only the record files: positions, geometry, and BS 0's core and detail at both
+carriers.
+
+```python
+scene_dir = DATA / "tiny" / "records" / f"scene={SCENE_ID}"
+remote = f"tiny/records/scene={SCENE_ID}"
+snapshot_download(REPO, repo_type="dataset", revision=REVISION, local_dir=DATA, allow_patterns=[
+    f"{remote}/positions.npz", f"{remote}/geometry.zip", f"{remote}/band_hz=*/component=*/bs{BS_ID:05d}.npz"])
+
+def record_path(carrier_hz, component):
+    return scene_dir / f"band_hz={carrier_hz}" / f"component={component}" / f"bs{BS_ID:05d}.npz"
+
+print(sorted(p.relative_to(scene_dir).as_posix() for p in scene_dir.rglob("*") if p.is_file()))
+```
+
+## 3. The hierarchy on disk
+
+Each scene folder holds `positions.npz` and `geometry.zip`, shared by both carriers, and one
+file per carrier, component and BS: `band_hz=<Hz>/component=<core|detail>/bs<NNNNN>.npz`.
+Every NPZ carries its identity in a JSON `__meta__` entry:
+
+```python
+with np.load(record_path(CARRIER_HZ, "core"), allow_pickle=False) as npz:
+    meta = json.loads(npz["__meta__"].item())
+print(json.dumps(meta["identity"], indent=1))
+print(meta["dimensions"])                      # retained links and paths in this record
+```
+
+## 4. Geometry and positions
+
+Geometry, positions and interaction points share one frame: scene metres, z up.
+
+```python
+with np.load(scene_dir / "positions.npz", allow_pickle=False) as positions:
+    bs_positions, ue_positions = positions["bs_positions"], positions["ue_positions"]
+bs_xyz, ue_xyz = bs_positions[BS_ID], ue_positions[UE_ID]
+print(bs_positions.shape, ue_positions.shape)
+print("BS", bs_xyz, "UE", ue_xyz, f"distance {np.linalg.norm(ue_xyz - bs_xyz):.1f} m")
+
+def top_view(read, names):
+    """Building triangles projected onto the ground (x, y), from OBJ meshes."""
+    triangles = []
+    for name in names:
+        verts, faces = [], []
+        for line in read(name).decode().splitlines():
+            if line.startswith("v "):
+                verts.append([float(v) for v in line.split()[1:4]])
+            elif line.startswith("f "):
+                idx = [int(t.split("/")[0]) for t in line.split()[1:]]
+                faces += [[idx[0], idx[k], idx[k + 1]] for k in range(1, len(idx) - 1)]
+        v = np.array(verts)
+        triangles += [v[[i - 1 for i in f], :2] for f in faces]   # OBJ indices start at 1
+    return triangles
+
+with zipfile.ZipFile(scene_dir / "geometry.zip") as geometry:
+    print("entry point:", json.loads(geometry.read("scene.json"))["entrypoint"])
+    meshes = [n for n in geometry.namelist() if n.endswith(".obj") and "ground" not in n]
+    triangles = top_view(geometry.read, meshes)
+print(len(meshes), "building meshes")
+```
+
+```python
+fig, ax = plt.subplots(figsize=(6, 6))
+ax.add_collection(PolyCollection(triangles, facecolor="#c3cbc2", edgecolor="none"))
+ax.scatter(ue_positions[:, 0], ue_positions[:, 1], s=0.2, color="#4d9688", label=f"{len(ue_positions):,} UEs")
+ax.scatter(bs_positions[:, 0], bs_positions[:, 1], marker="^", s=30, color="k", label=f"{len(bs_positions)} BSs")
+ax.plot(*zip(bs_xyz[:2], ue_xyz[:2]), color="#e2733d", lw=2, label=f"BS {BS_ID} → UE {UE_ID}")
+ax.set(xlim=(-250, 250), ylim=(-250, 250), aspect="equal", xlabel="x (m)", ylabel="y (m)", title=SCENE_ID)
+ax.legend(loc="upper right")
+plt.show()
+```
+
+## 5. Find the link
+
+`link_ue_index` lists the UEs this BS reaches, in ascending order; the link's row is where
+`UE_ID` sits in that list. Link `row` owns paths `link_path_offsets[row]` to
+`link_path_offsets[row + 1]`. A UE that is not listed has no retained link to this BS (not a
+zero-valued channel).
+
+```python
+def load(carrier_hz, component):
+    with np.load(record_path(carrier_hz, component), allow_pickle=False) as npz:
+        return {name: npz[name] for name in npz.files if name != "__meta__"}
+
+def link_of(core, detail, ue_id):
+    ue_ids = core["link_ue_index"]
+    row = int(np.searchsorted(ue_ids, ue_id))
+    if row == ue_ids.size or ue_ids[row] != ue_id:
+        return None                                        # no retained link to this UE
+    p0, p1 = map(int, core["link_path_offsets"][row:row + 2])
+    link_core = {k: v[p0:p1] for k, v in core.items() if k not in ("link_ue_index", "link_path_offsets")}
+    i0, i1 = map(int, detail["path_interaction_offsets"][[p0, p1]])
+    link_detail = {k: detail[k][i0:i1] for k in ("interaction_rank", "interaction_type", "interaction_vertex")}
+    link_detail["path_interaction_offsets"] = detail["path_interaction_offsets"][p0:p1 + 1] - i0
+    return row, link_core, link_detail
+
+core, detail = load(CARRIER_HZ, "core"), load(CARRIER_HZ, "detail")
+row, link_core, link_detail = link_of(core, detail, UE_ID)
+print(f"UE {UE_ID}: link row {row} of {core['link_ue_index'].size}, {link_core['tau'].size} paths")
+```
+
+## 6. What each path stores
+
+The same arrays as in the library tutorial: the complex coefficient `a_real + 1j*a_imag`
+(passband, without the carrier-delay phase, antennas included), the delay `tau` in seconds,
+departure and arrival angles in radians and, in detail, each interaction's type and location
+in order. Paths are stored strongest first, at most 16 per link above −150 dB.
+
+```python
+NAMES = {1: "specular reflection", 2: "diffuse reflection", 4: "refraction", 8: "diffraction"}
+
+def describe(core, detail):
+    """One line per retained path, strongest first."""
+    re, im = core["a_real"].astype(np.float64), core["a_imag"].astype(np.float64)
+    power_db = 10 * np.log10(re**2 + im**2)
+    off = detail["path_interaction_offsets"]
+    for p in range(len(core["tau"])):
+        kinds = [NAMES.get(int(t), str(t)) for t in detail["interaction_type"][off[p]:off[p + 1]]]
+        print(f"rank {int(core['path_rank'][p]):2d}  {core['tau'][p] * 1e9:8.2f} ns  {power_db[p]:7.2f} dB  "
+              f"AoD az {np.degrees(core['phi_t'][p]):6.1f}°  AoA az {np.degrees(core['phi_r'][p]):6.1f}°  "
+              f"{' → '.join(kinds) or 'line of sight'}")
+
+describe(link_core, link_detail)
+```
+
+## 7. A power–delay profile
+
+Placing each path by delay and power gives the link's power–delay profile: a path-based view
+of the stored channel, not a sampled impulse response.
+
+```python
+def stems(ax, tau, a_real, a_imag, label, marker, color):
+    power_db = 10 * np.log10(a_real.astype(np.float64)**2 + a_imag.astype(np.float64)**2)
+    ax.vlines(tau * 1e9, -150, power_db, color=color, lw=1.2)
+    ax.scatter(tau * 1e9, power_db, marker=marker, color=color, zorder=3, label=label)
+
+fig, ax = plt.subplots(figsize=(7, 3))
+stems(ax, link_core["tau"], link_core["a_real"], link_core["a_imag"], "3.5 GHz", "o", "#e2733d")
+ax.set(xlabel="delay (ns)", ylabel="path power (dB)", ylim=(-150, None),
+       title=f"{SCENE_ID} · BS {BS_ID} → UE {UE_ID}")
+ax.legend()
+plt.show()
+```
+
+## 8. The same link at 7 GHz
+
+```python
+other = link_of(load(OTHER_HZ, "core"), load(OTHER_HZ, "detail"), UE_ID)
+fig, ax = plt.subplots(figsize=(7, 3))
+stems(ax, link_core["tau"], link_core["a_real"], link_core["a_imag"], "3.5 GHz", "o", "#e2733d")
+if other is None:
+    print("UE", UE_ID, "has no retained link at 7 GHz")
+else:
+    _, core7, _ = other
+    stems(ax, core7["tau"], core7["a_real"], core7["a_imag"], "7 GHz", "s", "#4d9688")
+    for c, label in ((link_core, "3.5 GHz"), (core7, "7 GHz")):
+        power = np.sum(c["a_real"].astype(np.float64) ** 2 + c["a_imag"].astype(np.float64) ** 2)
+        print(f"{label}: {c['tau'].size} paths, link power {10 * np.log10(power):.2f} dB")
+ax.set(xlabel="delay (ns)", ylabel="path power (dB)", ylim=(-150, None))
+ax.legend()
+plt.show()
+```
+
+Ranks order the paths within one record, so the same rank at 3.5 and 7 GHz need not be
+the same route. Compare delays, interaction sequences or interaction points instead.
+
+## Next
+
+- [Without the library](without-library.md): TAR archives, catalogs and byte-range reads.
+- [Schema reference](schema-reference.md): every array, its dtype and its meaning.
+
+*Notebook: [02-read-one-scene-numpy.ipynb](notebooks/02-read-one-scene-numpy.ipynb). The page and the notebook hold the same code.*
+
+[Return to card](../README.md)

docs/without-library.md

@@ -0,0 +1,291 @@
+# Using Channels4World without the library
+
+Channel arrays and positions are ordinary NPZ files (`numpy.load`); geometry is an
+ordinary ZIP (`zipfile.ZipFile`). Start with the one-scene Tiny download on the
+[card](../README.md); plain NumPy needs only its record files, the last three patterns. The
+extra Tiny root, schemas and group metadata are needed for channels4world library
+navigation and verification.
+
+Commands use the release tag `v1.0.0`. The examples use the same scene, carrier and BS as
+the card.
+
+## Archive conventions
+
+You can treat a download as a collection of archives; folder names are only needed for
+choosing what to download. Everything else is in two naming patterns:
+
+| Item | Pattern | Example |
+|---|---|---|
+| Group | `<split>-<profile code>-g<NNNNN>`, exactly 25 scenes of one split and profile | `test-urban-g00000` |
+| Channel archive | `<group>-<band>-<core\|detail>.tar` | `test-urban-g00000-3.5ghz-core.tar` |
+| Scene-asset archive | `<group>-<positions\|geometry>.tar` | `test-urban-g00000-positions.tar` |
+| File inside an archive | `records/scene=<id>/band_hz=<Hz>/component=<core\|detail>/bs<NNNNN>.npz` | `records/scene=urban_scene_019234/band_hz=3500000000/component=core/bs00000.npz` |
+| Scene asset inside an archive | `records/scene=<id>/positions.npz`, `records/scene=<id>/geometry.zip` | |
+
+The profile code is `urban`, `metro` or `suburban`; the catalogs spell `metro` as
+`metropolitan`. Archive file names are unique, so `{p.name: p for p in Path(release_dir).rglob("*.tar")}`
+finds everything regardless of folders. To use a channel record, open the **positions
+archive of the same group** (`<group>-positions.tar`) and take the same scene's
+`positions.npz`. Inside a record, `link_ue_index` holds UE IDs (rows of `ue_positions`),
+and link `i` owns paths `link_path_offsets[i]:link_path_offsets[i+1]`.
+
+## A standalone reader
+
+[`read_archives.py`](read_archives.py) (about 100 lines, NumPy only) does
+exactly this for one release folder:
+
+```bash
+python read_archives.py c4w --band 3.5ghz --limit 5
+python read_archives.py c4w --scenes urban_scene_019234      # filter records afterwards
+```
+
+It stops reading once it has printed `--limit` records (`--limit 0` reads every record).
+It searches only `c4w/payload/`, stops if the same archive file name appears twice (for
+example, two downloads mixed in one folder), and lists any group whose positions archive
+is missing instead of failing halfway through. Copy and adapt it freely.
+
+## Read one Tiny scene
+
+Use exactly the same `TINY_ROOT`, `SCENE_ID`, `CARRIER_HZ`, `BS_ID` and `UE_ID` as the
+card's NumPy example. Do not independently choose the first catalog row and the first
+lexically sorted directory: those orders can differ.
+
+```python
+from pathlib import Path
+import numpy as np
+
+TINY_ROOT = Path("c4w/tiny")
+SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14
+scene_dir = TINY_ROOT / "records" / f"scene={SCENE_ID}"
+core_path = (scene_dir / f"band_hz={CARRIER_HZ}" / "component=core"
+             / f"bs{BS_ID:05d}.npz")
+
+with np.load(core_path, allow_pickle=False) as core, np.load(
+    scene_dir / "positions.npz", allow_pickle=False
+) as positions:
+    ue_ids = core["link_ue_index"]
+    link_row = int(np.searchsorted(ue_ids, UE_ID))
+    assert link_row < ue_ids.size and ue_ids[link_row] == UE_ID, "No retained link to this UE."
+    start, stop = map(int, core["link_path_offsets"][link_row:link_row + 2])
+    gain = core["a_real"][start:stop] + 1j * core["a_imag"][start:stop]
+    print(core["tau"][start:stop], gain)
+    print(np.linalg.norm(
+        positions["ue_positions"][UE_ID] - positions["bs_positions"][BS_ID]
+    ))
+```
+
+`UE_ID` indexes a position row; `link_row` indexes the retained-link table. Preserve
+that association when filtering. An unlisted UE in this **loaded** record has no
+retained link to this BS. This says nothing about payloads not downloaded or
+components not published.
+
+For geometry, use ZIP tools, not NumPy:
+
+```python
+import json
+import zipfile
+
+with zipfile.ZipFile(scene_dir / "geometry.zip") as archive:
+    descriptor = json.loads(archive.read("scene.json"))
+    print(descriptor["entrypoint"], archive.namelist())
+```
+
+The entrypoint is a Mitsuba XML referencing OBJ meshes. Keep relative paths together
+if later extracting the geometry for a renderer. This example only inspects it.
+
+## Download a tier's archives
+
+Increment folders are numbered in tier order, so a tier is one pattern per component:
+Small is `inc1-*`, Medium `inc[1-2]-*`, Large `inc[1-3]-*`, Full `inc*`. A split or
+profile narrows it by file name. For example, Medium test-split core at 3.5 GHz with
+positions:
+
+```bash
+hf download Intelligence-Networking-Lab/Channels4World --repo-type dataset \
+  --revision v1.0.0 --local-dir c4w \
+  --include 'payload/3.5ghz/core/inc[1-2]-*/test-*' \
+  --include 'payload/scene/positions/inc[1-2]-*/test-*'
+```
+
+In these patterns `*` also matches `/`. Detail uses `payload/<3.5ghz|7ghz>/detail/...` and
+is hosted for Small and Medium only, so the Large and Full patterns return Medium's detail.
+Positions and geometry archives are carrier-independent. The release root sits at the top
+of the repository, so these paths are also the local paths under `c4w/`.
+
+## Select with 🤗 Datasets
+
+The catalogs load as ordinary tables, so standard tools can choose what to download:
+
+```python
+from datasets import load_dataset
+from huggingface_hub import snapshot_download
+
+REPO, REV = "Intelligence-Networking-Lab/Channels4World", "v1.0.0"
+scenes = load_dataset(REPO, "scenes", split="catalog", revision=REV)
+files = load_dataset(REPO, "files", split="catalog", revision=REV)
+groups = set(scenes.filter(lambda r: r["split"] == "test")["group"])
+paths = [r["path"] for r in files
+         if r["group"] in groups and r["kind"] == "payload" and r["component"] in ("positions", "core")
+         and r["frequency_hz"] in (None, 3_500_000_000)]
+assert paths, "No matching published payloads."
+snapshot_download(REPO, repo_type="dataset", revision=REV, local_dir="c4w", allow_patterns=paths)
+```
+
+Use the catalog's actual `profile` values if narrowing further. The archives themselves
+also load with `load_dataset("webdataset", ...)`; the [HF guide](hf-datasets.md) pairs
+remote and local inputs and explains their decoded representation.
+
+## Arbitrary scenes: download the containing archives, then filter
+
+Archives hold whole groups, so a list of scenes means two steps: download the archives
+that **contain** those scenes (from the catalogs), then **filter records** to those scenes
+when reading. The catalogs are two small Parquet files at the release root:
+
+```python
+import pyarrow.parquet as pq
+from huggingface_hub import hf_hub_download, snapshot_download
+
+REPO, REV = "Intelligence-Networking-Lab/Channels4World", "v1.0.0"
+for table in ("c4w-root/scenes.parquet", "c4w-root/files.parquet"):
+    hf_hub_download(REPO, table, repo_type="dataset", revision=REV, local_dir="c4w")
+
+wanted_scenes = {"urban_scene_019234"}                     # your scene list
+scenes = pq.read_table("c4w/c4w-root/scenes.parquet").to_pylist()
+files = pq.read_table("c4w/c4w-root/files.parquet").to_pylist()
+groups = {s["group"] for s in scenes if s["scene_id"] in wanted_scenes}
+archives = [f["path"] for f in files
+            if f["kind"] == "payload" and f["group"] in groups
+            and (f["component"], f["frequency_hz"]) in {("core", 3_500_000_000), ("positions", None)}]
+snapshot_download(REPO, repo_type="dataset", revision=REV, local_dir="c4w", allow_patterns=archives)
+```
+
+Then read only those scenes: `python read_archives.py c4w --scenes urban_scene_019234`.
+The download includes the other scenes of the same groups; filtering skips them without
+reading their bytes. This works for any folder layout, because the catalog lists each
+archive's actual path.
+
+## Find the byte location of one record
+
+With PyArrow available, the scene table identifies the group for an explicit scene;
+the members table maps a member path to its archive and byte location:
+
+```python
+from pathlib import Path
+import pyarrow.parquet as pq
+
+RELEASE_ROOT = Path("c4w")             # the release root is the repository top level
+scenes = pq.read_table(RELEASE_ROOT / "c4w-root/scenes.parquet").to_pylist()
+scene_row = next(row for row in scenes if row["scene_id"] == SCENE_ID)
+GROUP_ID = scene_row["group"]
+# Download this group's members.parquet (and other needed metadata) first.
+members = pq.read_table(
+    RELEASE_ROOT / "groups" / GROUP_ID / "catalog/members.parquet"
+).to_pylist()
+core_member = (f"records/scene={SCENE_ID}/band_hz={CARRIER_HZ}/component=core/"
+               f"bs{BS_ID:05d}.npz")
+positions_member = f"records/scene={SCENE_ID}/positions.npz"
+core_row = next(row for row in members if row["member_path"] == core_member)
+pos_row = next(row for row in members if row["member_path"] == positions_member)
+print(core_row["object_path"], pos_row["object_path"])
+```
+
+Retrieve the group metadata, schemas and archives at the same revision as the catalogs
+(tag `v1.0.0`). A TAR is the transfer unit and can contain many scenes, so one chosen
+record can require more bytes than that record's own payload size. Root
+`files.parquet` lists archive byte counts/hashes; `members.parquet` lists member
+byte counts/hashes. Scene-only payload size excludes root/schema/group metadata.
+`data_offset` and `member_bytes` locate the member's bytes inside the uncompressed TAR,
+so a byte-range read can fetch one record without the rest of the archive.
+
+The published `files.parquet` is the authority for paths, sizes and hashes; reuse it for
+generated commands and size displays rather than keeping a second hand-written list.
+
+## Read one TAR member directly
+
+After downloading the archives identified above, ordinary Python can read a single
+NPZ member without extracting the whole TAR:
+
+```python
+import hashlib
+import io
+import tarfile
+import numpy as np
+
+def read_npz_member(archive_path, row):
+    with tarfile.open(archive_path, "r:") as archive:
+        member = archive.getmember(row["member_path"])
+        if not member.isfile():
+            raise ValueError("Expected a regular NPZ member.")
+        with archive.extractfile(member) as stream:
+            body = stream.read()
+    if len(body) != row["member_bytes"]:
+        raise ValueError("Member byte count mismatch.")
+    if hashlib.sha256(body).hexdigest() != row["member_sha256"]:
+        raise ValueError("Member hash mismatch.")
+    with np.load(io.BytesIO(body), allow_pickle=False) as npz:
+        return {name: npz[name] for name in npz.files if name != "__meta__"}
+
+core = read_npz_member(RELEASE_ROOT / core_row["object_path"], core_row)
+positions = read_npz_member(RELEASE_ROOT / pos_row["object_path"], pos_row)
+i = int(np.searchsorted(core["link_ue_index"], UE_ID))
+assert i < core["link_ue_index"].size and core["link_ue_index"][i] == UE_ID
+lo, hi = map(int, core["link_path_offsets"][i:i + 2])
+print(core["tau"][lo:hi], core["a_real"][lo:hi] + 1j * core["a_imag"][lo:hi])
+print(np.linalg.norm(positions["ue_positions"][UE_ID] - positions["bs_positions"][BS_ID]))
+```
+
+The shared scene/carrier/BS/UE constants and UE-position join match the card. Check the
+NPZ `__meta__` identity and dependencies when assembling data yourself; matching
+array lengths alone do not establish a core/detail association. The [schema](schema-reference.md)
+explains identities, hashes and path-axis alignment.
+
+## Or extract TARs to Tiny-like loose payloads
+
+**Prerequisite for this extraction example:** Python with `tarfile.data_filter`,
+provided in **3.11.4+**, including **3.12+**. This does not raise the library's
+Python ≥3.11 requirement. It applies only to this standard-library extraction code.
+
+```python
+from pathlib import Path
+import tarfile
+
+if not hasattr(tarfile, "data_filter"):
+    raise RuntimeError("Use Python 3.11.4+ with tarfile.data_filter (including 3.12+).")
+out = Path("unpacked")
+out.mkdir(exist_ok=False)  # use a new destination
+archives = {core_row["object_path"], pos_row["object_path"]}
+for object_path in sorted(archives):
+    with tarfile.open(RELEASE_ROOT / object_path, "r:") as archive:
+        archive.extractall(out, filter="data")
+```
+
+A member `records/scene=S/.../bs00000.npz` becomes
+`unpacked/records/scene=S/.../bs00000.npz`: the archive's own folders are not part of the
+member name. The extracted folder has Tiny's layout, so the same inspection works on it:
+
+```python
+import numpy as np
+
+scene_dir = out / "records" / f"scene={SCENE_ID}"
+core = np.load(scene_dir / f"band_hz={CARRIER_HZ}" / "component=core" / f"bs{BS_ID:05d}.npz")
+positions = np.load(scene_dir / "positions.npz")
+ue_ids = core["link_ue_index"]                    # retained UE IDs
+row = int(np.searchsorted(ue_ids, UE_ID))         # this UE's link row
+start, stop = core["link_path_offsets"][row:row + 2]
+print(core["tau"][start:stop])
+print(np.linalg.norm(positions["ue_positions"][UE_ID] - positions["bs_positions"][BS_ID]))
+```
+
+An archive holds a whole group of scenes, so extraction writes more scenes than the one
+you inspect.
+
+![Archive location, internal member path and extraction destinations](layout.svg)
+
+Ordinary TAR extraction writes payloads only. The library's
+`c4w.extract(selection, dest)` writes those selected member paths and unchanged
+payload bytes, preserves original group metadata/schemas, and creates a subset root
+and scene/file/record tables. Tiny uses that same loose subset representation.
+Simply copying a larger release manifest beside an extracted subset does not build
+a valid subset root.
+
+[Return to card](../README.md) · [Schema](schema-reference.md) · [Library guide](library-guide.md)

groups/test-metro-g00000/catalog/geometry.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e6f71ccbd1f1fe3ee90fd63d3265fdb2eab3f24e004f26182c2d6a22b8cc81e
+size 6172

groups/test-metro-g00000/catalog/members.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:520dfa2e3efc7592a7ff41866f6c9220c0bc3d9b963bcfac04426e9452cdcb40
+size 271472

groups/test-metro-g00000/catalog/objects.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd8bd7e8b50882cf8b539ec22e3f2e2ecae90ff7757cf2cb9f30c7e48280110d
+size 1944

groups/test-metro-g00000/catalog/records.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40d182fc0def92170790102c75e7a1b115ad7956a7ad80d104939dbbbfdf0355
+size 1539612

groups/test-metro-g00000/catalog/scenes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4176d808462f5a34fed019827323ac345b4054ff845af628525181910d1f2d99
+size 1594

groups/test-metro-g00001/catalog/geometry.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27cfba3d5537dcbd7f92686c5e6e76f09b7401b93f6074c01ab487f405b53553
+size 6175

groups/test-metro-g00001/catalog/members.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f48658527a1cadcbaaa78bf456567d7950038e3d985cc3810d3c204e2482118
+size 271392

groups/test-metro-g00001/catalog/objects.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17c8c1ce5b3a40eae69e6e38c5cfc11a3f0d764215383490ad598a429c846407
+size 1948

groups/test-metro-g00001/catalog/records.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d71d05adf1d19352e33c9ef8259764ffcc16df67d5f2ae286d67fc872651a200
+size 1540387

groups/test-metro-g00001/catalog/scenes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb3d93245ba246eb0ddc2e09bf18c8cc57407e52a746ae6f4d01c8c10e0904ca
+size 1592

groups/test-metro-g00002/catalog/geometry.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78a1a7eae1df0a949e9b6dc67cb0264dccb2b1aecc013466e72c77b1f361a69f
+size 6186

groups/test-metro-g00002/catalog/members.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d14363e0dcb247d58e4fb963673d1359013081a27596fb800a2136522e97bcf
+size 270934

groups/test-metro-g00002/catalog/objects.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1eb7041680a13164e48faa85df08fdf7c0a7793a22351b7d05baf1500c8bbe7
+size 1950

groups/test-metro-g00002/catalog/records.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c2db60564945700bb374dbcf4f884c51810903a1c1290638d5caa9e193b8dd8
+size 1536566

groups/test-metro-g00002/catalog/scenes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed4fca6d32aa5aeffd05e291da76a1b4f39fc2bfa50ff73f2e84b7fe52fe5c17
+size 1596

groups/test-metro-g00003/catalog/geometry.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72b7a39ace13b4c57ff3117c26bf3e776a7d864c0edaace51bfc06d4244f2e83
+size 6166

groups/test-metro-g00003/catalog/members.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35a38f8c681085daec0f49a57e412c480e92e7a9a644e4c93782a71ab8553954
+size 272499

groups/test-metro-g00003/catalog/objects.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51958ae62a10496477531a6f643483ee03278fb8b12ecb37f1a747e554643339
+size 1951

groups/test-metro-g00003/catalog/records.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99f3a816231ce589784a5cb302964a8421840acfa87931230a3dcb8716a088e5
+size 1534865

groups/test-metro-g00003/catalog/scenes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b1f565ce0123b55c306381dc6141dba4bebe08acc0cb0d00b9190b256da8747
+size 1592

groups/test-metro-g00004/catalog/geometry.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd85b2dbfabf2f9880e9bff08b09454d7830732d6cf5ef6efba8f9e21f998922
+size 6173

groups/test-metro-g00004/catalog/members.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51c8114412c762f121ebd65e1ebb47ff60b50e26aca32f294354c4d6fc44f72e
+size 273518

groups/test-metro-g00004/catalog/objects.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11c7689039a7785bb76bec06bbb25c1c9ffcb1dd93ab2434daa88fa946dbd4c7
+size 1950

groups/test-metro-g00004/catalog/records.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b04f0d80d7be2151e831625fb0eecaef5bb386770a8dfa63becc2c093cbb6869
+size 1536373

groups/test-metro-g00004/catalog/scenes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e731868325532e999a6124809f5446e77460978c5b4c935f6bb99fe8f2dbcb51
+size 1591