workshop v2: SSB working via aberration override; CoM via upstream model; per-panel Show2D

notebooks/berk_workshop_v1.ipynb

@@ -2,28 +2,28 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "4bc9d2fa",
+   "id": "d3f97498",
    "metadata": {},
    "source": [
-    "# Workshop: real-gold 4D-STEM — browse, BF, DF, DPC, and 5 direct-ptycho kernels (Colab T4)\n",
+    "# Workshop: real-gold 4D-STEM — browse, BF, DF, DPC, and 3 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",
     "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",
+    "field → DPC (via `CenterOfMassOriginModel`) → three single-shot phase-retrieval\n",
+    "kernels (parallax, SSB, ICOM) → side-by-side comparison.\n",
     "\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",
+    "Everything on torch on the Colab T4. Two installs only — `quantem.widget`\n",
+    "(TestPyPI prerelease) + `quantem` (`berk-workshop` branch). No `quantem.live`.\n",
     "\n",
-    "**Total runtime on T4: ~3-4 min** (install dominates)."
+    "**Workshop punchline:** phase retrieval (parallax, SSB) recovers atomic-lattice\n",
+    "contrast that BF/DF physically cannot, at the same dose."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "7343e468",
+   "id": "2230b09b",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -34,7 +34,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "c5cc149e",
+   "id": "88b999e7",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -42,7 +42,7 @@
     "import quantem.widget\n",
     "import torch\n",
     "\n",
-    "# cuDNN grid_sample bug at these detector dims — disable for the DirectPtycho path.\n",
+    "# cuDNN grid_sample bug at these detector dims; disable for DirectPtycho path.\n",
     "torch.backends.cudnn.enabled = False\n",
     "\n",
     "print(\"quantem        \", em.__version__)\n",
@@ -55,7 +55,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "fb1fd0b9",
+   "id": "9face372",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -69,8 +69,7 @@
     "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",
-    "# Numpy-backed Dataset4dstem feeds both Show4DSTEM (via torch tensor) and\n",
-    "# DirectPtychography (which reads dataset.array internally).\n",
+    "# numpy-backed for upstream CoM + DirectPtychography (they read dataset.array)\n",
     "dset = em.core.datastructures.Dataset4dstem.from_array(\n",
     "    data, sampling=meta[\"sampling\"], units=meta[\"units\"], name=meta[\"name\"],\n",
     ")\n",
@@ -81,22 +80,22 @@
   },
   {
    "cell_type": "markdown",
-   "id": "4e03791e",
+   "id": "e754cba7",
    "metadata": {},
    "source": [
     "## Step 1 — Browse the 4D-STEM dataset interactively\n",
     "\n",
-    "Drag the scan cursor; CBED updates live. This is real-time per-scan-position BF/DF."
+    "Drag the scan cursor; CBED updates live. Real-time per-scan-position BF/DF."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "847d780a",
+   "id": "c1342799",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Build a torch-backed view for Show4DSTEM so cursor drag is GPU-fast.\n",
+    "# Torch-backed view for Show4DSTEM (GPU-fast cursor drag)\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",
@@ -106,71 +105,69 @@
   },
   {
    "cell_type": "markdown",
-   "id": "0d59a9e8",
+   "id": "c1faa1b5",
    "metadata": {},
    "source": [
-    "## Step 2 — Bright field, dark field, DPC (inline torch on GPU)\n",
+    "## Step 2 — Bright field (BF)\n",
     "\n",
-    "Hardcode aperture at the detector center. One torch reduction per panel."
+    "Aperture mask at the detector center; per-scan-position sum INSIDE the disk.\n",
+    "Inline torch on the GPU, one reduction. (`Show2D` shown alone so contrast is\n",
+    "not yoked to anything else.)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "a22b761f",
+   "id": "5ed533ff",
    "metadata": {},
    "outputs": [],
    "source": [
     "data_f = torch.from_numpy(data).to(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
     "\n",
-    "# Detector grid + hardcoded aperture center (geometric).\n",
     "H, W = data_f.shape[-2:]\n",
-    "cy, cx = H / 2, W / 2\n",
+    "cy, cx = H / 2, W / 2                                    # hardcoded geometric center\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",
+    "df_mask = 1.0 - bf_mask                                  # reused in next step\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",
+    "bf = (data_f * bf_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
+    "print(f\"BF range [{bf.min():.1f}, {bf.max():.1f}]\")\n",
     "\n",
-    "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\")"
+    "quantem.widget.Show2D(\n",
+    "    bf, title=\"Bright field\",\n",
+    "    sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2],\n",
+    "    cmap=\"gray\",\n",
+    ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "3175e3e9",
+   "id": "6cc22c3c",
    "metadata": {},
    "source": [
-    "### BF + DF side by side"
+    "## Step 3 — Dark field (DF)\n",
+    "\n",
+    "Same data, complementary aperture mask — sum OUTSIDE the BF disk. Its own\n",
+    "`Show2D` widget so the contrast scale is independent of BF."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "5b00e878",
+   "id": "79e0c9fc",
    "metadata": {},
    "outputs": [],
    "source": [
+    "df = (data_f * df_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
+    "print(f\"DF range [{df.min():.1f}, {df.max():.1f}]\")\n",
+    "\n",
     "quantem.widget.Show2D(\n",
-    "    [bf, df],\n",
-    "    labels=[\"Bright field\", \"Dark field\"],\n",
+    "    df, title=\"Dark field\",\n",
     "    sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2],\n",
     "    cmap=\"gray\",\n",
     ")"
@@ -178,50 +175,74 @@
   },
   {
    "cell_type": "markdown",
-   "id": "07490d6d",
+   "id": "50bcd0fe",
    "metadata": {},
    "source": [
-    "### DPC — CoM row + CoM col + |CoM|"
+    "## Step 4 — DPC via `CenterOfMassOriginModel` (upstream torch on GPU)\n",
+    "\n",
+    "Per-scan-position centroid (CoM) — torch on the GPU through quantem's\n",
+    "`CenterOfMassOriginModel`. Returns a flat `(num_dps, 2)` tensor; reshape to\n",
+    "`(scan_row, scan_col, 2)` for image display."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "5cd86abd",
+   "id": "b360d1b5",
    "metadata": {},
    "outputs": [],
    "source": [
+    "from quantem.diffractive_imaging import CenterOfMassOriginModel\n",
+    "\n",
+    "com_model = CenterOfMassOriginModel.from_dataset(dset, device=\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "com_model.calculate_origin()\n",
+    "\n",
+    "scan_r, scan_c = dset.shape[:2]\n",
+    "com_map = com_model.origin_measured.view(scan_r, scan_c, 2)\n",
+    "\n",
+    "# Detrend so the divergent colormap is zero-centered on signed deflection.\n",
+    "com_row = com_map[..., 0] - com_map[..., 0].mean()\n",
+    "com_col = com_map[..., 1] - com_map[..., 1].mean()\n",
+    "com_mag = (com_row ** 2 + com_col ** 2).sqrt()\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",
+    "\n",
     "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], units=meta[\"units\"][:2],\n",
     "    cmap=\"RdBu_r\",\n",
+    "    link_contrast=False,\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "51bd59e3",
+   "id": "6c89c61d",
    "metadata": {},
    "source": [
-    "## Step 3 — DirectPtychography — five single-shot kernels\n",
+    "## Step 5 — Phase retrieval: `DirectPtychography` with three kernels\n",
     "\n",
-    "`DirectPtychography` runs CoM + origin fit + auto-rotation, then a single forward\n",
-    "pass to recover phase via one of five deconvolution kernels:\n",
+    "Build once, sweep three deconvolution kernels:\n",
     "\n",
     "- **`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."
+    "Two important workshop knobs:\n",
+    "\n",
+    "1. **`override_aberration_coefs`** — pass the operator's calibrated `C10`,\n",
+    "   `C12`, `phi12` (from the gold calibration file). Without them, SSB silently\n",
+    "   returns zero (it needs the probe phase profile to deconvolve).\n",
+    "2. **`parallax_flip_phase=False`** — leave the parallax phase un-flipped."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "330903f6",
+   "id": "1bee4839",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -229,118 +250,169 @@
     "\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",
+    "    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'}\")"
+    "print(\"DirectPtychography built\")"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "b1264ee0",
+   "id": "ee7193aa",
    "metadata": {},
    "outputs": [],
    "source": [
     "import time\n",
-    "KERNELS = [\"parallax\", \"ssb\", \"obf\", \"mf\", \"icom\"]\n",
+    "\n",
+    "# Operator's calibrated aberrations for this gold dataset.\n",
+    "# Source: /home/owner/ssd/data/bob/20260408_gold_4dstem_512_ssb/calibration.json\n",
+    "ABER = {\"C10\": -51.6, \"C12\": 5.2, \"phi12\": 0.14}\n",
+    "\n",
+    "KERNELS = [\"parallax\", \"ssb\", \"icom\"]\n",
     "phases = {}\n",
     "for k in KERNELS:\n",
     "    t0 = time.time()\n",
-    "    direct.reconstruct(deconvolution_kernel=k, verbose=False)\n",
+    "    direct.reconstruct(\n",
+    "        deconvolution_kernel=k,\n",
+    "        override_aberration_coefs=ABER,\n",
+    "        parallax_flip_phase=False,\n",
+    "        verbose=False,\n",
+    "    )\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}]\")"
+    "    print(f\"  {k:>9}: {time.time()-t0:.2f}s  range [{phases[k].min():.3f}, {phases[k].max():.3f}]\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d8101615",
+   "id": "5ffc4fd8",
    "metadata": {},
    "source": [
-    "## Step 4 — Compare all five kernels side by side\n",
+    "## Step 6 — All three kernels side by side\n",
     "\n",
-    "Same data, same forward pass, different deconvolution kernels — different\n",
-    "contrast / resolution tradeoffs."
+    "`link_contrast=False` so every kernel gets its own min/max (the SSB output is\n",
+    "~3 orders of magnitude smaller than ICOM)."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "95ef0d43",
+   "id": "d2987b1f",
    "metadata": {},
    "outputs": [],
    "source": [
     "quantem.widget.Show2D(\n",
-    "    [phases[k] for k in KERNELS],\n",
-    "    labels=[k for k in KERNELS],\n",
+    "    [phases[\"parallax\"], phases[\"ssb\"], phases[\"icom\"]],\n",
+    "    labels=[\"parallax\", \"SSB\", \"ICOM\"],\n",
     "    sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2],\n",
     "    cmap=\"gray\",\n",
+    "    link_contrast=False,\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "a7ac1bb0",
+   "id": "c2d0e9b4",
    "metadata": {},
    "source": [
-    "## Step 5 — Why does this matter? Phase retrieval vs classic imaging\n",
+    "## Step 7 — Phase retrieval vs classic imaging\n",
     "\n",
-    "Look at the panels below side by side, in this order: **BF · DF · |CoM| · parallax · SSB**.\n",
+    "The workshop punchline.\n",
     "\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",
+    "- **BF / DF**: intensity contrast from inside / outside the BF disk. Limited\n",
+    "  by probe size; atomic-lattice fringes mostly washed out.\n",
+    "- **|CoM|**: first-moment deflection per scan position; better than BF/DF.\n",
+    "- **parallax / SSB**: full diffraction pattern deconvolved against the probe\n",
+    "  transfer function. Sharper contrast at the same dose.\n",
     "\n",
-    "This is the workshop's scientific punchline: phase retrieval recovers contrast + resolution that BF/DF integration physically can't access."
+    "Each panel in its own `Show2D` widget (contrast NOT linked across panels —\n",
+    "they live on very different scales)."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "87cbe2f9",
+   "id": "5367fee4",
    "metadata": {},
    "outputs": [],
    "source": [
-    "quantem.widget.Show2D(\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",
-    ")"
+    "quantem.widget.Show2D(bf, title=\"BF — intensity inside disk\", sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2], cmap=\"gray\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6058a9b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantem.widget.Show2D(df, title=\"DF — intensity outside disk\", sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2], cmap=\"gray\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "faf40b28",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantem.widget.Show2D(com_mag.cpu().numpy(), title=\"|CoM| — first-moment magnitude\", sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2], cmap=\"magma\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "63197495",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantem.widget.Show2D(phases[\"parallax\"], title=\"parallax — phase retrieval\", sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2], cmap=\"gray\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "52f7726c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantem.widget.Show2D(phases[\"ssb\"], title=\"SSB — phase retrieval\", sampling=meta[\"sampling\"][:2], units=meta[\"units\"][:2], cmap=\"gray\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "c2fdc17c",
+   "id": "33a873d6",
    "metadata": {},
    "source": [
     "## What you just did\n",
     "\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",
-    "## Why phase retrieval beats BF/DF — the workshop takeaway\n",
+    "3. BF, DF: inline torch on GPU + separate `Show2D` widgets (independent contrast).\n",
+    "4. DPC: upstream `CenterOfMassOriginModel.from_dataset(..., device=\"cuda\").calculate_origin()` — torch on GPU.\n",
+    "5. Built `DirectPtychography` once, swept three deconvolution kernels (parallax,\n",
+    "   SSB, ICOM) using the operator's calibrated aberrations.\n",
+    "6. Compared all five modalities — each in its own widget.\n",
     "\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",
+    "| Method | What it uses | Result on this dataset |\n",
+    "|---|---|---|\n",
+    "| BF, DF | counts inside / outside the BF disk | smooth intensity, low contrast |\n",
+    "| DPC (`|CoM|`) | first moment per CBED | first-order field deflection |\n",
+    "| parallax, SSB, ICOM | full CBED at every scan position | recovers atomic-lattice phase |\n",
     "\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",
+    "The takeaway: phase retrieval recovers contrast + resolution that BF/DF can\n",
+    "not physically access, at the same dose.\n",
     "\n",
     "## Try next\n",
     "\n",
-    "- 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."
+    "- Swap to `gold_512_npy_bin4` for a 4× finer detector.\n",
+    "- Use `direct.optimize_hyperparameters(...)` with `OptimizationParameter` to FIT\n",
+    "  the aberrations from data instead of using the operator value (upstream Optuna\n",
+    "  workflow; currently has an open issue, working manual override above).\n",
+    "- v2 will add iterative ptychography (`PtychoLite`) for the highest-resolution phase."
    ]
   }
  ],