mx/Jungfraujoch
3
2 Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases 87 Wiki Activity

rc179: everything on rc178 after its merge into main (#88), except the CHANGELOG

Browse Source 
The rc178 branch continued after #88 was squash-merged; this is its content from b9ada7914 (the tree
#88 squashed) to 094eee31a, as one change on main. The individual commits stay on the rc178 branch:

- still battery: --cold evicts each set's input from the page cache; Alvra pixel masks; manifest fixes
- AGIPD: converter to one rigid panel per module, int16 photons, mask folded in; still battery reads the converted sets
- DetectorModules: panel look-up by id, plane -> panel, plane bounds and a per-pixel walk; mask size checked
- tests: [PanelLayout] equivalence harness, stacked vs assembled panel layout
- Dense per-pixel maps through the panel table (panel layout stage 1)
- Panel id on spots and the panel table in the start message
- Viewer and preview show a panel detector as it lies on the detector plane
- Panel layout stage 3: per-panel spot finding (CPU+GPU, CCL) and raster algorithms on the plane raster
- Panel layout stage 2: prediction and Bragg integration through the panel table
- XTC reader: frames handed up as stored, streams indexed in parallel
- XFEL reader: integer frames stay integer, one gain, placement by panel
- EXTERNAL_TEST_DATA_STILLS.md: images used vs the entry for every set; drop "Not in the battery"
- still battery: EuXFEL sets read the depositors' Cheetah CXI files directly; AGIPD converter removed
- float32_to_int16.py: a non-finite pixel becomes -32768, the int16 error marker, not a zero count
- CrystFEL geometry: read the pixel masks and bad regions instead of ignoring them
- Panel layout stage 5: the XFEL reader hands up the stored frame and its panel table
- Panel table persisted in NXmx; modulation grid and pre-scan memo key on the plane
- still battery: Alvra sets take their pixel mask from the CrystFEL geometry, not --mask-good
- still battery: take the deposited model as mmCIF where the RCSB has no PDB-format file
- still battery: dimple gets PDB-format coordinates converted from an mmCIF-only deposition
- stills fixed cost: geometry refinement and pre-scan do the same work in less wall time
- stills geometry sample and trial spot finding run as many workers as the image pass
- Stills integration: background ring reach measured on empty apertures, radial curvature from the whole frame
- StillsPartialityRefine: the partiality width is the run's, measured on the crystals, not the prediction window's
- MergeOnTheFly: capture term and multiplicative outlier band for the stills merge (both opt-in)
- Stills given a cell: the written cell is the mean over the frames that are merged
- Stills: the radial curvature correction decided per run on the same empty apertures
- StillsPartialityRefine: measure the run width only on shells with signal
- Stills pre-scan: report the paired z of the radial-correction comparison
- module placement: the five concurrent fits each keep every thread
- still battery: score R-free against the deposited data through the same dimple protocol
- still battery: the R-free target is the lower of the deposition's dimple and published values
- Stills: background clip follows the radial curve; signal disk from the lattice spacing
- Stills keep an overloaded observation as a lower bound instead of dropping it
- Stills: drop the lattice-spacing signal disk; the correction decision back on the plain clip
- battery: R-free against the deposition without refinement only, one protocol for rotation and stills
- still battery: EuXFEL sets run on a 2,000-image subset for now
- stills geometry refinement: fit the detector distance and the cell together
- stills geometry refinement: a distance given with --detector-distance is held in the joint fit
- Metal integration engine: back to its panel-s5 kernels; Mac stills keep the old clip, no saturation count
- Metal integration test: the CPU comparison runs on a rotation experiment
- Stills: kept overloads go back to the drop where they are not concentrated at low resolution
- stills distance search: an absolute 30-3000 mm scan, a sample found without d-limits, the fit iterated
- battery results: XFEL still battery 20261022-1358 on rc178 0cf62452c - 12 sets, cold, R_free unrefined
- battery results: still summary gains the resolution of our merge and of the deposition
- Pre-scan masks a pixel at the saturation limit on most frames, as one holding the error value
- Stills keep an overload as a lower bound only where it has pixels at the limit; run-level gate removed
- XFEL reader: a per-frame mask is read the way the frames are, its chunk inflated outside the HDF5 lock
- stills distance search: every centre scanned with a wider acceptance, a larger sample where nothing indexes
- rugnux usage: --beam-center-check describes the absolute 30-3000 mm stills distance scan, not the old 60-160 % grid
- stills: detector tilt refined in the geometry pre-pass, kept where held-out frames agree
- CLAUDE.md: the changelog is written once, just before the merge into main - condensed one-liners of what users get
- broker: serve the placed model and its maps of the last rugnux live run (/rugnux/model.cif, /rugnux/map.ccp4)
- frontend: Mol* viewer of the placed model and its density on the Rugnux live page
- writer: _model.cif from rugnux live keeps the input model's metadata, as the served model.cif does
- rugnux live maps: one unit cell centred on the model; the viewer opens on all of it
- Anomalous difference map: ANOM/PHANOM in _maps.mtz, /rugnux/map.ccp4?type=anom, a magenta mesh in the viewer
- Mol* viewer: open with the maps drawn within 10 A of the centre of view
- Mol* viewer: aaredb's structure-viewer setup, on a black stage
- rugnux: the gain of a stills file that states none is read off its single-photon peak where the background resolves photons
- Mol* viewer: in line with AareDB's StructureView at its current head (8ece2c2)
- ACKNOWLEDGEMENT: the web frontend's Mol* viewer follows AareDB's setup (G. Gotthard, PSI)
- stills tilt decision: the modules stay where the run placed them
- still battery: no distance pins and no per-set tuning flags; gain from the data except where a file's baseline hides it
- battery results: rc178 6f6f69 - full still battery and full rotation battery with REFMAC
- Bragg integration: a CCD rotation sweep's sigmas at the measured gain, intensities in photons
- BackgroundGain: the gain of a frame that resolves photons is the spacing of its photon peaks, so a baseline left in the frame no longer hides it
- ShadowFinder: measure the background's azimuthal modulation instead of predicting it from the polarization
- BackgroundGain: one gain estimate for rotation and stills; the still battery no longer gives EuXFEL 152 its gain
- ShadowFinder: measure the modulation robustly under a wide one-sided shadow
- ShadowFinderTest: a one-sided shadow is not fitted as part of the background's modulation
- ShadowFinder: back to the predicted polarization factor, in the plane the background shows
- MXAnalysisAfterFPGA: the Bragg engine's edge mask in the image's layout, so raw / untransformed FPGA runs start again
- battery results: still battery on rc178 e54f55 replaces the earlier rc178 still tables
- XFELReader: per-frame mask and photon conversion without a library call or a branch per pixel
- stills geometry trial: the hypotheses a search asks are indexed side by side
- stills tilt decision: the fits start beside the pre-scan and the geometry trial
- XFELReader: a deflated frame is inflated and converted a piece at a time, while it is in the cache
- XFELReader: a byte-shuffled frame is unshuffled a piece at a time, a whole pixel per step
- GeometryRefiner: residuals carry only the blocks a fit moves; beam and distance one block
- GeometryRefiner: a spot's residual differentiates its observed and predicted halves apart
- docs: EXTERNAL_TEST_DATA lists every open-arm battery set, with corrected values and counts
- battery: doc_check.py cross-checks the manifests against the dataset pages
- stills module placement: the placement fit gets half the threads, each held-out fit an eighth
- still battery: the EuXFEL sets run on all their frames, as the published still runs did
- battery results: still battery on rc178 a0ce6c, cold on a quiet machine, replaces the earlier rc178 table
- macOS build: explicit size_t in the XFEL reader's row bounds; parentheses in the CPU preprocessor's select

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015CeEGgpKdfkCTJb3YNMJcu
This commit is contained in:
leonarski_fandClaude Opus 5.5 committed 2026-10-23 17:56:42 +02:00
1 parent afbe844b20
commit 0a515bb086
218 files changed
+55733 -1764
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

reader/CrystFELGeometry.cpp
+94 -6
View File
@@ -3,6 +3,9 @@
#include "CrystFELGeometry.h"
#include <algorithm>
#include <array>
#include <filesystem>
#include <fstream>
#include <map>
#include <regex>
@@ -98,8 +101,8 @@ bool Bookkeeping(const std::string &key) {
// Keywords that change where a pixel lands or what it is worth, which this reader does not do.
const std::set<std::string> REFUSED = {"detector_shift_x", "detector_shift_y"};
// Sets one panel property; false if the key is not one. Only where the panel is: its pixel range, axes,
// corner, pixel size, depth offset and camera length.
// Sets one panel property; false if the key is not one. Where the panel is - its pixel range, axes,
// corner, pixel size, depth offset and camera length - and which of its pixels are left out.
bool SetPanel(const std::string &filename, Panel &p, const std::string &key, const std::string &value) {
if (key == "min_fs") p.min_fs = std::stoll(value);
else if (key == "max_fs") p.max_fs = std::stoll(value);
@@ -112,11 +115,58 @@ bool SetPanel(const std::string &filename, Panel &p, const std::string &key, con
else if (key == "res") p.res = std::stod(value);
else if (key == "clen") p.clen = ParseValue(filename, key, value, LENGTH_UNITS, 1e-3);
else if (key == "coffset") p.coffset = std::stod(value);
else if (key == "mask_edge_pixels") p.mask_edge_pixels = std::stoll(value);
else if (key == "no_index") p.no_index = value == "1" || value == "true";
else
return false;
return true;
}
// The up to eight masks a panel has (maskN_data, maskN_file, maskN_goodbits, maskN_badbits, N = 0..7;
// mask, mask_file, mask_good and mask_bad are mask 0's). Sets the one the key names; false if the key
// is not a mask key.
using Masks = std::array<xfel::Mask, 8>;
bool SetMask(Masks &masks, const std::string &key, const std::string &value) {
static const std::map<std::string, std::string> OLD = {
{"mask", "data"}, {"mask_file", "file"}, {"mask_good", "goodbits"}, {"mask_bad", "badbits"}};
static const std::regex CURRENT(R"(mask([0-7])_(data|file|goodbits|badbits))");
size_t n = 0;
std::string field;
std::smatch match;
if (OLD.contains(key))
field = OLD.at(key);
else if (std::regex_match(key, match, CURRENT)) {
n = std::stoul(match[1].str());
field = match[2].str();
} else
return false;
if (field == "data") masks[n].data = value;
else if (field == "file") masks[n].file = value;
else if (field == "goodbits") masks[n].good = static_cast<uint32_t>(std::stoul(value, nullptr, 0));
else masks[n].bad = static_cast<uint32_t>(std::stoul(value, nullptr, 0));
return true;
}
// Sets one property of a bad region: a box in the laboratory plane (min_x .. max_y, in pixels) or a
// pixel range in the stored frame (min_fs .. max_ss, inclusive) on one panel - or, in the old syntax,
// with no panel, on the whole frame. False if the key is not one.
bool SetBad(xfel::BadRegion &b, const std::string &key, const std::string &value) {
if (key == "min_x") b.min_x = std::stod(value);
else if (key == "max_x") b.max_x = std::stod(value);
else if (key == "min_y") b.min_y = std::stod(value);
else if (key == "max_y") b.max_y = std::stod(value);
else if (key == "min_fs") b.min_fs = std::stoll(value);
else if (key == "max_fs") b.max_fs = std::stoll(value);
else if (key == "min_ss") b.min_ss = std::stoll(value);
else if (key == "max_ss") b.max_ss = std::stoll(value);
else if (key == "panel") b.panel = value;
else
return false;
if (key.ends_with("_x") || key.ends_with("_y"))
b.in_lab = true;
return true;
}
} // namespace
xfel::Layout Read(const std::string &filename, std::vector<std::string> &ignored) {
@@ -128,7 +178,9 @@ xfel::Layout Read(const std::string &filename, std::vector<std::string> &ignored
// Global panel keys hold for every panel that appears after them, as in the old syntax; a file in
// the current syntax states them first, so this reads both the same.
Panel defaults;
std::map<std::string, size_t> panel_index;
Masks default_masks;
std::vector<Masks> panel_masks; // each panel's, beside geom.panels
std::map<std::string, size_t> panel_index, bad_index;
std::map<std::string, std::string> dims;
std::string line;
@@ -147,7 +199,8 @@ xfel::Layout Read(const std::string &filename, std::vector<std::string> &ignored
if (slash == std::string::npos) {
if (key == "data") geom.data = value;
else if (key.starts_with("dim")) dims[key] = value;
else if (!SetPanel(filename, defaults, key, value) && !Bookkeeping(key))
else if (!SetPanel(filename, defaults, key, value) && !SetMask(default_masks, key, value)
&& !Bookkeeping(key))
ignored.push_back(key);
continue;
}
@@ -156,7 +209,12 @@ xfel::Layout Read(const std::string &filename, std::vector<std::string> &ignored
const std::string prop = key.substr(slash + 1);
if (name.starts_with("bad")) {
ignored.push_back(key);
if (!bad_index.contains(name)) {
bad_index[name] = geom.bad.size();
geom.bad.emplace_back();
}
if (!SetBad(geom.bad[bad_index[name]], prop, value))
ignored.push_back(key);
continue;
}
@@ -173,8 +231,11 @@ xfel::Layout Read(const std::string &filename, std::vector<std::string> &ignored
panel_index[name] = geom.panels.size();
geom.panels.push_back(defaults);
geom.panels.back().name = name;
panel_masks.push_back(default_masks);
}
if (!SetPanel(filename, geom.panels[panel_index[name]], prop, value) && !Bookkeeping(prop))
const size_t n = panel_index[name];
if (!SetPanel(filename, geom.panels[n], prop, value) && !SetMask(panel_masks[n], prop, value)
&& !Bookkeeping(prop))
ignored.push_back(key);
}
@@ -195,6 +256,33 @@ xfel::Layout Read(const std::string &filename, std::vector<std::string> &ignored
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
filename + ": panel " + p.name + " has no pixel size (res)");
}
// Each mask once for the whole frame where every panel has it alike (the usual case: stated once,
// before the panels), otherwise once for each panel that has it, on that panel's pixels only.
for (size_t n = 0; n < default_masks.size(); n++) {
const auto &first = panel_masks[0][n];
const bool alike = std::all_of(panel_masks.begin(), panel_masks.end(),
[&](const Masks &m) { return m[n] == first; });
if (alike) {
if (!first.data.empty())
geom.masks.push_back(first);
continue;
}
for (size_t i = 0; i < geom.panels.size(); i++) {
if (panel_masks[i][n].data.empty())
continue;
geom.masks.push_back(panel_masks[i][n]);
geom.masks.back().panel = geom.panels[i].name;
}
}
// A mask file is named as it is, or relative to the working directory, as CrystFEL reads it; a
// relative one not found there is looked for beside the geometry file.
for (auto &m: geom.masks) {
const std::filesystem::path file(m.file);
const auto beside = std::filesystem::path(filename).parent_path() / file;
if (!m.file.empty() && file.is_relative() && !std::filesystem::exists(file) && std::filesystem::exists(beside))
m.file = beside.string();
}
return geom;
}