Datasets:

Intelligence-Networking-Lab
/

Channels4World

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