From 3504d96336c7f724832a9b1f856ae663cdffcf8c Mon Sep 17 00:00:00 2001 From: kferjaoui Date: Mon, 3 Aug 2026 11:59:27 +0200 Subject: [PATCH] ClusterFinderFrozen: CPU finder for CUDA correctness study - Diagnostic twin of ClusterFinder: identical decisions, but the pedestal is frozen per frame (snapshot at frame start, updates deferred to frame end), matching the CUDA kernel's update model. - Isolates pedestal-update timing as the sole remaining CPU/GPU mismatch. - Adds class + bindings + factory, validation notebook, and helper utilities. --- include/aare/ClusterFinderFrozen.hpp | 184 ++++++++ python/aare/ClusterFinder.py | 16 +- python/aare/__init__.py | 2 +- python/src/bind_ClusterFinderFrozen.hpp | 81 ++++ python/src/module.cpp | 2 + .../tests/ClusterFinderFrozen_vs_CUDA.ipynb | 360 ++++++++++++++++ python/tests/helper.py | 404 ++++++++++++++++++ 7 files changed, 1047 insertions(+), 2 deletions(-) create mode 100644 include/aare/ClusterFinderFrozen.hpp create mode 100644 python/src/bind_ClusterFinderFrozen.hpp create mode 100644 python/tests/ClusterFinderFrozen_vs_CUDA.ipynb create mode 100644 python/tests/helper.py diff --git a/include/aare/ClusterFinderFrozen.hpp b/include/aare/ClusterFinderFrozen.hpp new file mode 100644 index 00000000..e9487b3a --- /dev/null +++ b/include/aare/ClusterFinderFrozen.hpp @@ -0,0 +1,184 @@ +// SPDX-License-Identifier: MPL-2.0 +#pragma once +#include "aare/ClusterFile.hpp" +#include "aare/ClusterFinder.hpp" // no_2x2_cluster guard, reused here +#include "aare/ClusterVector.hpp" +#include "aare/Dtype.hpp" +#include "aare/NDArray.hpp" +#include "aare/NDView.hpp" +#include "aare/Pedestal.hpp" +#include "aare/defs.hpp" +#include +#include +#include + +namespace aare { + +/** + * @brief Diagnostic twin of ClusterFinder that freezes the pedestal per frame. + * + * This class is BYTE-FOR-BYTE identical to ClusterFinder in every decision it + * makes (negative skip, Test1 single-pixel significance, Test3 total + * significance, the `value == max` store gate, edge handling, rounding). It + * differs in exactly ONE respect: WHEN the pedestal is updated. + * + * - ClusterFinder : per-pixel. `push_fast` mutates the pedestal DURING + * the raster scan, so a pixel's update can change the + * decision for a later pixel in the same frame + * (scan-order dependent). + * + * - ClusterFinderFrozen : per-frame. Every decision in a frame reads a frozen + * snapshot taken at frame start; all `push_fast` + * updates are deferred to the end of the frame and so + * only affect decisions from the NEXT frame on. + * + * That is precisely the CUDA kernel's model (frozen decision, batch update at + * frame end). Running this variant against ClusterFinderCUDA isolates pedestal + * update timing as the sole remaining variable: if the two agree, timing is the + * proven cause of the CPU/CUDA mismatch. + */ +template , + typename FRAME_TYPE = uint16_t, typename PEDESTAL_TYPE = double, + typename = std::enable_if_t::value>> +class ClusterFinderFrozen { + Shape<2> m_image_size; + PEDESTAL_TYPE m_nSigma; + const PEDESTAL_TYPE c2; + const PEDESTAL_TYPE c3; + Pedestal m_pedestal; + ClusterVector m_clusters; + + static const uint8_t ClusterSizeX = ClusterType::cluster_size_x; + static const uint8_t ClusterSizeY = ClusterType::cluster_size_y; + using CT = typename ClusterType::value_type; + + public: + ClusterFinderFrozen(Shape<2> image_size, PEDESTAL_TYPE nSigma = 5.0, + size_t capacity = 1000000) + : m_image_size(image_size), m_nSigma(nSigma), + c2(sqrt((ClusterSizeY + 1) / 2 * (ClusterSizeX + 1) / 2)), + c3(sqrt(ClusterSizeX * ClusterSizeY)), + m_pedestal(image_size[0], image_size[1]), m_clusters(capacity) { + LOG(logDEBUG) << "ClusterFinderFrozen: " + << "image_size: " << image_size[0] << "x" << image_size[1] + << ", nSigma: " << nSigma << ", capacity: " << capacity; + } + + void set_nSigma(PEDESTAL_TYPE nSigma) { m_nSigma = nSigma; } + PEDESTAL_TYPE get_nSigma() const { return m_nSigma; } + + void push_pedestal_frame(NDView frame) { + m_pedestal.push(frame); + } + + NDArray pedestal() { return m_pedestal.mean(); } + NDArray noise() { return m_pedestal.std(); } + void clear_pedestal() { m_pedestal.clear(); } + + ClusterVector + steal_clusters(bool realloc_same_capacity = false) { + ClusterVector tmp = std::move(m_clusters); + if (realloc_same_capacity) + m_clusters = ClusterVector(tmp.capacity()); + else + m_clusters = ClusterVector{}; + return tmp; + } + + void find_clusters(NDView frame, uint64_t frame_number = 0) { + int dy = ClusterSizeY / 2; + int dx = ClusterSizeX / 2; + int has_center_pixel_x = ClusterSizeX % 2; + int has_center_pixel_y = ClusterSizeY % 2; + + m_clusters.set_frame_number(frame_number); + + // FROZEN pedestal snapshot. Every decision this frame reads from these + // copies, so an intra-frame push cannot influence a later pixel. This + // mirrors the CUDA kernel, which decides the whole frame against the + // pedestal as it stood at the start of the frame. + NDArray ped_mean = m_pedestal.mean(); + NDArray ped_std = m_pedestal.std(); + + // Pixels whose pedestal is updated at END of frame (deferred push), + // exactly the set the serial finder would push_fast in-line. + std::vector> deferred; + + for (int iy = 0; iy < frame.shape(0); iy++) { + for (int ix = 0; ix < frame.shape(1); ix++) { + + PEDESTAL_TYPE max = std::numeric_limits::min(); + PEDESTAL_TYPE total = 0; + + PEDESTAL_TYPE rms = ped_std(iy, ix); + PEDESTAL_TYPE value = (frame(iy, ix) - ped_mean(iy, ix)); + + if (value < -m_nSigma * rms) + continue; // NEGATIVE_PEDESTAL, no pedestal update + + for (int ir = -dy; ir < dy + has_center_pixel_y; ir++) { + for (int ic = -dx; ic < dx + has_center_pixel_x; ic++) { + if (ix + ic >= 0 && ix + ic < frame.shape(1) && + iy + ir >= 0 && iy + ir < frame.shape(0)) { + PEDESTAL_TYPE val = frame(iy + ir, ix + ic) - + ped_mean(iy + ir, ix + ic); + total += val; + max = std::max(max, val); + } + } + } + + if ((max > m_nSigma * rms)) { + if (value < max) + continue; // Not max, no pedestal update + } else if (total > c3 * m_nSigma * rms) { + // pass + } else { + // Defer the pedestal update to end of frame (see below). + deferred.emplace_back(iy, ix); + continue; + } + + // Store cluster + if (value == max) { + ClusterType cluster{}; + cluster.x = ix; + cluster.y = iy; + + int i = 0; + for (int ir = -dy; ir < dy + has_center_pixel_y; ir++) { + for (int ic = -dx; ic < dx + has_center_pixel_x; ic++) { + if (ix + ic >= 0 && ix + ic < frame.shape(1) && + iy + ir >= 0 && iy + ir < frame.shape(0)) { + if constexpr (std::is_integral_v && + std::is_floating_point_v< + PEDESTAL_TYPE>) { + auto tmp = + std::lround(frame(iy + ir, ix + ic) - + ped_mean(iy + ir, ix + ic)); + cluster.data[i] = static_cast(tmp); + } else { + auto tmp = frame(iy + ir, ix + ic) - + ped_mean(iy + ir, ix + ic); + cluster.data[i] = static_cast(tmp); + } + } + i++; + } + } + + m_clusters.push_back(cluster); + } + } + } + + // End-of-frame pedestal update (deferred). Identical push_fast to the + // serial finder, but every push now sees the SAME frozen baseline and + // only affects decisions from the NEXT frame on -> matches CUDA. Each + // pixel is visited at most once per frame, so push order is irrelevant. + for (const auto &p : deferred) + m_pedestal.push_fast(p.first, p.second, frame(p.first, p.second)); + } +}; + +} // namespace aare diff --git a/python/aare/ClusterFinder.py b/python/aare/ClusterFinder.py index 920b82c1..6f53f131 100644 --- a/python/aare/ClusterFinder.py +++ b/python/aare/ClusterFinder.py @@ -39,7 +39,21 @@ def ClusterFinder(image_size, cluster_size=(3,3), n_sigma=5, dtype = np.int32, c -def ClusterFinderMT(image_size, cluster_size = (3,3), dtype=np.int32, n_sigma=5, capacity = 1024, n_threads = 3): +def ClusterFinderFrozen(image_size, cluster_size=(3,3), n_sigma=5, dtype=np.int32, capacity=1024): + """ + Factory function to create a ClusterFinderFrozen object. + + Diagnostic twin of ClusterFinder: identical decision logic, but the pedestal + is frozen per frame (every decision reads a start-of-frame snapshot, and all + pedestal updates are deferred to the end of the frame). This mirrors the CUDA + kernel's per-frame update model, so running it against ClusterFinderCUDA + isolates pedestal-update timing as the sole variable. + """ + cls = _get_class("ClusterFinderFrozen", cluster_size, dtype) + return cls(image_size, n_sigma=n_sigma, capacity=capacity) + + +def ClusterFinderMT(image_size, cluster_size = (3,3), dtype=np.int32, n_sigma=5, capacity = 1024, n_threads = 3): """ Factory function to create a ClusterFinderMT object. Provides a cleaner syntax for the templated ClusterFinderMT in C++. diff --git a/python/aare/__init__.py b/python/aare/__init__.py index 58bce68e..7c6b3594 100644 --- a/python/aare/__init__.py +++ b/python/aare/__init__.py @@ -31,7 +31,7 @@ from ._aare import corner # from ._aare import ClusterFinderMT, ClusterCollector, ClusterFileSink, ClusterVector_i from ._version import __version__ -from .ClusterFinder import ClusterFinder, ClusterCollector, ClusterFinderMT, ClusterFileSink, ClusterFile +from .ClusterFinder import ClusterFinder, ClusterFinderFrozen, ClusterCollector, ClusterFinderMT, ClusterFileSink, ClusterFile from .ClusterFinder import ClusterFinderCUDA, ClusterFinderCUDAGraph, _cuda_available from .ClusterVector import ClusterVector from .Cluster import Cluster diff --git a/python/src/bind_ClusterFinderFrozen.hpp b/python/src/bind_ClusterFinderFrozen.hpp new file mode 100644 index 00000000..1f214e4d --- /dev/null +++ b/python/src/bind_ClusterFinderFrozen.hpp @@ -0,0 +1,81 @@ +// SPDX-License-Identifier: MPL-2.0 +#include "aare/ClusterFinderFrozen.hpp" +#include "aare/ClusterVector.hpp" +#include "aare/NDView.hpp" +#include "aare/Pedestal.hpp" +#include "np_helper.hpp" + +#include +#include +#include +#include + +namespace py = pybind11; +using pd_type = double; + +using namespace aare; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" + +template +void define_ClusterFinderFrozen(py::module &m, const std::string &typestr) { + auto class_name = fmt::format("ClusterFinderFrozen_{}", typestr); + + using ClusterType = Cluster; + + py::class_>( + m, class_name.c_str()) + .def(py::init, pd_type, size_t>(), py::arg("image_size"), + py::arg("n_sigma") = 5.0, py::arg("capacity") = 1'000'000) + + .def_property( + "nSigma", + &ClusterFinderFrozen::get_nSigma, + &ClusterFinderFrozen::set_nSigma, + R"(number of sigma above the pedestal to consider a photon during cluster finding.)") + + .def("push_pedestal_frame", + [](ClusterFinderFrozen &self, + py::array_t frame) { + auto view = make_view_2d(frame); + self.push_pedestal_frame(view); + }) + .def("clear_pedestal", &ClusterFinderFrozen::clear_pedestal) + .def_property_readonly( + "pedestal", + [](ClusterFinderFrozen &self) { + auto pd = new NDArray{}; + *pd = self.pedestal(); + return return_image_data(pd); + }) + .def_property_readonly( + "noise", + [](ClusterFinderFrozen &self) { + auto arr = new NDArray{}; + *arr = self.noise(); + return return_image_data(arr); + }) + .def( + "steal_clusters", + [](ClusterFinderFrozen &self, + bool realloc_same_capacity) { + ClusterVector clusters = + self.steal_clusters(realloc_same_capacity); + return clusters; + }, + py::arg("realloc_same_capacity") = false) + .def( + "find_clusters", + [](ClusterFinderFrozen &self, + py::array_t frame, uint64_t frame_number) { + auto view = make_view_2d(frame); + self.find_clusters(view, frame_number); + return; + }, + py::arg(), py::arg("frame_number") = 0); +} + +#pragma GCC diagnostic pop diff --git a/python/src/module.cpp b/python/src/module.cpp index 023a19ee..53277c23 100644 --- a/python/src/module.cpp +++ b/python/src/module.cpp @@ -7,6 +7,7 @@ #include "bind_ClusterFile.hpp" #include "bind_ClusterFileSink.hpp" #include "bind_ClusterFinder.hpp" +#include "bind_ClusterFinderFrozen.hpp" #include "bind_ClusterFinderMT.hpp" #include "bind_ClusterVector.hpp" #include "bind_Defs.hpp" @@ -54,6 +55,7 @@ double, 'f' for float) #define DEFINE_BINDINGS_CLUSTERFINDER(T, N, M, U, TYPE_CODE) \ define_ClusterFinder(m, "Cluster" #N "x" #M #TYPE_CODE); \ + define_ClusterFinderFrozen(m, "Cluster" #N "x" #M #TYPE_CODE); \ define_ClusterFinderMT(m, "Cluster" #N "x" #M #TYPE_CODE); \ define_ClusterFileSink(m, "Cluster" #N "x" #M #TYPE_CODE); \ define_ClusterCollector(m, "Cluster" #N "x" #M #TYPE_CODE); diff --git a/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb b/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb new file mode 100644 index 00000000..8f06d4a6 --- /dev/null +++ b/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb @@ -0,0 +1,360 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "md-intro", + "metadata": {}, + "source": [ + "# Frozen-CPU vs CUDA — isolating pedestal-update timing\n", + "\n", + "`ClusterFinderFrozen` is a diagnostic twin of the serial `ClusterFinder`: **identical**\n", + "decision logic (negative skip, Test1, Test3, `value == max` store gate, edge handling,\n", + "rounding), differing in **exactly one** respect — *when* the pedestal is updated.\n", + "\n", + "| finder | pedestal update |\n", + "|---|---|\n", + "| `ClusterFinder` | per-pixel, **during** the raster scan (scan-order dependent) |\n", + "| `ClusterFinderFrozen` | frozen snapshot for all decisions; **deferred** to frame end |\n", + "| `ClusterFinderCUDA` | frozen per frame; batch update at frame end |\n", + "\n", + "`Frozen` and `CUDA` share the same update *model*.\n", + "\n", + "**Expected result** (CUDA at `n_streams=1`):\n", + "- `cpu vs cuda` → the current gap (what we're explaining)\n", + "- `frozen vs cuda` → **≈ 0** (timing was the whole story)\n", + "- `frozen vs cpu` → ≈ the gap (exactly the flipped frames)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "imports", + "metadata": {}, + "outputs": [], + "source": [ + "import sys; sys.path.append('/home/ferjao_k/aare/build')\n", + "\n", + "from pathlib import Path\n", + "import numpy as np\n", + "import time\n", + "\n", + "from aare import File, ClusterFinder, ClusterFinderFrozen, ClusterFinderCUDA\n", + "from helper import (centers, only_sets, train_pedestal,\n", + " compare_finders, print_comparison, plot_spectra,\n", + " scan_mismatches, plot_masked_mismatch, walkthrough)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "config", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image (400, 400) pedestal 1000 data 50000 streams 1\n" + ] + } + ], + "source": [ + "base = Path('/mnt/sls_det_storage/matterhorn_data/aare_test_data/')\n", + "f = File(base / 'Moench03new/cu_half_speed_master_4.json')\n", + "\n", + "n_frames_pd = 1000\n", + "N = 20000\n", + "cluster_size = (3, 3)\n", + "rows, cols = f.rows, f.cols\n", + "image_size = (rows, cols)\n", + "capacity = 50_000\n", + "\n", + "N_STREAMS = 1 # single device pedestal -> apples-to-apples with the CPU finders\n", + "N_SIGMA = 5\n", + "sx, sy = cluster_size\n", + "rx, ry = sx // 2, sy // 2\n", + "print(f'image {image_size} pedestal {n_frames_pd} data {N} streams {N_STREAMS}')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "build", + "metadata": {}, + "outputs": [], + "source": [ + "cf_cpu = ClusterFinder(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n", + "cf_frozen = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n", + "cf_cuda = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n", + " max_clusters_per_frame=1500, n_streams=N_STREAMS)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "train", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pedestal train: 0.80s\n", + "data: (50000, 400, 400) uint16\n" + ] + } + ], + "source": [ + "# Train ALL three on the SAME pedestal frames, then load the data block.\n", + "f.seek(0)\n", + "t0 = time.perf_counter()\n", + "for _ in range(n_frames_pd):\n", + " img = f.read_frame().copy()\n", + " cf_cpu.push_pedestal_frame(img)\n", + " cf_frozen.push_pedestal_frame(img)\n", + " cf_cuda.push_pedestal_frame(img)\n", + "print(f'pedestal train: {time.perf_counter()-t0:.2f}s')\n", + "\n", + "f.seek(n_frames_pd)\n", + "data = f.read_n(N)\n", + "print('data:', data.shape, data.dtype)" + ] + }, + { + "cell_type": "markdown", + "id": "md-compare", + "metadata": {}, + "source": [ + "## The three-way comparison\n", + "\n", + "All three finders now carry the **same** trained pedestal. `compare_finders` runs each\n", + "over the same sampled frames and reports exact (tol=0) pairwise centre mismatches." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "compare", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scanned 20000 frames\n", + "\n", + "Total clusters per finder:\n", + " cpu 27,666,006\n", + " frozen 27,665,954\n", + " cuda 27,665,796\n", + "\n", + "Pairwise exact mismatches (tol=0):\n", + " pair A-only B-only total\n", + " cpu vs frozen 94 42 136 (0.0005%)\n", + " cpu vs cuda 252 42 294 (0.0011%)\n", + " frozen vs cuda 158 0 158 (0.0006%)\n" + ] + } + ], + "source": [ + "SCAN = 20000 # frames sampled across `data` (set to len(data) for the full block)\n", + "\n", + "totals, pairs, nscan, hists = compare_finders(\n", + " # {'frozen': cf_frozen, 'cuda': cf_cuda}, data, scan_count=SCAN)\n", + " {'cpu': cf_cpu, 'frozen': cf_frozen, 'cuda': cf_cuda}, data, scan_count=SCAN)\n", + "print_comparison(totals, pairs, nscan)" + ] + }, + { + "cell_type": "markdown", + "id": "md-read", + "metadata": {}, + "source": [ + "**Reading the table.** If `frozen vs cuda` collapses to ~0 while `cpu vs cuda` and\n", + "`frozen vs cpu` are comparable and non-trivial, pedestal-update *timing* is the proven\n", + "cause. A small non-zero `frozen vs cuda` residual would be a genuine surprise (FP corner,\n", + "edge pixel, or the multi-stream path) worth chasing — not expected background." + ] + }, + { + "cell_type": "markdown", + "id": "424e2976", + "metadata": {}, + "source": [ + "## Cluster-energy spectra\n", + "\n", + "The three finders' cluster-energy distributions, accumulated in the same compare pass\n", + "(no extra scan). They should overlap almost perfectly; the ratio panel (each vs `cpu`)\n", + "makes any per-bin divergence — e.g. the `frozen vs cuda` residual — visible." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f057e296", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": + "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plot_spectra(hists, totals,\n", + " title=f'Cluster energy spectra — cluster_size={cluster_size}, n_streams={N_STREAMS}')" + ] + }, + { + "cell_type": "markdown", + "id": "md-resid", + "metadata": {}, + "source": [ + "## Eyeball any residual `frozen vs cuda` mismatches\n", + "\n", + "Fresh finders, retrained identically, then the masked side-by-side view of the worst\n", + "residual frames. If the table showed 0, this should find nothing to plot." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "resid", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "frozen-only: 158 cuda-only: 0 frames shown: 8\n" + ] + }, + { + "data": { + "image/png": + "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cf_frozen2 = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n", + "cf_cuda2 = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n", + " max_clusters_per_frame=1500, n_streams=N_STREAMS)\n", + "train_pedestal([cf_frozen2, cf_cuda2], f, n_frames_pd, seek=0)\n", + "\n", + "# scan_mismatches(a, b, ...) snapshots a.pedestal/noise (host) and b.device_*(0).\n", + "show, res = scan_mismatches(cf_frozen2, cf_cuda2, data, rx, ry,\n", + " scan_count=SCAN, n_show=8, tol=0)\n", + "print('frozen-only:', res['cpu_only'], ' cuda-only:', res['cu_only'], ' frames shown:', len(show))\n", + "if show:\n", + " plot_masked_mismatch(show, data, rx, ry, rows, cols, zoom=30, show_vals=True)" + ] + }, + { + "cell_type": "markdown", + "id": "d470cd40", + "metadata": {}, + "source": [ + "## Walkthrough of the surviving mismatch\n", + "\n", + "Manual Test1/Test3 recompute of the strongest residual cluster in `show`, under each\n", + "finder's decision-time snapshot pedestal. For 7×7 (a single residual) this shows exactly\n", + "what the lone mismatched cluster looks like and which test tips it — naming the cause\n", + "(FP knife-edge at threshold, a border/tie corner, or a genuine third source)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c27d894d-64b2-45b2-aaa8-bfddc754b3f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "frame 35343 centre (x=19, y=349) accepted only by frozen\n", + "raw window (ADU):\n", + "[[5998 6480 6226]\n", + " [5952 9428 6189]\n", + " [6250 6202 6378]]\n", + "\n", + "--- frozen ---\n", + " subtracted window:\n", + " [[ -54.9 258. -127.8]\n", + " [ -56.4 3138.6 46.2]\n", + " [ 21.3 -91. -34.8]]\n", + " centre value = 3138.63 (local max? True)\n", + " max = 3138.63 total = 3099.23\n", + " rms(centre) = 54.017\n", + " Test1: max > 5*rms = 270.09 -> True\n", + " Test3: total > 3*5*rms = 810.26 -> True\n", + " ACCEPT = True\n", + "\n", + "--- cuda ---\n", + " subtracted window:\n", + " [[ -54.9 258. -127.8]\n", + " [ -56.4 3138.6 46.2]\n", + " [ 21.3 -91. -34.8]]\n", + " centre value = 3138.63 (local max? True)\n", + " max = 3138.63 total = 3099.23\n", + " rms(centre) = 54.017\n", + " Test1: max > 5*rms = 270.09 -> True\n", + " Test3: total > 3*5*rms = 810.26 -> True\n", + " ACCEPT = True\n", + "\n", + "RESULT: frozen = ACCEPT , cuda = ACCEPT\n", + "pedestal mean gap @centre = 0.0000 ADU; rms gap = 0.0000\n", + "NOTE: recompute agrees for this centre pixel — the split is FP rounding right at threshold or a window-neighbour effect; try another pick.\n" + ] + } + ], + "source": [ + "# Dissect the surviving frozen-vs-cuda residual (best seen for 7x7, where it's ~1).\n", + "# Recomputes Test1/Test3 under each finder's decision-time snapshot pedestal, so the\n", + "# lone mismatched cluster is fully explained (which test flips, and the pedestal gap).\n", + "walkthrough(show, data, rx, ry, rows, cols, N_SIGMA, pick=0, labels=('frozen', 'cuda'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2f86c8d-5d44-40ad-9fa7-80997aa260e6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/python/tests/helper.py b/python/tests/helper.py new file mode 100644 index 00000000..d524a1d1 --- /dev/null +++ b/python/tests/helper.py @@ -0,0 +1,404 @@ +"""Helpers for the CPU-vs-CUDA ClusterFinder mismatch analysis. + +Pure, parameterised versions of the functions that used to live inline in the +notebook's forensic-view cell, plus the reusable scan + plot routines so the +notebook cells stay thin. Import in the notebook with:: + + from helper import (centers, only_sets, footprint_mask, shift_dist, + train_pedestal, scan_mismatches, plot_masked_mismatch) + +None of these rely on notebook globals — cluster geometry (rx, ry) and the +frame shape (rows, cols) are passed in explicitly. +""" + +import numpy as np +import matplotlib.pyplot as plt +import boost_histogram as bh + +# --------------------------------------------------------------------------- # +# Pure helpers +# --------------------------------------------------------------------------- # +def print_pinning_budget(rows, cols, dtype=np.uint16, headroom_gb=4.0): + """ + Print system RAM stats and estimate the maximum number of frames + that can be safely registered with cudaHostRegister / register_input_buffer. + + Parameters + ---------- + rows, cols : int Detector frame dimensions. + dtype : np.dtype Frame element type (default uint16 = 2 bytes/pixel). + headroom_gb: float RAM to keep free for OS + CUDA context (default 4 GB). + """ + # /proc/meminfo is always available on Linux — no extra dependency needed + meminfo = {} + with open('/proc/meminfo') as f: + for line in f: + key, val = line.split(':') + meminfo[key.strip()] = int(val.split()[0]) * 1024 # kB → bytes + + total_bytes = meminfo['MemTotal'] + available_bytes = meminfo['MemAvailable'] # free + reclaimable cache + safe_bytes = max(0, available_bytes - int(headroom_gb * 1024**3)) + + frame_bytes = rows * cols * np.dtype(dtype).itemsize + max_frames = safe_bytes // frame_bytes + + GiB = 1024**3 + print("── System RAM ──────────────────────────────────────────") + print(f" Total RAM : {total_bytes/GiB:.1f} GiB") + print(f" Currently available : {available_bytes/GiB:.1f} GiB " + f"(free + reclaimable cache)") + print(f" Reserved headroom : {headroom_gb:.1f} GiB " + f"(OS + CUDA context)") + print(f" Safe pinning budget : {safe_bytes/GiB:.1f} GiB") + print() + print("── Frame layout ────────────────────────────────────────") + print(f" Frame size : {rows} × {cols} × " + f"{np.dtype(dtype).itemsize} B = {frame_bytes/1024:.1f} kB") + print() + print("── Pinning estimate ────────────────────────────────────") + print(f" Max frames pinnable : {max_frames:,} " + f"({max_frames * frame_bytes / GiB:.1f} GiB)") + print() + print(" Note: no swap on this machine — exceeding available RAM") + print(" will trigger the OOM killer. Stay within the budget.") + +def centers(cv): + """Set of ``(x, y)`` integer cluster centres from a ClusterVector.""" + if cv.size == 0: + return set() + a = np.asarray(cv) + return {(int(x), int(y)) for x, y in zip(a["x"], a["y"])} + + +def only_sets(cpu_c, cu_c, tol=1): + """CPU-only / CUDA-only centres, ignoring ``<=tol`` px 'shifted' matches. + + ``tol=0`` returns the exact set difference (shifted twins stay counted as + mismatches); ``tol=1`` drops any mismatch that has a counterpart in the + other finder's 8-neighbourhood. + """ + def near(p, other): + x, y = p + return any((x + dx, y + dy) in other + for dx in range(-tol, tol + 1) + for dy in range(-tol, tol + 1)) + + cpu_only = {p for p in cpu_c - cu_c if not near(p, cu_c)} + cu_only = {p for p in cu_c - cpu_c if not near(p, cpu_c)} + return cpu_only, cu_only + + +def footprint_mask(cs, shape, rx, ry): + """Boolean map: True where a pixel lies in some cluster's footprint. + + Each centre paints a ``(2*ry+1) x (2*rx+1)`` box, clipped at the borders. + """ + m = np.zeros(shape, bool) + for (cx, cy) in cs: + m[max(0, cy - ry):cy + ry + 1, max(0, cx - rx):cx + rx + 1] = True + return m + + +def shift_dist(p, other, R=4): + """Chebyshev distance from ``p`` to the nearest member of ``other``. + + Rings are searched inner-to-outer so the first hit is the nearest. + Returns ``-1`` if nothing lies within ``R`` px. + """ + x, y = p + for r in range(1, R + 1): + for dx in range(-r, r + 1): + for dy in range(-r, r + 1): + if max(abs(dx), abs(dy)) == r and (x + dx, y + dy) in other: + return r + return -1 + + +# --------------------------------------------------------------------------- # +# Reusable scan + plot +# --------------------------------------------------------------------------- # +def train_pedestal(finders, f, n_frames, seek=0): + """Push the first ``n_frames`` frames of ``f`` into every finder given.""" + f.seek(seek) + for _ in range(n_frames): + img = f.read_frame().copy() + for cf in finders: + cf.push_pedestal_frame(img) + + +def scan_mismatches(cf_cpu, cf_cuda, data, rx, ry, + scan_count=1000, n_show=8, tol=0): + """Run both finders over ``scan_count`` frames sampled across ``data``. + + Before every frame it snapshots the pedestal each finder will DECIDE with + (CPU: host mean/rms; CUDA: device mean/rms on stream 0), so a later + recompute uses the exact decision-time baseline. + + ``tol`` is forwarded to :func:`only_sets` when scoring a frame; ``tol=0`` + keeps shifted twins as mismatches. Returns ``(show, totals)`` where + ``show`` is the ``n_show`` frames with the most mismatches, each a dict + with ``fid``, ``score``, ``cpu_c``, ``cu_c``, ``mism`` and the four + pedestal arrays ``ped_cpu/noise_cpu/ped_cu/noise_cu``. + """ + show = [] + tot_cpu_only = tot_cu_only = 0 + for fid in np.linspace(0, len(data) - 1, scan_count, dtype=int): + snap = dict(ped_cpu=np.asarray(cf_cpu.pedestal).copy(), + noise_cpu=np.asarray(cf_cpu.noise).copy(), + ped_cu=np.asarray(cf_cuda.device_pedestal(0)).copy(), + noise_cu=np.asarray(cf_cuda.device_noise(0)).copy()) + cf_cpu.find_clusters(data[fid]) + cpu_c = centers(cf_cpu.steal_clusters(realloc_same_capacity=True)) + cf_cuda.find_clusters(data[fid]) + cu_c = centers(cf_cuda.steal_clusters(realloc_same_capacity=True)) + + cpu_only, cu_only = only_sets(cpu_c, cu_c, tol=tol) + tot_cpu_only += len(cpu_only) + tot_cu_only += len(cu_only) + mism = cpu_only | cu_only + if not mism: + continue + if len(show) < n_show or len(mism) > show[-1]["score"]: + show.append(dict(score=len(mism), fid=int(fid), + cpu_c=cpu_c, cu_c=cu_c, mism=mism, **snap)) + show.sort(key=lambda e: -e["score"]) + del show[n_show:] + return show, dict(cpu_only=tot_cpu_only, cu_only=tot_cu_only) + + +def compare_finders(finders, data, scan_count=1000, n_bins=200, e_range=(-2, 4000)): + """Run several finders over the same frames and score pairwise agreement. + + ``finders`` is a dict ``{name: finder}``; every finder must already be + trained on the SAME pedestal frames. Each is run over the same + ``scan_count`` frames sampled across ``data`` (identical ``find_clusters``/ + ``steal_clusters`` API for CPU, frozen-CPU and CUDA). In the same pass it + accumulates a per-finder cluster-energy histogram (from ``cv.sum()``), so no + extra scan is needed to draw the spectra. + + Returns ``(totals, pairs, frames_scanned, hists)``: + * ``totals[name]`` total clusters found by that finder + * ``pairs[(a, b)]`` dict with ``a_only``/``b_only``/``mismatch`` + summed over frames (exact, tol=0) + * ``hists[name]`` boost ``Histogram`` of cluster energies + Companions :func:`print_comparison` and :func:`plot_spectra` render these. + """ + names = list(finders) + totals = {n: 0 for n in names} + hists = {n: bh.Histogram(bh.axis.Regular(n_bins, *e_range)) for n in names} + pairs = {} + for i, a in enumerate(names): + for b in names[i + 1:]: + pairs[(a, b)] = dict(a_only=0, b_only=0, mismatch=0) + + fids = np.linspace(0, len(data) - 1, scan_count, dtype=int) + for fid in fids: + cs = {} + for n, cf in finders.items(): + cf.find_clusters(data[fid]) + cv = cf.steal_clusters(realloc_same_capacity=True) + cs[n] = centers(cv) + totals[n] += len(cs[n]) + if cv.size: + hists[n].fill(np.asarray(cv.sum()).ravel()) + for (a, b), acc in pairs.items(): + a_only, b_only = only_sets(cs[a], cs[b], tol=0) + acc["a_only"] += len(a_only) + acc["b_only"] += len(b_only) + acc["mismatch"] += len(a_only) + len(b_only) + return totals, pairs, len(fids), hists + + +def plot_spectra(hists, totals=None, title="Cluster energy spectrum"): + """Overlay per-finder cluster-energy spectra with a ratio panel. + + ``hists`` is the ``{name: Histogram}`` returned by :func:`compare_finders`; + the first finder is the reference for the ratio panel. Returns the Figure. + """ + names = list(hists) + ref = names[0] + edges = hists[ref].axes[0].edges + vals = {n: hists[n].values() for n in names} + + fig, (ax_spec, ax_ratio) = plt.subplots( + 2, 1, figsize=(8, 6), sharex=True, + gridspec_kw={"height_ratios": [3, 1]}) + + styles = ["-", "--", "-.", ":"] + for i, n in enumerate(names): + lbl = n if totals is None else f"{n} ({totals[n]:,} clusters)" + ax_spec.stairs(vals[n], edges, label=lbl, linestyle=styles[i % len(styles)]) + ax_spec.set_ylabel("Counts") + ax_spec.set_title(title) + ax_spec.legend() + ax_spec.grid(alpha=0.2) + + with np.errstate(divide="ignore", invalid="ignore"): + for i, n in enumerate(names[1:], start=1): + ratio = np.where(vals[ref] > 0, vals[n] / vals[ref], np.nan) + ax_ratio.stairs(ratio, edges, label=f"{n} / {ref}", + color=f"C{i}", linestyle=styles[i % len(styles)]) + ax_ratio.axhline(1.0, color="gray", linewidth=0.5) + ax_ratio.set_ylabel(f"/ {ref}") + ax_ratio.set_xlabel("Energy [ADU]") + ax_ratio.set_ylim(0.5, 2.0) + ax_ratio.legend(fontsize=8) + ax_ratio.grid(alpha=0.3) + + plt.tight_layout() + plt.show() + return fig + + +def print_comparison(totals, pairs, frames_scanned): + """Pretty-print the output of :func:`compare_finders`.""" + print(f"Scanned {frames_scanned} frames\n") + print("Total clusters per finder:") + for n, t in totals.items(): + print(f" {n:<16} {t:>12,}") + print("\nPairwise exact mismatches (tol=0):") + print(f" {'pair':<28} {'A-only':>10} {'B-only':>10} {'total':>10}") + for (a, b), acc in pairs.items(): + ref = max(totals[a], totals[b], 1) + pct = 100.0 * acc["mismatch"] / ref + print(f" {a+' vs '+b:<28} {acc['a_only']:>10,} " + f"{acc['b_only']:>10,} {acc['mismatch']:>10,} ({pct:.4f}%)") + + +def walkthrough(show, data, rx, ry, rows, cols, n_sigma, pick=0, + labels=('A', 'B')): + """Manual Test1/Test3 recompute of the strongest residual mismatch. + + Dissects ``show[pick]`` (from :func:`scan_mismatches`, run as ``(a, b)``) + under each finder's decision-time snapshot pedestal — ``a`` = ``ped_cpu`` / + ``noise_cpu``, ``b`` = ``ped_cu`` / ``noise_cu`` — and prints the raw and + pedestal-subtracted window plus the accept/reject each finder reaches. With + the double/double build the recompute reproduces the kernel exactly, so a + lone surviving mismatch (e.g. the single 7x7 residual) is fully explained: + the test that flips (Test1/Test3) and the pedestal gap name the cause. + """ + if not show: + print("No residual mismatches to walk through.") + return + e = show[pick] + sx, sy = 2 * rx + 1, 2 * ry + 1 + c3 = np.sqrt(sx * sy) + frame = data[e['fid']].astype(np.float64) + sub_a = frame - e['ped_cpu'] + sub_b = frame - e['ped_cu'] + + # strongest mismatch pixel whose full window stays inside the frame + cand = [p for p in e['mism'] + if rx <= p[0] < cols - rx and ry <= p[1] < rows - ry] + if not cand: + print(f"frame {e['fid']}: all mismatches on the border — pick another.") + return + X0, Y0 = max(cand, key=lambda p: max(sub_a[p[1], p[0]], sub_b[p[1], p[0]])) + + def evaluate(mean, rms_img): + sig = (frame[Y0 - ry:Y0 + ry + 1, X0 - rx:X0 + rx + 1] + - mean[Y0 - ry:Y0 + ry + 1, X0 - rx:X0 + rx + 1]) + value = frame[Y0, X0] - mean[Y0, X0] + rms = rms_img[Y0, X0] + thr1, thr3 = n_sigma * rms, c3 * n_sigma * rms + mx, total = sig.max(), sig.sum() + localmax = bool(value >= mx) + t1, t3 = bool(mx > thr1), bool(total > thr3) + accept = bool(value >= -thr1) and localmax and (t1 or t3) + return dict(sig=sig, value=value, rms=rms, thr1=thr1, thr3=thr3, + mx=mx, total=total, localmax=localmax, t1=t1, t3=t3, + accept=accept) + + la, lb = labels + owner = la if (X0, Y0) in e['cpu_c'] else lb + print(f"frame {e['fid']} centre (x={X0}, y={Y0}) accepted only by {owner}") + print("raw window (ADU):") + print(np.array2string(frame[Y0 - ry:Y0 + ry + 1, + X0 - rx:X0 + rx + 1].astype(int))) + print() + + ra = evaluate(e['ped_cpu'], e['noise_cpu']) + rb = evaluate(e['ped_cu'], e['noise_cu']) + + def detail(tag, r): + print(f"--- {tag} ---") + print(" subtracted window:") + print(" ", np.array2string(r['sig'], precision=1, prefix=' ')) + print(f" centre value = {float(r['value']):8.2f} " + f"(local max? {r['localmax']})") + print(f" max = {float(r['mx']):8.2f} " + f"total = {float(r['total']):8.2f}") + print(f" rms(centre) = {float(r['rms']):8.3f}") + print(f" Test1: max > {n_sigma}*rms = {float(r['thr1']):8.2f} -> {r['t1']}") + print(f" Test3: total > {c3:.0f}*{n_sigma}*rms = {float(r['thr3']):8.2f} -> {r['t3']}") + print(f" ACCEPT = {r['accept']}") + print() + + detail(la, ra) + detail(lb, rb) + print(f"RESULT: {la} = {'ACCEPT' if ra['accept'] else 'reject'} , " + f"{lb} = {'ACCEPT' if rb['accept'] else 'reject'}") + gap = abs(float(e['ped_cpu'][Y0, X0] - e['ped_cu'][Y0, X0])) + rgap = abs(float(e['noise_cpu'][Y0, X0] - e['noise_cu'][Y0, X0])) + print(f"pedestal mean gap @centre = {gap:.4f} ADU; rms gap = {rgap:.4f}") + if ra['accept'] == rb['accept']: + print("NOTE: recompute agrees for this centre pixel — the split is FP " + "rounding right at threshold or a window-neighbour effect; " + "try another pick.") + + +def plot_masked_mismatch(show, data, rx, ry, rows, cols, + zoom=30, show_vals=True): + """Side-by-side masked view of each frame in ``show``. + + Cluster pixels are coloured by pedestal-subtracted value (value printed + when ``show_vals``); non-cluster pixels are white; a red dot marks every + cluster centre. The cut is centred on the strongest mismatch pixel of the + frame. No box, no tolerance discarding — a shifted twin in the other + finder stays visible. Returns the Figure. + """ + cmap = plt.cm.viridis.copy() + cmap.set_bad("white") + fig, axes = plt.subplots(len(show), 2, figsize=(11, 5.3 * len(show)), + squeeze=False) + for r, e in enumerate(show): + fid = e["fid"] + sub_cpu = data[fid].astype(np.float64) - e["ped_cpu"] + sub_cu = data[fid].astype(np.float64) - e["ped_cu"] + X0, Y0 = max(e["mism"], + key=lambda p: max(sub_cpu[p[1], p[0]], sub_cu[p[1], p[0]])) + half = zoom // 2 + r0, r1 = max(0, Y0 - half), min(rows, Y0 + half) + c0, c1 = max(0, X0 - half), min(cols, X0 + half) + win_cpu, win_cu = sub_cpu[r0:r1, c0:c1], sub_cu[r0:r1, c0:c1] + mask_cpu = footprint_mask(e["cpu_c"], sub_cpu.shape, rx, ry)[r0:r1, c0:c1] + mask_cu = footprint_mask(e["cu_c"], sub_cu.shape, rx, ry)[r0:r1, c0:c1] + union = mask_cpu | mask_cu + vmax = max(np.percentile(np.concatenate([win_cpu[union], win_cu[union]]), + 99) if union.any() else 50.0, 50.0) + + for ax, win, mask, cs, name in [ + (axes[r][0], win_cpu, mask_cpu, e["cpu_c"], "CPU"), + (axes[r][1], win_cu, mask_cu, e["cu_c"], "CUDA")]: + ax.imshow(np.ma.masked_where(~mask, win), cmap=cmap, vmin=0, + vmax=vmax, interpolation="nearest") + for (cx, cy) in cs: + if c0 <= cx < c1 and r0 <= cy < r1: + ax.plot(cx - c0, cy - r0, ".", color="red", ms=7) + if show_vals: + for i in range(win.shape[0]): + for j in range(win.shape[1]): + if mask[i, j]: + ax.text(j, i, f"{win[i, j]:.0f}", ha="center", + va="center", fontsize=6, + color="white" if win[i, j] < 0.55 * vmax + else "black") + ax.set_title(f"frame {fid} — {name}: {len(cs)} clusters", fontsize=10) + ax.set_xticks([]) + ax.set_yticks([]) + axes[r][0].set_ylabel(f"{e['score']} mismatches\nzoom @ ({X0},{Y0})", + fontsize=9) + plt.tight_layout() + plt.show() + return fig