docs(README): one-click Colab link, EMD-confirmed optics, sampling caveat

README.md

@@ -10,54 +10,54 @@ pretty_name: quantem-data
 
 # quantem-data
 
-Reference electron-microscopy datasets for browsing and learning. Open them in your browser via [quantem.widget](https://github.com/bobleesj/quantem.widget) — **no quantem.live install needed**.
+Reference electron-microscopy datasets for browsing and learning. Open in your browser via [quantem.widget](https://github.com/bobleesj/quantem.widget) — **no quantem.live install needed**.
 
-Two buckets, that's it:
+Two buckets:
 
 - **`4dstem/`** — 4D-STEM acquisitions. `_npy_bin*` variants are pre-binned NumPy files for fast workshop / Colab demos; the originals are full Arina h5 bundles.
 - **`haadf/`** — HAADF survey images. `_npy` variants are pre-cooked NumPy + a `meta.json` sidecar carrying sampling + optics; the originals are full Velox EMD files.
 
-## Workshop quick start — Show4DSTEM (Google Colab or any Jupyter)
+A ready-to-run notebook sits at `notebooks/show4dstem_colab.ipynb` in this repo.
 
-Just `quantem.widget` from TestPyPI + `huggingface_hub`. No CUDA, no h5, no quantem.live.
+## One-click workshop notebook (Google Colab)
+
+[**▶ Open `show4dstem_colab.ipynb` in Colab**](https://colab.research.google.com/?url=https%3A%2F%2Fhuggingface.co%2Fdatasets%2Fbobleesj%2Fquantem-data%2Fresolve%2Fmain%2Fnotebooks%2Fshow4dstem_colab.ipynb)
+
+It does the full pipeline in 7 cells: install `quantem.widget` (TestPyPI rc) + `quantem` (dev fork branch), download the pre-binned NumPy bundle from this dataset, wrap it as `Dataset4dstem.from_tensor`, render with `Show4DSTEM` in your browser via WebGPU. No CUDA on Colab. No quantem.live.
+
+## Workshop quick start — Show4DSTEM (any Jupyter)
 
 ```python
 !pip install -q --pre --extra-index-url https://test.pypi.org/simple/ quantem.widget huggingface_hub
+!pip install -q git+https://github.com/bobleesj/quantem.git@dataset-support-torch
 
 import os, json, numpy as np, torch
 from huggingface_hub import snapshot_download
+from quantem.core.datastructures import Dataset4dstem
 from quantem.widget import Show4DSTEM
 
-folder = snapshot_download(
-    "bobleesj/quantem-data",
-    repo_type="dataset",
-    allow_patterns=["4dstem/gold_512_npy_bin8/*"],
-)
+folder = snapshot_download("bobleesj/quantem-data", repo_type="dataset",
+                          allow_patterns=["4dstem/gold_512_npy_bin8/*"])
 asset = os.path.join(folder, "4dstem", "gold_512_npy_bin8")
-data = np.load(os.path.join(asset, "data.npy"))            # (512, 512, 24, 24) uint16, ~300 MB
+data = np.load(os.path.join(asset, "data.npy"))
 meta = json.load(open(os.path.join(asset, "meta.json")))
 
-Show4DSTEM(torch.from_numpy(data), sampling=meta["sampling"], units=meta["units"])
+dset = Dataset4dstem.from_tensor(torch.from_numpy(data),
+                                 sampling=meta["sampling"], units=meta["units"])
+Show4DSTEM(dset)
 ```
 
-Drag the scan cursor in the real-space image; the CBED updates in real time. Chrome works best (WebGPU).
-
 ## Workshop quick start — Show2D for HAADF
 
-Same pattern; no Velox parser needed (the EMD has been pre-decoded to NumPy + a sampling sidecar).
-
 ```python
 import os, json, numpy as np, torch
 from huggingface_hub import snapshot_download
 from quantem.widget import Show2D
 
-folder = snapshot_download(
-    "bobleesj/quantem-data",
-    repo_type="dataset",
-    allow_patterns=["haadf/gold_haadf_npy/*"],
-)
+folder = snapshot_download("bobleesj/quantem-data", repo_type="dataset",
+                          allow_patterns=["haadf/gold_haadf_npy/*"])
 asset = os.path.join(folder, "haadf", "gold_haadf_npy")
-img  = np.load(os.path.join(asset, "data.npy"))            # (4096, 4096) uint16
+img  = np.load(os.path.join(asset, "data.npy"))
 meta = json.load(open(os.path.join(asset, "meta.json")))
 
 Show2D(torch.from_numpy(img), sampling=meta["sampling"], units=meta["units"])
@@ -65,16 +65,18 @@ Show2D(torch.from_numpy(img), sampling=meta["sampling"], units=meta["units"])
 
 ## Acquisition parameters
 
-| dataset | voltage | probe | scan | scan sampling | det pitch | mag | format |
+The 20260423 drift session's optics are **confirmed via the session's own HAADF EMD** (`AccelerationVoltage`, `BeamConvergence`, `CameraLength`). 4D-STEM `scan_sampling` is an **operator pattern from a sibling SSB session** — the drift acquisition itself was never per-file calibrated.
+
+| dataset | voltage | probe | CL | scan | scan sampling | det pitch | mag |
 |---|---|---|---|---|---|---|---|
-| `haadf/gold_haadf_npy` | 300 kV | 30 mrad | 4096² image | 0.0186 nm/px | n/a | FOV 76.2 nm | Velox EMD → NumPy |
-| `4dstem/gold_512_npy_bin8` | 200 kV | 30 mrad (op) | 512² | 0.5 Å (op) | 3.68 mrad/px | (unknown) | NumPy bundle |
-| `4dstem/gold_512_npy_bin4` | 200 kV | 30 mrad (op) | 512² | 0.5 Å (op) | 1.84 mrad/px | (unknown) | NumPy bundle |
-| `4dstem/gold_512` | 200 kV | 30 mrad (op) | 512² | 0.5 Å (op) | 0.46 mrad/px | (unknown) | Arina h5 |
-| `4dstem/gold_30mrad1.3mx04` … `09` | 200 kV | 30 mrad | smaller | (session yaml) | 0.46 mrad/px | 1.3 Mx | Arina h5 |
-| `haadf/gold_haadf.emd` | 300 kV | 30 mrad | 4096² image | 0.0186 nm/px | n/a | FOV 76.2 nm | Velox EMD |
+| `haadf/gold_haadf_npy` | 300 kV ✓ | 30 mrad ✓ | 91 mm ✓ | 4096² image | 0.0186 nm/px | n/a | FOV 76.2 nm |
+| `4dstem/gold_512_npy_bin8` | 300 kV ✓ | 30 mrad ✓ | 91 mm ✓ | 512² | 0.5 Å (op) | 3.68 mrad/px | unknown |
+| `4dstem/gold_512_npy_bin4` | 300 kV ✓ | 30 mrad ✓ | 91 mm ✓ | 512² | 0.5 Å (op) | 1.84 mrad/px | unknown |
+| `4dstem/gold_512` | 300 kV ✓ | 30 mrad ✓ | 91 mm ✓ | 512² | 0.5 Å (op) | 0.46 mrad/px | unknown |
+| `4dstem/gold_30mrad1.3mx04`…`09` | 300 kV | 30 mrad | 91 mm | smaller | (session yaml) | 0.46 mrad/px | 1.3 Mx |
+| `haadf/gold_haadf.emd` | 300 kV ✓ | 30 mrad ✓ | 91 mm ✓ | 4096² image | 0.0186 nm/px | n/a | FOV 76.2 nm |
 
-`(op)` = operator-supplied, not stored in the file. Arina h5 records detector + scan count but no optics; the optics live in the operator's session yaml. EMD carries full optics (BeamConvergence, CameraLength, AccelerationVoltage, pixel sizes).
+✓ = confirmed via EMD/yaml. `(op)` = operator pattern, not file-certified.
 
 ## Datasets at a glance
 
@@ -82,44 +84,38 @@ Show2D(torch.from_numpy(img), sampling=meta["sampling"], units=meta["units"])
 |---|---|---|---|---|---|
 | `4dstem/gold_512_npy_bin8/` | NumPy bundle | (512, 512, 24, 24) | uint16 | ~302 MB | workshop / Colab demo |
 | `4dstem/gold_512_npy_bin4/` | NumPy bundle | (512, 512, 48, 48) | uint16 | ~1.2 GB | sharper workshop version |
-| `4dstem/gold_512/` | Arina h5 (full) | (512, 512, 192, 192) | uint16 | ~5 GB | power user |
-| `4dstem/gold_30mrad1.3mx04` … `09` | Arina h5 (full) | varies | uint16 | ~5 GB each | series demo |
+| `4dstem/gold_512/` | Arina h5 | (512, 512, 192, 192) | uint16 | ~5 GB | power user |
+| `4dstem/gold_30mrad1.3mx04` … `09` | Arina h5 | varies | uint16 | ~5 GB each | series demo |
 | `haadf/gold_haadf_npy/` | NumPy bundle | (4096, 4096) | uint16 | ~34 MB | workshop / Colab Show2D |
 | `haadf/gold_haadf.emd` | Velox EMD | (4096, 4096) | uint16 | a few MB | full optics carrier |
 
-Each `_npy*` bundle ships a `meta.json` next to `data.npy`: shape, dtype, sampling, units, plus voltage / probe / camera length / FOV when known.
+Each `_npy*` bundle ships a `meta.json` next to `data.npy`: shape, dtype, sampling, units, voltage / probe / CL (with provenance flags) when known.
 
 ## Power-user path (full data, GPU decompression)
 
-Have an NVIDIA GPU and want the full uncooked h5 / EMD? Install [`quantem.live`](https://github.com/bobleesj/quantem.live) — it carries a sampling-aware loader (`io.read_image` → `Dataset2d` → `Show2D` for HAADF; `io.load` for 4D-STEM):
+Got an NVIDIA GPU and want the full Arina h5 / Velox EMD path? Install [`quantem.live`](https://github.com/bobleesj/quantem.live):
 
 ```python
 from quantem.live import io
 from quantem.widget import Show4DSTEM, Show2D
 import torch
 
-# 4D-STEM, full Arina h5 → GPU
 folder = io.download("gold_512")
 result = io.load(io.discover_masters(folder)[0], det_bin=2)
 Show4DSTEM(torch.from_dlpack(result.data))
 
-# HAADF, full Velox EMD with sampling carried through
-ds = io.read_image(io.download("gold_haadf"))                 # → Dataset2d
-Show2D(ds)                                                    # sampling auto-picked
+ds = io.read_image(io.download("gold_haadf"))
+Show2D(ds)
 ```
 
 ## Memory (VRAM) for the full h5
 
-The Arina h5 sets are 512×512×192×192. Peak VRAM is about 1.4× the loaded array; control with `det_bin`:
-
 | `det_bin` | detector | loaded | peak VRAM | fits 16 GB? |
 |---|---|---|---|---|
 | 1 | 192×192 | 18 GB | ~25 GB | no |
 | **2** | 96×96 | 4.5 GB | **~6.9 GB** | **yes** |
 | 4 | 48×48 | 1.1 GB | ~2.2 GB | yes |
-| 8 | 24×24 | 0.3 GB | ~0.5 GB | yes (good for flipping through many) |
-
-Show4DSTEM keeps the data on the GPU; cursor interaction is ~0.03 ms/frame.
+| 8 | 24×24 | 0.3 GB | ~0.5 GB | yes |
 
 ## Licence