leonarski_fandClaude Opus 5.5
f849e2d1be
The two pre-scan steps that were still CPU-bound in a GPU build now run where the projection already is. - FindBeamCenterFromBackground: the per-iteration binning pass and the two clip rounds run on the device (BeamCenterBackgroundGPU); the fit itself stays on the host. Each cell is summed in the host's order (pixel order within the host's row blocks, blocks in order), and the per-pixel cell/derivative formula is shared (BackgroundBand.h). The angles come from BackgroundAtan2 (IEEE ops only) instead of atan2f, and both translation units are compiled without FMA contraction, so host and device give the same bits: 0 of 6.5 M pixels in a different cell, identical walks on the three in-house rotation sets. With glibc/CUDA atan2f and default contraction ~30 pixels per 16 Mpx sweep changed cell and the fitted centre moved by up to 0.05 px. - ShadowFinder::GetMask: the whole mask (pooling, ring medians, components, morphology, hole fill, arm search) runs on the device from ShadowAccumulatorGPU's projection (ShadowMaskGPU), so the 360 MB projection no longer comes back; the mean projection is divided on the device too (same bits). The two small fits over rings and sectors (BlockedOutTo, HarmonicFit) are shared with the host path in ShadowFinderInternal.h. Integers, comparisons, sorts and components are exact; the polarization trig, the Poisson log and the arm-search azimuth are not, so a pixel at a threshold can differ. The one-time change against the previous CPU arithmetic (BackgroundAtan2, no contraction), measured on the myoglobin, cytochrome C and thaumatin rotation sets: ring centre moves 0.002-0.045 px (fit sigma 0.75-1.2 px), beam-centre capture 0.01-0.04 px; beam-stop mask differs on 31 / 144 / 53 pixels of 259k / 144k / 198k (25 of the myoglobin ones are GPU-vs-CPU arithmetic in the mask, the rest follow the centre); hot-pixel mask identical. Spot width, integration radii, bandwidth, beam-centre arbitration, indexing, space group, cell, resolution and the merged statistics table are identical; only the error model moves in its 4th digit. CPU build: the same centres and decisions. Timing (GPU, box at load 30-38): ring walk 0.54 -> 0.23-0.27 s, mask 1.24-1.44 -> 0.18-0.22 s, beam-centre capture walk 1.1-1.3 -> 0.31-0.35 s. Tests: ShadowFinder_DeviceMaskMatchesHost, BeamCenterFromBackground_DeviceMatchesHost (bit-exact), plus [ShadowFinder], [BeamCenter], [HotPixelFinder]. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K5K8jvPPbmCrbqnWkddTuB
91 lines
4.8 KiB
C++
91 lines
4.8 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
// What ShadowFinder::GetMask shares with its device twin (ShadowMaskGPU): the constants it tests
|
|
// against, and the two small fits made over whole rings and sectors, which stay on the host on both
|
|
// paths.
|
|
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
namespace shadow_finder {
|
|
|
|
// The values of ShadowFinder::SHADOW and ShadowFinder::TRANSMITTING, for the device code, which does
|
|
// not include ShadowFinder.h.
|
|
inline constexpr uint32_t MASK_SHADOW = 1;
|
|
inline constexpr uint32_t MASK_TRANSMITTING = 2;
|
|
|
|
// A pixel is shadow when its background is below this fraction of the background it is
|
|
// compared against.
|
|
inline constexpr float SHADOW_RATIO = 0.50f;
|
|
|
|
// The boundary grows outward into partially shadowed pixels down to this fraction, but no
|
|
// further than PENUMBRA_MAX_PX from the core. A pin or a loop casts a wide half-shadow, so the
|
|
// reach is a good deal more than the beam stop's own edge needs.
|
|
inline constexpr float PENUMBRA_RATIO = 0.75f;
|
|
inline constexpr int PENUMBRA_MAX_PX = 30;
|
|
|
|
// Bridge small breaks along the holder arm. A module gap wider than this is bridged separately for
|
|
// the arm search (see bridge_gaps).
|
|
inline constexpr int BRIDGE_PX = 6;
|
|
|
|
// A pixel whose maximum reaches this recorded a real reflection and is never masked - a
|
|
// beam stop cannot block a reflection that was measured.
|
|
inline constexpr int64_t MIN_REFLECTION = 25;
|
|
|
|
// How far below the background it is compared against a pixel must sit before the dip is
|
|
// believed, in standard deviations of the counts that back it. The counts are photons, so their
|
|
// scatter is Poisson and the deficit is measured against it rather than against a fixed number:
|
|
// on a well-exposed sweep a third of the background missing is overwhelming, and on a handful of
|
|
// low-background frames the same third is noise. Without this a six-frame pre-scan of a
|
|
// low-background sweep masks three quarters of the detector.
|
|
inline constexpr double MIN_DEFICIT_SIGMA = 6.0;
|
|
|
|
// Smallest region the per-pixel test may return. A shadow is cast by something physical and is
|
|
// correspondingly large; an isolated patch this small is the background wandering, not hardware.
|
|
// This is what keeps the test specific now that a shadow no longer has to touch the direct beam.
|
|
inline constexpr int MIN_SHADOW_PIXELS = 2000;
|
|
|
|
// ... and of those, how many must be deep (below SHADOW_RATIO) for a region of merely DIM pixels -
|
|
// hardware that lets part of the beam through - to count. A thin holder arm is dim along most of
|
|
// its length and deep in places; the background drifting over a detector's edge is dim everywhere
|
|
// and deep nowhere.
|
|
inline constexpr int MIN_CORE_PIXELS = 200;
|
|
|
|
// The arm search compares a pixel with its ring as the ring actually varies around the beam. A ring
|
|
// of background is not flat once divided by the polarization factor when that factor is not the
|
|
// beam's: the remainder is a second harmonic in azimuth, cos 2phi, which reaches tens of percent at
|
|
// high angle. It is measured over radial bands of HARMONIC_BAND_PX, from the median of each of
|
|
// HARMONIC_SECTORS sectors that holds at least MIN_SECTOR_PIXELS pixels.
|
|
inline constexpr int HARMONIC_BAND_PX = 64;
|
|
inline constexpr int HARMONIC_SECTORS = 24;
|
|
inline constexpr int MIN_SECTOR_PIXELS = 200;
|
|
|
|
// Side of the box the background is pooled over before testing. Its area is how many pixels back
|
|
// a ring's countability test, which decides where an azimuthal comparison is possible at all.
|
|
inline constexpr int POOL_PX = 5;
|
|
inline constexpr double MEAN_POOLED_PIXELS = POOL_PX * POOL_PX;
|
|
|
|
// A ring with fewer valid pixels than this says nothing about whether it was counted.
|
|
inline constexpr int MIN_RING_PIXELS = 32;
|
|
|
|
// A ring lies wholly inside the stop when its background is below this fraction of the background
|
|
// further out. This asks about a whole ring rather than about a pixel, so it keeps a threshold of
|
|
// its own and does not follow SHADOW_RATIO.
|
|
inline constexpr float BLOCKED_RING_RATIO = 0.35f;
|
|
|
|
// The rings that lie wholly inside the stop: walking outward, every judgeable ring (at least
|
|
// MIN_RING_PIXELS pixels) before the first whose baseline reaches BLOCKED_RING_RATIO of the typical
|
|
// background. -1 when there is none. See GetMask.
|
|
int BlockedOutTo(const std::vector<float> &baseline, const std::vector<int> &ring_pixels);
|
|
|
|
// The second harmonic in azimuth of each radial band, relative to its level, fitted to the medians of
|
|
// its HARMONIC_SECTORS sectors (sector_median[band * HARMONIC_SECTORS + k], negative where the sector
|
|
// has too few pixels). See GetMask.
|
|
void HarmonicFit(const std::vector<double> §or_median, int n_bands,
|
|
std::vector<float> &harm_c, std::vector<float> &harm_s);
|
|
|
|
} // namespace shadow_finder
|