v1.0.0-rc.166 (#76)

* `rugnux --mode calibration` writes `<prefix>.json` beside the `.poni`, whose `dataset_settings` member is a `jfjoch_broker` `dataset_settings` body as it stands.
* `rugnux` and `jfjoch_viewer` read PILATUS miniCBF sweeps natively, without conversion.
* Masters written by other facilities open, including Eiger 1.x and third-party NXmx variants.
* `rugnux` measures the beam centre on every run, and indexes with it when the file's value indexes nothing.
* A detector swung out on a 2theta arm is placed where the file says it stands, and the calibration can hold the tilt fixed.
* `rugnux` writes the unmerged MTZ by default, and a P1 merge beside it, so a wrong space group can be re-merged without reprocessing.
* Significant improvements to symmetry handling in `rugnux`: the lattice, the point group, the setting and the systematic absences.
* The `rugnux` report gives the resolution the CC1/2 fit reached, beside the range the reflections were written to.
* The `rugnux` report gives the twinning statistics measured before the space group was decided, beside the ones measured after.
* The `rugnux` report gives the strong-direction diffraction limit, and warns when CC1/2 is not monotone with resolution.
* `rugnux` ranks screw axes on the evidence their absences carry, rather than on how many control reflections a candidate happens to have.
* Twinning is no longer reported when the L-test contradicts it.
* The `rugnux` report gives the detector tilt, the measured tilt and the direct beam beside the beam centre, and a post-refined beam centre is judged against the run's own measurement rather than the file's.
* `--no-refine-tilt` holds the detector tilt at the value in the file, instead of zeroing it, when the calibration starts from the spots.
* The `jfjoch_viewer` grid scan view draws the cells in the proportion of the scan steps, so the map has the shape of the scanned area.

Reviewed-on: #76
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

image_analysis/bragg_integration/BraggIntegrationEngineCPU.cpp

@@ -164,6 +164,7 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
         out.k_bin = BraggStencilKernelIndex(st, n_kern);
 
         int64_t I_sum = 0, I_sum_x = 0, I_sum_y = 0, n_inner = 0, n_inner_valid = 0;
+        int64_t x_sum = 0, y_sum = 0;   // positions of the pixels behind I_sum, for the centroid
         int n_disk = 0, n_own = 0;   // pixels in the signal disk, and how many are this reflection's
         double bkg_sum = 0.0;
         int n_bkg = 0;
@@ -192,6 +193,10 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
                     I_sum += px;
                     I_sum_x += static_cast<int64_t>(x) * px;
                     I_sum_y += static_cast<int64_t>(y) * px;
+                    // Position sums over the very same pixels, so the background can be taken out of
+                    // the centroid below. It is not known yet - the ring is read in this same loop.
+                    x_sum += x;
+                    y_sum += y;
                     ++n_inner_valid;
                 } else if (d.inner >= r2_sq && d.outer < r3_sq) {
                     if (refl_mask[y * W + x]) { ++n_bkg_neighbour; continue; }
@@ -283,8 +288,23 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
             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);
-                out.obs_y = static_cast<double>(I_sum_y) / static_cast<double>(I_sum);
+                // The centroid of the SIGNAL, not of the disk. Weighting by the raw counts weights by
+                // signal plus background, and the background is flat over a disk centred on the
+                // PREDICTION - so its own centroid is the prediction exactly, and it pulls the answer
+                // there. The measured displacement comes out shrunk by I/(I + n*bkg), which is worst
+                // where the background dominates, i.e. at high resolution. Post-refinement fits the
+                // beam and the distance on these centroids, so it under-corrects by that factor and
+                // does so resolution-dependently. Subtracting a flat pedestal from a first moment is
+                // exact: sum(x*(px-bkg)) = I_sum_x - bkg*x_sum over the same pixels.
+                const double net = static_cast<double>(I_sum) - n_inner_valid * out.bkg;
+                if (net > 0.0) {
+                    out.obs_x = (static_cast<double>(I_sum_x) - out.bkg * x_sum) / net;
+                    out.obs_y = (static_cast<double>(I_sum_y) - out.bkg * y_sum) / net;
+                } else {
+                    // Nothing above background to take a centroid of; the raw one is all there is.
+                    out.obs_x = static_cast<double>(I_sum_x) / static_cast<double>(I_sum);
+                    out.obs_y = static_cast<double>(I_sum_y) / static_cast<double>(I_sum);
+                }
                 // A disk with a hole in it gives a centroid pulled away from the hole, and the hole
                 // sits at a fixed place on the detector - post-refinement would read that as geometry.
                 out.has_obs = full;