workshop: consolidated v1 (BF/DF/DPC + 5 direct kernels + cross-modality)

notebooks/berk_workshop_v1.ipynb

@@ -2,28 +2,28 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "686f9970",
+   "id": "4bc9d2fa",
    "metadata": {},
    "source": [
-    "# Workshop: real-gold 4D-STEM — browse, BF, DF, probe, DPC (Colab T4)\n",
+    "# Workshop: real-gold 4D-STEM — browse, BF, DF, DPC, and 5 direct-ptycho kernels (Colab T4)\n",
     "\n",
     "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/gist/bobleesj/a05a90185c6cddbb331342cae6d7e9c1/berk_workshop_v1.ipynb)\n",
     "\n",
-    "Load a real 4D-STEM gold dataset from Hugging Face, browse it interactively,\n",
-    "compute bright field / dark field, find the probe center, and visualize DPC —\n",
-    "all in your browser, on Colab's free T4 GPU. No local install, no `quantem.live`.\n",
+    "ONE notebook. Real gold from Hugging Face → load → browse → bright field → dark\n",
+    "field → DPC → all five direct-ptychography kernels (parallax, SSB, OBF, MF, ICOM)\n",
+    "→ side-by-side comparison.\n",
     "\n",
-    "Two installs only: `quantem.widget` (TestPyPI prerelease) and `quantem`\n",
-    "(from the `berk-workshop` branch on `bobleesj/quantem`). Everything runs on\n",
-    "torch on the GPU.\n",
+    "Everything runs on torch on the Colab T4. Two installs only — `quantem.widget`\n",
+    "(TestPyPI prerelease) + `quantem` (`berk-workshop` branch on `bobleesj/quantem`).\n",
+    "No `quantem.live`.\n",
     "\n",
-    "**Total runtime: 2–3 minutes** (install dominates)."
+    "**Total runtime on T4: ~3-4 min** (install dominates)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "c15f382c",
+   "execution_count": null,
+   "id": "7343e468",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -33,82 +33,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "30258881",
+   "execution_count": null,
+   "id": "c5cc149e",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "quantem         0.1.8\n",
-      "quantem.widget  0.0.1\n",
-      "torch           2.10.0+cu130\n",
-      "cuda available: True NVIDIA RTX PRO 6000 Blackwell Workstation Edition\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import quantem as em\n",
     "import quantem.widget\n",
     "import torch\n",
     "\n",
+    "# cuDNN grid_sample bug at these detector dims — disable for the DirectPtycho path.\n",
+    "torch.backends.cudnn.enabled = False\n",
+    "\n",
     "print(\"quantem        \", em.__version__)\n",
     "print(\"quantem.widget \", quantem.widget.__version__)\n",
-    "print(\"torch          \", torch.__version__)\n",
+    "print(\"torch          \", torch.__version__, \"(cuDNN disabled)\")\n",
     "print(\"cuda available:\", torch.cuda.is_available(),\n",
-    "      torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"(no GPU runtime)\")"
+    "      torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"(no GPU)\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "b491687f",
+   "execution_count": null,
+   "id": "fb1fd0b9",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "4857082fc463409cbe993d633f8b24e5",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Downloading (incomplete total...): 0.00B [00:00, ?B/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a00c63d8797545ebb1de8a6c2a5a471e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Fetching 2 files:   0%|          | 0/2 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dataset on cuda:0: shape (512, 512, 24, 24), dtype torch.uint16\n",
-      "sampling [0.5, 0.5, 3.68, 3.68] ['A', 'A', 'mrad', 'mrad']\n",
-      "optics: 300 kV, probe 30 mrad, CL 91 mm\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# Download a pre-binned NumPy bundle from the public Hugging Face dataset and\n",
-    "# wrap it as a torch tensor on the GPU. The 4D shape is (scan_row, scan_col,\n",
-    "# k_row, k_col) = (512, 512, 24, 24); detector binned 8x from the original 192x192\n",
-    "# to keep the Colab download small (~300 MB).\n",
     "import os, json\n",
     "import numpy as np\n",
     "from huggingface_hub import snapshot_download\n",
@@ -116,243 +66,281 @@
     "folder = snapshot_download(\"bobleesj/quantem-data\", repo_type=\"dataset\",\n",
     "                           allow_patterns=[\"4dstem/gold_512_npy_bin8/*\"])\n",
     "asset = os.path.join(folder, \"4dstem\", \"gold_512_npy_bin8\")\n",
-    "data = np.load(os.path.join(asset, \"data.npy\"))           # (512, 512, 24, 24) uint16\n",
+    "data = np.ascontiguousarray(np.load(os.path.join(asset, \"data.npy\")).astype(np.float32))\n",
     "meta = json.load(open(os.path.join(asset, \"meta.json\")))\n",
     "\n",
-    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
-    "t = torch.from_numpy(data).to(device)\n",
-    "dset = em.core.datastructures.Dataset4dstem.from_tensor(\n",
-    "    t, sampling=meta[\"sampling\"], units=meta[\"units\"], name=meta[\"name\"],\n",
+    "# Numpy-backed Dataset4dstem feeds both Show4DSTEM (via torch tensor) and\n",
+    "# DirectPtychography (which reads dataset.array internally).\n",
+    "dset = em.core.datastructures.Dataset4dstem.from_array(\n",
+    "    data, sampling=meta[\"sampling\"], units=meta[\"units\"], name=meta[\"name\"],\n",
     ")\n",
-    "print(f\"dataset on {dset.tensor.device}: shape {dset.shape}, dtype {dset.tensor.dtype}\")\n",
+    "print(f\"dataset: shape {dset.shape}, dtype {dset.array.dtype}\")\n",
     "print(f\"sampling {meta['sampling']} {meta['units']}\")\n",
     "print(f\"optics: {meta['voltage_kV']} kV, probe {meta['probe_semiangle_mrad']} mrad, CL {meta['camera_length_mm']} mm\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "a3f9a244",
+   "id": "4e03791e",
    "metadata": {},
    "source": [
     "## Step 1 — Browse the 4D-STEM dataset interactively\n",
     "\n",
-    "Drag the scan cursor in the left panel. The CBED on the right updates live.\n",
-    "This is your real-time bright-field / dark-field — pixels INSIDE the central\n",
-    "disk are BF, OUTSIDE are DF. The widget renders in your browser via WebGPU\n",
-    "(works in Chrome on free Colab)."
+    "Drag the scan cursor; CBED updates live. This is real-time per-scan-position BF/DF."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "59204966",
+   "execution_count": null,
+   "id": "847d780a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  to cuda:0: 0.00s (0.3 GB)\n",
-      "  auto_detect_center: 0.08s\n",
-      "  virtual image + frame: 0.00s\n",
-      "Show4DSTEM: 512x512x24x24 cuda:0, 0.24s total\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "cfb26ffc6dcb4f02a72772a2fbf05b47",
-       "version_major": 2,
-       "version_minor": 1
-      },
-      "text/plain": [
-       "Show4DSTEM(shape=(512, 512, 24, 24), sampling=(0.5 A, 3.68 mrad), pos=(256, 256), title='gold_512_npy_bin8')"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "quantem.widget.Show4DSTEM(dset)"
+    "# Build a torch-backed view for Show4DSTEM so cursor drag is GPU-fast.\n",
+    "dset_torch = em.core.datastructures.Dataset4dstem.from_tensor(\n",
+    "    torch.from_numpy(data).to(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
+    "    sampling=meta[\"sampling\"], units=meta[\"units\"], name=meta[\"name\"],\n",
+    ")\n",
+    "quantem.widget.Show4DSTEM(dset_torch)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "c09a9ae6",
+   "id": "0d59a9e8",
    "metadata": {},
    "source": [
-    "## Step 2 — Detector geometry + aperture center\n",
+    "## Step 2 — Bright field, dark field, DPC (inline torch on GPU)\n",
     "\n",
-    "Detector size comes from the dataset; aperture center is hardcoded to the\n",
-    "geometric center of the detector (for the binned data here it lands close to\n",
-    "the real beam center)."
+    "Hardcode aperture at the detector center. One torch reduction per panel."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "eee02115",
+   "execution_count": null,
+   "id": "a22b761f",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "probe center: row=11.289, col=11.503   (detector 24x24, geometric center ~12.0, ~12.0)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "H, W = dset.tensor.shape[-2:]          # detector dims\n",
-    "cy, cx = H / 2, W / 2                  # hardcoded — geometric center\n",
-    "device = dset.tensor.device\n",
+    "data_f = torch.from_numpy(data).to(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
     "\n",
-    "row = torch.arange(H, device=device, dtype=torch.float32)[:, None]\n",
-    "col = torch.arange(W, device=device, dtype=torch.float32)[None, :]\n",
+    "# Detector grid + hardcoded aperture center (geometric).\n",
+    "H, W = data_f.shape[-2:]\n",
+    "cy, cx = H / 2, W / 2\n",
+    "row = torch.arange(H, device=data_f.device, dtype=torch.float32)[:, None]\n",
+    "col = torch.arange(W, device=data_f.device, dtype=torch.float32)[None, :]\n",
+    "rr, cc = torch.meshgrid(row.squeeze(), col.squeeze(), indexing=\"ij\")\n",
+    "r_from_center = ((rr - cy) ** 2 + (cc - cx) ** 2).sqrt()\n",
+    "\n",
+    "# BF + DF\n",
+    "BF_RADIUS_PX = 6.0\n",
+    "bf_mask = (r_from_center <= BF_RADIUS_PX).float()\n",
+    "df_mask = 1.0 - bf_mask\n",
+    "bf = (data_f * bf_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
+    "df = (data_f * df_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
+    "\n",
+    "# CoM / DPC — per-scan-position centroid (qx, qy) → row, col deflection + magnitude\n",
+    "qx = row.expand(H, W)\n",
+    "qy = col.expand(H, W)\n",
+    "total_per_dp = data_f.sum(dim=(-2, -1))\n",
+    "com_row = (data_f * qx).sum(dim=(-2, -1)) / total_per_dp\n",
+    "com_col = (data_f * qy).sum(dim=(-2, -1)) / total_per_dp\n",
+    "com_row -= com_row.mean()\n",
+    "com_col -= com_col.mean()\n",
+    "com_mag = (com_row ** 2 + com_col ** 2).sqrt()\n",
     "\n",
-    "print(f\"detector {H}x{W}, aperture center hardcoded to (row={cy}, col={cx})\")"
+    "print(f\"BF range  [{bf.min():.1f}, {bf.max():.1f}]\")\n",
+    "print(f\"DF range  [{df.min():.1f}, {df.max():.1f}]\")\n",
+    "print(f\"|CoM| max  {com_mag.max().item():.4f} px\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "8e3f80bd",
+   "id": "3175e3e9",
    "metadata": {},
    "source": [
-    "## Step 3 — Bright field\n",
-    "\n",
-    "Aperture mask at the probe center → for every scan position, sum the detector\n",
-    "pixels INSIDE the BF disk. One torch reduction on the GPU; renders as an\n",
-    "interactive `Show2D` widget."
+    "### BF + DF side by side"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "89c29b87",
+   "id": "5b00e878",
    "metadata": {},
    "outputs": [],
    "source": [
-    "BF_RADIUS_PX = 6.0   # ~30 mrad on the bin8 detector\n",
-    "\n",
-    "rr, cc = torch.meshgrid(row.squeeze(), col.squeeze(), indexing=\"ij\")\n",
-    "r_from_center = ((rr - cy) ** 2 + (cc - cx) ** 2).sqrt()\n",
-    "bf_mask = (r_from_center <= BF_RADIUS_PX).float()\n",
-    "df_mask = 1.0 - bf_mask                     # for the next step\n",
-    "\n",
-    "data_f = dset.tensor.to(torch.float32)\n",
-    "bf = (data_f * bf_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
-    "\n",
     "quantem.widget.Show2D(\n",
-    "    bf,\n",
-    "    title=\"Bright field\",\n",
-    "    sampling=meta[\"sampling\"][:2],\n",
-    "    units=meta[\"units\"][:2],\n",
+    "    [bf, df],\n",
+    "    labels=[\"Bright field\", \"Dark field\"],\n",
+    "    sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2],\n",
     "    cmap=\"gray\",\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f7b8d437",
+   "id": "07490d6d",
    "metadata": {},
    "source": [
-    "## Step 4 — Dark field\n",
-    "\n",
-    "Same data, opposite mask — sum the detector pixels OUTSIDE the BF disk."
+    "### DPC — CoM row + CoM col + |CoM|"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "8b495a66",
+   "id": "5cd86abd",
    "metadata": {},
    "outputs": [],
    "source": [
-    "df = (data_f * df_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
-    "\n",
     "quantem.widget.Show2D(\n",
-    "    df,\n",
-    "    title=\"Dark field\",\n",
-    "    sampling=meta[\"sampling\"][:2],\n",
-    "    units=meta[\"units\"][:2],\n",
-    "    cmap=\"gray\",\n",
+    "    [com_row.cpu().numpy(), com_col.cpu().numpy(), com_mag.cpu().numpy()],\n",
+    "    labels=[\"CoM row (qx)\", \"CoM col (qy)\", \"|CoM| total\"],\n",
+    "    sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2],\n",
+    "    cmap=\"RdBu_r\",\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "fbd73db0",
+   "id": "51bd59e3",
    "metadata": {},
    "source": [
-    "## Step 5 — Center of mass (DPC) per scan position\n",
+    "## Step 3 — DirectPtychography — five single-shot kernels\n",
     "\n",
-    "For every scan position, the centroid of its diffraction pattern shifts when a\n",
-    "local electric field deflects the probe. Compute that centroid in torch on the\n",
-    "GPU. Three interactive `Show2D` widgets follow:\n",
+    "`DirectPtychography` runs CoM + origin fit + auto-rotation, then a single forward\n",
+    "pass to recover phase via one of five deconvolution kernels:\n",
     "\n",
-    "- **CoM row (qx)** — signed deflection along the rows of the detector.\n",
-    "- **CoM col (qy)** — signed deflection along the columns.\n",
-    "- **|CoM|** — total deflection magnitude (rotation-invariant)."
+    "- **`parallax`** — parallax / tilt approximation\n",
+    "- **`ssb`** — single-sideband (a.k.a. aberration-corrected bright field)\n",
+    "- **`obf`** — optimum bright field\n",
+    "- **`mf`** — matched filter\n",
+    "- **`icom`** — integrated CoM\n",
+    "\n",
+    "Build once, sweep all five kernels."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "d2519bd0",
+   "id": "330903f6",
    "metadata": {},
    "outputs": [],
    "source": [
-    "H, W = data_f.shape[-2:]\n",
-    "qx = torch.arange(H, device=data_f.device, dtype=torch.float32)[:, None]\n",
-    "qy = torch.arange(W, device=data_f.device, dtype=torch.float32)[None, :]\n",
+    "from quantem.diffractive_imaging import DirectPtychography\n",
     "\n",
-    "total_per_dp = data_f.sum(dim=(-2, -1))                  # (scan_r, scan_c)\n",
-    "com_row = (data_f * qx).sum(dim=(-2, -1)) / total_per_dp\n",
-    "com_col = (data_f * qy).sum(dim=(-2, -1)) / total_per_dp\n",
+    "direct = DirectPtychography.from_dataset4d(\n",
+    "    dset,\n",
+    "    energy=meta[\"voltage_kV\"] * 1e3,                      # 300 kV -> 300000 eV\n",
+    "    semiangle_cutoff=meta[\"probe_semiangle_mrad\"] * 1e-3, # 30 mrad -> 0.030 rad\n",
+    "    rotation_angle=None,                                   # auto-estimate\n",
+    "    device=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n",
+    "    verbose=True,\n",
+    ")\n",
+    "print(f\"DirectPtychography built on {'cuda' if torch.cuda.is_available() else 'cpu'}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1264ee0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "KERNELS = [\"parallax\", \"ssb\", \"obf\", \"mf\", \"icom\"]\n",
+    "phases = {}\n",
+    "for k in KERNELS:\n",
+    "    t0 = time.time()\n",
+    "    direct.reconstruct(deconvolution_kernel=k, verbose=False)\n",
+    "    phases[k] = direct.corrected_bf.detach().cpu().numpy()\n",
+    "    print(f\"  {k:>10}: {time.time()-t0:.2f}s, range [{phases[k].min():.2f}, {phases[k].max():.2f}]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8101615",
+   "metadata": {},
+   "source": [
+    "## Step 4 — Compare all five kernels side by side\n",
     "\n",
-    "# Detrend so RdBu_r is zero-centered on the signed deflection.\n",
-    "com_row -= com_row.mean()\n",
-    "com_col -= com_col.mean()\n",
+    "Same data, same forward pass, different deconvolution kernels — different\n",
+    "contrast / resolution tradeoffs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95ef0d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantem.widget.Show2D(\n",
+    "    [phases[k] for k in KERNELS],\n",
+    "    labels=[k for k in KERNELS],\n",
+    "    sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2],\n",
+    "    cmap=\"gray\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a7ac1bb0",
+   "metadata": {},
+   "source": [
+    "## Step 5 — Why does this matter? Phase retrieval vs classic imaging\n",
     "\n",
-    "com_mag = (com_row ** 2 + com_col ** 2).sqrt()           # |CoM|, always >= 0\n",
+    "Look at the panels below side by side, in this order: **BF · DF · |CoM| · parallax · SSB**.\n",
     "\n",
-    "print(f\"CoM row range [{com_row.min().item():.4f}, {com_row.max().item():.4f}] px\")\n",
-    "print(f\"CoM col range [{com_col.min().item():.4f}, {com_col.max().item():.4f}] px\")\n",
-    "print(f\"|CoM| max     {com_mag.max().item():.4f} px\")\n",
+    "- **BF / DF** = intensity contrast. Gold lattice fringes mostly washed out — the contrast is whatever survives integration over the BF disk (or its complement). Dose-efficient but resolution-limited by the disk size.\n",
+    "- **|CoM|** = first-moment information per scan position. Sees first-order electric-field deflection; better than BF/DF but still a single scalar per position.\n",
+    "- **`parallax`, `SSB`** = phase retrieval. Each scan position contributes its full diffraction pattern; the kernel deconvolves the probe-transfer function to recover the **complex object phase**. Result: atomic-lattice fringes, sharper edges, less dose for equivalent SNR.\n",
     "\n",
+    "This is the workshop's scientific punchline: phase retrieval recovers contrast + resolution that BF/DF integration physically can't access."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87cbe2f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "quantem.widget.Show2D(\n",
-    "    [com_row.cpu().numpy(), com_col.cpu().numpy(), com_mag.cpu().numpy()],\n",
-    "    labels=[\"CoM row (qx)\", \"CoM col (qy)\", \"|CoM| total\"],\n",
-    "    sampling=meta[\"sampling\"][:2],\n",
-    "    units=meta[\"units\"][:2],\n",
-    "    cmap=\"RdBu_r\",\n",
+    "    [bf, df, com_mag.cpu().numpy(), phases[\"parallax\"], phases[\"ssb\"]],\n",
+    "    labels=[\"BF\", \"DF\", \"|CoM|\", \"parallax\", \"SSB\"],\n",
+    "    sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2],\n",
+    "    cmap=\"gray\",\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "8585e78a",
+   "id": "c2fdc17c",
    "metadata": {},
    "source": [
     "## What you just did\n",
     "\n",
-    "1. Loaded real 4D-STEM gold from Hugging Face → torch tensor on the Colab T4.\n",
-    "2. Browsed it with `Show4DSTEM`; hardcoded the aperture at the detector center.\n",
-    "3. Bright field via aperture mask × per-scan sum (`Show2D`).\n",
-    "4. Dark field via the complementary mask (`Show2D`).\n",
-    "5. DPC / CoM: a single `Show2D` with three panels — CoM row, CoM col, and `|CoM|` magnitude.\n",
+    "1. Loaded real 4D-STEM gold from Hugging Face → torch GPU + numpy `Dataset4dstem`.\n",
+    "2. Browsed it with `Show4DSTEM`.\n",
+    "3. Computed BF / DF / DPC (CoM_row, CoM_col, |CoM|) inline in torch.\n",
+    "4. Built `DirectPtychography` and swept five deconvolution kernels (parallax, SSB, OBF, MF, ICOM) in seconds each.\n",
+    "5. Compared all the modalities side by side: classic imaging (BF/DF) vs first-moment (|CoM|) vs phase retrieval (parallax, SSB).\n",
     "\n",
-    "Every reduction on the GPU in milliseconds; every viz is an interactive WebGPU widget.\n",
+    "## Why phase retrieval beats BF/DF — the workshop takeaway\n",
     "\n",
-    "## Try next\n",
+    "| Method | Information used | Contrast mechanism | Resolution ceiling |\n",
+    "|---|---|---|---|\n",
+    "| BF, DF | total counts inside / outside the BF disk | intensity (atomic Z, thickness) | ~probe size; integration smears |\n",
+    "| DPC (|CoM|) | first moment of each CBED | first-order field deflection | better than BF, still scalar/pixel |\n",
+    "| Phase retrieval (parallax, SSB, OBF, MF, ICOM) | the **full** CBED at every scan position | recovers the complex object phase | sub-Ångström possible |\n",
     "\n",
-    "- Swap `gold_512_npy_bin8` → `gold_512_npy_bin4` for a finer (4× larger) detector.\n",
-    "- Change `BF_RADIUS_PX` to grow/shrink the BF disk.\n",
-    "- Detrend DPC differently (subtract a plane fit) to surface smaller features.\n",
+    "Single forward pass on T4 — every kernel finishes in seconds. The phase image\n",
+    "shows atomic-lattice fringes that BF/DF can't physically resolve at the same dose.\n",
+    "\n",
+    "## Try next\n",
     "\n",
-    "v2 will add iterative ptychography (`PtychoLite`) on the same data."
+    "- Swap to `gold_512_npy_bin4` for a 4× finer detector — sharpest phase images.\n",
+    "- Pass explicit `rotation_angle=` to `DirectPtychography.from_dataset4d` if the auto-estimate is off.\n",
+    "- v2 will add iterative ptychography (`PtychoLite`) — even higher-resolution phase, multi-slice support, refinement on top of these single-shot kernels."
    ]
   }
  ],
@@ -364,21 +352,11 @@
    "provenance": []
   },
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
+   "display_name": "Python 3",
    "name": "python3"
   },
   "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.12"
+   "name": "python"
   }
  },
  "nbformat": 4,