Bragg integration: drop the 2% sigma floor and carry the background variance

Two changes to the same variance chain; they are in one commit because the second
exists to remove an assumption the first was breaking, and separating them leaves a
tree that is correct only by luck.

The reported sigma was floored at 2% of the intensity, a per-partial I/sigma cap of
50. It applied only to the box-sum seed, never to the profile fit, so the shipped
default was unaffected - but the combine back-derives each partial's non-signal
variance as sigma^2 - I, and a floored sigma makes that quantity mean nothing. It
then read corr^2 * (0.0004 I^2 - I), which is not a background variance. Measured on
--integrator boxsum: the reported sigma understated the true scatter by up to 16x at
I ~ 21000 counts per partial, and pooled_I amplified a 1 ct/px background drift into
an 11.5% intensity error on the strongest reflections.

What the floor stood in for - that at high intensity the error is systematic rather
than counting - is already carried downstream, twice: the fitted b in
v = a*sigma^2 + (b*I)^2, measured from the data rather than assumed, and
SigmaWithSystematicFloor on the merged sigma. The floor was that idea applied one
level too early with a hardcoded b of 0.02. It arrived without a test or a setter and
was unreachable from the CLI, the API and the config.

The merge now takes the non-signal variance the integrator actually measured instead
of inverting sigma^2 = I + N. That identity is exact for a box sum once the floor is
gone and was never exact for a profile fit, whose sigma^2 = 1/den + (wsum/den)^2 *
bkg_var is formed against a fitted intensity. The value is carried through
BraggFitResult, Reflection and Obs, both engines, both merges, and the process-file
round trip; files written before this change are read with the term absent, which is
what they had.

Battery, 37 crystals, paired: space groups unchanged, reflection sets unchanged,
median delta zero on R_meas and CC1/2. --integrator boxsum on the reference crystal
goes ISa 8.9 -> 20.2 with a 0.947 -> 1.032.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

image_analysis/bragg_integration/BraggIntegrationEngineCPU.cpp

@@ -86,6 +86,7 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
     struct Rough {
         double I = 0.0, sigma = NAN, bkg = 0.0, obs_x = 0.0, obs_y = 0.0;
         double bkg_var = 0.0;   // variance of the background ESTIMATE itself, bkg / n_bkg
+        double var_bkg = 0.0;   // total non-signal variance carried to the merge
         int64_t I_sum = 0;      // kept so I can be rebuilt after the radial background correction
         int n_inner = 0;
         int r_bin = 0;          // rounded distance from the beam centre, indexes the radial curve
@@ -194,10 +195,12 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
             // the second term out understates sigma by sqrt(1 + n_inner/n_bkg) - 1.109x at the
             // default r1=4/r2=6/r3=10 stencil, on every reflection of every dataset.
             out.bkg_var = out.bkg / n_bkg_used;
+            out.var_bkg = static_cast<double>(n_inner) * out.bkg
+                          + static_cast<double>(n_inner) * n_inner * out.bkg_var;
             out.I_sum = I_sum;
             out.n_inner = static_cast<int>(n_inner);
             const double var_bkg_term = static_cast<double>(n_inner) * n_inner * out.bkg_var;
-            out.sigma = std::max(1.0, out.I * min_sigma_ratio);
+            out.sigma = 1.0;
             if (I_sum > 0) {
                 out.sigma = std::max(out.sigma, std::sqrt(static_cast<double>(I_sum) + var_bkg_term));
                 out.obs_x = static_cast<double>(I_sum_x) / static_cast<double>(I_sum);
@@ -244,7 +247,8 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
             const auto &rh = rough[i];
             if (!rh.ok) continue;
             results[i] = {static_cast<float>(rh.I), static_cast<float>(rh.sigma), static_cast<float>(rh.bkg),
-                          static_cast<float>(rh.obs_x), static_cast<float>(rh.obs_y), true, rh.has_obs};
+                          static_cast<float>(rh.obs_x), static_cast<float>(rh.obs_y),
+                          static_cast<float>(rh.var_bkg), true, rh.has_obs};
         }
         return Finalize(predicted, npredicted, results, image_number);
     }
@@ -409,15 +413,19 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
         // I = sum(P*(px-bkg)/v) / sum(P^2/v), so dI/dbkg = -wsum/den and the background estimate's
         // own error adds (wsum/den)^2 * var(bkg) - the same term the box sum was missing.
         double sigma = std::sqrt(1.0 / den + (wsum / den) * (wsum / den) * rh.bkg_var);
+        double var_bkg = std::max(0.0, 1.0 / den - std::max(0.0, I)
+                                       + (wsum / den) * (wsum / den) * rh.bkg_var);
         if (std::abs(I - rh.I) > PROFILE_SUMMATION_MAX_NSIGMA * rh.sigma) {
             I = rh.I;
             sigma = rh.sigma;
+            var_bkg = rh.var_bkg;
         }
         // Carry the Pass-A box-sum intensity-weighted centroid (observed spot position) through the
         // profile path too - post-refinement uses it as the observed position (beam-centre / distance).
         results[i] = {static_cast<float>(I), static_cast<float>(sigma),
                       static_cast<float>(rh.bkg),
-                      static_cast<float>(rh.obs_x), static_cast<float>(rh.obs_y), true, rh.has_obs};
+                      static_cast<float>(rh.obs_x), static_cast<float>(rh.obs_y),
+                      static_cast<float>(var_bkg), true, rh.has_obs};
     }
 
     return Finalize(predicted, npredicted, results, image_number);