mx/Jungfraujoch
3
2 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 87 Wiki Activity
Files
0cf62452cd452b038e4e38fef7d0ac53258ab68f
Jungfraujoch/tests/CrystFELGeometryTest.cpp
T
leonarski_fandClaude Opus 5.5 7c23b4befe CrystFEL geometry: read the pixel masks and bad regions instead of ignoring them 
The .geom parser now takes the masking information the format defines:
- mask arrays: mask/mask_file/mask_good/mask_bad (mask 0) and maskN_data/maskN_file/maskN_goodbits/
  maskN_badbits for N = 0..7; global keys hold for the panels after them, a panel may override. A mask
  that is the same on every panel is one whole-frame mask, otherwise one per panel, applied on that
  panel's pixels only.
- a relative mask_file is looked for in the working directory (as CrystFEL does), then beside the .geom.
- bad regions (bad*): a lab-plane box (min_x..max_y) or a fs/ss range on a panel (or, old syntax, on
  the whole frame); mask_edge_pixels and no_index.

JFJochXFELReader already had the static pixel mask and the per-frame mask path for these; the masks
go through them unchanged. A mask whose path holds % (one per shot group) is applied frame by frame
like a 3D one. Where the geometry names mask arrays, the data file's own Cheetah masks (CXI
mask_shared and per-shot mask with Cheetah's generic bad bits, /metadata/pixelmask) are not added:
the geometry says which bits matter (e.g. an AGIPD mask_bad that includes bit 32). --mask-good /
--mask-bad still add their masks to these.

Tests: [CrystFELGeometry] (new keys, per-panel override, relative mask file), JFJochXFELReader_*
(new GeometryMasks case on a synthetic CXI + .geom), [JFJochMultiReader], JFJochXTCReader*.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015CeEGgpKdfkCTJb3YNMJcu
2026-10-21 12:42:08 +02:00

231 lines
8.1 KiB
C++
Raw Blame History

// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#include <catch2/catch_all.hpp>
#include <algorithm>
#include <filesystem>
#include <fstream>
#include "../reader/CrystFELGeometry.h"
namespace {
std::string WriteGeom(const std::string &name, const std::string &text) {
const auto path = (std::filesystem::temp_directory_path() / name).string();
std::ofstream(path) << text;
return path;
}
} // namespace
TEST_CASE("CrystFELGeometry_OldSyntax", "[CrystFELGeometry][portable]") {
// One panel and whole-frame bad strips, global keys only: the old syntax.
std::vector<std::string> ignored;
const auto geom = crystfel::Read("../../tests/crystfel/jf4m.geom", ignored);
REQUIRE(geom.panels.size() == 1);
CHECK(geom.panels[0].res == Catch::Approx(13333.3));
CHECK(geom.panels[0].clen->path.empty());
CHECK(geom.panels[0].clen->value == Catch::Approx(0.075));
CHECK(geom.data == "/entry/data/data");
// Gain, photon energy and value flags are ignored; the bad strips, with no panel, are on the whole frame.
CHECK(!geom.panels[0].adu_per_photon.has_value());
CHECK(!geom.photon_energy.has_value());
CHECK(std::find(ignored.begin(), ignored.end(), "photon_energy") != ignored.end());
CHECK(std::find(ignored.begin(), ignored.end(), "flag_lessthan") != ignored.end());
REQUIRE(geom.bad.size() == 4);
CHECK(geom.bad[0].panel.empty());
CHECK(!geom.bad[0].in_lab);
CHECK(geom.bad[0].min_fs == 1030);
CHECK(geom.bad[0].max_fs == 1037);
CHECK(geom.bad[0].max_ss == 2163);
CHECK(geom.bad[3].min_ss == 1614);
}
TEST_CASE("CrystFELGeometry_Panels", "[CrystFELGeometry][portable]") {
const auto path = WriteGeom("jfjoch_crystfel_geometry_test.geom", R"(
clen = /LCLS/detector_1/EncoderValue ; read from the file
res = 20000
adu_per_eV = 0.001 ; per eV
data = /%/data
photon_energy = /%/photon_energy_ev
mask = /data/data
mask_file = mask.h5
mask_good = 0x0
mask_bad = 0x1
q1/min_fs = 0
q1/max_fs = 511
q1/min_ss = 0
q1/max_ss = 1023
q1/fs = +0.000390x -1.000000y
q1/ss = +1.000000x +0.000390y
q1/corner_x = 25.5
q1/corner_y = 1040.25
q1/coffset = 0.000067
q2/min_ss = 1024
q2/max_ss = 2047
q2/max_fs = 511
q2/fs = -x
q2/ss = y
q2/adu_per_photon = 9.5
badq1/min_fs = 0
badq1/max_fs = 4
badq1/min_ss = 0
badq1/max_ss = 1023
badq1/panel = q1
badbox/min_x = -10
badbox/max_x = 10
badbox/min_y = -5
badbox/max_y = 5
)");
std::vector<std::string> ignored;
const auto geom = crystfel::Read(path, ignored);
REQUIRE(geom.panels.size() == 2);
const auto &q1 = geom.panels[0];
CHECK(q1.name == "q1");
CHECK(q1.clen->path == "/LCLS/detector_1/EncoderValue");
CHECK(q1.clen->scale == Catch::Approx(1e-3));
CHECK(q1.coffset == Catch::Approx(0.000067));
CHECK(!q1.adu_per_eV.has_value());
CHECK(q1.fs_x == Catch::Approx(0.00039));
CHECK(q1.fs_y == Catch::Approx(-1.0));
CHECK(q1.ss_x == Catch::Approx(1.0));
CHECK(q1.ss_y == Catch::Approx(0.00039));
CHECK(q1.corner_y == Catch::Approx(1040.25));
CHECK(q1.max_ss == 1023);
const auto &q2 = geom.panels[1];
CHECK(q2.fs_x == Catch::Approx(-1.0));
CHECK(q2.fs_y == Catch::Approx(0.0));
CHECK(q2.ss_y == Catch::Approx(1.0));
CHECK(q2.min_ss == 1024);
CHECK(!q2.adu_per_photon.has_value());
CHECK(q2.res == Catch::Approx(20000));
CHECK(geom.data == "/%/data");
// The old mask keywords are mask 0, the same for both panels: one mask for the whole frame.
REQUIRE(geom.masks.size() == 1);
CHECK(geom.masks[0].data == "/data/data");
CHECK(geom.masks[0].file == "mask.h5");
CHECK(geom.masks[0].good == 0);
CHECK(geom.masks[0].bad == 1);
CHECK(geom.masks[0].panel.empty());
REQUIRE(geom.bad.size() == 2);
CHECK(geom.bad[0].panel == "q1");
CHECK(!geom.bad[0].in_lab);
CHECK(geom.bad[0].max_fs == 4);
CHECK(geom.bad[0].max_ss == 1023);
CHECK(geom.bad[1].in_lab);
CHECK(geom.bad[1].min_x == Catch::Approx(-10));
CHECK(geom.bad[1].max_y == Catch::Approx(5));
for (const std::string key: {"adu_per_eV", "photon_energy", "q2/adu_per_photon"})
CHECK(std::find(ignored.begin(), ignored.end(), key) != ignored.end());
for (const std::string key: {"mask", "mask_file", "mask_good", "mask_bad", "badq1/min_fs", "badbox/max_y"})
CHECK(std::find(ignored.begin(), ignored.end(), key) == ignored.end());
std::filesystem::remove(path);
}
TEST_CASE("CrystFELGeometry_UnitsAndRefusals", "[CrystFELGeometry][portable]") {
std::vector<std::string> ignored;
const auto path = WriteGeom("jfjoch_crystfel_geometry_units.geom", R"(
clen = 70.5 mm
photon_energy = 9.3 keV
res = 10000
mask0_data = /entry/mask
mask0_badbits = 0x6
p0/min_fs = 0
p0/max_fs = 99
p0/min_ss = 0
p0/max_ss = 99
p0/mask_edge_pixels = 2
p0/no_index = false
some_new_keyword = 1
)");
const auto geom = crystfel::Read(path, ignored);
CHECK(geom.panels[0].clen->value == Catch::Approx(0.0705));
CHECK(!geom.photon_energy.has_value());
REQUIRE(geom.masks.size() == 1);
CHECK(geom.masks[0].data == "/entry/mask");
CHECK(geom.masks[0].file.empty());
CHECK(geom.masks[0].bad == 6);
CHECK(geom.panels[0].mask_edge_pixels == 2);
CHECK(!geom.panels[0].no_index);
CHECK(std::find(ignored.begin(), ignored.end(), "some_new_keyword") != ignored.end());
// A camera length is optional.
const auto no_clen = WriteGeom("jfjoch_crystfel_geometry_noclen.geom",
"res = 10000\np0/min_fs = 0\np0/max_fs = 9\np0/min_ss = 0\np0/max_ss = 9\n");
CHECK(!crystfel::Read(no_clen, ignored).panels[0].clen.has_value());
std::filesystem::remove(no_clen);
for (const std::string bad: {"p0/fs = +1.0x +0.1z", "dim1 = 0", "p0/data = /other", "detector_shift_x = /x"}) {
const auto p = WriteGeom("jfjoch_crystfel_geometry_refused.geom",
"clen = 0.1\nres = 10000\nphoton_energy = 9000\np0/min_fs = 0\np0/max_fs = 9\n"
"p0/min_ss = 0\np0/max_ss = 9\n" + bad + "\n");
CHECK_THROWS(crystfel::Read(p, ignored));
std::filesystem::remove(p);
}
std::filesystem::remove(path);
}
TEST_CASE("CrystFELGeometry_Masks", "[CrystFELGeometry][portable]") {
// Two masks: mask 0 for every panel, with its bad bits overridden on panel a; mask 1 in a file named
// relative to the geometry file's directory. A bad region on panel b, and panel c left out.
const auto dir = std::filesystem::temp_directory_path() / "jfjoch_crystfel_geometry_masks";
std::filesystem::create_directories(dir);
std::ofstream(dir / "pixels.h5") << "";
const auto path = (dir / "masks.geom").string();
std::ofstream(path) << R"(
res = 10000
mask0_data = /entry/mask
mask0_goodbits = 0x1
mask1_data = /%/pixel_mask
mask1_file = pixels.h5
mask1_badbits = 0xfeff
a/min_fs = 0
a/max_fs = 9
a/min_ss = 0
a/max_ss = 9
a/mask0_badbits = 4
b/min_fs = 10
b/max_fs = 19
b/min_ss = 0
b/max_ss = 9
c/min_fs = 20
c/max_fs = 29
c/min_ss = 0
c/max_ss = 9
c/no_index = true
bad_b/min_fs = 12
bad_b/max_fs = 13
bad_b/min_ss = 0
bad_b/max_ss = 9
bad_b/panel = b
)";
std::vector<std::string> ignored;
const auto geom = crystfel::Read(path, ignored);
CHECK(ignored.empty());
REQUIRE(geom.panels.size() == 3);
CHECK(geom.panels[2].no_index);
CHECK(!geom.panels[1].no_index);
// Mask 0 differs between panels: one per panel. Mask 1 is the same everywhere: one for the frame.
REQUIRE(geom.masks.size() == 4);
for (size_t i = 0; i < 3; i++) {
CHECK(geom.masks[i].data == "/entry/mask");
CHECK(geom.masks[i].good == 1);
CHECK(geom.masks[i].panel == geom.panels[i].name);
}
CHECK(geom.masks[0].bad == 4);
CHECK(geom.masks[1].bad == 0);
CHECK(geom.masks[3].data == "/%/pixel_mask");
CHECK(geom.masks[3].bad == 0xfeff);
CHECK(geom.masks[3].panel.empty());
CHECK(std::filesystem::path(geom.masks[3].file) == dir / "pixels.h5");
REQUIRE(geom.bad.size() == 1);
CHECK(geom.bad[0].panel == "b");
CHECK(geom.bad[0].min_fs == 12);
CHECK(geom.bad[0].max_fs == 13);
std::filesystem::remove_all(dir);
}
Reference in new issue View Git Blame Copy Permalink