integration: the background is fitted over the ring that survives, not averaged over it

The signal disk and the background ring are concentric, which is the whole reason a linear
background cancels between them. Within the outer ring radius of the edge of the sensor array
that concentricity is gone: the ring loses its outer part while the disk barely loses anything,
so what is left of the ring sits further into the detector, where the radial background is
higher, and the reflection reads low.

Measured at signal-free positions four pixels from a border: the ring reads 162.35 counts per
pixel against a true background over the disk of 160.57, which over a hundred disk pixels is 182
counts of deficit, against 216 to 239 observed. <I/sigma> runs -1.83, -2.34 and -1.18 at nought
to three, three to six and six to nine pixels from the border, and recovers exactly at the outer
ring radius. The same reflection measured at a border reads 179 counts lower than in the
interior over seven thousand matched pairs.

A masked module gap does the same thing but signed by the direction of the displacement, which is
why nothing has caught this: at a gap the two populations cancel in the mean, while at the sensor
border the truncation is always inward, so the bias is always negative.

The background is now the intercept of a straight line in radial offset over whatever ring pixels
survive, read at the reflection's centre. Three extra sums per ring pixel and no extra reads; the
radial distance was already computed there. It is exact under any truncation and reduces to the
mean when the ring is whole, so it is unconditional rather than a mode: a badly truncated ring
pays in sigma, through the variance the fit honestly reports, rather than in a rejection.

On the crystal where this surfaced the outermost shell's correlation with a deposited model goes
from -0.234 to +0.004, and the shell above it from -0.091 to +0.179. Correcting beats discarding:
dropping every observation within fifteen pixels of a border reached only -0.019 and +0.127,
because the corrected observations still carry signal. Interior reflections do not move.

The cost is one geometry: where a neighbour mask has already truncated the ring almost everywhere,
the fit roughly doubles the variance of the background estimate while finding no gradient worth
removing, and a crowded small detector loses one to two points of CC1/2 in its finest shells.

Also: the MINPK denominator counted only profile mass that lands on the detector, so a reflection
whose peak is off the sensor scored a perfect one and no guard could fire.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EFEJG6WBQv8th4UJFNe53N

tests/BraggIntegrationEngineGPUTest.cpp

@@ -45,17 +45,26 @@ Reflection MakeReflection(float x, float y, float d, int hkl) {
 // centre of every 5th, a mid-profile pixel of every 7th and a disk-edge pixel of every 11th. That is
 // the MINPK rescue's own case - a reflection kept and fitted over the pixels it has - and with it the
 // peak-loss rule, which has to fire on the same reflections in both engines.
+// border > 0 puts a radial background ramp of that many counts per pixel of radius under the scene
+// and moves the spot grid onto the edges of the array, so the r2..r3 ring of the outermost spots is
+// truncated by the boundary. That is the case the radial-linear background fit exists for, and the
+// two engines have to fit the same line over the pixels each of them kept.
 Scene BuildScene(size_t width, size_t height, int spacing = 60, float companion_dx = 0.0f,
-                 bool clip_spots = false) {
+                 bool clip_spots = false, float border = 0.0f) {
     Scene s;
     s.width = width;
     s.height = height;
     s.image.assign(width * height, 12);   // flat background
+    if (border > 0.0f)
+        for (size_t y = 0; y < height; ++y)
+            for (size_t x = 0; x < width; ++x)
+                s.image[y * width + x] = 200 + static_cast<int32_t>(std::lround(
+                        border * std::hypot(static_cast<double>(x) - 400.0, static_cast<double>(y) - 400.0)));
 
     // A grid of spots, well separated so background rings do not overlap the neighbours' disks.
     // A spread of intensities (some weak, some very strong) and a spread of d (so several resolution
     // shells are populated) exercises the strong-spot selection, shell learning and the fit.
-    const int margin = 45;
+    const int margin = border > 0.0f ? 3 : 45;
     int hkl = 1;
     for (int gy = 0; margin + gy * spacing < static_cast<int>(height) - margin; ++gy) {
         for (int gx = 0; margin + gx * spacing < static_cast<int>(width) - margin; ++gx) {
@@ -145,7 +154,7 @@ void CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
                      float stencil_k = 0.0f,
                      float r1 = 0.0f, float r2 = 0.0f, float r3 = 0.0f,
                      OverlapMode overlap = OverlapMode::Off, float companion_dx = 0.0f,
-                     bool clip_spots = false) {
+                     bool clip_spots = false, float border = 0.0f) {
     const DiffractionExperiment experiment =
             MakeExperiment(mode, bandwidth_fwhm, clip_nsigma, radial, DetJF(2), stencil_k, r1, r2, r3,
                            overlap);
@@ -154,7 +163,7 @@ void CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
     const size_t npixel = experiment.GetPixelsNum();
     REQUIRE(npixel == width * height);
 
-    const Scene scene = BuildScene(width, height, spacing, companion_dx, clip_spots);
+    const Scene scene = BuildScene(width, height, spacing, companion_dx, clip_spots, border);
     REQUIRE(scene.image.size() == npixel);
     REQUIRE(scene.predicted.size() > 60);
 
@@ -183,7 +192,7 @@ void CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
     if (clip_spots) {
         // Guard against the coverage going vacuous: the punched pixels have to actually cost some
         // reflections, or the two engines are being compared on a case neither of them meets.
-        const Scene clean_scene = BuildScene(width, height, spacing, companion_dx, false);
+        const Scene clean_scene = BuildScene(width, height, spacing, companion_dx, false, border);
         ImagePreprocessorBuffer clean_image(npixel);
         for (size_t i = 0; i < npixel; ++i)
             clean_image[i] = clean_scene.image[i];
@@ -293,6 +302,22 @@ TEST_CASE("BraggIntegrationEngineGPU_MatchesCPU") {
         CompareCpuVsGpu(IntegratorMode::BoxSum, std::nullopt, 4.0f, false, 60, 0.0f,
                         0.0f, 0.0f, 0.0f, OverlapMode::Off, 0.0f, true);
     }
+    // Spots on the edges of the array under a radial background ramp: their background rings are
+    // truncated by the boundary, so the radial-linear fit that replaces the ring mean has a different
+    // pixel set - and a different line - for every one of them. The clip and the trim select that
+    // pixel set differently in the two engines, so both estimators need the case.
+    SECTION("ProfileGaussian border gradient") {
+        CompareCpuVsGpu(IntegratorMode::ProfileGaussian, std::nullopt, 4.0f, false, 60, 0.0f,
+                        0.0f, 0.0f, 0.0f, OverlapMode::Off, 0.0f, false, 2.0f);
+    }
+    SECTION("BoxSum border gradient") {
+        CompareCpuVsGpu(IntegratorMode::BoxSum, std::nullopt, 4.0f, false, 60, 0.0f,
+                        0.0f, 0.0f, 0.0f, OverlapMode::Off, 0.0f, false, 2.0f);
+    }
+    SECTION("ProfileGaussian border gradient trim") {
+        CompareCpuVsGpu(IntegratorMode::ProfileGaussian, std::nullopt, 0.0f, false, 60, 0.0f,
+                        0.0f, 0.0f, 0.0f, OverlapMode::Off, 0.0f, false, 2.0f);
+    }
     // The radial background curvature correction is computed independently in the two engines
     // (host loop vs radial_correct kernel), so it needs its own parity coverage.
     SECTION("BoxSum radial")             { CompareCpuVsGpu(IntegratorMode::BoxSum, std::nullopt, 4.0f, true); }