Jungfraujoch/tests/CrystFELGeometryTest.cpp

// 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);
}