| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
|
|
| HC_EV_NM = 1239.841984 |
| METERS_PER_NM = 1e-9 |
|
|
|
|
| def wavelength_nm_from_energy_ev(energy_ev: float) -> float: |
| """ |
| Convert photon energy to wavelength in nanometers. |
| |
| Parameters |
| ---------- |
| energy_ev : float |
| Photon energy in eV. |
| |
| Returns |
| ------- |
| float |
| Wavelength in nm. |
| """ |
| return HC_EV_NM / float(energy_ev) |
|
|
|
|
| def lambda_to_nm( |
| coord_lambda: float | np.ndarray, |
| energy_ev: float, |
| ) -> float | np.ndarray: |
| """ |
| Convert lambda-normalized coordinates to nanometers. |
| |
| Parameters |
| ---------- |
| coord_lambda : float or numpy.ndarray |
| Coordinate value(s) in units of wavelength. |
| energy_ev : float |
| Photon energy in eV. |
| |
| Returns |
| ------- |
| float or numpy.ndarray |
| Coordinate value(s) in nanometers. |
| """ |
| return np.asarray(coord_lambda, dtype=float) * wavelength_nm_from_energy_ev(energy_ev) |
|
|
|
|
| def geometry_at_energy(path: str | Path, energy_ev: float) -> dict[str, Any]: |
| """ |
| Load geometry JSON and scale shape points to nanometers. |
| |
| Parameters |
| ---------- |
| path : str or Path |
| Path to ``geometry.json``. |
| energy_ev : float |
| Photon energy in eV. |
| |
| Returns |
| ------- |
| dict |
| Geometry manifest with points in nanometers. |
| """ |
| geometry = json.loads(Path(path).read_text(encoding="utf-8")) |
| units = geometry.get("units", "lambda") |
| if units == "nm": |
| return geometry |
| if units != "lambda": |
| raise ValueError(f"Unsupported geometry units: {units!r}") |
| wavelength_nm = wavelength_nm_from_energy_ev(energy_ev) |
| for shape in geometry.get("shapes", []): |
| points = np.asarray(shape["points"], dtype=float) |
| shape["points"] = (points * wavelength_nm).tolist() |
| geometry["units"] = "nm" |
| geometry["energy_ev"] = energy_ev |
| geometry["wavelength_nm"] = wavelength_nm |
| return geometry |
|
|
|
|
| def _grid_units_from_npz(data: np.lib.npyio.NpzFile) -> str: |
| if "units" in data: |
| return str(np.asarray(data["units"]).item()) |
| return "m" |
|
|
|
|
| def _coords_in_nm( |
| *, |
| x_grid: np.ndarray, |
| y_grid: np.ndarray, |
| units: str, |
| energy_ev: float, |
| ) -> tuple[np.ndarray, np.ndarray]: |
| if units == "m": |
| return x_grid / METERS_PER_NM, y_grid / METERS_PER_NM |
| if units == "lambda": |
| return lambda_to_nm(x_grid, energy_ev), lambda_to_nm(y_grid, energy_ev) |
| if units == "nm": |
| return x_grid, y_grid |
| raise ValueError(f"Unsupported grid units: {units!r}") |
|
|
|
|
| def load_json_artifact(path: str | Path) -> dict[str, Any]: |
| """ |
| Load a JSON artifact shipped with the exported dataset. |
| |
| Parameters |
| ---------- |
| path : str or Path |
| Path to a JSON file such as ``geometry.json`` or a manifest. |
| |
| Returns |
| ------- |
| dict |
| Parsed JSON payload. |
| """ |
| return json.loads(Path(path).read_text(encoding="utf-8")) |
|
|
|
|
| def load_domain_ids(path: str | Path, energy_ev: float) -> dict[str, np.ndarray | float | str]: |
| """ |
| Load domain-id raster data with grid coordinates in nanometers. |
| |
| Parameters |
| ---------- |
| path : str or Path |
| Path to ``domain_ids.npz``. |
| energy_ev : float |
| Photon energy in eV for lambda-unit grids. |
| |
| Returns |
| ------- |
| dict |
| ``domain_ids``, ``X_nm``, ``Y_nm``, and metadata keys. |
| """ |
| with np.load(Path(path)) as data: |
| units = _grid_units_from_npz(data) |
| domain_ids = np.asarray(data["domain_ids"]) |
| x_grid = np.asarray(data["X"], dtype=float) |
| y_grid = np.asarray(data["Y"], dtype=float) |
| x_nm, y_nm = _coords_in_nm(x_grid=x_grid, y_grid=y_grid, units=units, energy_ev=energy_ev) |
| return { |
| "domain_ids": domain_ids, |
| "X": x_grid, |
| "Y": y_grid, |
| "X_nm": x_nm, |
| "Y_nm": y_nm, |
| "grid_units": units, |
| "energy_ev": energy_ev, |
| } |
|
|
|
|
| def load_nk_tensor(path: str | Path, energy_ev: float) -> dict[str, np.ndarray | float | str]: |
| """ |
| Load nk tensor raster data with grid coordinates in nanometers. |
| |
| Parameters |
| ---------- |
| path : str or Path |
| Path to ``nk_tensor.npz``. |
| energy_ev : float |
| Photon energy in eV for lambda-unit grids. |
| |
| Returns |
| ------- |
| dict |
| ``nk_tensor``, ``domain_ids``, ``X_nm``, ``Y_nm``, and metadata keys. |
| """ |
| with np.load(Path(path)) as data: |
| units = _grid_units_from_npz(data) |
| nk_tensor = np.asarray(data["nk_tensor"]) |
| domain_ids = np.asarray(data["domain_ids"]) |
| x_grid = np.asarray(data["X"], dtype=float) |
| y_grid = np.asarray(data["Y"], dtype=float) |
| payload = {key: np.asarray(data[key]) for key in data.files} |
| x_nm, y_nm = _coords_in_nm(x_grid=x_grid, y_grid=y_grid, units=units, energy_ev=energy_ev) |
| payload["X_nm"] = x_nm |
| payload["Y_nm"] = y_nm |
| payload["grid_units"] = units |
| payload["energy_ev"] = energy_ev |
| return payload |
|
|
|
|
| def load_electric_field(path: str | Path, energy_ev: float) -> dict[str, np.ndarray | float | str]: |
| """ |
| Load an electric-field raster with coordinates in nanometers. |
| |
| Parameters |
| ---------- |
| path : str or Path |
| Path to ``electric_field.npz``. |
| energy_ev : float |
| Photon energy in eV for lambda-unit grids. |
| |
| Returns |
| ------- |
| dict |
| ``electric_field``, coordinate grids, and stored metadata keys. |
| """ |
| with np.load(Path(path)) as data: |
| units = _grid_units_from_npz(data) |
| x_grid = np.asarray(data["X"], dtype=float) |
| y_grid = np.asarray(data["Y"], dtype=float) |
| payload = {key: np.asarray(data[key]) for key in data.files} |
| x_nm, y_nm = _coords_in_nm(x_grid=x_grid, y_grid=y_grid, units=units, energy_ev=energy_ev) |
| payload["X_nm"] = x_nm |
| payload["Y_nm"] = y_nm |
| payload["grid_units"] = units |
| payload["energy_ev"] = energy_ev |
| return payload |
|
|
|
|
| def load_sample(sample_dir: str | Path, energy_ev: float) -> dict[str, Any]: |
| """ |
| Load core assets for one squiggles sample at a chosen energy scale. |
| |
| Parameters |
| ---------- |
| sample_dir : str or Path |
| Path to ``sample_XXXX`` directory. |
| energy_ev : float |
| Photon energy in eV. |
| |
| Returns |
| ------- |
| dict |
| Geometry, domain map, and available labeled-region tensors. |
| """ |
| root = Path(sample_dir) |
| result: dict[str, Any] = { |
| "sample_id": root.name, |
| "energy_ev": energy_ev, |
| "wavelength_nm": wavelength_nm_from_energy_ev(energy_ev), |
| } |
| geometry_path = root / "geometry.json" |
| if geometry_path.is_file(): |
| result["geometry"] = geometry_at_energy(geometry_path, energy_ev) |
| result["geometry_manifest"] = load_json_artifact(geometry_path) |
| domain_path = root / "domain_ids.npz" |
| if domain_path.is_file(): |
| result["domain_ids"] = load_domain_ids(domain_path, energy_ev) |
| ooc_root = root / "ooc" |
| if ooc_root.is_dir(): |
| ooc: dict[str, dict[str, Any]] = {} |
| sweep_manifest_path = ooc_root / "oc_sweep_manifest.json" |
| if sweep_manifest_path.is_file(): |
| result["ooc_sweep_manifest"] = load_json_artifact(sweep_manifest_path) |
| for case_dir in sorted(path for path in ooc_root.iterdir() if path.is_dir()): |
| case_payload: dict[str, Any] = {} |
| manifest_path = case_dir / "oc_manifest.json" |
| if manifest_path.is_file(): |
| case_payload["manifest"] = load_json_artifact(manifest_path) |
| nk_path = case_dir / "nk_tensor.npz" |
| if nk_path.is_file(): |
| case_payload["nk_tensor"] = load_nk_tensor(nk_path, energy_ev) |
| if case_payload: |
| ooc[case_dir.name] = case_payload |
| if ooc: |
| result["ooc"] = ooc |
| fields_root = root / "fields" |
| if fields_root.is_dir(): |
| fields: dict[str, dict[str, Any]] = {} |
| for run_dir in sorted(path for path in fields_root.iterdir() if path.is_dir()): |
| run_payload: dict[str, Any] = {} |
| manifest_path = run_dir / "field_manifest.json" |
| if manifest_path.is_file(): |
| run_payload["manifest"] = load_json_artifact(manifest_path) |
| electric_field_path = run_dir / "electric_field.npz" |
| if electric_field_path.is_file(): |
| run_payload["electric_field"] = load_electric_field(electric_field_path, energy_ev) |
| nk_path = run_dir / "nk_tensor.npz" |
| if nk_path.is_file(): |
| run_payload["nk_tensor"] = load_nk_tensor(nk_path, energy_ev) |
| if run_payload: |
| fields[run_dir.name] = run_payload |
| if fields: |
| result["fields"] = fields |
| return result |
|
|
