Files
Jungfraujoch/reader/JFJochReaderDataset.h
leonarski_fandClaude Opus 5.5 7bc98279a9 rugnux: image counts per stage and a per-image merged vector
The report now states how many images made it through each stage, as
counts beside the indexing rate: IMAGES_INDEXED and LATTICES_INDEXED
(section 2; a stills measure, --developer on rotation like
INDEXING_RATE), IMAGES_INTEGRATED (section 2) and IMAGES_MERGED
(section 3), plus an "Images" summary line and a console line. An image
is integrated on its main lattice only - extra lattices are indexed but
not integrated - so integrated images are also integrated lattices.

The merge records per image whether any of its observations reached
it (MergeStatistics::image_merged): on stills from MergeOnTheFly's
AddImages (past the cell form, scale and --min-image-cc), on rotation
from the disposition ledger (not rejected). It drives the merged column
of _plot.txt (which on stills used to be approximated by "has a scale"),
goes to the _process.h5 as /entry/MX/imageMerged (and through CBOR),
is read back by the reader, replaces MergedCrystals for --mode scale's
INPUT_nn rows, and --mode scale now writes a _plot.txt for its merge.
_plot.txt gains an indexed column at the end, so no column moves.

jfjoch_viewer's image list gets a Merged column and, from the Index and
Merged header context menus, Yes/No/N/A row filters that combine (e.g.
indexed but not merged); a file without imageMerged shows N/A.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HVeDQrPqZ52Tp6rzzZGxf3
2026-11-19 13:51:31 +01:00

127 lines
5.8 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/StillsRunWidth.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;
// The e.s.d.s of the experiment's unit cell, a b c alpha beta gamma (/entry/sample/unit_cell_esd); empty
// where the file has none.
std::optional<UnitCell> unit_cell_esd;
// Stills: the rocking curve the run's frames were predicted through (/entry/MX/stillsRockingWidth*).
std::optional<StillsRunWidth> stills_run_width;
// Stills: the cell the run was given, whose population of frames it merged (/entry/MX/stillsGivenUnitCell).
std::optional<UnitCell> stills_given_cell;
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> merge_result; // /entry/MX/imageMerged: 1 merged, 0 not; empty in a file without it
std::vector<float> indexing_lattice_count;
std::vector<float> bkg_estimate;
// The XFEL pulse ID and event code of each image (/entry/xfel), where the file records them.
std::vector<uint64_t> xfel_pulse_id;
std::vector<uint64_t> xfel_event_code;
// NaN entries are frames with no value (CANNOT SAY), not zeros.
std::vector<float> spindle_blind_fraction;
std::vector<float> ice_ring_score;
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;
std::vector<int64_t> pixel_sum;
// 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;
// Per-image disposition from /entry/MX/frameDisposition: a 0-based index into
// frame_disposition_codes (merged, downgraded, rejected). What was DONE with the image, where
// sweep_quality above says what was SEEN.
std::vector<uint8_t> frame_disposition;
std::vector<std::string> frame_disposition_codes;
// 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;
};