leonarski_fandClaude Opus 5
7c10d62dab
It was multiplied into the per-reflection factor at prediction, so that factor held Lorentz, polarization and efficiency at once and the two spellings that reach a file - the wire key and the reflection dataset - meant something different from what they had meant the day before. The unmerged MTZ had to divide the two apart again at write time to fill its own columns, which is a good sign the wrong thing was being carried. Carry them separately. The prescaling factor is Lorentz and polarization again, what its name and both reference implementations mean by it, and the efficiency is its own field through prediction, integration, serialization and storage. Fifteen sites that want the total now multiply the two - once per reflection, not once per pixel. The efficiency is stored rather than recomputed on read, because the writer has no geometry to recompute it from, and because a file written before the correction existed would have had a radial trend invented for it. Sixty stored files were checked for the one combination that would be ambiguous - the old meaning of the factor beside a stored efficiency - and none carries it. Output does not move. Re-scaling a file written before the efficiency existed is byte-identical, which is a proof rather than a sample, since the stored factor is exactly one there. Where the efficiency is live, one product is reassociated - (L*Q)/P becomes (L/P)*Q - and about a third of the values differ in the last bit or two: every structural column is identical, so no reflection is gained, lost or reindexed, and no intensity in 1.4 million observations moves by as much as 1e-4 of its own sigma. The parity tests now compare the efficiency as well, and their non-vacuity guard watches it rather than the factor it left - which is the same guard that went blind when the efficiency was added to a field it was not watching. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EFEJG6WBQv8th4UJFNe53N
76 lines
3.2 KiB
C++
76 lines
3.2 KiB
C++
// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <optional>
|
|
#include <cmath>
|
|
|
|
#include "SpotToSave.h"
|
|
|
|
struct Reflection {
|
|
int32_t h;
|
|
int32_t k;
|
|
int32_t l;
|
|
float image_number; // Can be in-between for 3D integration
|
|
float delta_phi_deg; // phi angle from XDS - difference from middle of current frame (NOT an absolute angle)
|
|
float predicted_x;
|
|
float predicted_y;
|
|
float observed_x;
|
|
float observed_y;
|
|
float d;
|
|
float I;
|
|
float bkg;
|
|
float var_bkg; // non-signal (background) part of sigma^2, carried to the merge
|
|
float sigma;
|
|
float dist_ewald;
|
|
// The reciprocal Lorentz factor (rotation only - a still's Lorentz factor is one) times the
|
|
// reciprocal polarization factor, and nothing else. This is what LP means everywhere in the
|
|
// field, and it is what the CBOR key "rlp" and the HDF5 dataset "lp" store the reciprocal of.
|
|
// What it is not is a scale: the fitted per-image scale and the partiality stay out of it and
|
|
// are divided in separately below. (Named after DIALS's prescaling_correction.)
|
|
float prescaling_corr;
|
|
// The sensor's angle-dependent efficiency, QE(0)/QE(alpha): always <= 1, and exactly 1 where the
|
|
// sensor is opaque or its material and thickness are unknown. It is carried BESIDE
|
|
// prescaling_corr rather than inside it, because LP and detector response are two different
|
|
// things and every file the field reads keeps them apart. The total deterministic correction on
|
|
// a reflection is therefore prescaling_corr * qe_corr, and every site that corrects an intensity
|
|
// multiplies the two. Defaulted to 1 so a reflection read from a file written before this
|
|
// existed is a no-op rather than a zero.
|
|
float qe_corr = 1.0f;
|
|
float partiality; // fraction of the reflection recorded in the sampled (rocking) slice
|
|
float zeta;
|
|
float image_scale_corr; // I_true = image_scale_corr * I; = prescaling_corr * qe_corr / (partiality * image_scale)
|
|
bool observed = false;
|
|
bool on_ice_ring = false; // sits on a hexagonal-ice powder ring: excluded from scaling, kept for merging
|
|
};
|
|
|
|
struct MergedReflection {
|
|
int32_t h = 0;
|
|
int32_t k = 0;
|
|
int32_t l = 0;
|
|
float I = NAN;
|
|
float sigma = NAN;
|
|
float I_half[2] = {NAN, NAN};
|
|
float sigma_half[2] = {NAN, NAN};
|
|
float d = 0.0;
|
|
bool rfree_flag = false;
|
|
float F = NAN; // French-Wilson amplitude |F| (filled by ApplyFrenchWilson at end of merge)
|
|
float sigmaF = NAN; // its sigma
|
|
// Anomalous (Bijvoet) split of this reflection's own observations, kept even when the merge is
|
|
// Friedel-averaged (I above is the Friedel mean). Lets I(+)/I(-) be written and CCano reported by
|
|
// default without scaling anomalously; NaN when a hand was not measured or for centrics.
|
|
float I_plus = NAN;
|
|
float sigma_plus = NAN;
|
|
float I_minus = NAN;
|
|
float sigma_minus = NAN;
|
|
// French-Wilson amplitudes of the two hands (filled by ApplyFrenchWilson from I_plus/I_minus).
|
|
float F_plus = NAN;
|
|
float sigmaF_plus = NAN;
|
|
float F_minus = NAN;
|
|
float sigmaF_minus = NAN;
|
|
};
|
|
|
|
|