| """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 |
| 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 |
| 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"] |
| offsets = core["link_path_offsets"] |
| if ue_ids.size == 0: |
| continue |
| i = 0 |
| 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() |
| 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() |
|
|
