{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6b56abb0",
   "metadata": {},
   "source": [
    "# Inverse beamforming on a CIRS phantom scan\n",
    "\n",
    "This tutorial applies [`zea.inverse`](../../_autosummary/zea.inverse.rst) to a recorded\n",
    "acquisition of a **simulated CIRS point-scatterer phantom** (3 plane waves, 80 elements,\n",
    "simulated with FIELD II, ground-truth scatterer positions included) and reproduces the\n",
    "phantom results of the standalone\n",
    "[DAS-inversion study](https://github.com/sankethvedula/das-inverse) that `zea.inverse`\n",
    "was ported from. We recover the **pre-beamformed channel data** from the\n",
    "**post-beamformed image** alone and compare it against the recorded channel data. The\n",
    "reference numbers we aim to reproduce (from the original study):\n",
    "\n",
    "| inversion | pre-BF corr | post-BF corr |\n",
    "|-----------|:-----------:|:------------:|\n",
    "| direct pseudo-inverse | 0.56 | 1.00 |\n",
    "| scatterer prior (15k) | 0.84 | 0.996 |\n",
    "\n",
    "For a fully synthetic walkthrough see the\n",
    "[introductory tutorial](fish_example.ipynb); for in-vivo data continue\n",
    "with the [carotid tutorial](carotid_example.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a0573bb",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/tue-bmd/zea/blob/main/docs/source/notebooks/inverse/cirs_example.ipynb)\n",
    "[![View on GitHub](https://img.shields.io/badge/GitHub-View%20Source-blue?logo=github)](https://github.com/tue-bmd/zea/blob/main/docs/source/notebooks/inverse/cirs_example.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e0f7a9c",
   "metadata": {},
   "source": [
    "‼️ **Important:** This notebook is optimized for **GPU/TPU**. Code execution on a **CPU** may be very slow.\n",
    "\n",
    "If you are running in Colab, please enable a hardware accelerator via:\n",
    "\n",
    "**Runtime → Change runtime type → Hardware accelerator → GPU/TPU** 🚀."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6dc6018b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:16.823814Z",
     "iopub.status.busy": "2026-07-21T15:54:16.823723Z",
     "iopub.status.idle": "2026-07-21T15:54:18.046360Z",
     "shell.execute_reply": "2026-07-21T15:54:18.045515Z"
    }
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "%pip install zea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ef0af038",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:18.048003Z",
     "iopub.status.busy": "2026-07-21T15:54:18.047872Z",
     "iopub.status.idle": "2026-07-21T15:54:21.464035Z",
     "shell.execute_reply": "2026-07-21T15:54:21.463321Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: Using backend 'jax'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------GPU settings-------------------\n",
      "0/1 GPUs were disabled\n",
      "     memory\n",
      "GPU        \n",
      "0       81072\n",
      "Selecting 1 GPU based on available memory.\n",
      "Selected GPU 0 with Free Memory: 81072.00 MiB\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'gpu:0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "os.environ[\"KERAS_BACKEND\"] = \"jax\"\n",
    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
    "\n",
    "import time\n",
    "import urllib.request\n",
    "from pathlib import Path\n",
    "\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from keras import ops\n",
    "from matplotlib.animation import FuncAnimation, PillowWriter\n",
    "\n",
    "import zea\n",
    "from zea.inverse import DASOperator, ScattererSimulator, invert_direct, invert_scatterers\n",
    "\n",
    "zea.init_device()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8e1c6f0c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:21.465704Z",
     "iopub.status.busy": "2026-07-21T15:54:21.465409Z",
     "iopub.status.idle": "2026-07-21T15:54:21.467731Z",
     "shell.execute_reply": "2026-07-21T15:54:21.467306Z"
    },
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "# Parameters (overridden for fast CI runs, see tests/test_notebooks.py)\n",
    "# CGLS is stopped early: on ill-posed problems the iteration count doubles as\n",
    "# the regularization parameter, and 40 iterations capture nearly all of the\n",
    "# attainable correlation at a fraction of the runtime.\n",
    "n_iter = 40\n",
    "n_scatterers = 15000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf642c75",
   "metadata": {},
   "source": [
    "## Download the scan\n",
    "\n",
    "The CIRS phantom scan (2 MB, simulated with FIELD II, ground-truth scatterers included)\n",
    "comes from the original study's repository. It is in the (legacy) `zea` HDF5 format and\n",
    "loads directly with [`zea.File`](../../_autosummary/zea.data.file.rst)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7f5002a8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:21.469012Z",
     "iopub.status.busy": "2026-07-21T15:54:21.468901Z",
     "iopub.status.idle": "2026-07-21T15:54:21.472067Z",
     "shell.execute_reply": "2026-07-21T15:54:21.471684Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cirs_simulated.hdf5: already downloaded\n"
     ]
    }
   ],
   "source": [
    "DATA_DIR = Path(os.environ.get(\"ZEA_INVERSE_DATA_DIR\", \"~/zea-inverse-data\")).expanduser()\n",
    "DATA_DIR.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "SCAN_PATH = DATA_DIR / \"cirs_simulated.hdf5\"\n",
    "SCAN_URL = (\n",
    "    \"https://raw.githubusercontent.com/sankethvedula/das-inverse/main/data/cirs_simulated.hdf5\"\n",
    ")\n",
    "\n",
    "if SCAN_PATH.exists():\n",
    "    print(f\"{SCAN_PATH.name}: already downloaded\")\n",
    "else:\n",
    "    print(f\"downloading {SCAN_PATH.name} ...\")\n",
    "    urllib.request.urlretrieve(SCAN_URL, SCAN_PATH)\n",
    "    print(f\"  -> {SCAN_PATH} ({SCAN_PATH.stat().st_size / 1e6:.0f} MB)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d06010a",
   "metadata": {},
   "source": [
    "## Loading a scan for inversion\n",
    "\n",
    "We load the acquisition into [`zea.Parameters`](../../parameters_doc.rst) with a few\n",
    "overrides that match the conventions of the original study:\n",
    "\n",
    "- **`t_peak`**: the original beamformer used the two-way waveform's time-to-peak,\n",
    "  *doubled* (a jaxus convention). We override `t_peak` accordingly so the delay model\n",
    "  matches exactly.\n",
    "- **`element_width`**: these legacy files store the element width under `scan/`, which\n",
    "  the legacy loader drops — we read it directly and pass it as an override (it drives\n",
    "  the element directivity model in the simulator).\n",
    "- **grid**: a 0.6-wavelength pixel grid over the imaging region, and a receive\n",
    "  f-number of 1.5 (the original configuration)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b2f6493d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:21.473543Z",
     "iopub.status.busy": "2026-07-21T15:54:21.473432Z",
     "iopub.status.idle": "2026-07-21T15:54:21.479808Z",
     "shell.execute_reply": "2026-07-21T15:54:21.479370Z"
    }
   },
   "outputs": [],
   "source": [
    "def load_scan(path, region, pixels_per_wavelength=1 / 0.6, f_number=1.5, frame=0):\n",
    "    \"\"\"Load a scan and its raw RF data with the original study's conventions.\"\"\"\n",
    "    with h5py.File(path, \"r\") as h:\n",
    "        element_width = float(h[\"scan/element_width\"][()])\n",
    "    with zea.File(path) as file:\n",
    "        parameters = file.load_parameters()\n",
    "        raw_data = np.asarray(file[\"data/raw_data\"][frame, ..., 0], dtype=np.float32)\n",
    "\n",
    "    # t_peak: two-way waveform peak time, doubled (jaxus/original-study convention)\n",
    "    waveform = np.asarray(parameters.waveforms_two_way[0])\n",
    "    t_peak = np.full(parameters.n_tx, 2.0 * np.argmax(waveform) / 250e6, dtype=np.float32)\n",
    "\n",
    "    # 0.6-wavelength pixel grid over the requested region\n",
    "    spacing = parameters.sound_speed / float(np.mean(parameters.center_frequency))\n",
    "    spacing = spacing / pixels_per_wavelength\n",
    "    grid_size_x = int((region[1] - region[0]) / spacing) + 1\n",
    "    grid_size_z = int((region[3] - region[2]) / spacing) + 1\n",
    "\n",
    "    with zea.File(path) as file:\n",
    "        parameters = file.load_parameters(\n",
    "            t_peak=t_peak,\n",
    "            element_width=element_width,\n",
    "            f_number=f_number,\n",
    "            xlims=(region[0], region[1]),\n",
    "            zlims=(region[2], region[3]),\n",
    "            grid_size_x=grid_size_x,\n",
    "            grid_size_z=grid_size_z,\n",
    "        )\n",
    "    print(\n",
    "        f\"{Path(path).name}: n_tx={parameters.n_tx} n_el={parameters.n_el} \"\n",
    "        f\"n_ax={parameters.n_ax} grid=({grid_size_z}, {grid_size_x})\"\n",
    "    )\n",
    "    return parameters, raw_data\n",
    "\n",
    "\n",
    "def correlation(a, b):\n",
    "    \"\"\"Absolute normalized correlation between two arrays.\"\"\"\n",
    "    a = np.asarray(ops.convert_to_numpy(a)).ravel()\n",
    "    b = np.asarray(ops.convert_to_numpy(b)).ravel()\n",
    "    a, b = a - a.mean(), b - b.mean()\n",
    "    return abs(np.vdot(a, b)) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-30)\n",
    "\n",
    "\n",
    "def report(label, result, raw_data, image, reference):\n",
    "    \"\"\"Print pre/post-beamforming correlations next to the reference values.\"\"\"\n",
    "    pre = correlation(result.channel_data, raw_data)\n",
    "    post = correlation(result.image, image)\n",
    "    print(\n",
    "        f\"{label:28s} pre-BF corr {pre:.3f} (reference {reference[0]:.3f})   \"\n",
    "        f\"post-BF corr {post:.3f} (reference {reference[1]:.3f})\"\n",
    "    )\n",
    "    return pre, post"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf3c11c1",
   "metadata": {},
   "source": [
    "## Rendering helpers\n",
    "\n",
    "`show_images` compares the measured image with the re-beamformed reconstruction\n",
    "(log-compressed `|RF|`, as in the original study). `render_prebf_gif` animates the\n",
    "recovered pre-beamformed channel data across transmits next to the recorded ground\n",
    "truth — this is the quantity being recovered, which the inversion never observes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "02b0d732",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:21.481254Z",
     "iopub.status.busy": "2026-07-21T15:54:21.481139Z",
     "iopub.status.idle": "2026-07-21T15:54:21.486825Z",
     "shell.execute_reply": "2026-07-21T15:54:21.486322Z"
    }
   },
   "outputs": [],
   "source": [
    "def to_db(image_2d):\n",
    "    magnitude = np.abs(image_2d)\n",
    "    return 20 * np.log10(magnitude / (magnitude.max() + 1e-12) + 1e-6)\n",
    "\n",
    "\n",
    "def show_images(operator, image, result, region, scatterers=None, title=\"\"):\n",
    "    extent = [region[0] * 1e3, region[1] * 1e3, region[3] * 1e3, region[2] * 1e3]\n",
    "    fig, axes = plt.subplots(1, 2, figsize=(10, 4.5))\n",
    "    panels = [(image, \"measured image\"), (result.image, \"re-beamformed reconstruction\")]\n",
    "    for ax, (flat, label) in zip(axes, panels):\n",
    "        ax.imshow(\n",
    "            to_db(ops.convert_to_numpy(operator.to_grid(flat))),\n",
    "            cmap=\"gray\",\n",
    "            vmin=-50,\n",
    "            vmax=0,\n",
    "            extent=extent,\n",
    "            aspect=\"equal\",\n",
    "        )\n",
    "        if scatterers is not None:\n",
    "            ax.scatter(\n",
    "                scatterers[:, 0] * 1e3,\n",
    "                scatterers[:, 2] * 1e3,\n",
    "                s=16,\n",
    "                facecolors=\"none\",\n",
    "                edgecolors=\"r\",\n",
    "                linewidths=0.8,\n",
    "            )\n",
    "        ax.set(title=label, xlabel=\"x [mm]\", ylabel=\"z [mm]\")\n",
    "    fig.suptitle(title)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def render_prebf_gif(filename, channel_data_true, channel_data_recon, transmits, fps=10):\n",
    "    \"\"\"Animate ground-truth vs recovered channel data across transmits.\"\"\"\n",
    "    gt = np.asarray(ops.convert_to_numpy(channel_data_true))\n",
    "    recon = np.asarray(ops.convert_to_numpy(channel_data_recon))\n",
    "    fig, axes = plt.subplots(1, 2, figsize=(7, 4.5))\n",
    "\n",
    "    def draw(tx):\n",
    "        for ax in axes:\n",
    "            ax.clear()\n",
    "        for ax, cube, label in zip(axes, [gt, recon], [\"recorded pre-BF\", \"recovered pre-BF\"]):\n",
    "            ax.imshow(\n",
    "                np.abs(cube[tx]),\n",
    "                aspect=\"auto\",\n",
    "                cmap=\"viridis\",\n",
    "                vmax=np.percentile(np.abs(cube[tx]), 99.5) + 1e-12,\n",
    "            )\n",
    "            ax.set(title=label, xlabel=\"element\", ylabel=\"sample\")\n",
    "        tx_corr = correlation(recon[tx], gt[tx])\n",
    "        fig.suptitle(f\"transmit {tx + 1}/{gt.shape[0]}   corr {tx_corr:.3f}\")\n",
    "        fig.tight_layout()\n",
    "\n",
    "    animation = FuncAnimation(fig, draw, frames=list(transmits), interval=1000 / fps)\n",
    "    animation.save(filename, writer=PillowWriter(fps=fps))\n",
    "    plt.close(fig)\n",
    "    print(f\"saved {filename} ({Path(filename).stat().st_size / 1e6:.1f} MB)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1d9756b",
   "metadata": {},
   "source": [
    "## CIRS phantom: pseudo-inverse vs scatterer prior\n",
    "\n",
    "We beamform the recorded channel data once to get the *measured image* — from here on,\n",
    "the inversions see only that image. The direct method runs CGLS on the full channel-data\n",
    "cube (the minimum-norm solution); the scatterer prior seeds 15,000 scatterers from the\n",
    "image envelope and solves for their magnitudes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ee4dfcf8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:21.487992Z",
     "iopub.status.busy": "2026-07-21T15:54:21.487886Z",
     "iopub.status.idle": "2026-07-21T15:54:48.014596Z",
     "shell.execute_reply": "2026-07-21T15:54:48.013987Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m This ``zea.File`` '/nfs/scistore20/bronsgrp/svedula/das-inversion/data/cirs_simulated.hdf5' was created with a legacy version of zea (<0.1.0), while you are using zea v0.1.2. It may behave in unexpected ways. Install an earlier version of zea<0.1.0 for full compatibility or re-save the file with zea v0.1.0 or later (e.g. via File.create).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_one_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_two_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_one_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_two_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cirs_simulated.hdf5: n_tx=3 n_el=80 n_ax=2048 grid=(312, 217)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m width/grid_size_x = 0.0002949 > wavelength/2 = 0.0002464. Consider increasing grid_size_x to 260 or more, or unsetting it to size the grid automatically.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m depth/grid_size_z = 0.0002949 > wavelength/2 = 0.0002464. Consider increasing grid_size_z to 374 or more, or unsetting it to size the grid automatically.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "direct inversion: 3s\n",
      "CIRS direct pseudo-inverse   pre-BF corr 0.556 (reference 0.557)   post-BF corr 1.000 (reference 1.000)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scatterer-prior inversion: 17s\n",
      "CIRS scatterer prior (15k)   pre-BF corr 0.842 (reference 0.838)   post-BF corr 0.993 (reference 0.996)\n"
     ]
    }
   ],
   "source": [
    "REGION_CIRS = (-0.032, 0.032, 0.003, 0.095)\n",
    "\n",
    "parameters, raw_data = load_scan(SCAN_PATH, REGION_CIRS)\n",
    "with h5py.File(SCAN_PATH, \"r\") as h:\n",
    "    scatterers_true = np.asarray(h[\"phantom/scatterer_positions\"])\n",
    "\n",
    "operator = DASOperator(parameters)\n",
    "image = operator.forward(raw_data)\n",
    "\n",
    "start = time.time()\n",
    "result_direct = invert_direct(operator, image, n_iter=n_iter)\n",
    "print(f\"direct inversion: {time.time() - start:.0f}s\")\n",
    "report(\"CIRS direct pseudo-inverse\", result_direct, raw_data, image, (0.557, 1.000))\n",
    "\n",
    "start = time.time()\n",
    "simulator = ScattererSimulator(parameters, chunk_size=8192)\n",
    "result_cirs = invert_scatterers(\n",
    "    operator, image, n_scatterers=n_scatterers, n_iter=n_iter, seed=0, simulator=simulator\n",
    ")\n",
    "print(f\"scatterer-prior inversion: {time.time() - start:.0f}s\")\n",
    "report(\"CIRS scatterer prior (15k)\", result_cirs, raw_data, image, (0.838, 0.996));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fe9c29e4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T15:54:48.016065Z",
     "iopub.status.busy": "2026-07-21T15:54:48.015938Z",
     "iopub.status.idle": "2026-07-21T15:54:49.182965Z",
     "shell.execute_reply": "2026-07-21T15:54:49.182390Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved cirs_prebf.gif (0.1 MB)\n"
     ]
    }
   ],
   "source": [
    "show_images(\n",
    "    operator,\n",
    "    image,\n",
    "    result_cirs,\n",
    "    REGION_CIRS,\n",
    "    scatterers=scatterers_true,\n",
    "    title=\"CIRS phantom — scatterer prior\",\n",
    ")\n",
    "render_prebf_gif(\n",
    "    \"cirs_prebf.gif\",\n",
    "    raw_data,\n",
    "    result_cirs.channel_data,\n",
    "    transmits=range(parameters.n_tx),\n",
    "    fps=2,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "430eb719",
   "metadata": {},
   "source": [
    "![CIRS pre-beamformed channel data: recorded vs recovered](cirs_prebf.gif)\n",
    "\n",
    "The recovered channel data reproduces the scatterer hyperbolae of the recorded data —\n",
    "the scatterer prior has filled the nullspace of the beamformer with physically\n",
    "consistent echoes. Compare the direct pseudo-inverse, which fits the image perfectly\n",
    "(post-BF corr 1.00) yet correlates far less with the true channel data.\n",
    "\n",
    "## Takeaways\n",
    "\n",
    "- Both inversions reproduce the reference results of the\n",
    "  [original study](https://github.com/sankethvedula/das-inverse) (small differences in\n",
    "  the third digit come from a different random seeding stream and pixel-grid rounding).\n",
    "- **Post-beamformed fit is easy; pre-beamformed recovery is the hard part.** The\n",
    "  pseudo-inverse drives the image error to zero while recovering little of the channel\n",
    "  data — the DAS operator sums ~`n_el x n_tx` samples per pixel, so almost everything\n",
    "  about the channel data lives in its nullspace.\n",
    "- A **physical scatterer prior** closes most of that gap on point targets (pre-BF corr\n",
    "  0.56 → 0.84). How much survives on diffuse in-vivo tissue? Continue with the\n",
    "  [carotid tutorial](carotid_example.ipynb)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "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.12.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}