leonarski_fandClaude Opus 5
14e2bf3c0f
Both lanes added a per-image scalar to the same eleven files, so every conflict was two
additions competing for one line. All were resolved by keeping both, with three that needed
more than that:
- ScanResultGenerator: rc167 changed the per-image float vectors to resize(n, NAN) so a frame
that never arrived does not read back as a real 0. v_protein_score and v_ice_score are exactly
that case - 0 is a real answer ("nothing detected here") - so they take the NAN default too.
- HDF5MetadataSource: rc167 established that NaN in a stored per-image array means "no value" and
the optional must come back absent. The two detection scores now follow it, which they did not
before the merge; without the guard a missing score would come back as a NaN that a threshold
would silently compare against.
- CBORTest: designated initialisers must follow member declaration order, so spindle_blind_fraction
precedes the two scores in the DataMessage aggregate.
Verified after the merge that every CBOR key that is encoded is also decoded (198 encoded keys,
one intentional exception: the "type" discriminator), that both lanes' fields survive in the
writer, the reader, the plots and the API, and that a stored file still round-trips.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EFEJG6WBQv8th4UJFNe53N
116 lines
5.1 KiB
C++
116 lines
5.1 KiB
C++
// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <string>
|
|
#include <array>
|
|
#include <optional>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <memory>
|
|
|
|
#include "../common/DiffractionGeometry.h"
|
|
#include "../common/DiffractionExperiment.h"
|
|
#include "../common/PixelMask.h"
|
|
#include "../common/AzimuthalIntegrationMapping.h"
|
|
|
|
struct JFJochReaderDataset {
|
|
std::string arm_date;
|
|
|
|
DiffractionExperiment experiment;
|
|
// Shared, not copied, across dataset snapshots: the mask is constant for a run, so a per-frame
|
|
// dataset refresh / mutable copy must not clone the full-detector (~tens of MB) mask. Held as
|
|
// shared_ptr<const>; the rare edit (user mask) builds a fresh mask (copy-on-write). Never null.
|
|
std::shared_ptr<const PixelMask> pixel_mask = std::make_shared<const PixelMask>();
|
|
|
|
std::optional<int64_t> error_value;
|
|
|
|
// The master file's detect_ice_rings key, kept as written rather than collapsed to a bool, so a
|
|
// consumer can tell "the file asked for this" from "the file said nothing". Offline processing
|
|
// defaults ice handling by geometry when the file is silent (see rugnux_cli).
|
|
std::optional<bool> file_detect_ice_rings;
|
|
|
|
std::string jfjoch_release;
|
|
|
|
// Change of basis (3x3 integers, row major) from the setting the per-image reflections and
|
|
// lattices in this file were written in to the setting of experiment's unit cell and space group:
|
|
// hkl_cell = M . hkl_written. The per-image data are written as each image is processed, but the
|
|
// space group - and the conventional setting that comes with it - is only settled after the merge,
|
|
// so the two are not always the same setting. Empty means they are. Read straight from
|
|
// /entry/MX/reindexMatrix; the reader applies it, so everything this class hands out is already in
|
|
// the cell's setting.
|
|
std::optional<std::array<int32_t, 9>> reindex_matrix;
|
|
|
|
std::vector<float> az_int_bin_to_q;
|
|
std::vector<float> az_int_bin_to_phi;
|
|
size_t azimuthal_bins = 0;
|
|
size_t q_bins = 0;
|
|
|
|
std::vector<float> spot_count;
|
|
std::vector<float> spot_count_indexed;
|
|
std::vector<float> spot_count_low_res;
|
|
std::vector<float> spot_count_ice_rings;
|
|
std::vector<float> spot_count_ice_control;
|
|
|
|
std::vector<float> indexing_result;
|
|
std::vector<float> indexing_lattice_count;
|
|
std::vector<float> bkg_estimate;
|
|
// NaN entries are frames with no value (CANNOT SAY), not zeros.
|
|
std::vector<float> spindle_blind_fraction;
|
|
std::vector<float> ice_ring_score;
|
|
// The two per-image detection scores, in [0,1] and saturating: is there protein diffraction on
|
|
// this image, and is there crystalline ice. From /entry/MX/proteinScore and /entry/MX/iceScore;
|
|
// empty when the file predates them. score_beam_center_x/y is the beam centre they were computed
|
|
// with, which is NOT necessarily the refined one the geometry above carries.
|
|
std::vector<float> protein_score;
|
|
std::vector<float> ice_score;
|
|
std::optional<float> score_beam_center_x;
|
|
std::optional<float> score_beam_center_y;
|
|
std::vector<float> resolution_estimate;
|
|
std::vector<float> efficiency;
|
|
std::vector<float> profile_radius;
|
|
std::vector<float> mosaicity_deg;
|
|
std::vector<float> b_factor;
|
|
std::vector<float> integrated_reflections;
|
|
std::vector<float> image_scale_factor;
|
|
std::vector<float> image_scale_cc;
|
|
std::vector<int64_t> max_value;
|
|
|
|
// Per-image sweep-quality code from /entry/MX/sweepQuality: 0 = the image is in no flagged range,
|
|
// otherwise a 1-based index into sweep_quality_reasons (the vocabulary stored beside it, so the
|
|
// codes read back without this source). Both empty when the file carries no sweep quality, which
|
|
// means the run never looked - not that every image was clean.
|
|
std::vector<uint8_t> sweep_quality;
|
|
std::vector<std::string> sweep_quality_reasons;
|
|
|
|
// Maps this dataset's image index -> the original/collected image number it came from.
|
|
// Empty means identity (image i == original image i). Lets a dataset be a subset (or strided
|
|
// selection) of the truly collected images: reprocessing snapshots over a sub-range, and (in
|
|
// future) a main dataset that was filtered on-the-fly during collection.
|
|
std::vector<int> source_image_number;
|
|
|
|
std::vector<std::string> roi;
|
|
std::vector<std::vector<int64_t>> roi_sum;
|
|
std::vector<std::vector<int64_t>> roi_sum_sq;
|
|
std::vector<std::vector<int64_t>> roi_max;
|
|
std::vector<std::vector<int64_t>> roi_npixel;
|
|
std::vector<std::vector<float>> roi_x;
|
|
std::vector<std::vector<float>> roi_y;
|
|
|
|
// ROI definitions stored in the master file. The logical definitions populate
|
|
// experiment.ROI() (they re-derive with the current geometry); roi_map is the
|
|
// per-pixel bitmask as written (constant footprint), with roi_bit_index mapping
|
|
// each ROI name to its bit.
|
|
std::vector<uint16_t> roi_map;
|
|
std::map<std::string, uint16_t> roi_bit_index;
|
|
|
|
std::vector<std::string> calibration_data;
|
|
|
|
JFJochReaderDataset() = default;
|
|
JFJochReaderDataset(const JFJochReaderDataset &other) = default;
|
|
};
|
|
|
|
|
|
|