| # 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. |
|
|
|  |
|
|
| 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) |
|
|
