From 953089009f88056ad71c81e4f60f4e534fabd12b Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 2 Jun 2026 15:50:11 +0200 Subject: [PATCH 01/46] AzimuthalIntegrationProfile: Add standard deviation + save pixel count + improve handling of special cases (missing image) --- common/AzimuthalIntegrationProfile.cpp | 35 ++++++++- common/AzimuthalIntegrationProfile.h | 7 +- common/JFJochMessages.h | 3 + frame_serialize/CBORStream2Deserializer.cpp | 4 ++ frame_serialize/CBORStream2Serializer.cpp | 4 ++ image_analysis/MXAnalysisWithoutFPGA.cpp | 3 + image_analysis/azint/AzIntEngineCPU.cpp | 2 +- image_analysis/azint/AzIntEngineGPU.cu | 2 +- receiver/JFJochReceiverFPGA.cpp | 1 + tests/AzimuthalIntegrationTest.cpp | 78 ++++++++++++++++++--- tests/CBORTest.cpp | 13 +++- writer/HDF5DataFilePluginAzInt.cpp | 34 ++++++++- writer/HDF5DataFilePluginAzInt.h | 5 ++ 13 files changed, 175 insertions(+), 16 deletions(-) diff --git a/common/AzimuthalIntegrationProfile.cpp b/common/AzimuthalIntegrationProfile.cpp index d1f128c9..4ccfb609 100644 --- a/common/AzimuthalIntegrationProfile.cpp +++ b/common/AzimuthalIntegrationProfile.cpp @@ -7,8 +7,15 @@ inline float sum_to_count(float sum, uint64_t count) { if (count == 0) return NAN; - else - return sum / (static_cast(count)); + return sum / (static_cast(count)); +} + +inline float calc_std(float sum, float sum2, uint64_t count) { + if (count == 0 || count == 1) + return NAN; + const auto fp_count = static_cast(count); + const float variance = (sum2 - sum * sum / fp_count) / (fp_count - 1); + return std::sqrt(variance); } AzimuthalIntegrationProfile::AzimuthalIntegrationProfile(const AzimuthalIntegrationMapping &mapping) @@ -46,13 +53,20 @@ void AzimuthalIntegrationProfile::Add(int64_t bin, int64_t value) { count[bin]++; } -void AzimuthalIntegrationProfile::Add(const std::vector &in_sum, const std::vector &in_count) { +void AzimuthalIntegrationProfile::Add(const std::vector &in_sum, + const std::vector &in_sum2, + const std::vector &in_count) { std::unique_lock ul(m); if ((in_sum.size() == sum.size()) && (in_count.size() == count.size())) { for (int i = 0; i < sum.size(); i++) { sum[i] += in_sum[i]; count[i] += in_count[i]; } + if (in_sum2.size() == sum2.size()) { + for (int i = 0; i < sum.size(); i++) { + sum2[i] += in_sum2[i]; + } + } } else if (!in_sum.empty() && !in_count.empty()) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Mismatch in size of sum/count datasets"); } @@ -66,6 +80,20 @@ std::vector AzimuthalIntegrationProfile::GetResult() const { return rad_int_profile; } +std::vector AzimuthalIntegrationProfile::GetStd() const { + std::unique_lock ul(m); + + std::vector rad_int_profile(sum.size(), 0); + for (int i = 0; i < sum.size(); i++) + rad_int_profile[i] = calc_std(sum[i], sum2[i], count[i]); + return rad_int_profile; +} + +std::vector AzimuthalIntegrationProfile::GetPixelCount() const { + std::unique_lock ul(m); + return count; +} + std::vector AzimuthalIntegrationProfile::GetResult1D() const { std::unique_lock ul(m); @@ -151,6 +179,7 @@ AzimuthalIntegrationProfile &AzimuthalIntegrationProfile::operator+=(const Azimu for (int i = 0; i < sum.size(); i++) { sum[i] += other.sum[i]; + sum2[i] += other.sum2[i]; count[i] += other.count[i]; } diff --git a/common/AzimuthalIntegrationProfile.h b/common/AzimuthalIntegrationProfile.h index fb78fbaa..87d681db 100644 --- a/common/AzimuthalIntegrationProfile.h +++ b/common/AzimuthalIntegrationProfile.h @@ -32,10 +32,15 @@ public: void Clear(const AzimuthalIntegrationMapping &mapping); void SetTitle(const std::string& input); void Add(const DeviceOutput &result); - void Add(const std::vector &sum, const std::vector &count); + void Add(const std::vector &sum, + const std::vector &sum2, + const std::vector &count); void Add(int64_t bin, int64_t value); std::vector GetResult() const; + std::vector GetStd() const; + std::vector GetPixelCount() const; + std::vector GetResult1D() const; float GetMeanValueOfBins(uint16_t min_bin, uint16_t max_bin) const; diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index 44a617d3..de830204 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -107,6 +107,9 @@ struct DataMessage { std::vector spot_plot_one_over_d_square; std::vector az_int_profile; + std::vector az_int_profile_std; + std::vector az_int_profile_count; + std::optional bkg_estimate; std::optional indexing_result; diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp index d5ff05ff..0b8e0a57 100644 --- a/frame_serialize/CBORStream2Deserializer.cpp +++ b/frame_serialize/CBORStream2Deserializer.cpp @@ -711,6 +711,10 @@ namespace { message.spot_count_ice_rings = GetCBORUInt(value); else if (key == "az_int_profile") GetCBORFloatArray(value, message.az_int_profile); + else if (key == "az_int_profile_std") + GetCBORFloatArray(value, message.az_int_profile_std); + else if (key == "az_int_profile_count") + GetCBORUInt64Array(value, message.az_int_profile_count); else if (key == "indexing_result") message.indexing_result = GetCBORBool(value); else if (key == "indexing_lattice") { diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp index 6473c0c4..4966be47 100644 --- a/frame_serialize/CBORStream2Serializer.cpp +++ b/frame_serialize/CBORStream2Serializer.cpp @@ -742,6 +742,10 @@ void CBORStream2Serializer::SerializeImageInternal(CborEncoder &mapEncoder, cons CBOR_ENC(mapEncoder, "spot_count_low_res", message.spot_count_low_res); CBOR_ENC(mapEncoder, "spot_count_indexed", message.spot_count_indexed); CBOR_ENC(mapEncoder, "az_int_profile", message.az_int_profile); + if (!message.az_int_profile_std.empty()) + CBOR_ENC(mapEncoder, "az_int_profile_std", message.az_int_profile_std); + CBOR_ENC(mapEncoder, "az_int_profile_count", message.az_int_profile_count); + CBOR_ENC(mapEncoder, "indexing_result", message.indexing_result); if (message.indexing_lattice) CBOR_ENC(mapEncoder, "indexing_lattice", message.indexing_lattice->GetVector()); diff --git a/image_analysis/MXAnalysisWithoutFPGA.cpp b/image_analysis/MXAnalysisWithoutFPGA.cpp index c7e55fb6..7bade492 100644 --- a/image_analysis/MXAnalysisWithoutFPGA.cpp +++ b/image_analysis/MXAnalysisWithoutFPGA.cpp @@ -100,6 +100,9 @@ void MXAnalysisWithoutFPGA::Analyze(DataMessage &output, output.error_pixel_count = ret.error_pixel_count; output.saturated_pixel_count = ret.saturated_pixel_count; output.az_int_profile = profile.GetResult(); + output.az_int_profile_count = profile.GetPixelCount(); + output.az_int_profile_std = profile.GetStd(); + output.bkg_estimate = profile.GetBkgEstimate(integration.Settings()); } diff --git a/image_analysis/azint/AzIntEngineCPU.cpp b/image_analysis/azint/AzIntEngineCPU.cpp index afaa6ebb..f8dc7321 100644 --- a/image_analysis/azint/AzIntEngineCPU.cpp +++ b/image_analysis/azint/AzIntEngineCPU.cpp @@ -31,5 +31,5 @@ void AzIntEngineCPU::Run(const ImagePreprocessorBuffer &image, AzimuthalIntegrat } profile.Clear(integration); - profile.Add(azint_sum, azint_count); + profile.Add(azint_sum, azint_sum2, azint_count); } diff --git a/image_analysis/azint/AzIntEngineGPU.cu b/image_analysis/azint/AzIntEngineGPU.cu index dfc81076..132f9761 100644 --- a/image_analysis/azint/AzIntEngineGPU.cu +++ b/image_analysis/azint/AzIntEngineGPU.cu @@ -139,5 +139,5 @@ void AzIntEngineGPU::Run(const ImagePreprocessorBuffer &image, AzimuthalIntegrat cuda_err(cudaStreamSynchronize(*stream)); profile.Clear(integration); - profile.Add(azint_sum, azint_count); + profile.Add(azint_sum, azint_sum2, azint_count); } diff --git a/receiver/JFJochReceiverFPGA.cpp b/receiver/JFJochReceiverFPGA.cpp index a237e0d2..18dc2d12 100644 --- a/receiver/JFJochReceiverFPGA.cpp +++ b/receiver/JFJochReceiverFPGA.cpp @@ -435,6 +435,7 @@ void JFJochReceiverFPGA::FrameTransformationThread(uint32_t threadid) { message.receiver_buf_in_preparation = status.preparation_slots; message.receiver_buf_in_sending = status.sending_slots; message.az_int_profile = az_int_profile_image.GetResult(); + message.az_int_profile_count = az_int_profile_image.GetPixelCount(); message.bkg_estimate = az_int_profile_image.GetBkgEstimate(experiment.GetAzimuthalIntegrationSettings()); scan_result.Add(message); diff --git a/tests/AzimuthalIntegrationTest.cpp b/tests/AzimuthalIntegrationTest.cpp index ac95a083..ed49b531 100644 --- a/tests/AzimuthalIntegrationTest.cpp +++ b/tests/AzimuthalIntegrationTest.cpp @@ -171,18 +171,19 @@ TEST_CASE("AzimuthalIntegrationProfile","[AzimuthalIntegration]") { AzimuthalIntegrationProfile profile(mapping); - std::vector sum(mapping.GetBinNumber()); + std::vector sum(mapping.GetBinNumber()), sum2(mapping.GetBinNumber()); std::vector count(mapping.GetBinNumber()); for (int i = 0; i < mapping.GetBinNumber(); i++) { sum[i] = i * i * 4; + sum2[i] = i * i * i * i * 4; count[i] = i; } - REQUIRE_NOTHROW(profile.Add(sum, count)); - REQUIRE_NOTHROW(profile.Add(sum, count)); + REQUIRE_NOTHROW(profile.Add(sum, sum2, count)); + REQUIRE_NOTHROW(profile.Add(sum, sum2, count)); std::vector sum_wr(mapping.GetBinNumber() - 1); - REQUIRE_THROWS(profile.Add(sum_wr, count)); + REQUIRE_THROWS(profile.Add(sum_wr, sum2, count)); auto plot = profile.GetPlot(); REQUIRE(plot.GetPlots().size() == 1); @@ -198,6 +199,63 @@ TEST_CASE("AzimuthalIntegrationProfile","[AzimuthalIntegration]") { } } +TEST_CASE("AzimuthalIntegrationProfile_GetStd","[AzimuthalIntegration]") { + DiffractionExperiment x(DetJF4M()); + x.DetectorDistance_mm(50).BeamX_pxl(1000).BeamY_pxl(1000); + x.QSpacingForAzimInt_recipA(0.1).QRangeForAzimInt_recipA(0.1, 4); + + PixelMask pixel_mask(x); + AzimuthalIntegrationMapping mapping(x, pixel_mask); + + AzimuthalIntegrationProfile profile(mapping); + + REQUIRE(mapping.GetBinNumber() >= 4); + + std::vector sum(mapping.GetBinNumber()), sum2(mapping.GetBinNumber()); + std::vector count(mapping.GetBinNumber()); + + sum[0] = 2 + 3 + 4 + 5; + sum2[0] = 4 + 9 + 16 + 25; + count[0] = 4; + + sum[1] = 1 + 1; + sum2[1] = 1 + 1; + count[1] = 2; + + sum[2] = 1; + sum2[2] = 1; + count[2] = 1; + + sum[3] = 0; + sum2[3] = 0; + count[3] = 0; + + REQUIRE_NOTHROW(profile.Add(sum, sum2, count)); + + auto ret_mean = profile.GetResult(); + auto ret_stddev = profile.GetStd(); + auto ret_count = profile.GetPixelCount(); + REQUIRE(ret_mean.size() == mapping.GetBinNumber()); + REQUIRE(ret_stddev.size() == mapping.GetBinNumber()); + REQUIRE(ret_count.size() == mapping.GetBinNumber()); + + CHECK(ret_mean[0] == Catch::Approx(3.5)); + CHECK(ret_stddev[0] == Catch::Approx(std::sqrt(5.0/ 3.0))); + CHECK(ret_count[0] == 4); + + CHECK(ret_mean[1] == Catch::Approx(1.0)); + CHECK(ret_stddev[1] == 0.0f); + CHECK(ret_count[1] == 2); + + CHECK(ret_mean[2] == Catch::Approx(1.0)); + CHECK(std::isnan(ret_stddev[2])); + CHECK(ret_count[2] == 1); + + CHECK(std::isnan(ret_mean[3])); + CHECK(std::isnan(ret_stddev[3])); + CHECK(ret_count[3] == 0); +} + TEST_CASE("AzimuthalIntegrationProfile_operatorAdd","[AzimuthalIntegration]") { DiffractionExperiment x(DetJF4M()); x.DetectorDistance_mm(50).BeamX_pxl(1000).BeamY_pxl(1000); @@ -208,14 +266,15 @@ TEST_CASE("AzimuthalIntegrationProfile_operatorAdd","[AzimuthalIntegration]") { AzimuthalIntegrationProfile profile0(mapping), profile1(mapping); - std::vector sum(mapping.GetBinNumber()); + std::vector sum(mapping.GetBinNumber()), sum2(mapping.GetBinNumber()); std::vector count(mapping.GetBinNumber()); for (int i = 0; i < mapping.GetBinNumber(); i++) { sum[i] = (i + 1) * i * 4; + sum2[i] = (i+ 1) * i * 5; count[i] = i + 1; } - REQUIRE_NOTHROW(profile0.Add(sum, count)); + REQUIRE_NOTHROW(profile0.Add(sum, sum2, count)); REQUIRE_NOTHROW(profile1 += profile0); auto plot = profile1.GetPlot(); @@ -240,13 +299,15 @@ TEST_CASE("AzimuthalIntegrationProfile_GetMeanValueOfBins","[AzimuthalIntegratio AzimuthalIntegrationProfile profile(mapping); std::vector sum(mapping.GetBinNumber()); + std::vector sum2(mapping.GetBinNumber()); std::vector count(mapping.GetBinNumber()); for (int i = 0; i < mapping.GetBinNumber(); i++) { sum[i] = i * i * 4; + sum2[i] = i * i * i * i * 4; count[i] = i; } - REQUIRE_NOTHROW(profile.Add(sum, count)); + REQUIRE_NOTHROW(profile.Add(sum, sum2, count)); REQUIRE(profile.GetMeanValueOfBins(0,2) == Catch::Approx((sum[0] + sum[1] + sum[2]) / double(count[0] + count[1] + count[2]))); REQUIRE(profile.GetMeanValueOfBins(5,7) == Catch::Approx((sum[5] + sum[6] + sum[7]) / double (count[5] + count[6] + count[7]))); @@ -276,6 +337,7 @@ TEST_CASE("AzimuthalIntegrationProfile_GetResult1D","[AzimuthalIntegration]") { REQUIRE(mapping.GetBinNumber() == 9); std::vector sum(mapping.GetBinNumber(), 0.0f); + std::vector sum2(mapping.GetBinNumber(), 20.0f); std::vector count(mapping.GetBinNumber(), 0); // Layout is [azimuth][q], flattened: @@ -299,7 +361,7 @@ TEST_CASE("AzimuthalIntegrationProfile_GetResult1D","[AzimuthalIntegration]") { sum[7] = 31; count[7] = 1; // az2 q1 sum[8] = 32; count[8] = 1; // az2 q2 - REQUIRE_NOTHROW(profile.Add(sum, count)); + REQUIRE_NOTHROW(profile.Add(sum, sum2, count)); auto result_1d = profile.GetResult1D(); diff --git a/tests/CBORTest.cpp b/tests/CBORTest.cpp index 0c871a4c..8690f51a 100644 --- a/tests/CBORTest.cpp +++ b/tests/CBORTest.cpp @@ -797,7 +797,9 @@ TEST_CASE("CBORSerialize_Image_Rad_Int_Profile", "[CBOR]") { DataMessage message{ .number = 789, .image = image, - .az_int_profile = {4.0, 5.0, 7.0, 12.0, 13.25, 0.125} + .az_int_profile = {4.0, 5.0, 7.0, 12.0, 13.25, 0.125}, + .az_int_profile_std = {1.0, 0.0, NAN, NAN, 8.0, 12.0}, + .az_int_profile_count = {3,2,0,1,5,7} }; REQUIRE_NOTHROW(serializer.SerializeImage(message)); @@ -813,6 +815,15 @@ TEST_CASE("CBORSerialize_Image_Rad_Int_Profile", "[CBOR]") { REQUIRE(image_array.image.GetCompressedSize() == test.size() * sizeof(uint16_t)); REQUIRE(memcmp(image_array.image.GetCompressed(), test.data(), test.size() * sizeof(uint16_t)) == 0); REQUIRE(image_array.az_int_profile == message.az_int_profile); + REQUIRE(image_array.az_int_profile_std.size() == message.az_int_profile_std.size()); + for (int i = 0; i < image_array.az_int_profile_std.size(); i++) { + if (std::isnan(message.az_int_profile_std[i])) + CHECK(std::isnan(image_array.az_int_profile_std[i])); + else + CHECK(message.az_int_profile_std[i] == Catch::Approx(image_array.az_int_profile_std[i])); + } + REQUIRE(image_array.az_int_profile_std == message.az_int_profile_std); + REQUIRE(image_array.az_int_profile_count == message.az_int_profile_count); } TEST_CASE("CBORSerialize_Image_Spots", "[CBOR]") { diff --git a/writer/HDF5DataFilePluginAzInt.cpp b/writer/HDF5DataFilePluginAzInt.cpp index 1f032e04..5274aae9 100644 --- a/writer/HDF5DataFilePluginAzInt.cpp +++ b/writer/HDF5DataFilePluginAzInt.cpp @@ -25,6 +25,14 @@ void HDF5DataFilePluginAzInt::OpenFile(HDF5File &data_file, const DataMessage &m data_file.SaveVector("/entry/azint/bin_to_phi", az_int_bin_to_phi, dim); az_int_image.reserve(images_per_file * azimuthal_bins * q_bins); + if (!msg.az_int_profile_count.empty()) { + save_profile_count = true; + az_int_image_count.reserve(images_per_file * azimuthal_bins * q_bins); + } + if (!msg.az_int_profile_std.empty()) { + save_profile_std = true; + az_int_image_std.reserve(images_per_file * azimuthal_bins * q_bins); + } } void HDF5DataFilePluginAzInt::Write(const DataMessage &msg, uint64_t image_number) { @@ -33,17 +41,41 @@ void HDF5DataFilePluginAzInt::Write(const DataMessage &msg, uint64_t image_numbe if (image_number >= max_image_number || (max_image_number == 0)) { max_image_number = image_number; - az_int_image.resize((max_image_number + 1) * azimuthal_bins * q_bins); + az_int_image.resize((max_image_number + 1) * azimuthal_bins * q_bins, NAN); + if (save_profile_count) + az_int_image_count.resize((max_image_number + 1) * azimuthal_bins * q_bins, 0); + if (save_profile_std) + az_int_image_std.resize((max_image_number + 1) * azimuthal_bins * q_bins, NAN); } if (!msg.az_int_profile.empty() && (msg.az_int_profile.size() == azimuthal_bins * q_bins)) { for (int i = 0; i < azimuthal_bins * q_bins; i++) az_int_image[image_number * azimuthal_bins * q_bins + i] = msg.az_int_profile[i]; } + + if (save_profile_count + && !msg.az_int_profile_count.empty() + && (msg.az_int_profile_count.size() == azimuthal_bins * q_bins)) { + for (int i = 0; i < azimuthal_bins * q_bins; i++) + az_int_image_count[image_number * azimuthal_bins * q_bins + i] = msg.az_int_profile_count[i]; + } + + if (save_profile_std + && !msg.az_int_profile_std.empty() + && (msg.az_int_profile_std.size() == azimuthal_bins * q_bins)) { + for (int i = 0; i < azimuthal_bins * q_bins; i++) + az_int_image_std[image_number * azimuthal_bins * q_bins + i] = msg.az_int_profile_std[i]; + } } void HDF5DataFilePluginAzInt::WriteFinal(HDF5File &data_file) { if (!az_int_image.empty()) data_file.SaveVector("/entry/azint/image", az_int_image, {(hsize_t) (max_image_number + 1), azimuthal_bins, q_bins}); + if (!az_int_image_std.empty()) + data_file.SaveVector("/entry/azint/image_std", az_int_image_std, + {(hsize_t) (max_image_number + 1), azimuthal_bins, q_bins}); + if (!az_int_image_count.empty()) + data_file.SaveVector("/entry/azint/image_count", az_int_image_count, + {(hsize_t) (max_image_number + 1), azimuthal_bins, q_bins}); } diff --git a/writer/HDF5DataFilePluginAzInt.h b/writer/HDF5DataFilePluginAzInt.h index dc4e3c9a..07b82942 100644 --- a/writer/HDF5DataFilePluginAzInt.h +++ b/writer/HDF5DataFilePluginAzInt.h @@ -14,6 +14,11 @@ class HDF5DataFilePluginAzInt : public HDF5DataFilePlugin { std::vector az_int_bin_to_two_theta; std::vector az_int_bin_to_phi; std::vector az_int_image; + std::vector az_int_image_std; + std::vector az_int_image_count; + + bool save_profile_count = false; + bool save_profile_std = false; // std::unique_ptr dataset; public: -- 2.52.0 From a36caa4ca7e8c20fe5861da16d20c0b62247b545 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 2 Jun 2026 16:11:56 +0200 Subject: [PATCH 02/46] Save azimuthal integration map --- common/JFJochMessages.h | 1 + docs/CBOR.md | 3 +++ frame_serialize/CBORStream2Deserializer.cpp | 10 +++++++ frame_serialize/CBORStream2Serializer.cpp | 18 +++++++++++++ tests/CBORTest.cpp | 30 ++++++++++++++++++++- writer/HDF5NXmx.cpp | 3 +++ 6 files changed, 64 insertions(+), 1 deletion(-) diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index de830204..585e85dc 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -259,6 +259,7 @@ struct StartMessage { std::vector az_int_bin_to_phi; std::optional az_int_q_bin_count; std::optional az_int_phi_bin_count; + std::vector az_int_map; std::map> pixel_mask; diff --git a/docs/CBOR.md b/docs/CBOR.md index d9b0a1b1..7731bc35 100644 --- a/docs/CBOR.md +++ b/docs/CBOR.md @@ -74,6 +74,7 @@ There are minor differences at the moment: | az_int_bin_to_q | Array(float) | Q value for each azimuthal integration bin \[angstrom^-1\] | | | az_int_bin_to_two_theta | Array(float) | Two theta angle value for each azimuthal integration bin \[deg\] | | | az_int_bin_to_phi | Array(float) | Phi value for each azimuthal integration bin \[deg\] | | +| az_int_map | Image | Mapping between pixel and bin number | | | summation | uint64 | Factor of frame summation | | | user_data | string | JSON serialized to string that can contain the following fields (all fields are optional): | X | | - file_prefix | string | File prefix | | @@ -157,6 +158,8 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s | spot_count_indexed | uint64 | Number of spots which fit indexing solution within a given tolerance | | | | az_int_profile | Array(float) | Azimuthal integration results, use az_int_bin_to_q from start message for legend | | | | | | NaN is used for empty bins and has to be taken care by the receiver | | | +| az_int_std | Array(float) | Standard deviation for azimuthal integration. (NaN for less than 2 samples) | | | +| az_int_count | Array(uint64) | Number of pixels contributing to azimuthal bin | | | | indexing_result | bool | Indexing successful | | | | indexing_lattice | Array(9 * float) | Indexing result real lattice; present only if indexed | | X | | indexing_unit_cell | object | Indexing result unit cell: a, b, c \[angstrom\] and alpha, beta, gamma \[degree\]; present only if indexed | | X | diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp index 0b8e0a57..645059f2 100644 --- a/frame_serialize/CBORStream2Deserializer.cpp +++ b/frame_serialize/CBORStream2Deserializer.cpp @@ -1024,6 +1024,14 @@ namespace { cborErr(cbor_value_leave_container(&value, &map_value)); } + void ProcessAzintMapElement(StartMessage &message, CborValue &value) { + CompressedImage image = GetCBORMultidimTypedArray(value); + if (image.GetMode() == CompressedImageMode::Uint16) + JFJochDecompress(message.az_int_map, image.GetCompressionAlgorithm(), + image.GetCompressed(), image.GetCompressedSize(), + image.GetWidth() * image.GetHeight()); + } + std::optional ProcessHDF5Format(int input) { auto tmp = static_cast(input); switch (tmp) { @@ -1185,6 +1193,8 @@ namespace { message.run_number = GetCBORUInt(value); else if (key == "pixel_mask") ProcessPixelMaskElement(message, value); + else if (key == "az_int_map") + ProcessAzintMapElement(message, value); else if (key == "channels") GetCBORStringArray(value, message.channels); else if (key == "detector_translation") diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp index 4966be47..1e255573 100644 --- a/frame_serialize/CBORStream2Serializer.cpp +++ b/frame_serialize/CBORStream2Serializer.cpp @@ -423,6 +423,23 @@ inline void CBOR_ENC_PIXEL_MASK(CborEncoder &encoder, const StartMessage &msg) { cborErr(cbor_encoder_close_container(&encoder, &mapEncoder)); } +inline void CBOR_ENC_AZINT_MAP(CborEncoder &encoder, const StartMessage &msg) { + if (msg.az_int_map.empty()) + return; + + if (msg.az_int_map.size() != msg.image_size_x * msg.image_size_y) + throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, + "Mismatch in size of pixel mask"); + + JFJochBitShuffleCompressor compressor(CompressionAlgorithm::BSHUF_LZ4); + auto mask_compressed = compressor.Compress(msg.az_int_map); + CompressedImage image(mask_compressed.data(), mask_compressed.size(), + msg.image_size_x, msg.image_size_y, + CompressedImageMode::Uint16, + CompressionAlgorithm::BSHUF_LZ4, "az_int_map"); + CBOR_ENC_2D_TYPED_ARRAY(encoder, image); +} + inline void CBOR_ENC(CborEncoder &encoder, const char* key, const UnitCell &val) { CborEncoder mapEncoder; @@ -637,6 +654,7 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message) CBOR_ENC(mapEncoder, "geometry_transformation_enabled", message.geometry_transformation_enabled); CBOR_ENC_PIXEL_MASK(mapEncoder, message); + CBOR_ENC_AZINT_MAP(mapEncoder, message); CBOR_ENC(mapEncoder, "channels", message.channels); CBOR_ENC(mapEncoder, "max_spot_count", message.max_spot_count); diff --git a/tests/CBORTest.cpp b/tests/CBORTest.cpp index 8690f51a..da3ecd21 100644 --- a/tests/CBORTest.cpp +++ b/tests/CBORTest.cpp @@ -822,10 +822,38 @@ TEST_CASE("CBORSerialize_Image_Rad_Int_Profile", "[CBOR]") { else CHECK(message.az_int_profile_std[i] == Catch::Approx(image_array.az_int_profile_std[i])); } - REQUIRE(image_array.az_int_profile_std == message.az_int_profile_std); REQUIRE(image_array.az_int_profile_count == message.az_int_profile_count); } +TEST_CASE("CBORSerialize_Start_AzintMap", "[CBOR]") { + std::vector buffer(8 * 1024 * 1024); + CBORStream2Serializer serializer(buffer.data(), buffer.size()); + + std::vector test(512); + for (int i = 0; i < test.size(); i++) + test[i] = (i * 253 + 56) % 256; + + std::vector azint_map(32 * 15, 57); + azint_map[0] = 123; + azint_map[32*14] = UINT16_MAX; + + StartMessage msg{ + .image_size_x = 32, + .image_size_y = 15, + .az_int_map = azint_map + }; + + + REQUIRE_NOTHROW(serializer.SerializeSequenceStart(msg)); + + auto deserialized = CBORStream2Deserialize(buffer.data(), serializer.GetBufferSize()); + REQUIRE(deserialized); + REQUIRE(deserialized->msg_type == CBORImageType::START); + REQUIRE(deserialized->start_message); + CHECK(deserialized->start_message->az_int_map == azint_map); +} + + TEST_CASE("CBORSerialize_Image_Spots", "[CBOR]") { std::vector buffer(8 * 1024 * 1024); CBORStream2Serializer serializer(buffer.data(), buffer.size()); diff --git a/writer/HDF5NXmx.cpp b/writer/HDF5NXmx.cpp index 13c03e39..0a119323 100644 --- a/writer/HDF5NXmx.cpp +++ b/writer/HDF5NXmx.cpp @@ -724,6 +724,9 @@ void NXmx::AzimuthalIntegration(const StartMessage &start, const EndMessage &end if (x != "image") az_int_group.SaveVector(x, y, dim); } + + if (!start.az_int_map.empty() && start.az_int_map.size() == start.image_size_y * start.image_size_x) + az_int_group.SaveVector("map", start.az_int_map, {start.image_size_y, start.image_size_x}); } } -- 2.52.0 From 57fc38195e7702570f0ec53011913b7bdb36dc4e Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 2 Jun 2026 18:36:46 +0200 Subject: [PATCH 03/46] Save Pixel-to-bin map in JFJochReceiver, and write it compressed in the master file --- common/AzimuthalIntegrationMapping.h | 2 +- receiver/JFJochReceiver.cpp | 5 ++++- writer/HDF5NXmx.cpp | 3 ++- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/common/AzimuthalIntegrationMapping.h b/common/AzimuthalIntegrationMapping.h index 3203187e..eddab1f7 100644 --- a/common/AzimuthalIntegrationMapping.h +++ b/common/AzimuthalIntegrationMapping.h @@ -42,7 +42,7 @@ public: size_t nthreads = 0); [[nodiscard]] uint16_t GetBinNumber() const; - [[nodiscard]] const std::vector&GetPixelToBin() const; + [[nodiscard]] const std::vector& GetPixelToBin() const; [[nodiscard]] const std::vector &GetBinToQ() const; [[nodiscard]] const std::vector &GetBinToD() const; [[nodiscard]] const std::vector &GetBinToTwoTheta() const; diff --git a/receiver/JFJochReceiver.cpp b/receiver/JFJochReceiver.cpp index ba6d05f4..da9367c9 100644 --- a/receiver/JFJochReceiver.cpp +++ b/receiver/JFJochReceiver.cpp @@ -115,12 +115,15 @@ void JFJochReceiver::SendStartMessage() { message.az_int_bin_to_q = az_int_mapping->GetBinToQ(); message.az_int_bin_to_two_theta = az_int_mapping->GetBinToTwoTheta(); message.az_int_phi_bin_count = az_int_mapping->GetAzimuthalBinCount(); - if (az_int_mapping->GetAzimuthalBinCount() > 1) + if (az_int_mapping->GetAzimuthalBinCount() > 1) { message.az_int_bin_to_phi = az_int_mapping->GetBinToPhi(); + message.az_int_map = az_int_mapping->GetPixelToBin(); + } message.writer_notification_zmq_addr = image_pusher.GetWriterNotificationSocketAddress(); message.rois = experiment.ROI().ExportMetadata(); message.max_spot_count = experiment.GetMaxSpotCount(); + std::vector nexus_mask; message.pixel_mask["default"] = pixel_mask.GetMask(experiment); diff --git a/writer/HDF5NXmx.cpp b/writer/HDF5NXmx.cpp index 0a119323..5a45a78c 100644 --- a/writer/HDF5NXmx.cpp +++ b/writer/HDF5NXmx.cpp @@ -726,7 +726,8 @@ void NXmx::AzimuthalIntegration(const StartMessage &start, const EndMessage &end } if (!start.az_int_map.empty() && start.az_int_map.size() == start.image_size_y * start.image_size_x) - az_int_group.SaveVector("map", start.az_int_map, {start.image_size_y, start.image_size_x}); + az_int_group.SaveVector("map", start.az_int_map, {start.image_size_y, start.image_size_x}, + CompressionAlgorithm::BSHUF_LZ4); } } -- 2.52.0 From 4e4b0a9b33acdb153e61f068efd0856e9bbb17ed Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 2 Jun 2026 20:05:38 +0200 Subject: [PATCH 04/46] AzIntEngine: Fixes --- image_analysis/azint/AzIntEngine.cpp | 1 + image_analysis/azint/AzIntEngineCPU.cpp | 26 +-------------------- image_analysis/azint/AzIntEngineCPU.h | 30 +++++++++++++++++++++++++ 3 files changed, 32 insertions(+), 25 deletions(-) diff --git a/image_analysis/azint/AzIntEngine.cpp b/image_analysis/azint/AzIntEngine.cpp index 27d0d462..99cb8aab 100644 --- a/image_analysis/azint/AzIntEngine.cpp +++ b/image_analysis/azint/AzIntEngine.cpp @@ -7,5 +7,6 @@ AzIntEngine::AzIntEngine(const AzimuthalIntegrationMapping &integration) : integration(integration), npixel(integration.GetPixelToBin().size()), azint_sum(integration.GetBinNumber(), 0.0f), +azint_sum2(integration.GetBinNumber(), 0.0f), azint_count(integration.GetBinNumber(), 0.0f), azint_bins(integration.GetBinNumber()){} diff --git a/image_analysis/azint/AzIntEngineCPU.cpp b/image_analysis/azint/AzIntEngineCPU.cpp index f8dc7321..9e848682 100644 --- a/image_analysis/azint/AzIntEngineCPU.cpp +++ b/image_analysis/azint/AzIntEngineCPU.cpp @@ -7,29 +7,5 @@ AzIntEngineCPU::AzIntEngineCPU(const AzimuthalIntegrationMapping &integration) : AzIntEngine(integration) {} void AzIntEngineCPU::Run(const ImagePreprocessorBuffer &image, AzimuthalIntegrationProfile &profile){ - - for (int i = 0; i < azint_count.size(); i++) { - azint_sum[i] = 0.0f; - azint_sum2[i] = 0.0f; - azint_count[i] = 0; - } - - if (image.size() != npixel) - throw std::runtime_error("ImageSpotFinder::AzimIntegration: Mismatch in size"); - - const uint16_t *pixel_to_bin = integration.GetPixelToBin().data(); - const float *corrections = integration.Corrections().data(); - - for (int i = 0; i < image.size(); i++) { - const uint16_t bin = pixel_to_bin[i]; - if (bin < azint_bins) { - float val = static_cast(image[i]) * corrections[i]; - azint_sum[bin] += val; - azint_sum2[bin] += val * val; - ++azint_count[bin]; - } - } - - profile.Clear(integration); - profile.Add(azint_sum, azint_sum2, azint_count); + RunAzint(image, profile); } diff --git a/image_analysis/azint/AzIntEngineCPU.h b/image_analysis/azint/AzIntEngineCPU.h index d89c211d..3089cd45 100644 --- a/image_analysis/azint/AzIntEngineCPU.h +++ b/image_analysis/azint/AzIntEngineCPU.h @@ -7,6 +7,36 @@ class AzIntEngineCPU : public AzIntEngine { public: + // image is anything that can be referenced with operator[] + template + void RunAzint(const T &image, AzimuthalIntegrationProfile &profile) { + for (int i = 0; i < azint_count.size(); i++) { + azint_sum[i] = 0.0f; + azint_sum2[i] = 0.0f; + azint_count[i] = 0; + } + + if (image.size() != npixel) + throw std::runtime_error("ImageSpotFinder::AzimIntegration: Mismatch in size"); + + const uint16_t *pixel_to_bin = integration.GetPixelToBin().data(); + const float *corrections = integration.Corrections().data(); + + for (int i = 0; i < image.size(); i++) { + const float val = static_cast(image[i]) * corrections[i]; + const float val_sq = val * val; + const uint16_t bin = pixel_to_bin[i]; + if (bin < azint_bins) { + azint_sum[bin] += val; + azint_sum2[bin] += val_sq; + ++azint_count[bin]; + } + } + + profile.Clear(integration); + profile.Add(azint_sum, azint_sum2, azint_count); + } + AzIntEngineCPU(const AzimuthalIntegrationMapping& integration); void Run(const ImagePreprocessorBuffer &image, AzimuthalIntegrationProfile &profile) override; }; \ No newline at end of file -- 2.52.0 From dcef5469e8784147c99d598662ed1c17e606ae03 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 2 Jun 2026 20:05:54 +0200 Subject: [PATCH 05/46] jfjoch_azint_test: Add temporary tool to benchmark azint --- tools/CMakeLists.txt | 3 +++ tools/jfjoch_azint_test.cpp | 45 +++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+) create mode 100644 tools/jfjoch_azint_test.cpp diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt index 8fd2eb97..272612ca 100644 --- a/tools/CMakeLists.txt +++ b/tools/CMakeLists.txt @@ -41,6 +41,9 @@ ADD_EXECUTABLE(jfjoch_extract_hkl jfjoch_extract_hkl.cpp TARGET_LINK_LIBRARIES(jfjoch_extract_hkl JFJochReader) INSTALL(TARGETS jfjoch_extract_hkl RUNTIME COMPONENT viewer) +ADD_EXECUTABLE(jfjoch_azint_test jfjoch_azint_test.cpp) +TARGET_LINK_LIBRARIES(jfjoch_azint_test JFJochImageAnalysis JFJochCommon) + ADD_EXECUTABLE(jfjoch_process jfjoch_process.cpp) TARGET_LINK_LIBRARIES(jfjoch_process JFJochReader JFJochImageAnalysis JFJochWriter JFJochReceiver) INSTALL(TARGETS jfjoch_process RUNTIME COMPONENT viewer) diff --git a/tools/jfjoch_azint_test.cpp b/tools/jfjoch_azint_test.cpp new file mode 100644 index 00000000..5b99e614 --- /dev/null +++ b/tools/jfjoch_azint_test.cpp @@ -0,0 +1,45 @@ +#include +#include +#include + +#include "../common/DiffractionExperiment.h" +#include "../common/AzimuthalIntegrationMapping.h" +#include "../common/AzimuthalIntegrationProfile.h" +#include "../common/AzimuthalIntegrationProfile.h" +#include "../common/Logger.h" +#include "../image_analysis/azint/AzIntEngineCPU.h" + +int main(int argc, char** argv) { + constexpr const uint32_t nimages = 1000; + + DiffractionExperiment experiment(DetEIGER(18, 3, 36, 8)); + + AzimuthalIntegrationSettings azim_settings; + azim_settings.QSpacing_recipA(0.01).QRange_recipA(0.005, 5.0).AzimuthalBinCount(64); + experiment.ImportAzimuthalIntegrationSettings(azim_settings).DetectorDistance_mm(100).BeamX_pxl(1500).BeamY_pxl(1500); + + PixelMask pixel_mask(experiment); + AzimuthalIntegrationMapping mapping(experiment, pixel_mask); + spdlog::info("Bins {}", mapping.GetBinNumber()); + + std::vector image(experiment.GetPixelsNum()); + + std::mt19937 rng(42); // seed + std::poisson_distribution poisson(20.0); // mean = 20 photons + + for (auto& pixel : image) + pixel = static_cast(poisson(rng)); + + spdlog::info("Generated image"); + + AzIntEngineCPU azint_engine(mapping); + AzimuthalIntegrationProfile profile(mapping); + + auto start_time = std::chrono::steady_clock::now(); + for (int i = 0; i < nimages; i++) + azint_engine.RunAzint(image, profile); + + auto end_time = std::chrono::steady_clock::now(); + auto duration = std::chrono::duration(end_time - start_time).count(); + spdlog::info("Time: {} ms", duration/nimages * 1000.0); +} \ No newline at end of file -- 2.52.0 From ffcf037205db94c4b5c870360a43c9d23bc2ae1d Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 2 Jun 2026 20:30:22 +0200 Subject: [PATCH 06/46] Make x86-64-v3 default architecture --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 02668e08..8fd729a3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,8 +8,8 @@ SET(CMAKE_POLICY_DEFAULT_CMP0077 NEW) SET(CMAKE_CXX_STANDARD 20) SET(CMAKE_CXX_STANDARD_REQUIRED True) -SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-deprecated-enum-enum-conversion -DNDEBUG") -SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG") +SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-deprecated-enum-enum-conversion -DNDEBUG -march=x86-64-v3") +SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG -march=x86-64-v3") SET(JFJOCH_WRITER_ONLY OFF CACHE BOOL "Compile HDF5 writer only") SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (ignored if building writer only; necessary for RPM building)") -- 2.52.0 From 4aac2aabd37ccbfb574812c74314095790b4cbfe Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 3 Jun 2026 11:51:33 +0200 Subject: [PATCH 07/46] jfjoch_test: Reduce precision requirements after switching to -march=x86_64-v3. --- tests/CalcBraggPredictionTest.cpp | 6 +++--- tests/IndexingUnitTest.cpp | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/CalcBraggPredictionTest.cpp b/tests/CalcBraggPredictionTest.cpp index 50b609fd..8619258b 100644 --- a/tests/CalcBraggPredictionTest.cpp +++ b/tests/CalcBraggPredictionTest.cpp @@ -35,7 +35,7 @@ TEST_CASE("BraggPrediction_11keV") { REQUIRE(std::abs(r.l) < settings.max_hkl ); REQUIRE(r.d >= settings.high_res_A); REQUIRE(r.d == Catch::Approx(1/std::sqrt(recip * recip)).margin(0.01f)); - REQUIRE(r.dist_ewald == Catch::Approx(std::abs(geom.DistFromEwaldSphere(recip))).epsilon(1e-5)); + REQUIRE(r.dist_ewald == Catch::Approx(std::abs(geom.DistFromEwaldSphere(recip))).epsilon(1e-4)); auto [x,y] = geom.RecipToDetector(recip); REQUIRE(r.predicted_x == Catch::Approx(x).margin(0.01)); REQUIRE(r.predicted_y == Catch::Approx(y).margin(0.01)); @@ -71,7 +71,7 @@ TEST_CASE("BraggPrediction_15keV") { REQUIRE(std::abs(r.l) < settings.max_hkl ); REQUIRE(r.d >= settings.high_res_A); REQUIRE(r.d == Catch::Approx(1/std::sqrt(recip * recip)).margin(0.01f)); - REQUIRE(r.dist_ewald == Catch::Approx(std::abs(geom.DistFromEwaldSphere(recip))).epsilon(1e-5)); + REQUIRE(r.dist_ewald == Catch::Approx(std::abs(geom.DistFromEwaldSphere(recip))).epsilon(1e-3)); auto [x,y] = geom.RecipToDetector(recip); REQUIRE(r.predicted_x == Catch::Approx(x).margin(0.01)); REQUIRE(r.predicted_y == Catch::Approx(y).margin(0.01)); @@ -108,7 +108,7 @@ TEST_CASE("BraggPrediction_Rot1_Rot2") { REQUIRE(std::abs(r.l) < settings.max_hkl ); REQUIRE(r.d >= settings.high_res_A); REQUIRE(r.d == Catch::Approx(1/std::sqrt(recip * recip)).margin(0.01f)); - REQUIRE(r.dist_ewald == Catch::Approx(std::abs(geom.DistFromEwaldSphere(recip))).epsilon(1e-5)); + REQUIRE(r.dist_ewald == Catch::Approx(std::abs(geom.DistFromEwaldSphere(recip))).epsilon(1e-4)); auto [x,y] = geom.RecipToDetector(recip); REQUIRE(r.predicted_x == Catch::Approx(x).margin(0.01)); REQUIRE(r.predicted_y == Catch::Approx(y).margin(0.01)); diff --git a/tests/IndexingUnitTest.cpp b/tests/IndexingUnitTest.cpp index 1e1e1e49..d97b3ce9 100644 --- a/tests/IndexingUnitTest.cpp +++ b/tests/IndexingUnitTest.cpp @@ -219,8 +219,8 @@ TEST_CASE("FFTIndexer","[Indexing]") { REQUIRE(result.lattice.size() == 1); auto uc_out = result.lattice[0].GetUnitCell(); - CHECK(uc_out.a == Catch::Approx(uc.a)); - CHECK(uc_out.b == Catch::Approx(uc.b)); + CHECK(uc_out.a == Catch::Approx(uc.b)); + CHECK(uc_out.b == Catch::Approx(uc.a)); CHECK(uc_out.c == Catch::Approx(uc.c)); CHECK(uc_out.alpha == Catch::Approx(uc.alpha)); -- 2.52.0 From c1f884279d3cf0eaccddfb926e06b1501e1d4f5f Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 3 Jun 2026 12:03:13 +0200 Subject: [PATCH 08/46] Architecture is set in CI file, not in CMake file (so one can still compile with mtune=native, march=native --- .gitea/workflows/build_and_test.yml | 15 +++++++++------ CMakeLists.txt | 4 ++-- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml index 056ba51c..ac19d87e 100644 --- a/.gitea/workflows/build_and_test.yml +++ b/.gitea/workflows/build_and_test.yml @@ -1,5 +1,8 @@ name: Build Packages +env: + MARCH_CMAKE_FLAGS: '-DCMAKE_CXX_FLAGS="-march=x86-64-v3" -DCMAKE_C_FLAGS="-march=x86-64-v3"' + on: push: branches: @@ -33,7 +36,7 @@ jobs: run: | mkdir -p build cd build - cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.MARCH_CMAKE_FLAGS }} .. ninja -j48 jfjoch_test jfjoch_hdf5_test jfjoch_hdf5_enospc_test enospc_shim - name: Run unit tests shell: bash @@ -116,7 +119,7 @@ jobs: run: | mkdir -p build cd build - cmake -G Ninja -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON -DCMAKE_BUILD_TYPE=Release ${{ matrix.cmake_flags }} .. + cmake -G Ninja -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON ${{ env.MARCH_CMAKE_FLAGS }} -DCMAKE_BUILD_TYPE=Release ${{ matrix.cmake_flags }} .. - name: Build packages shell: bash run: | @@ -167,7 +170,7 @@ jobs: run: | mkdir -p build cd build - cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.MARCH_CMAKE_FLAGS }} .. ninja -j16 jfjoch_hdf5_test - name: Run DIALS processing on legacy format shell: bash @@ -203,7 +206,7 @@ jobs: run: | mkdir -p build cd build - cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.MARCH_CMAKE_FLAGS }} .. ninja -j16 jfjoch_hdf5_test - name: Run XDS with Durin and legacy HDF5 format shell: bash @@ -239,7 +242,7 @@ jobs: run: | mkdir -p build cd build - cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.MARCH_CMAKE_FLAGS }} .. ninja -j16 jfjoch_hdf5_test ninja -j16 jfjoch_xds_plugin - name: Run XDS with legacy HDF5 format @@ -275,7 +278,7 @@ jobs: run: | mkdir -p build cd build - cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.MARCH_CMAKE_FLAGS }} .. ninja -j16 jfjoch_hdf5_test - name: Run XDS with Neggia and legacy HDF5 format shell: bash diff --git a/CMakeLists.txt b/CMakeLists.txt index 8fd729a3..02668e08 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,8 +8,8 @@ SET(CMAKE_POLICY_DEFAULT_CMP0077 NEW) SET(CMAKE_CXX_STANDARD 20) SET(CMAKE_CXX_STANDARD_REQUIRED True) -SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-deprecated-enum-enum-conversion -DNDEBUG -march=x86-64-v3") -SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG -march=x86-64-v3") +SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-deprecated-enum-enum-conversion -DNDEBUG") +SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG") SET(JFJOCH_WRITER_ONLY OFF CACHE BOOL "Compile HDF5 writer only") SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (ignored if building writer only; necessary for RPM building)") -- 2.52.0 From ce23a6ccf2cc276b230c4c35046413c1fc5560df Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 3 Jun 2026 12:08:45 +0200 Subject: [PATCH 09/46] FFTIndexerTest: Update test to sort input vectors + remove old, unused file duplicating this test --- tests/FFTIndexerTest.cpp | 54 -------------------------------------- tests/IndexingUnitTest.cpp | 22 +++++++++++++--- 2 files changed, 19 insertions(+), 57 deletions(-) delete mode 100644 tests/FFTIndexerTest.cpp diff --git a/tests/FFTIndexerTest.cpp b/tests/FFTIndexerTest.cpp deleted file mode 100644 index b4cd67e8..00000000 --- a/tests/FFTIndexerTest.cpp +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute -// SPDX-License-Identifier: GPL-3.0-only - -#include -#include "../image_analysis/indexing/IndexerFactory.h" -#include "../common/Logger.h" - -TEST_CASE("FFTIndexer") { - Logger logger("FFTIndexer"); - - UnitCell uc(39,45,78,90,90,90); - CrystalLattice cl(uc); - - DiffractionExperiment experiment; - IndexingSettings settings; - settings.Algorithm(IndexingAlgorithmEnum::FFT) - .FFT_MaxUnitCell_A(250.0).FFT_HighResolution_A(2 * M_PI / 3.0); - experiment.ImportIndexingSettings(settings).SetUnitCell(uc); - -#ifndef JFJOCH_USE_CUDA - REQUIRE(experiment.GetIndexingAlgorithm() == IndexingAlgorithmEnum::None); -#else - REQUIRE(experiment.GetIndexingAlgorithm() == IndexingAlgorithmEnum::FFT); - REQUIRE(experiment.GetIndexingSettings().GetTolerance() == Catch::Approx(0.1f)); - std::unique_ptr indexer = CreateIndexer(experiment); - REQUIRE(indexer); - - std::vector vec; - for (int h = -2; h < 10; h++) { - for (int k = -5; k < 10; k++) { - for (int l = -3; l < 10; l++) { - vec.push_back(h * cl.Astar() + k * cl.Bstar() + l * cl.Cstar()); - } - } - } - logger.Info("Spots {}", vec.size()); - - auto start = std::chrono::high_resolution_clock::now(); - auto result = indexer->Run(vec); - auto end = std::chrono::high_resolution_clock::now(); - - REQUIRE(result.lattice.size() == 1); - auto uc_out = result.lattice[0].GetUnitCell(); - CHECK(uc_out.a == Catch::Approx(uc.a));; - CHECK(uc_out.b == Catch::Approx(uc.b));; - CHECK(uc_out.c == Catch::Approx(uc.c));; - - CHECK(uc_out.alpha == Catch::Approx(uc.alpha));; - CHECK(uc_out.beta == Catch::Approx(uc.beta));; - CHECK(uc_out.gamma == Catch::Approx(uc.gamma));; - - logger.Info("Time: {} ms", std::chrono::duration_cast(end - start).count()); -#endif -} diff --git a/tests/IndexingUnitTest.cpp b/tests/IndexingUnitTest.cpp index d97b3ce9..390daf9b 100644 --- a/tests/IndexingUnitTest.cpp +++ b/tests/IndexingUnitTest.cpp @@ -218,10 +218,26 @@ TEST_CASE("FFTIndexer","[Indexing]") { auto end = std::chrono::high_resolution_clock::now(); REQUIRE(result.lattice.size() == 1); + auto uc_out = result.lattice[0].GetUnitCell(); - CHECK(uc_out.a == Catch::Approx(uc.b)); - CHECK(uc_out.b == Catch::Approx(uc.a)); - CHECK(uc_out.c == Catch::Approx(uc.c)); + + // Collect and sort both sets of lengths to compare order-independently + std::array out_lengths = { + static_cast(uc_out.a), + static_cast(uc_out.b), + static_cast(uc_out.c) + }; + std::array ref_lengths = { + static_cast(uc.a), + static_cast(uc.b), + static_cast(uc.c) + }; + std::sort(out_lengths.begin(), out_lengths.end()); + std::sort(ref_lengths.begin(), ref_lengths.end()); + + CHECK(out_lengths[0] == Catch::Approx(ref_lengths[0])); + CHECK(out_lengths[1] == Catch::Approx(ref_lengths[1])); + CHECK(out_lengths[2] == Catch::Approx(ref_lengths[2])); CHECK(uc_out.alpha == Catch::Approx(uc.alpha)); CHECK(uc_out.beta == Catch::Approx(uc.beta)); -- 2.52.0 From 1b1df4a6054c921305fc2a3a34a29ec72f125a95 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 3 Jun 2026 12:11:12 +0200 Subject: [PATCH 10/46] CHANGELOG --- docs/CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 7028a8a3..873cea36 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -3,6 +3,7 @@ ### 1.0.0-rc.147 This is an UNSTABLE release. The release has significant modifications for data processing - in case of troubles go back to 1.0.0-rc.144. +* CI pipeline builds software with x86_64-v3 architecture, it should be compatible with practically all x86 hardware manufactured after 2015. * jfjoch_viewer: Add reciprocal space viewer * jfjoch_process: Two pass algorithm that does spot finding/indexing + integration of full dataset * jfjoch_process: Improve logic for rotation indexer, to make execution more deterministic (still work in progress) -- 2.52.0 From ab9db988dd9f330ae31bb0ba9e0cbe0c785935bd Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 3 Jun 2026 13:34:38 +0200 Subject: [PATCH 11/46] CrystalLattice: Add Niggli reduction option --- common/CrystalLattice.cpp | 12 ++++++++++++ common/CrystalLattice.h | 2 ++ tests/CrystalLatticeTest.cpp | 18 ++++++++++++++++++ 3 files changed, 32 insertions(+) diff --git a/common/CrystalLattice.cpp b/common/CrystalLattice.cpp index 968d28f4..888bee1a 100644 --- a/common/CrystalLattice.cpp +++ b/common/CrystalLattice.cpp @@ -7,6 +7,7 @@ #include "gemmi/symmetry.hpp" #include "gemmi/unitcell.hpp" +#include "gemmi/cellred.hpp" #define DEG_TO_RAD static_cast(M_PI/180.0) @@ -211,3 +212,14 @@ std::vector CrystalLattice::GetUBMatrix() const { astar.z, bstar.z, cstar.z }; } + +CrystalLattice CrystalLattice::NiggliReduce() const { + UnitCell uc = GetUnitCell(); + gemmi::UnitCell g_uc(uc.a, uc.b, uc.c, uc.alpha, uc.beta, uc.gamma); + gemmi::GruberVector g_vec(g_uc, 'P', /*track_change_of_basis=*/true); + g_vec.niggli_reduce(); + + if (g_vec.change_of_basis) + return Multiply(gemmi::rot_as_mat33(g_vec.change_of_basis->rot).transpose()); + return *this; +} \ No newline at end of file diff --git a/common/CrystalLattice.h b/common/CrystalLattice.h index 7ec162d7..3e6cd33b 100644 --- a/common/CrystalLattice.h +++ b/common/CrystalLattice.h @@ -39,6 +39,8 @@ public: void Sort(); void Regularize(const gemmi::CrystalSystem &input); [[nodiscard]] std::vector GetUBMatrix() const; + + CrystalLattice NiggliReduce() const; }; diff --git a/tests/CrystalLatticeTest.cpp b/tests/CrystalLatticeTest.cpp index f6db596a..d99d5757 100644 --- a/tests/CrystalLatticeTest.cpp +++ b/tests/CrystalLatticeTest.cpp @@ -169,3 +169,21 @@ TEST_CASE("CrystalLattice_FromPrimitive") { CHECK(uc_c.beta == Catch::Approx(90.f).margin(1e-3f)); CHECK(uc_c.gamma == Catch::Approx(90.f).margin(1e-3f)); } + +TEST_CASE("CrystalLattice_NiggliReduce") { + Coord a = {3,0,0}; + Coord b = {0,4,0}; + Coord c = {0,0,5}; + + CrystalLattice l(a + 2 * b, b, c - 5 * b); + + auto red_uc = l.NiggliReduce().GetUnitCell(); + + CHECK(red_uc.a == Catch::Approx(3.0)); + CHECK(red_uc.b == Catch::Approx(4.0)); + CHECK(red_uc.c == Catch::Approx(5.0)); + + CHECK(red_uc.alpha == Catch::Approx(90.0)); + CHECK(red_uc.beta == Catch::Approx(90.0)); + CHECK(red_uc.gamma == Catch::Approx(90.0)); +} -- 2.52.0 From 5ffe44892cbc713d9f0a9f0ea0550a1f4e376d3d Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 3 Jun 2026 13:47:55 +0200 Subject: [PATCH 12/46] FFTIndexer: Use Niggli Reduction --- image_analysis/indexing/FFTIndexer.cpp | 30 +++++++++++--------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/image_analysis/indexing/FFTIndexer.cpp b/image_analysis/indexing/FFTIndexer.cpp index ecf68998..978ee639 100644 --- a/image_analysis/indexing/FFTIndexer.cpp +++ b/image_analysis/indexing/FFTIndexer.cpp @@ -97,23 +97,20 @@ std::vector FFTIndexer::ReduceResults(const std::vector & // sort vectors by length for reduction Sort(A,B,C); - // Lattice reduction - B = B - std::round(B * A / (A * A)) * A; - C = C - std::round(C * A / (A * A)) * A; - C = C - std::round(C * B / (B * B)) * B; + CrystalLattice raw(A, B, C); + CrystalLattice reduced = raw.NiggliReduce(); // Reduce cell + const auto uc = reduced.GetUnitCell(); - float alpha = angle_deg(B, C); - float beta = angle_deg(A, C); - float gamma = angle_deg(A, B); + if (uc.a < min_length_A || uc.b < min_length_A || uc.c < min_length_A) + continue; - // Check if values are OK after lattice reduction - if (A.Length() >= min_length_A - && B.Length() >= min_length_A - && C.Length() >= min_length_A - && alpha >= min_angle_deg && alpha <= max_angle_deg - && beta >= min_angle_deg && beta <= max_angle_deg - && gamma >= min_angle_deg && gamma <= max_angle_deg) - candidates.emplace_back(A, B, C); + float alpha = uc.alpha, beta = uc.beta, gamma = uc.gamma; + if (alpha < min_angle_deg || alpha > max_angle_deg || + beta < min_angle_deg || beta > max_angle_deg || + gamma < min_angle_deg || gamma > max_angle_deg) + continue; + + candidates.emplace_back(std::move(reduced)); } } } @@ -141,8 +138,7 @@ std::vector FFTIndexer::FilterFFTResults() const { std::vector ret; // Remove vectors less than 5 deg apart, as most likely these are colinear - constexpr float COS_5_DEG = 0.996194; - + const float COS_5_DEG = std::cos(5.0f * M_PI / 180.0f); // Minimum relative amplitude to accept a shorter vector (fundamental) // over a longer one (harmonic). -- 2.52.0 From 14b681655299395dbb725a139d92dd71db119986 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Wed, 3 Jun 2026 22:25:18 +0200 Subject: [PATCH 13/46] jfjoch_process: Allow to force lattice for rotation indexing --- image_analysis/IndexAndRefine.cpp | 5 + image_analysis/IndexAndRefine.h | 3 +- .../rotation_indexer/RotationIndexer.cpp | 19 ++++ .../rotation_indexer/RotationIndexer.h | 1 + tools/jfjoch_process.cpp | 91 ++++++++++++++++--- 5 files changed, 107 insertions(+), 12 deletions(-) diff --git a/image_analysis/IndexAndRefine.cpp b/image_analysis/IndexAndRefine.cpp index 18a58e1b..b72712d4 100644 --- a/image_analysis/IndexAndRefine.cpp +++ b/image_analysis/IndexAndRefine.cpp @@ -433,3 +433,8 @@ std::vector &IndexAndRefine::GetIntegrationOutcome() { const std::vector &IndexAndRefine::GetIntegrationOutcome() const { return integration_outcome; } + +void IndexAndRefine::ForceRotationIndexerLattice(const CrystalLattice &lattice) { + if (rotation_indexer) + rotation_indexer->ForceLattice(lattice); +} diff --git a/image_analysis/IndexAndRefine.h b/image_analysis/IndexAndRefine.h index ac4d7cd7..eab212a0 100644 --- a/image_analysis/IndexAndRefine.h +++ b/image_analysis/IndexAndRefine.h @@ -68,6 +68,8 @@ public: IndexAndRefine(const DiffractionExperiment &x, IndexerThreadPool *indexer); void AddImageToRotationIndexer(DataMessage &msg); + void ForceRotationIndexerLattice(const CrystalLattice& lattice); + void ProcessImage(DataMessage &msg, const SpotFindingSettings &settings, const CompressedImage &image, BraggPrediction &prediction); IndexAndRefine& ReferenceIntensities(std::vector &reference); @@ -83,5 +85,4 @@ public: std::vector &GetIntegrationOutcome(); const std::vector &GetIntegrationOutcome() const; - }; diff --git a/image_analysis/rotation_indexer/RotationIndexer.cpp b/image_analysis/rotation_indexer/RotationIndexer.cpp index 3f588a4f..e9919377 100644 --- a/image_analysis/rotation_indexer/RotationIndexer.cpp +++ b/image_analysis/rotation_indexer/RotationIndexer.cpp @@ -127,3 +127,22 @@ std::optional RotationIndexer::GetLattice() const { }; } +void RotationIndexer::ForceLattice(const CrystalLattice &lattice) { + indexed_lattice = lattice; + auto sg_num = experiment.GetSpaceGroupNumber().value_or(1); + auto sg = gemmi::find_spacegroup_by_number(sg_num); + if (sg != nullptr) { + search_result_ = LatticeSearchResult{ + .niggli_class = 0, // Since Niggli class was not searched for, we don't know which one + .conventional = lattice, // If lattice provided, it is for now primitive == conventional + .system = sg->crystal_system(), + .centering = sg->centring_type(), + }; + } else + search_result_ = LatticeSearchResult{ + .niggli_class = 0, // Since Niggli class was not searched for, we don't know which one + .conventional = lattice, // If lattice provided, it is for now primitive == conventional + .system = gemmi::CrystalSystem::Triclinic, + .centering = 'P', + }; +} diff --git a/image_analysis/rotation_indexer/RotationIndexer.h b/image_analysis/rotation_indexer/RotationIndexer.h index 585af5ab..73bc8901 100644 --- a/image_analysis/rotation_indexer/RotationIndexer.h +++ b/image_analysis/rotation_indexer/RotationIndexer.h @@ -44,4 +44,5 @@ public: void ProcessImage(int64_t image, const std::vector& spots); void RunIndexing(); std::optional GetLattice() const; + void ForceLattice(const CrystalLattice& lattice); }; diff --git a/tools/jfjoch_process.cpp b/tools/jfjoch_process.cpp index b2d16722..f0f32aab 100644 --- a/tools/jfjoch_process.cpp +++ b/tools/jfjoch_process.cpp @@ -54,6 +54,7 @@ void print_usage() { std::cout << " -R, --two-pass-rotation[=num] Two-pass offline rotation indexing (optional: number of images, default: 30)" << std::endl; std::cout << " --single-pass-rotation[=num] Use online-like single-pass rotation indexing (optional: min angular range deg)" << std::endl; std::cout << " --redo-rotation-spots Redo spot finding for two-pass rotation indexing" << std::endl; + std::cout << " --force-rotation-lattice Force rotation indexer with external lattice (in Angstrom) : \"a0x,a0y,a0z,a1x,a1y,a1z,a2x,a2y,a2z\" (9 floats, skips first pass)" << std::endl; std::cout << " -X, --indexing-algorithm Indexing algorithm (FFBIDX|FFT|FFTW|Auto|None)" << std::endl; std::cout << " -S, --space-group Space group number - used for both indexing and scaling" << std::endl; std::cout << " -C, --unit-cell Fix reference unit cell: \"a,b,c,alpha,beta,gamma\"" << std::endl; @@ -85,7 +86,8 @@ enum { OPT_SCALING_HIGH_RESOLUTION, OPT_SCALING_OUTPUT, OPT_SINGLE_PASS_ROTATION, - OPT_REDO_ROTATION_SPOTS + OPT_REDO_ROTATION_SPOTS, + OPT_FORCE_ROTATION_LATTICE }; static option long_options[] = { @@ -109,6 +111,8 @@ static option long_options[] = { {"two-pass-rotation", optional_argument, nullptr, 'R'}, {"single-pass-rotation", optional_argument, nullptr, OPT_SINGLE_PASS_ROTATION}, {"redo-rotation-spots", no_argument, nullptr, OPT_REDO_ROTATION_SPOTS}, + {"force-rotation-lattice", required_argument, nullptr, OPT_FORCE_ROTATION_LATTICE}, + {"spot-sigma", required_argument, nullptr, OPT_SPOT_SIGMA}, {"spot-threshold", required_argument, nullptr, OPT_SPOT_THRESHOLD}, @@ -130,6 +134,16 @@ void trim_in_place(std::string &t) { t = t.substr(b, e - b); }; +bool parse_float_strict(const std::string &t, float &out) { + try { + size_t idx = 0; + out = std::stof(t, &idx); + return idx == t.size(); + } catch (...) { + return false; + } +}; + std::optional parse_unit_cell_arg(const char *arg) { if (!arg) return std::nullopt; @@ -160,15 +174,7 @@ std::optional parse_unit_cell_arg(const char *arg) { if (parts.size() != 6) return std::nullopt; - auto parse_float_strict = [](const std::string &t, float &out) -> bool { - try { - size_t idx = 0; - out = std::stof(t, &idx); - return idx == t.size(); - } catch (...) { - return false; - } - }; + UnitCell uc{}; if (!parse_float_strict(parts[0], uc.a)) return std::nullopt; @@ -181,6 +187,43 @@ std::optional parse_unit_cell_arg(const char *arg) { return uc; } +std::optional parse_lattice_arg(const char *arg) { + if (!arg) + return std::nullopt; + + std::string s(arg); + trim_in_place(s); + + if (s.size() >= 2 && ((s.front() == '"' && s.back() == '"') || (s.front() == '\'' && s.back() == '\''))) { + s = s.substr(1, s.size() - 2); + trim_in_place(s); + } + + std::vector parts; + parts.reserve(9); + size_t start = 0; + while (true) { + size_t pos = s.find(',', start); + if (pos == std::string::npos) { + parts.push_back(s.substr(start)); + break; + } + parts.push_back(s.substr(start, pos - start)); + start = pos + 1; + } + + if (parts.size() != 9) + return std::nullopt; + + std::vector vals(9); + for (int i = 0; i < 9; i++) { + if (!parse_float_strict(parts[i], vals[i])) + return std::nullopt; + } + + return CrystalLattice(vals); +} + std::vector select_equally_spaced_image_ordinals(int images_to_process, int requested_images) { std::vector ret; @@ -248,6 +291,7 @@ int main(int argc, char **argv) { double min_partiality = 0.02; double min_image_cc = 0.0; int64_t scaling_iter = 3; + std::optional forced_rotation_lattice; IndexingAlgorithmEnum indexing_algorithm = IndexingAlgorithmEnum::Auto; GeomRefinementAlgorithmEnum refinement_algorithm = GeomRefinementAlgorithmEnum::BeamCenter; @@ -312,6 +356,28 @@ int main(int argc, char **argv) { case OPT_REDO_ROTATION_SPOTS: reuse_rotation_spots = false; break; + case OPT_FORCE_ROTATION_LATTICE: { + if (rotation_indexing) { + logger.Error("Rotation indexing already enabled"); + exit(EXIT_FAILURE); + } + rotation_indexing = true; + + auto latt = parse_lattice_arg(optarg); + if (!latt.has_value()) { + logger.Error( + "Invalid rotation lattice. Expected: \"a0x,a0y,a0z,a1x,a1y,a1z,a2x,a2y,a2z\" (9 floats, comma-separated). Got: {}", + optarg ? optarg : ""); + print_usage(); + exit(EXIT_FAILURE); + } + forced_rotation_lattice = latt; + auto uc = latt->GetUnitCell(); + logger.Info( + "Forced rotation lattice set: a={:.3f} b={:.3f} c={:.3f} alpha={:.3f} beta={:.3f} gamma={:.3f}", + uc.a, uc.b, uc.c, uc.alpha, uc.beta, uc.gamma); + break; + } case 'X': { std::string alg = optarg ? optarg : ""; std::transform(alg.begin(), alg.end(), alg.begin(), @@ -635,7 +701,10 @@ int main(int argc, char **argv) { if (!reference_data.empty()) indexer.ReferenceIntensities(reference_data); - if (rotation_indexing && two_pass_rotation) { + if (forced_rotation_lattice.has_value()) { + indexer.ForceRotationIndexerLattice(*forced_rotation_lattice); + logger.Info("Rotation indexer lattice forced externally - skipping first pass indexing"); + } else if (rotation_indexing && two_pass_rotation) { const auto selected_ordinals = select_equally_spaced_image_ordinals( images_to_process, rotation_indexing_image_count); -- 2.52.0 From 47a066d631582243ed2b374ab6d8d9b60609fdc5 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Thu, 4 Jun 2026 18:44:36 +0200 Subject: [PATCH 14/46] FFTIndexer: Fixes to handle better multiple lattices --- common/Coord.cpp | 6 --- common/Coord.h | 4 ++ image_analysis/indexing/FFTIndexer.cpp | 24 ++++++------ .../indexing/PostIndexingRefinement.cpp | 37 +++++++++---------- .../indexing/PostIndexingRefinement.h | 2 +- 5 files changed, 34 insertions(+), 39 deletions(-) diff --git a/common/Coord.cpp b/common/Coord.cpp index cde960ea..54809077 100644 --- a/common/Coord.cpp +++ b/common/Coord.cpp @@ -152,12 +152,6 @@ void Coord::swap(Coord &other) noexcept { std::swap(z, other.z); } -// Then outside the class but in the same namespace: -inline void swap(Coord& a, Coord& b) noexcept { - a.swap(b); -} - - RotMatrix::RotMatrix() { for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) diff --git a/common/Coord.h b/common/Coord.h index 96d0a320..33191d15 100644 --- a/common/Coord.h +++ b/common/Coord.h @@ -59,4 +59,8 @@ public: std::vector arr() const; }; +inline void swap(Coord& a, Coord& b) noexcept { + a.swap(b); +} + #endif //INDEX_COORD_H diff --git a/image_analysis/indexing/FFTIndexer.cpp b/image_analysis/indexing/FFTIndexer.cpp index 978ee639..a0f224d3 100644 --- a/image_analysis/indexing/FFTIndexer.cpp +++ b/image_analysis/indexing/FFTIndexer.cpp @@ -89,7 +89,6 @@ std::vector FFTIndexer::ReduceResults(const std::vector & for (int k = 0; k < 3; k++) { if (i + j + k + 2 >= results.size()) break; - Coord A = results[i]; Coord B = results[(i + j + 1)]; Coord C = results[(i + j + 1) + k + 1]; @@ -133,7 +132,7 @@ std::vector FFTIndexer::FilterFFTResults() const { it != fft_result_map.rend() && count < max_vectors; ++it, ++count) { fft_result_filtered.emplace_back(it->second); - } + } std::vector ret; @@ -180,6 +179,7 @@ std::vector FFTIndexer::FilterFFTResults() const { // If it's less than 25%, the shorter peak is likely noise/aliasing, // and the longer vector is the true primitive cell. if (magnitude_ratio > MIN_FUNDAMENTAL_PEAK_RATIO) { + dir_i = dir_j; len_i = fft_result_filtered[j].length; best_idx = j; } @@ -189,6 +189,12 @@ std::vector FFTIndexer::FilterFFTResults() const { Coord best_dir = direction_vectors.at(fft_result_filtered[best_idx].direction); ret.push_back(best_dir * fft_result_filtered[best_idx].length); } + + // Sort filtered vectors by magnitude + std::sort(ret.begin(), ret.end(), [](const Coord &A, const Coord &B) { + return A.Length() < B.Length(); + }); + return ret; } @@ -204,8 +210,8 @@ std::vector FFTIndexer::RunInternal(const std::vector &co assert(coord.size() <= FFT_MAX_SPOTS); ExecuteFFT(coord, nspots); - auto f = FilterFFTResults(); - auto r = ReduceResults(f); + const auto f = FilterFFTResults(); + const auto r = ReduceResults(f); Eigen::MatrixX3 oCell(r.size() * 3u, 3u); Eigen::VectorX scores(r.size()); @@ -238,13 +244,5 @@ std::vector FFTIndexer::RunInternal(const std::vector &co .indexing_tolerance = indexing_tolerance }; - auto ref_latt = Refine(coord, nspots, oCell, scores, parameters); - if (ref_latt.size() >= 1) { - auto uc = ref_latt.at(0).GetUnitCell(); - if (uc.alpha < min_angle_deg || uc.alpha > max_angle_deg - || uc.beta < min_angle_deg || uc.beta > max_angle_deg - || uc.gamma < min_angle_deg || uc.gamma > max_angle_deg) - return {}; - } - return ref_latt; + return Refine(coord, nspots, oCell, scores, parameters); } \ No newline at end of file diff --git a/image_analysis/indexing/PostIndexingRefinement.cpp b/image_analysis/indexing/PostIndexingRefinement.cpp index 36b0b837..45960eca 100644 --- a/image_analysis/indexing/PostIndexingRefinement.cpp +++ b/image_analysis/indexing/PostIndexingRefinement.cpp @@ -3,6 +3,8 @@ #include "PostIndexingRefinement.h" +#include + namespace { struct config_ifssr final { float threshold_contraction = .8; // contract error threshold by this value in every iteration @@ -170,17 +172,18 @@ std::vector Refine(const std::vector &in_spots, } else { if (row_norms.minCoeff() < p.min_length_A || row_norms.maxCoeff() > p.max_length_A) continue; - - float alpha = std::acos(cell_rows.row(1).normalized().dot(cell_rows.row(2).normalized())) * 180.0f / M_PI; - float beta = std::acos(cell_rows.row(0).normalized().dot(cell_rows.row(2).normalized())) * 180.0f / M_PI; - float gamma = std::acos(cell_rows.row(0).normalized().dot(cell_rows.row(1).normalized())) * 180.0f / M_PI; - - if (alpha < p.min_angle_deg || alpha > p.max_angle_deg || - beta < p.min_angle_deg || beta > p.max_angle_deg || - gamma < p.min_angle_deg || gamma > p.max_angle_deg) - continue; } + // Filter for wrong angles + float alpha = std::acos(cell_rows.row(1).normalized().dot(cell_rows.row(2).normalized())) * 180.0f / M_PI; + float beta = std::acos(cell_rows.row(0).normalized().dot(cell_rows.row(2).normalized())) * 180.0f / M_PI; + float gamma = std::acos(cell_rows.row(0).normalized().dot(cell_rows.row(1).normalized())) * 180.0f / M_PI; + + if (alpha < p.min_angle_deg || alpha > p.max_angle_deg || + beta < p.min_angle_deg || beta > p.max_angle_deg || + gamma < p.min_angle_deg || gamma > p.max_angle_deg) + continue; + int64_t indexed_spot_count = 0; auto indexed_mask = ComputeIndexedMask(spots.topRows(nspots), cell_cols, p.indexing_tolerance, indexed_spot_count); @@ -223,25 +226,21 @@ std::vector Refine(const std::vector &in_spots, std::vector accepted; for (const auto &candidate: candidates) { - bool too_similar = false; + int64_t overlap = 0; + // Check all already selected lattices and see how many spots are already indexed for the candidate + // If the overlap is more than 40% of indexed spots - we assume the lattice doesn't bring anything new for (const auto &selected: accepted) { - int64_t overlap = 0; for (size_t i = 0; i < candidate.indexed_mask.size(); ++i) { if (candidate.indexed_mask[i] && selected.indexed_mask[i]) overlap++; } - - const int64_t max_set_size = std::max(candidate.indexed_spot_count, selected.indexed_spot_count); - if (overlap > static_cast(REFINE_CANDIDATE_OVERLAP_RATIO_THRESHOLD - * static_cast(max_set_size))) { - too_similar = true; - break; - } } - if (!too_similar) + if (overlap < static_cast(REFINE_CANDIDATE_OVERLAP_RATIO_THRESHOLD + * static_cast(candidate.indexed_spot_count))) { accepted.emplace_back(candidate); + } } ret.reserve(accepted.size()); diff --git a/image_analysis/indexing/PostIndexingRefinement.h b/image_analysis/indexing/PostIndexingRefinement.h index e69c22f6..df7d0329 100644 --- a/image_analysis/indexing/PostIndexingRefinement.h +++ b/image_analysis/indexing/PostIndexingRefinement.h @@ -14,7 +14,7 @@ constexpr float REFINE_CANDIDATE_SPOT_COUNT_RATIO_THRESHOLD = 0.9f; constexpr float REFINE_CANDIDATE_VOLUME_RATIO_THRESHOLD = 1.05f; -constexpr float REFINE_CANDIDATE_OVERLAP_RATIO_THRESHOLD = 0.2f; +constexpr float REFINE_CANDIDATE_OVERLAP_RATIO_THRESHOLD = 0.4f; constexpr float REFINE_MIN_VOLUME_EPSILON = 1e-12f; constexpr float REFINE_MIN_REFERENCE_LENGTH_EPSILON = 1e-6f; -- 2.52.0 From 56144a6e5fb5f2b1c802e42c575377d2e1292b8f Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Thu, 4 Jun 2026 20:02:41 +0200 Subject: [PATCH 15/46] LatticeSearch: Primitive reduced should return reduced value --- image_analysis/lattice_search/LatticeSearch.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/image_analysis/lattice_search/LatticeSearch.cpp b/image_analysis/lattice_search/LatticeSearch.cpp index 4c03dccc..7b9ba324 100644 --- a/image_analysis/lattice_search/LatticeSearch.cpp +++ b/image_analysis/lattice_search/LatticeSearch.cpp @@ -335,7 +335,7 @@ LatticeSearchResult LatticeSearch(const CrystalLattice &L, double dist_tolerance if (ok) { return LatticeSearchResult{ .niggli_class = c.number, - .primitive_reduced = L, + .primitive_reduced = L_niggli, .conventional = L_niggli.Multiply(c.reindex), .system = c.system, .centering = c.centering, @@ -345,8 +345,8 @@ LatticeSearchResult LatticeSearch(const CrystalLattice &L, double dist_tolerance return LatticeSearchResult{ .niggli_class = 44, - .primitive_reduced = L, - .conventional = L, + .primitive_reduced = L_niggli, + .conventional = L_niggli, .system = gemmi::CrystalSystem::Triclinic, .centering = 'P', }; -- 2.52.0 From fd9a9429b56e29cc428a774ec02726fa7f6a6736 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Thu, 4 Jun 2026 21:22:46 +0200 Subject: [PATCH 16/46] LatticeSearch: Return reindex matrix --- image_analysis/lattice_search/LatticeSearch.cpp | 2 ++ image_analysis/lattice_search/LatticeSearch.h | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/image_analysis/lattice_search/LatticeSearch.cpp b/image_analysis/lattice_search/LatticeSearch.cpp index 7b9ba324..c2257a68 100644 --- a/image_analysis/lattice_search/LatticeSearch.cpp +++ b/image_analysis/lattice_search/LatticeSearch.cpp @@ -339,6 +339,7 @@ LatticeSearchResult LatticeSearch(const CrystalLattice &L, double dist_tolerance .conventional = L_niggli.Multiply(c.reindex), .system = c.system, .centering = c.centering, + .reindex = c.reindex, }; } } @@ -349,5 +350,6 @@ LatticeSearchResult LatticeSearch(const CrystalLattice &L, double dist_tolerance .conventional = L_niggli, .system = gemmi::CrystalSystem::Triclinic, .centering = 'P', + .reindex = gemmi::Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1), }; } diff --git a/image_analysis/lattice_search/LatticeSearch.h b/image_analysis/lattice_search/LatticeSearch.h index 21b26c4c..b6866d48 100644 --- a/image_analysis/lattice_search/LatticeSearch.h +++ b/image_analysis/lattice_search/LatticeSearch.h @@ -16,6 +16,10 @@ struct LatticeSearchResult { CrystalLattice conventional; gemmi::CrystalSystem system = gemmi::CrystalSystem::Triclinic; char centering = 'P'; // 'P','A','B','C','I','F','R' + + // Change-of-basis from primitive_reduced to conventional: + // conventional = primitive_reduced.Multiply(reindex) + gemmi::Mat33 reindex = gemmi::Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1); }; LatticeSearchResult LatticeSearch(const CrystalLattice& L, double dist_tolerance = 0.03, double angle_tolerance_deg = 3); -- 2.52.0 From 736f5f2405e4f1aa48ccacf56103f3462a816063 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Thu, 4 Jun 2026 21:29:47 +0200 Subject: [PATCH 17/46] MultiLatticeSearch: Add function --- image_analysis/indexing/CMakeLists.txt | 6 +- .../indexing/MultiLatticeSearch.cpp | 99 +++++++++++++++++++ image_analysis/indexing/MultiLatticeSearch.h | 33 +++++++ tests/CMakeLists.txt | 1 + tests/MultiLatticeSearchTest.cpp | 68 +++++++++++++ 5 files changed, 205 insertions(+), 2 deletions(-) create mode 100644 image_analysis/indexing/MultiLatticeSearch.cpp create mode 100644 image_analysis/indexing/MultiLatticeSearch.h create mode 100644 tests/MultiLatticeSearchTest.cpp diff --git a/image_analysis/indexing/CMakeLists.txt b/image_analysis/indexing/CMakeLists.txt index bea0431b..f40c1492 100644 --- a/image_analysis/indexing/CMakeLists.txt +++ b/image_analysis/indexing/CMakeLists.txt @@ -13,8 +13,10 @@ ADD_LIBRARY(JFJochIndexing STATIC FFTResult.h FFTIndexer.cpp FFTIndexer.h - PostIndexingRefinement.cpp) -TARGET_LINK_LIBRARIES(JFJochIndexing JFJochCommon) + PostIndexingRefinement.cpp + MultiLatticeSearch.cpp + MultiLatticeSearch.h) +TARGET_LINK_LIBRARIES(JFJochIndexing JFJochCommon JFJochLatticeSearch) IF (JFJOCH_CUDA_AVAILABLE) FetchContent_Declare( diff --git a/image_analysis/indexing/MultiLatticeSearch.cpp b/image_analysis/indexing/MultiLatticeSearch.cpp new file mode 100644 index 00000000..c799d9ab --- /dev/null +++ b/image_analysis/indexing/MultiLatticeSearch.cpp @@ -0,0 +1,99 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#include "MultiLatticeSearch.h" + +#include + +namespace { + // Direct lattice vectors as matrix columns: M = [a | b | c] + Eigen::Matrix3d LatticeMatrix(const CrystalLattice &latt) { + const Coord a = latt.Vec0(); + const Coord b = latt.Vec1(); + const Coord c = latt.Vec2(); + + Eigen::Matrix3d M; + M.col(0) = Eigen::Vector3d(a.x, a.y, a.z); + M.col(1) = Eigen::Vector3d(b.x, b.y, b.z); + M.col(2) = Eigen::Vector3d(c.x, c.y, c.z); + return M; + } + + // Proper rotation mapping reference -> target (target = R * reference). + // R = Mtarget * Mref^-1, projected to the nearest rotation via SVD. + Eigen::Matrix3d RotationRefToTarget(const CrystalLattice &reference, const CrystalLattice &target) { + Eigen::Matrix3d R = LatticeMatrix(target) * LatticeMatrix(reference).inverse(); + + Eigen::JacobiSVD svd(R, Eigen::ComputeFullU | Eigen::ComputeFullV); + R = svd.matrixU() * svd.matrixV().transpose(); + if (R.determinant() < 0.0) { + Eigen::Matrix3d U = svd.matrixU(); + U.col(2) *= -1.0; + R = U * svd.matrixV().transpose(); + } + return R; + } +} + +std::vector MultiLatticeSearch(const std::vector &lattices, + float dist_tolerance, + float angle_tolerance_deg) { + std::vector ret; + if (lattices.empty()) + return ret; + + const CrystalLattice &reference = lattices[0]; + const UnitCell ref_cell = reference.GetUnitCell(); + + ret.push_back({reference, reference, Coord(0, 0, 0)}); + + for (size_t i = 1; i < lattices.size(); i++) { + const CrystalLattice &latt = lattices[i]; + + if (!latt.GetUnitCell().is_close(ref_cell, dist_tolerance, angle_tolerance_deg)) + continue; + + const Eigen::Matrix3d R = RotationRefToTarget(reference, latt); + + const Eigen::AngleAxisd aa(R); + const Eigen::Vector3d rod = aa.angle() * aa.axis(); + const Coord rotation_vector(static_cast(rod.x()), + static_cast(rod.y()), + static_cast(rod.z())); + + // output_lattice = R * reference, built straight from the Eigen matrix + // so it is exactly a proper rotation of the reference (full double precision). + const Eigen::Matrix3d out = R * LatticeMatrix(reference); + ret.push_back({ + latt, + CrystalLattice(Coord(out(0, 0), out(1, 0), out(2, 0)), + Coord(out(0, 1), out(1, 1), out(2, 1)), + Coord(out(0, 2), out(1, 2), out(2, 2))), + rotation_vector + }); + } + + return ret; +} + +std::vector MultiLatticeSearchReduced(const std::vector &lattices, + float dist_tolerance, + float angle_tolerance_deg) { + if (lattices.empty()) + return {}; + + // Reduce lattice 0 to its primitive Niggli setting; that becomes the reference basis. + std::vector reduced; + reduced.reserve(lattices.size()); + + // Reduce every candidate the same way so metric comparison and rotation + // are all done in the reduced setting. + for (const auto & lattice : lattices) + reduced.push_back(lattice.NiggliReduce()); + + auto ret = MultiLatticeSearch(reduced, dist_tolerance, angle_tolerance_deg); + + // Keep input_lattice pointing at the original (un-reduced) lattices for debugging. + + return ret; +} \ No newline at end of file diff --git a/image_analysis/indexing/MultiLatticeSearch.h b/image_analysis/indexing/MultiLatticeSearch.h new file mode 100644 index 00000000..09eddabf --- /dev/null +++ b/image_analysis/indexing/MultiLatticeSearch.h @@ -0,0 +1,33 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#pragma once + +#include + +#include "../common/CrystalLattice.h" +#include "../common/Coord.h" +#include "../lattice_search/LatticeSearch.h" + +struct MultiLatticeSearchResult { + CrystalLattice input_lattice; // lattice as it came in (kept for debugging only) + CrystalLattice output_lattice; // R * reference - a proper rotation of the first lattice + Coord rotation_vector; // Rodrigues vector: axis * angle, magnitude == angle [rad] +}; + +// Input: lattices assumed to describe the same crystal (same unit cell), differing +// only by orientation, and describing non-overlapping sets of spots. +// The first lattice is the reference. A subsequent lattice is kept only if its unit +// cell matches the reference (within tolerances); for each kept lattice we find the +// proper rotation R mapping reference -> lattice and store output_lattice = R * reference. +std::vector MultiLatticeSearch(const std::vector &lattices, + float dist_tolerance = 0.03f, + float angle_tolerance_deg = 3.0f); + +// Same as above, but first runs LatticeSearch on lattice 0 to obtain a +// Niggli-reduced / conventional reference, and reduces every candidate the +// same way before comparing/rotating. Rotations are returned in the reduced +// reference setting. +std::vector MultiLatticeSearchReduced(const std::vector &lattices, + float dist_tolerance = 0.03f, + float angle_tolerance_deg = 3.0f); \ No newline at end of file diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 951350cd..f4868b12 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -70,6 +70,7 @@ ADD_EXECUTABLE(jfjoch_test MergeScaleTest.cpp UnitCellTest.cpp CCTest.cpp + MultiLatticeSearchTest.cpp ) target_link_libraries(jfjoch_test Catch2WithMain JFJochBroker JFJochReceiver JFJochReader JFJochWriter diff --git a/tests/MultiLatticeSearchTest.cpp b/tests/MultiLatticeSearchTest.cpp new file mode 100644 index 00000000..b40cc537 --- /dev/null +++ b/tests/MultiLatticeSearchTest.cpp @@ -0,0 +1,68 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#include + +#include "../image_analysis/indexing/MultiLatticeSearch.h" + +namespace { + // Rotation-invariant comparison via Gram matrix G = L^T L + void check_same_cell(const CrystalLattice &a, const CrystalLattice &b, double margin) { + const Coord av[3] = {a.Vec0(), a.Vec1(), a.Vec2()}; + const Coord bv[3] = {b.Vec0(), b.Vec1(), b.Vec2()}; + for (int i = 0; i < 3; i++) + for (int j = 0; j < 3; j++) + CHECK((av[i] * av[j]) == Catch::Approx(bv[i] * bv[j]).margin(margin)); + } +} + +TEST_CASE("MultiLatticeSearch_RecoversRotation") { + CrystalLattice reference(40, 50, 80, 90, 95, 90); + + // Known rotation: 0.4 rad about a tilted axis + const Coord axis = Coord(0.3f, 0.9f, 0.1f).Normalize(); + const float angle = 0.4f; + const RotMatrix R(angle, axis); + + const CrystalLattice rotated(R * reference.Vec0(), + R * reference.Vec1(), + R * reference.Vec2()); + + auto result = MultiLatticeSearch({reference, rotated}); + + REQUIRE(result.size() == 2); + + // First entry: identity + CHECK(result[0].rotation_vector.Length() == Catch::Approx(0.0).margin(1e-6)); + check_same_cell(result[0].output_lattice, reference, 1e-3); + + // Second entry: angle and axis recovered + CHECK(result[1].rotation_vector.Length() == Catch::Approx(angle).margin(1e-4)); + const Coord recovered_axis = result[1].rotation_vector.Normalize(); + CHECK(recovered_axis.x == Catch::Approx(axis.x).margin(1e-3)); + CHECK(recovered_axis.y == Catch::Approx(axis.y).margin(1e-3)); + CHECK(recovered_axis.z == Catch::Approx(axis.z).margin(1e-3)); + + // output_lattice is a proper rotation of the reference => same metric + check_same_cell(result[1].output_lattice, reference, 1e-2); + + // and output equals the rotated input (same orientation) + check_same_cell(result[1].output_lattice, rotated, 1e-2); +} + +TEST_CASE("MultiLatticeSearch_SkipsDifferentCell") { + CrystalLattice reference(40, 50, 80, 90, 90, 90); + CrystalLattice other_cell(45, 50, 80, 90, 90, 90); // a differs by 5 A + + + auto result = MultiLatticeSearch({reference, other_cell}); + + // Only the reference survives + REQUIRE(result.size() == 1); + CHECK(result[0].rotation_vector.Length() == Catch::Approx(0.0).margin(1e-6)); +} + +TEST_CASE("MultiLatticeSearch_Empty") { + auto result = MultiLatticeSearch({}); + CHECK(result.empty()); +} \ No newline at end of file -- 2.52.0 From 0c3efda5aca17955f6371e58c5bfcc1d8f889e6b Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 07:29:17 +0200 Subject: [PATCH 18/46] CrystalLattice: Print function --- common/Coord.h | 5 +---- common/CrystalLattice.h | 8 +++++--- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/common/Coord.h b/common/Coord.h index 33191d15..fd2f06d6 100644 --- a/common/Coord.h +++ b/common/Coord.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef INDEX_COORD_H -#define INDEX_COORD_H +#pragma once #include #include @@ -62,5 +61,3 @@ public: inline void swap(Coord& a, Coord& b) noexcept { a.swap(b); } - -#endif //INDEX_COORD_H diff --git a/common/CrystalLattice.h b/common/CrystalLattice.h index 3e6cd33b..34a0b867 100644 --- a/common/CrystalLattice.h +++ b/common/CrystalLattice.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_CRYSTALLATTICE_H -#define JUNGFRAUJOCH_CRYSTALLATTICE_H +#pragma once #include "../gemmi_gph/gemmi/math.hpp" #include "../gemmi_gph/gemmi/symmetry.hpp" @@ -43,5 +42,8 @@ public: CrystalLattice NiggliReduce() const; }; +inline std::ostream &operator<<( std::ostream &output, const CrystalLattice &in ) { + output << in.Vec0() << std::endl << in.Vec1() << std::endl << in.Vec2() << std::endl; + return output; +} -#endif //JUNGFRAUJOCH_CRYSTALLATTICE_H -- 2.52.0 From 1a3403a25c24a701047c95acb5708bce9436aa4e Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 10:30:00 +0200 Subject: [PATCH 19/46] CrystalLattice: Don't fix handedness after multiplying --- common/CrystalLattice.cpp | 2 -- common/CrystalLattice.h | 1 - 2 files changed, 3 deletions(-) diff --git a/common/CrystalLattice.cpp b/common/CrystalLattice.cpp index 888bee1a..0172b8fa 100644 --- a/common/CrystalLattice.cpp +++ b/common/CrystalLattice.cpp @@ -156,7 +156,6 @@ CrystalLattice CrystalLattice::Multiply(const RotMatrix &input) const { l.vec[0] = input * vec[0]; l.vec[1] = input * vec[1]; l.vec[2] = input * vec[2]; - l.FixHandedness(); return l; } @@ -167,7 +166,6 @@ CrystalLattice CrystalLattice::Multiply(const gemmi::Mat33 &c2p) const { l.vec[i][j] = c2p[i][0] * vec[0][j] + c2p[i][1] * vec[1][j] + c2p[i][2] * vec[2][j]; } } - l.FixHandedness(); return l; } diff --git a/common/CrystalLattice.h b/common/CrystalLattice.h index 34a0b867..5f4e6519 100644 --- a/common/CrystalLattice.h +++ b/common/CrystalLattice.h @@ -38,7 +38,6 @@ public: void Sort(); void Regularize(const gemmi::CrystalSystem &input); [[nodiscard]] std::vector GetUBMatrix() const; - CrystalLattice NiggliReduce() const; }; -- 2.52.0 From 21a8ea51eea660e075dc834475602a939a544c8b Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 11:06:21 +0200 Subject: [PATCH 20/46] Replace header guards with #pragma once (only keep ones in HLS/driver code) --- acquisition_device/AcquisitionCounters.h | 6 +----- acquisition_device/AcquisitionDevice.h | 5 +---- acquisition_device/AcquisitionDeviceGroup.h | 5 +---- acquisition_device/Completion.h | 5 +---- acquisition_device/FPGAAcquisitionDevice.h | 5 +---- acquisition_device/HLSSimulatedDevice.h | 6 +----- acquisition_device/PCIExpressDevice.h | 5 +---- broker/JFJochBrokerParser.h | 5 +---- broker/JFJochServices.h | 5 +---- broker/JFJochStateMachine.h | 6 +----- broker/OpenAPIConvert.h | 5 ++--- common/ADUHistogram.h | 5 +---- common/AzimuthalIntegrationMapping.h | 6 +----- common/AzimuthalIntegrationProfile.h | 5 +---- common/AzimuthalIntegrationSettings.h | 5 +---- common/BraggIntegrationSettings.h | 6 +----- common/CUDAWrapper.h | 5 +---- common/CheckPath.h | 5 +---- common/ColorScale.h | 5 +---- common/CompressedImage.h | 5 +---- common/DarkMaskSettings.h | 6 +----- common/DatasetSettings.h | 5 +---- common/DetectorGeometry.h | 5 +---- common/DetectorGeometryFixed.h | 6 +----- common/DetectorGeometryModular.h | 5 +---- common/DetectorModuleGeometry.h | 5 +---- common/DetectorSettings.h | 5 ++--- common/DetectorSetup.h | 5 +---- common/DiffractionExperiment.h | 5 +---- common/DiffractionGeometry.h | 7 +------ common/DiffractionSpot.h | 5 +---- common/FileWriterSettings.h | 6 +----- common/GitInfo.h | 5 +---- common/GoniometerAxis.h | 6 +----- common/GridScanSettings.h | 6 +----- common/Histogram.h | 5 +---- common/ImageBuffer.h | 5 +---- common/ImageFormatSettings.h | 5 +---- common/IndexingSettings.h | 6 +----- common/InstrumentMetadata.h | 5 +---- common/JFJochException.h | 4 +--- common/JFJochMessages.h | 5 +---- common/Logger.h | 5 +---- common/ModuleSummation.h | 5 +---- common/MovingAverage.h | 5 ++--- common/MultiLinePlot.h | 5 ++--- common/NUMAHWPolicy.h | 5 +---- common/NetworkAddressConvert.h | 5 +---- common/PixelMask.h | 6 +----- common/Plot.h | 5 +---- common/ROIAzimuthal.h | 5 ++--- common/ROIBox.h | 5 +---- common/ROICircle.h | 5 +---- common/ROIDefinition.h | 5 +---- common/ROIElement.h | 6 +----- common/ROIMap.h | 5 +---- common/RawToConvertedGeometry.h | 5 +---- common/RawToConvertedGeometryCore.h | 6 +----- common/Reflection.h | 5 ++--- common/ResolutionShells.h | 4 +--- common/ScanResult.h | 5 ++--- common/ScanResultGenerator.h | 5 ++--- common/SpotToSave.h | 5 +---- common/StatusVector.h | 5 +---- common/TopPixels.h | 4 +--- common/XrayFluorescenceSpectrum.h | 4 +--- common/ZMQWrappers.h | 5 +---- common/ZeroCopyReturnValue.h | 5 +---- common/print_license.h | 5 ++--- compression/CompressionAlgorithmEnum.h | 5 +---- compression/JFJochCompressor.h | 7 +------ compression/JFJochDecompress.h | 5 +---- compression/JFJochZstdCompressor.h | 6 +----- compression/MaxCompressedSize.h | 5 +---- detector_control/DectrisDetectorWrapper.h | 5 ++--- detector_control/DectrisSimplonClient.h | 5 ++--- detector_control/DetectorWrapper.h | 5 ++--- detector_control/SLSDetectorWrapper.h | 6 +----- fpga/hls_simulation/HLSDevice.h | 5 ++--- fpga/hls_simulation/datamover_model.h | 5 +---- fpga/hls_simulation/hls_cores.h | 5 +---- fpga/host_library/JungfraujochDevice.h | 5 +---- frame_serialize/CBORStream2Deserializer.h | 5 +---- frame_serialize/CBORStream2Serializer.h | 6 +----- frame_serialize/CborErr.h | 5 +---- frame_serialize/CborUtil.h | 5 +---- image_analysis/MXAnalysisAfterFPGA.h | 6 +----- image_analysis/MXAnalysisWithoutFPGA.h | 5 ++--- image_analysis/RotationParameters.h | 4 +--- image_analysis/bragg_integration/CalcISigma.h | 4 +--- image_analysis/bragg_integration/Regression.h | 5 +---- image_analysis/bragg_prediction/BraggPrediction.h | 5 ++--- image_analysis/bragg_prediction/BraggPredictionFactory.h | 4 +--- image_analysis/bragg_prediction/BraggPredictionGPU.h | 4 +--- image_analysis/dark_mask_analysis/DarkMaskAnalysis.h | 4 +--- image_analysis/geom_refinement/AssignSpotsToRings.h | 5 ++--- image_analysis/geom_refinement/RingOptimizer.h | 5 ++--- image_analysis/geom_refinement/XtalOptimizer.h | 5 ++--- image_analysis/indexing/AnalyzeIndexing.h | 4 +--- image_analysis/indexing/CUDAMemHelpers.h | 5 ++--- image_analysis/indexing/FFBIDXIndexer.h | 5 +---- image_analysis/indexing/FFTIndexer.h | 4 +--- image_analysis/indexing/FFTIndexerCPU.h | 5 ++--- image_analysis/indexing/FFTIndexerGPU.h | 5 ++--- image_analysis/indexing/FFTResult.h | 5 ++--- image_analysis/indexing/FitProfileRadius.h | 4 +--- image_analysis/indexing/Indexer.h | 5 ++--- image_analysis/indexing/IndexerFactory.h | 5 ++--- image_analysis/indexing/IndexerThreadPool.h | 5 ++--- image_analysis/lattice_search/LatticeSearch.h | 4 +--- image_analysis/spot_finding/DetModuleSpotFinder_cpu.h | 5 +---- image_analysis/spot_finding/ImageSpotFinder.h | 5 ++--- image_analysis/spot_finding/ImageSpotFinderCPU.h | 5 ++--- image_analysis/spot_finding/ImageSpotFinderGPU.h | 5 ++--- image_analysis/spot_finding/SpotFindingSettings.h | 5 +---- image_analysis/spot_finding/SpotUtils.h | 5 ++--- image_analysis/spot_finding/StrongPixelSet.h | 6 +----- image_puller/ImagePuller.h | 5 ++--- image_puller/TestImagePuller.h | 5 ++--- image_puller/ZMQImagePuller.h | 5 +---- image_pusher/CBORFilePusher.h | 6 +----- image_pusher/HDF5FilePusher.h | 6 +----- image_pusher/ImagePusher.h | 6 +----- image_pusher/NonePusher.h | 5 ++--- image_pusher/TestImagePusher.h | 6 +----- image_pusher/ZMQStream2Pusher.h | 5 +---- image_pusher/ZMQStream2PusherSocket.h | 5 +---- image_pusher/ZMQWriterNotificationPuller.h | 5 ++--- jungfrau/JFCalibration.h | 5 +---- jungfrau/JFConversionFloatingPoint.h | 6 +----- jungfrau/JFModuleGainCalibration.h | 5 +---- jungfrau/JFModulePedestal.h | 6 +----- jungfrau/JFPedestalCalc.h | 5 +---- preview/PreviewCounter.h | 5 +---- preview/PreviewImage.h | 5 +---- preview/ZMQPreviewSettings.h | 5 ++--- preview/ZMQPreviewSocket.h | 5 ++--- reader/JFJochHttpReader.h | 5 ++--- reader/JFJochReaderDataset.h | 5 ++--- reader/JFJochReaderImage.h | 5 ++--- receiver/FrameTransformation.h | 5 +---- receiver/ImageMetadata.h | 6 +----- receiver/JFJochReceiver.h | 5 ++--- receiver/JFJochReceiverCurrentStatus.h | 5 ++--- receiver/JFJochReceiverFPGA.h | 6 +----- receiver/JFJochReceiverLite.h | 5 ++--- receiver/JFJochReceiverOutput.h | 5 ++--- receiver/JFJochReceiverPlots.h | 5 +---- receiver/JFJochReceiverService.h | 6 +----- receiver/JFJochReceiverTest.h | 5 +---- receiver/LossyFilter.h | 6 +----- tools/UDPSimulator.h | 3 +-- tools/XdsIntegrateParser.h | 1 - viewer/JFJochImageReadingWorker.h | 6 +----- viewer/JFJochViewerDatasetInfo.h | 5 ++--- viewer/JFJochViewerMenu.h | 7 +------ viewer/JFJochViewerSidePanel.h | 5 ++--- viewer/JFJochViewerStatusBar.h | 5 ++--- viewer/JFJochViewerWindow.h | 6 +----- viewer/charts/JFJochDatasetInfoChartView.h | 5 ++--- viewer/charts/JFJochSimpleChartView.h | 5 ++--- viewer/dbus/JFJochViewerAdaptor.h | 6 +----- viewer/image_viewer/JFJochAzIntImage.h | 4 +--- viewer/image_viewer/JFJochGridScanImage.h | 4 +--- viewer/toolbar/JFJochViewerToolbarDisplay.h | 5 ++--- viewer/toolbar/JFJochViewerToolbarImage.h | 4 +--- viewer/widgets/JFJochViewerImageROIStatistics.h | 4 +--- viewer/widgets/JFJochViewerImageROIStatistics_Box.h | 4 +--- viewer/widgets/JFJochViewerImageROIStatistics_Circle.h | 4 +--- viewer/widgets/JFJochViewerImageStatistics.h | 5 ++--- viewer/widgets/JFJochViewerROIResult.h | 4 +--- viewer/widgets/JFJochViewerSidePanelChart.h | 5 ++--- viewer/widgets/NumberLineEdit.h | 5 +---- viewer/widgets/NumericComboBox.h | 5 ++--- viewer/widgets/ResolutionRingWidget.h | 4 +--- viewer/widgets/SliderPlusBox.h | 5 ++--- viewer/widgets/TitleLabel.h | 5 ++--- viewer/windows/JFJoch2DAzintImageWindow.h | 6 +----- viewer/windows/JFJochAzIntWindow.h | 4 +--- viewer/windows/JFJochHelperWindow.h | 4 +--- viewer/windows/JFJochViewerImageListWindow.h | 5 ++--- viewer/windows/JFJochViewerMetadataWindow.h | 5 ++--- viewer/windows/JFJochViewerProcessingWindow.h | 5 ++--- viewer/windows/JFJochViewerReciprocalSpaceWindow.h | 1 + viewer/windows/JFJochViewerReflectionListWindow.h | 4 +--- viewer/windows/JFJochViewerSpotListWindow.h | 4 +--- writer/CBFWriter.h | 5 ++--- writer/FileWriter.h | 5 +---- writer/HDF5DataFile.h | 5 +---- writer/HDF5DataFilePlugin.h | 5 +---- writer/HDF5DataFilePluginAzInt.h | 5 +---- writer/HDF5DataFilePluginDetector.h | 5 +---- writer/HDF5DataFilePluginImageStats.h | 5 +---- writer/HDF5DataFilePluginMX.h | 5 +---- writer/HDF5DataFilePluginROI.h | 5 +---- writer/HDF5DataFilePluginReflection.h | 6 +----- writer/HDF5DataFilePluginXFEL.h | 6 +----- writer/HDF5Objects.h | 5 +---- writer/MakeDirectory.h | 7 +------ writer/StreamWriter.h | 6 +----- 200 files changed, 256 insertions(+), 753 deletions(-) diff --git a/acquisition_device/AcquisitionCounters.h b/acquisition_device/AcquisitionCounters.h index 4222d328..5e978bd4 100644 --- a/acquisition_device/AcquisitionCounters.h +++ b/acquisition_device/AcquisitionCounters.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ACQUISITIONCOUNTERS_H -#define JUNGFRAUJOCH_ACQUISITIONCOUNTERS_H +#pragma once #include #include @@ -67,6 +66,3 @@ public: uint64_t GetModuleNumber() const; }; - - -#endif //JUNGFRAUJOCH_ACQUISITIONCOUNTERS_H diff --git a/acquisition_device/AcquisitionDevice.h b/acquisition_device/AcquisitionDevice.h index be54b1c4..71e60ca3 100644 --- a/acquisition_device/AcquisitionDevice.h +++ b/acquisition_device/AcquisitionDevice.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ACQUISITIONDEVICE_H -#define JUNGFRAUJOCH_ACQUISITIONDEVICE_H +#pragma once #include #include @@ -119,5 +118,3 @@ public: void RunInternalGenerator(const DiffractionExperiment& experiment); }; - -#endif //JUNGFRAUJOCH_ACQUISITIONDEVICE_H diff --git a/acquisition_device/AcquisitionDeviceGroup.h b/acquisition_device/AcquisitionDeviceGroup.h index 6efce6f5..7044936a 100644 --- a/acquisition_device/AcquisitionDeviceGroup.h +++ b/acquisition_device/AcquisitionDeviceGroup.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ACQUISITIONDEVICEGROUP_H -#define JUNGFRAUJOCH_ACQUISITIONDEVICEGROUP_H +#pragma once #include #include "AcquisitionDevice.h" @@ -20,5 +19,3 @@ public: std::vector GetDeviceStatus() const; void EnableLogging(Logger *logger); }; - -#endif //JUNGFRAUJOCH_ACQUISITIONDEVICEGROUP_H diff --git a/acquisition_device/Completion.h b/acquisition_device/Completion.h index 6616d03a..200716ef 100644 --- a/acquisition_device/Completion.h +++ b/acquisition_device/Completion.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_COMPLETION_H -#define JUNGFRAUJOCH_COMPLETION_H +#pragma once #include @@ -21,5 +20,3 @@ struct Completion { }; Completion parse_hw_completion(uint32_t hw_input); - -#endif //JUNGFRAUJOCH_COMPLETION_H diff --git a/acquisition_device/FPGAAcquisitionDevice.h b/acquisition_device/FPGAAcquisitionDevice.h index f81ed235..03a802e3 100644 --- a/acquisition_device/FPGAAcquisitionDevice.h +++ b/acquisition_device/FPGAAcquisitionDevice.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_FPGAACQUISITIONDEVICE_H -#define JUNGFRAUJOCH_FPGAACQUISITIONDEVICE_H +#pragma once #include "AcquisitionDevice.h" #include "../fpga/pcie_driver/jfjoch_fpga.h" @@ -49,5 +48,3 @@ public: void SetInternalGeneratorFrame(const uint16_t *input, size_t module_number) override; uint32_t GetExpectedDescriptorsPerModule() const override; }; - -#endif //JUNGFRAUJOCH_FPGAACQUISITIONDEVICE_H diff --git a/acquisition_device/HLSSimulatedDevice.h b/acquisition_device/HLSSimulatedDevice.h index b2ae5fae..4fee45bc 100644 --- a/acquisition_device/HLSSimulatedDevice.h +++ b/acquisition_device/HLSSimulatedDevice.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HLSSIMULATEDDEVICE_H -#define JUNGFRAUJOCH_HLSSIMULATEDDEVICE_H +#pragma once #include @@ -41,6 +40,3 @@ public: void Cancel() override; DeviceStatus GetDeviceStatus() const override; }; - - -#endif //JUNGFRAUJOCH_HLSSIMULATEDDEVICE_H diff --git a/acquisition_device/PCIExpressDevice.h b/acquisition_device/PCIExpressDevice.h index 4d5b8516..2362a1fe 100644 --- a/acquisition_device/PCIExpressDevice.h +++ b/acquisition_device/PCIExpressDevice.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_PCIEXPRESSDEVICE_H -#define JUNGFRAUJOCH_PCIEXPRESSDEVICE_H +#pragma once #include "FPGAAcquisitionDevice.h" #include "../fpga/host_library/JungfraujochDevice.h" @@ -36,5 +35,3 @@ public: DeviceStatus GetDeviceStatus() const override; DataCollectionStatus GetDataCollectionStatus() const override; }; - -#endif //JUNGFRAUJOCH_PCIEXPRESSDEVICE_H diff --git a/broker/JFJochBrokerParser.h b/broker/JFJochBrokerParser.h index 9de6ae0f..f5f2f839 100644 --- a/broker/JFJochBrokerParser.h +++ b/broker/JFJochBrokerParser.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHBROKERPARSER_H -#define JUNGFRAUJOCH_JFJOCHBROKERPARSER_H +#pragma once #include "../common/DiffractionExperiment.h" #include "../acquisition_device/AcquisitionDeviceGroup.h" @@ -22,5 +21,3 @@ std::unique_ptr ParseImagePusher(const org::openapitools::server::m void ParseAcquisitionDeviceGroup(const org::openapitools::server::model::Jfjoch_settings &input, AcquisitionDeviceGroup &aq_devices); void ParseReceiverSettings(const org::openapitools::server::model::Jfjoch_settings &input, JFJochReceiverService &service); SpotFindingSettings ParseSpotFindingSettings(const org::openapitools::server::model::Jfjoch_settings &input); - -#endif //JUNGFRAUJOCH_JFJOCHBROKERPARSER_H diff --git a/broker/JFJochServices.h b/broker/JFJochServices.h index 0ffd64a7..88a6a8b8 100644 --- a/broker/JFJochServices.h +++ b/broker/JFJochServices.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHSERVICES_H -#define JUNGFRAUJOCH_JFJOCHSERVICES_H +#pragma once #include #include "../common/DiffractionExperiment.h" @@ -75,5 +74,3 @@ public: ImagePusherStatus GetImagePusherStatus() const; }; - -#endif //JUNGFRAUJOCH_JFJOCHSERVICES_H diff --git a/broker/JFJochStateMachine.h b/broker/JFJochStateMachine.h index 53c0f416..1d5fb56a 100644 --- a/broker/JFJochStateMachine.h +++ b/broker/JFJochStateMachine.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHSTATEMACHINE_H -#define JUNGFRAUJOCH_JFJOCHSTATEMACHINE_H +#pragma once #include #include @@ -247,6 +246,3 @@ public: ImagePusherStatus GetImagePusherStatus() const; }; - - -#endif //JUNGFRAUJOCH_JFJOCHSTATEMACHINE_H diff --git a/broker/OpenAPIConvert.h b/broker/OpenAPIConvert.h index 9c382cfd..6337f84a 100644 --- a/broker/OpenAPIConvert.h +++ b/broker/OpenAPIConvert.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_OPENAPICONVERT_H -#define JFJOCH_OPENAPICONVERT_H +#pragma once #include "Dark_mask_settings.h" #include "Image_pusher_status.h" @@ -96,4 +95,4 @@ org::openapitools::server::model::Dark_mask_settings Convert(const DarkMaskSetti DarkMaskSettings Convert(const org::openapitools::server::model::Dark_mask_settings& input); org::openapitools::server::model::Image_pusher_status Convert(const ImagePusherStatus& input); -#endif //JFJOCH_OPENAPICONVERT_H + diff --git a/common/ADUHistogram.h b/common/ADUHistogram.h index d3940cc2..2e30d90b 100644 --- a/common/ADUHistogram.h +++ b/common/ADUHistogram.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ADUHISTOGRAM_H -#define JUNGFRAUJOCH_ADUHISTOGRAM_H +#pragma once #include #include "MultiLinePlot.h" @@ -19,5 +18,3 @@ public: MultiLinePlot GetPlot() const; void Restart(); }; - -#endif //JUNGFRAUJOCH_ADUHISTOGRAM_H diff --git a/common/AzimuthalIntegrationMapping.h b/common/AzimuthalIntegrationMapping.h index eddab1f7..14337547 100644 --- a/common/AzimuthalIntegrationMapping.h +++ b/common/AzimuthalIntegrationMapping.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_AZIMUTHALINTEGRATIONMAPPING_H -#define JUNGFRAUJOCH_AZIMUTHALINTEGRATIONMAPPING_H +#pragma once #include #include "DiffractionExperiment.h" @@ -57,6 +56,3 @@ public: [[nodiscard]] int32_t GetQBinCount() const; [[nodiscard]] size_t GetNThreads() const; }; - - -#endif //JUNGFRAUJOCH_AZIMUTHALINTEGRATIONMAPPING_H diff --git a/common/AzimuthalIntegrationProfile.h b/common/AzimuthalIntegrationProfile.h index 87d681db..90000efb 100644 --- a/common/AzimuthalIntegrationProfile.h +++ b/common/AzimuthalIntegrationProfile.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_AZIMUTHALINTEGRATIONPROFILE_H -#define JUNGFRAUJOCH_AZIMUTHALINTEGRATIONPROFILE_H +#pragma once #include #include @@ -48,5 +47,3 @@ public: MultiLinePlot GetPlot(bool force_1d = false, PlotAzintUnit plot_unit = PlotAzintUnit::Q_recipA) const; AzimuthalIntegrationProfile& operator+=(const AzimuthalIntegrationProfile& profile); // Not thread safe }; - -#endif //JUNGFRAUJOCH_AZIMUTHALINTEGRATIONPROFILE_H diff --git a/common/AzimuthalIntegrationSettings.h b/common/AzimuthalIntegrationSettings.h index 02ddea55..eafb97f5 100644 --- a/common/AzimuthalIntegrationSettings.h +++ b/common/AzimuthalIntegrationSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_AZIMUTHALINTEGRATIONSETTINGS_H -#define JFJOCH_AZIMUTHALINTEGRATIONSETTINGS_H +#pragma once #include #include @@ -46,5 +45,3 @@ public: [[nodiscard]] uint16_t GetBin(float q, float phi_deg) const; }; - -#endif //JFJOCH_AZIMUTHALINTEGRATIONSETTINGS_H diff --git a/common/BraggIntegrationSettings.h b/common/BraggIntegrationSettings.h index 151f4eab..60ab4059 100644 --- a/common/BraggIntegrationSettings.h +++ b/common/BraggIntegrationSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_BRAGGINTEGRATIONSETTINGS_H -#define JFJOCH_BRAGGINTEGRATIONSETTINGS_H +#pragma once #include @@ -30,6 +29,3 @@ public: [[nodiscard]] float GetMinimumSigmaInRegardsToI() const; }; - - -#endif //JFJOCH_BRAGGINTEGRATIONSETTINGS_H diff --git a/common/CUDAWrapper.h b/common/CUDAWrapper.h index e3325f97..dce83bb0 100644 --- a/common/CUDAWrapper.h +++ b/common/CUDAWrapper.h @@ -1,13 +1,10 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_CUDAWRAPPER_H -#define JUNGFRAUJOCH_CUDAWRAPPER_H +#pragma once #include int32_t get_gpu_count(); void set_gpu(int32_t dev_id); int get_gpu_numa_node(int dev_id); - -#endif //JUNGFRAUJOCH_CUDAWRAPPER_H diff --git a/common/CheckPath.h b/common/CheckPath.h index 9c9d4ffb..331efa79 100644 --- a/common/CheckPath.h +++ b/common/CheckPath.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_CHECKPATH_H -#define JFJOCH_CHECKPATH_H +#pragma once #include #include "JFJochException.h" @@ -22,5 +21,3 @@ inline void CheckPath(const std::string &s) { throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Path cannot contain /../"); } - -#endif //JFJOCH_CHECKPATH_H diff --git a/common/ColorScale.h b/common/ColorScale.h index 81a7d2e7..cb8c33e8 100644 --- a/common/ColorScale.h +++ b/common/ColorScale.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_COLORSCALE_H -#define JFJOCH_COLORSCALE_H +#pragma once #include #include @@ -93,5 +92,3 @@ public: ColorScale &Gap(rgb input); ColorScale &BadPixel(rgb input); }; - -#endif //JFJOCH_COLORSCALE_H diff --git a/common/CompressedImage.h b/common/CompressedImage.h index 28e011f8..79e2265e 100644 --- a/common/CompressedImage.h +++ b/common/CompressedImage.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_COMPRESSEDIMAGE_H -#define JFJOCH_COMPRESSEDIMAGE_H +#pragma once #include #include @@ -57,5 +56,3 @@ public: [[nodiscard]] const uint8_t *GetCompressed() const; [[nodiscard]] size_t GetCompressedSize() const; }; - -#endif //JFJOCH_COMPRESSEDIMAGE_H diff --git a/common/DarkMaskSettings.h b/common/DarkMaskSettings.h index 15a97e73..8ed92023 100644 --- a/common/DarkMaskSettings.h +++ b/common/DarkMaskSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DARKMASKSETTINGS_H -#define JFJOCH_DARKMASKSETTINGS_H +#pragma once #include #include @@ -27,6 +26,3 @@ public: [[nodiscard]] int64_t GetMaxFramesWithCounts() const; [[nodiscard]] int64_t GetMaxCounts() const; }; - - -#endif //JFJOCH_DARKMASKSETTINGS_H \ No newline at end of file diff --git a/common/DatasetSettings.h b/common/DatasetSettings.h index c06afe27..9ec5672e 100644 --- a/common/DatasetSettings.h +++ b/common/DatasetSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DATASETSETTINGS_H -#define JUNGFRAUJOCH_DATASETSETTINGS_H +#pragma once #include #include @@ -164,5 +163,3 @@ public: bool IsDetectIceRings() const; const XrayFluorescenceSpectrum &GetFluorescenceSpectrum() const; }; - -#endif //JUNGFRAUJOCH_DATASETSETTINGS_H diff --git a/common/DetectorGeometry.h b/common/DetectorGeometry.h index d62245bf..bfd59dd3 100644 --- a/common/DetectorGeometry.h +++ b/common/DetectorGeometry.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DETECTORGEOMETRY_H -#define JUNGFRAUJOCH_DETECTORGEOMETRY_H +#pragma once #include #include @@ -22,5 +21,3 @@ public: [[nodiscard]] virtual Coord GetFastDirection(int64_t module_number) const = 0; [[nodiscard]] virtual Coord GetSlowDirection(int64_t module_number) const = 0; }; - -#endif //JUNGFRAUJOCH_DETECTORGEOMETRY_H diff --git a/common/DetectorGeometryFixed.h b/common/DetectorGeometryFixed.h index b932fa91..b7c703bd 100644 --- a/common/DetectorGeometryFixed.h +++ b/common/DetectorGeometryFixed.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DETECTORGEOMETRYFIXED_H -#define JFJOCH_DETECTORGEOMETRYFIXED_H +#pragma once #include "DetectorGeometry.h" @@ -23,6 +22,3 @@ public: Coord GetSlowDirection(int64_t module_number) const override; void VerticalFlip(); }; - - -#endif //JFJOCH_DETECTORGEOMETRYFIXED_H diff --git a/common/DetectorGeometryModular.h b/common/DetectorGeometryModular.h index b3762f43..c9a503a1 100644 --- a/common/DetectorGeometryModular.h +++ b/common/DetectorGeometryModular.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DETECTORGEOMETRYMODULAR_H -#define JFJOCH_DETECTORGEOMETRYMODULAR_H +#pragma once #include "DetectorGeometry.h" @@ -32,5 +31,3 @@ public: void VerticalFlip(); }; - -#endif //JFJOCH_DETECTORGEOMETRYMODULAR_H diff --git a/common/DetectorModuleGeometry.h b/common/DetectorModuleGeometry.h index 99618591..dcd9c91a 100644 --- a/common/DetectorModuleGeometry.h +++ b/common/DetectorModuleGeometry.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DETECTORMODULEGEOMETRY_H -#define JUNGFRAUJOCH_DETECTORMODULEGEOMETRY_H +#pragma once #include #include @@ -36,5 +35,3 @@ public: void VerticalFlip(size_t detector_height); }; - -#endif //JUNGFRAUJOCH_DETECTORMODULEGEOMETRY_H diff --git a/common/DetectorSettings.h b/common/DetectorSettings.h index ef3de5d0..dbd56f18 100644 --- a/common/DetectorSettings.h +++ b/common/DetectorSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DETECTORSETTINGS_H -#define JFJOCH_DETECTORSETTINGS_H +#pragma once #include #include @@ -79,4 +78,4 @@ public: }; -#endif //JFJOCH_DETECTORSETTINGS_H + diff --git a/common/DetectorSetup.h b/common/DetectorSetup.h index a0cd9a60..0b082fdc 100644 --- a/common/DetectorSetup.h +++ b/common/DetectorSetup.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DETECTORSETUP_H -#define JUNGFRAUJOCH_DETECTORSETUP_H +#pragma once #include #include @@ -149,5 +148,3 @@ DetectorSetup DetEIGER(const DetectorGeometryModular &geom, DetectorSetup DetDECTRIS(int64_t width, int64_t height, const std::string &description, const std::string &addr); - -#endif //JUNGFRAUJOCH_DETECTORSETUP_H diff --git a/common/DiffractionExperiment.h b/common/DiffractionExperiment.h index 11e82816..131c3bff 100644 --- a/common/DiffractionExperiment.h +++ b/common/DiffractionExperiment.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef DIFFRACTIONEXPERIMENT_H -#define DIFFRACTIONEXPERIMENT_H +#pragma once #include #include @@ -417,5 +416,3 @@ public: std::optional GetRotationWedgeForScaling() const; bool GetRefineRotationWedgeInScaling() const; }; - -#endif //DIFFRACTIONEXPERIMENT_H diff --git a/common/DiffractionGeometry.h b/common/DiffractionGeometry.h index c56eaf3b..171977b2 100644 --- a/common/DiffractionGeometry.h +++ b/common/DiffractionGeometry.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DIFFRACTIONGEOMETRY_H -#define JUNGFRAUJOCH_DIFFRACTIONGEOMETRY_H +#pragma once #include "JFJochException.h" #include "Coord.h" @@ -65,8 +64,4 @@ public: [[nodiscard]] float AngleFromEwaldSphere_deg(const Coord &p0) const; [[nodiscard]] const RotMatrix& GetPoniRotMatrix() const; - - }; - -#endif //JUNGFRAUJOCH_DIFFRACTIONGEOMETRY_H diff --git a/common/DiffractionSpot.h b/common/DiffractionSpot.h index 7600a280..2614b4c9 100644 --- a/common/DiffractionSpot.h +++ b/common/DiffractionSpot.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DIFFRACTIONSPOT_H -#define JUNGFRAUJOCH_DIFFRACTIONSPOT_H +#pragma once #include "Coord.h" #include "DiffractionExperiment.h" @@ -29,5 +28,3 @@ public: std::optional Export(const DiffractionGeometry &geometry, int64_t image_num = 0) const; void AddPixel(uint32_t col, uint32_t line, int64_t photons); }; - -#endif //JUNGFRAUJOCH_DIFFRACTIONSPOT_H diff --git a/common/FileWriterSettings.h b/common/FileWriterSettings.h index e9011e68..45f7841e 100644 --- a/common/FileWriterSettings.h +++ b/common/FileWriterSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_FILEWRITERSETTINGS_H -#define JFJOCH_FILEWRITERSETTINGS_H +#pragma once #include "JFJochMessages.h" @@ -16,6 +15,3 @@ public: FileWriterFormat GetFileFormat() const; bool IsOverwriteExistingFiles() const; }; - - -#endif //JFJOCH_FILEWRITERSETTINGS_H diff --git a/common/GitInfo.h b/common/GitInfo.h index a597831a..b61e79ec 100644 --- a/common/GitInfo.h +++ b/common/GitInfo.h @@ -1,13 +1,10 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_GITINFO_H -#define JUNGFRAUJOCH_GITINFO_H +#pragma once #include std::string jfjoch_git_sha1(); std::string jfjoch_git_date(); std::string jfjoch_version(); - -#endif //JUNGFRAUJOCH_GITINFO_H diff --git a/common/GoniometerAxis.h b/common/GoniometerAxis.h index ecda91df..6c3fd097 100644 --- a/common/GoniometerAxis.h +++ b/common/GoniometerAxis.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_GONIOMETERAXIS_H -#define JFJOCH_GONIOMETERAXIS_H +#pragma once #include #include @@ -47,6 +46,3 @@ public: [[nodiscard]] RotMatrix GetTransformationAngle(float angle_deg) const; }; - - -#endif //JFJOCH_GONIOMETERAXIS_H diff --git a/common/GridScanSettings.h b/common/GridScanSettings.h index aa5c5046..4ef8a5bf 100644 --- a/common/GridScanSettings.h +++ b/common/GridScanSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_GRIDSCANSETTINGS_H -#define JFJOCH_GRIDSCANSETTINGS_H +#pragma once #include #include @@ -61,6 +60,3 @@ public: [[nodiscard]] std::vector Rearrange(const std::vector &input, float fill_value = -1) const; [[nodiscard]] std::vector Rearrange(const std::vector &input, uint64_t fill_value) const; }; - - -#endif //JFJOCH_GRIDSCANSETTINGS_H diff --git a/common/Histogram.h b/common/Histogram.h index c4643569..1e3b44d9 100644 --- a/common/Histogram.h +++ b/common/Histogram.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HISTOGRAM_H -#define JUNGFRAUJOCH_HISTOGRAM_H +#pragma once #include #include @@ -112,5 +111,3 @@ public: return count.size() - 1; } }; - -#endif //JUNGFRAUJOCH_HISTOGRAM_H diff --git a/common/ImageBuffer.h b/common/ImageBuffer.h index 316d0ff0..9c0be379 100644 --- a/common/ImageBuffer.h +++ b/common/ImageBuffer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_IMAGEBUFFER_H -#define JUNGFRAUJOCH_IMAGEBUFFER_H +#pragma once #include "ThreadSafeFIFO.h" #include "DiffractionExperiment.h" @@ -93,5 +92,3 @@ public: ImageBufferStatus GetStatus() const; }; - -#endif //JUNGFRAUJOCH_IMAGEBUFFER_H diff --git a/common/ImageFormatSettings.h b/common/ImageFormatSettings.h index 6fbb1523..13aca090 100644 --- a/common/ImageFormatSettings.h +++ b/common/ImageFormatSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_IMAGEFORMATSETTINGS_H -#define JFJOCH_IMAGEFORMATSETTINGS_H +#pragma once #include #include @@ -50,5 +49,3 @@ public: void Conv(); }; - -#endif //JFJOCH_IMAGEFORMATSETTINGS_H diff --git a/common/IndexingSettings.h b/common/IndexingSettings.h index 7f603f93..577e2ed3 100644 --- a/common/IndexingSettings.h +++ b/common/IndexingSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_INDEXINGSETTINGS_H -#define JFJOCH_INDEXINGSETTINGS_H +#pragma once #include @@ -72,6 +71,3 @@ public: [[nodiscard]] float GetRotationIndexingAngularStride_deg() const; [[nodiscard]] bool GetBlockingBehavior() const; }; - - -#endif //JFJOCH_INDEXINGSETTINGS_H diff --git a/common/InstrumentMetadata.h b/common/InstrumentMetadata.h index f23d331d..fada5606 100644 --- a/common/InstrumentMetadata.h +++ b/common/InstrumentMetadata.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_INSTRUMENTMETADATA_H -#define JFJOCH_INSTRUMENTMETADATA_H +#pragma once #include #include @@ -29,5 +28,3 @@ public: [[nodiscard]] bool IsPulsedSource() const; [[nodiscard]] bool IsElectronSource() const; }; - -#endif //JFJOCH_INSTRUMENTMETADATA_H diff --git a/common/JFJochException.h b/common/JFJochException.h index 07afe5a9..d2ecdb0f 100644 --- a/common/JFJochException.h +++ b/common/JFJochException.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef SLSEXCEPTION_H -#define SLSEXCEPTION_H +#pragma once #include #include @@ -163,4 +162,3 @@ public: msg += " (" + std::string(strerror(errno)) + ")"; } }; -#endif //SLSEXCEPTION_H diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index 585e85dc..0fcd2868 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHMESSAGES_H -#define JUNGFRAUJOCH_JFJOCHMESSAGES_H +#pragma once #include #include @@ -359,5 +358,3 @@ struct MetadataMessage { uint64_t run_number; std::vector images; }; - -#endif //JUNGFRAUJOCH_JFJOCHMESSAGES_H diff --git a/common/Logger.h b/common/Logger.h index 548505d9..61aeae50 100644 --- a/common/Logger.h +++ b/common/Logger.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_LOGGER_H -#define JUNGFRAUJOCH_LOGGER_H +#pragma once #include #include @@ -53,5 +52,3 @@ public: Logger& Verbose(bool input); }; - -#endif //JUNGFRAUJOCH_LOGGER_H diff --git a/common/ModuleSummation.h b/common/ModuleSummation.h index 7947d212..31d63b17 100644 --- a/common/ModuleSummation.h +++ b/common/ModuleSummation.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef IMAGESUMMATION_H -#define IMAGESUMMATION_H +#pragma once #include #include @@ -29,5 +28,3 @@ public: [[nodiscard]] DeviceOutput& GetOutput(); [[nodiscard]] bool empty() const; }; - -#endif //IMAGESUMMATION_H diff --git a/common/MovingAverage.h b/common/MovingAverage.h index 89691601..3a925e7d 100644 --- a/common/MovingAverage.h +++ b/common/MovingAverage.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_MOVINGAVERAGE_H -#define JFJOCH_MOVINGAVERAGE_H +#pragma once #include #include @@ -20,4 +19,4 @@ public: }; -#endif //JFJOCH_MOVINGAVERAGE_H + diff --git a/common/MultiLinePlot.h b/common/MultiLinePlot.h index d0ad9413..3fbefff9 100644 --- a/common/MultiLinePlot.h +++ b/common/MultiLinePlot.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_MULTILINEPLOT_H -#define JFJOCH_MULTILINEPLOT_H +#pragma once #include #include @@ -38,4 +37,4 @@ public: }; -#endif //JFJOCH_MULTILINEPLOT_H + diff --git a/common/NUMAHWPolicy.h b/common/NUMAHWPolicy.h index 4c8e503a..6c1375dd 100644 --- a/common/NUMAHWPolicy.h +++ b/common/NUMAHWPolicy.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_NUMAHWPOLICY_H -#define JUNGFRAUJOCH_NUMAHWPOLICY_H +#pragma once #include #include @@ -32,5 +31,3 @@ public: static void SelectGPU(int32_t gpu); static void SelectGPUAndItsNUMA(int32_t gpu); }; - -#endif //JUNGFRAUJOCH_NUMAHWPOLICY_H diff --git a/common/NetworkAddressConvert.h b/common/NetworkAddressConvert.h index a252b9bb..7dda1921 100644 --- a/common/NetworkAddressConvert.h +++ b/common/NetworkAddressConvert.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_NETWORKADDRESSCONVERT_H -#define JUNGFRAUJOCH_NETWORKADDRESSCONVERT_H +#pragma once #include #include @@ -11,5 +10,3 @@ std::string IPv4AddressToStr(uint32_t addr); std::string MacAddressToStr(uint64_t addr); uint32_t IPv4AddressFromStr(const std::string& addr); uint64_t MacAddressFromStr(const std::string& addr); - -#endif //JUNGFRAUJOCH_NETWORKADDRESSCONVERT_H diff --git a/common/PixelMask.h b/common/PixelMask.h index f4210861..5f9ae7c7 100644 --- a/common/PixelMask.h +++ b/common/PixelMask.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_PIXELMASK_H -#define JUNGFRAUJOCH_PIXELMASK_H +#pragma once #include "DetectorSetup.h" #include "DiffractionExperiment.h" @@ -54,6 +53,3 @@ public: [[nodiscard]] std::vector GetUserMask() const; [[nodiscard]] PixelMaskStatistics GetStatistics() const; }; - - -#endif //JUNGFRAUJOCH_PIXELMASK_H diff --git a/common/Plot.h b/common/Plot.h index 840e7fc1..7b12c8de 100644 --- a/common/Plot.h +++ b/common/Plot.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_PLOT_H -#define JUNGFRAUJOCH_PLOT_H +#pragma once #include #include @@ -30,5 +29,3 @@ struct PlotRequest { PlotAzintUnit azint_unit = PlotAzintUnit::Q_recipA; std::optional fill_value; }; - -#endif //JUNGFRAUJOCH_PLOT_H diff --git a/common/ROIAzimuthal.h b/common/ROIAzimuthal.h index 5e648c40..3934df9a 100644 --- a/common/ROIAzimuthal.h +++ b/common/ROIAzimuthal.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ROIAZIMUTHAL_H -#define JFJOCH_ROIAZIMUTHAL_H +#pragma once #include "ROIElement.h" @@ -21,4 +20,4 @@ public: }; -#endif //JFJOCH_ROIAZIMUTHAL_H + diff --git a/common/ROIBox.h b/common/ROIBox.h index 91aa2f53..35bc2952 100644 --- a/common/ROIBox.h +++ b/common/ROIBox.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ROIBOX_H -#define JUNGFRAUJOCH_ROIBOX_H +#pragma once #include "ROIElement.h" @@ -25,5 +24,3 @@ public: bool CheckROI(int64_t x, int64_t y, float resolution) const override; ROIConfig ExportMetadata() const override; }; - -#endif //JUNGFRAUJOCH_ROIBOX_H diff --git a/common/ROICircle.h b/common/ROICircle.h index 316b6550..63b192ee 100644 --- a/common/ROICircle.h +++ b/common/ROICircle.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ROICIRCLE_H -#define JUNGFRAUJOCH_ROICIRCLE_H +#pragma once #include "ROIElement.h" @@ -21,5 +20,3 @@ public: bool CheckROI(int64_t x, int64_t y, float resolution) const override; ROIConfig ExportMetadata() const override; }; - -#endif //JUNGFRAUJOCH_ROICIRCLE_H diff --git a/common/ROIDefinition.h b/common/ROIDefinition.h index 0c425aa3..0c197de0 100644 --- a/common/ROIDefinition.h +++ b/common/ROIDefinition.h @@ -1,7 +1,6 @@ // Copyright (2019-2024) Paul Scherrer Institute -#ifndef ROIDEFINITION_H -#define ROIDEFINITION_H +#pragma once #include #include "ROIBox.h" @@ -13,5 +12,3 @@ struct ROIDefinition { std::vector circles; std::vector azimuthal; }; - -#endif //ROIDEFINITION_H diff --git a/common/ROIElement.h b/common/ROIElement.h index 13336f9f..432f72a6 100644 --- a/common/ROIElement.h +++ b/common/ROIElement.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ROIELEMENT_H -#define JUNGFRAUJOCH_ROIELEMENT_H +#pragma once #include #include @@ -22,6 +21,3 @@ public: void MarkROI(std::vector &v, uint16_t value_to_mark, int64_t xpixel, int64_t ypixel, const std::vector &resolution_map) const; }; - - -#endif //JUNGFRAUJOCH_ROIELEMENT_H diff --git a/common/ROIMap.h b/common/ROIMap.h index c7dc9231..40be957d 100644 --- a/common/ROIMap.h +++ b/common/ROIMap.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ROIMAP_H -#define JUNGFRAUJOCH_ROIMAP_H +#pragma once #include #include @@ -26,5 +25,3 @@ public: [[nodiscard]] size_t size() const; [[nodiscard]] std::vector ExportMetadata() const; }; - -#endif //JUNGFRAUJOCH_ROIMAP_H diff --git a/common/RawToConvertedGeometry.h b/common/RawToConvertedGeometry.h index 2ae2de14..a3a179f1 100644 --- a/common/RawToConvertedGeometry.h +++ b/common/RawToConvertedGeometry.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_RAWTOCONVERTEDGEOMETRY_H -#define JUNGFRAUJOCH_RAWTOCONVERTEDGEOMETRY_H +#pragma once #include #include "RawToConvertedGeometryCore.h" @@ -149,5 +148,3 @@ inline void RawToEigerInput32(uint32_t *dest, const uint32_t *source) { } } } - -#endif \ No newline at end of file diff --git a/common/RawToConvertedGeometryCore.h b/common/RawToConvertedGeometryCore.h index 309119d2..c7692f71 100644 --- a/common/RawToConvertedGeometryCore.h +++ b/common/RawToConvertedGeometryCore.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_RAWTOCONVERTEDGEOMETRYCORE_H -#define JUNGFRAUJOCH_RAWTOCONVERTEDGEOMETRYCORE_H +#pragma once #include #include @@ -162,6 +161,3 @@ void Bin2x2_or(T *destination, const T *source, size_t width, size_t height) { } } } - - -#endif //JUNGFRAUJOCH_RAWTOCONVERTEDGEOMETRYCORE_H diff --git a/common/Reflection.h b/common/Reflection.h index b4573c34..08959c62 100644 --- a/common/Reflection.h +++ b/common/Reflection.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_REFLECTION_H -#define JFJOCH_REFLECTION_H +#pragma once #include #include @@ -44,4 +43,4 @@ struct MergedReflection { bool rfree_flag = false; }; -#endif //JFJOCH_REFLECTION_H + diff --git a/common/ResolutionShells.h b/common/ResolutionShells.h index 26969935..19358fa5 100644 --- a/common/ResolutionShells.h +++ b/common/ResolutionShells.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_RESOLUTIONSHELLS_H -#define JFJOCH_RESOLUTIONSHELLS_H +#pragma once #include #include @@ -20,4 +19,3 @@ public: }; -#endif //JFJOCH_RESOLUTIONSHELLS_H \ No newline at end of file diff --git a/common/ScanResult.h b/common/ScanResult.h index 3cef3f60..0d9e8de6 100644 --- a/common/ScanResult.h +++ b/common/ScanResult.h @@ -2,8 +2,7 @@ // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_SCANRESULT_H -#define JFJOCH_SCANRESULT_H +#pragma once #include #include @@ -51,4 +50,4 @@ struct ScanResult { std::optional rotation_lattice; }; -#endif //JFJOCH_SCANRESULT_H + diff --git a/common/ScanResultGenerator.h b/common/ScanResultGenerator.h index c7e59c99..2f96a526 100644 --- a/common/ScanResultGenerator.h +++ b/common/ScanResultGenerator.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_SCANRESULTGENERATOR_H -#define JFJOCH_SCANRESULTGENERATOR_H +#pragma once #include #include @@ -30,4 +29,4 @@ public: }; -#endif //JFJOCH_SCANRESULTGENERATOR_H + diff --git a/common/SpotToSave.h b/common/SpotToSave.h index 9efb978d..114a9995 100644 --- a/common/SpotToSave.h +++ b/common/SpotToSave.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_SPOTTOSAVE_H -#define JUNGFRAUJOCH_SPOTTOSAVE_H +#pragma once #include "DiffractionGeometry.h" @@ -22,5 +21,3 @@ struct SpotToSave { Coord ReciprocalCoord(const DiffractionGeometry &experiment) const; }; - -#endif //JUNGFRAUJOCH_SPOTTOSAVE_H diff --git a/common/StatusVector.h b/common/StatusVector.h index c8c7e4b7..8b2dd6e3 100644 --- a/common/StatusVector.h +++ b/common/StatusVector.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_STATUSVECTOR_H -#define JUNGFRAUJOCH_STATUSVECTOR_H +#pragma once #include #include @@ -40,5 +39,3 @@ public: MultiLinePlot GetMaxPlot(int64_t bin_size, float x_start, float x_incr, const std::optional &fill_value = {}) const; }; - -#endif //JUNGFRAUJOCH_STATUSVECTOR_H diff --git a/common/TopPixels.h b/common/TopPixels.h index c65fabb0..8db0ee66 100644 --- a/common/TopPixels.h +++ b/common/TopPixels.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_TOPPIXELS_H -#define JFJOCH_TOPPIXELS_H +#pragma once #include #include @@ -83,4 +82,3 @@ private: } }; -#endif //JFJOCH_TOPPIXELS_H \ No newline at end of file diff --git a/common/XrayFluorescenceSpectrum.h b/common/XrayFluorescenceSpectrum.h index b73e1a8f..06073cf1 100644 --- a/common/XrayFluorescenceSpectrum.h +++ b/common/XrayFluorescenceSpectrum.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_XRAYFLUORESCENCESPECTRUM_H -#define JFJOCH_XRAYFLUORESCENCESPECTRUM_H +#pragma once #include @@ -18,4 +17,3 @@ public: }; -#endif //JFJOCH_XRAYFLUORESCENCESPECTRUM_H \ No newline at end of file diff --git a/common/ZMQWrappers.h b/common/ZMQWrappers.h index 97730ad8..0aaaf6f0 100644 --- a/common/ZMQWrappers.h +++ b/common/ZMQWrappers.h @@ -2,8 +2,7 @@ // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ZMQWRAPPERS_H -#define JUNGFRAUJOCH_ZMQWRAPPERS_H +#pragma once #include #include @@ -80,5 +79,3 @@ public: std::string GetEndpointName(); }; - -#endif //JUNGFRAUJOCH_ZMQWRAPPERS_H diff --git a/common/ZeroCopyReturnValue.h b/common/ZeroCopyReturnValue.h index fe1c32b9..2d46fb95 100644 --- a/common/ZeroCopyReturnValue.h +++ b/common/ZeroCopyReturnValue.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ZEROCOPYRETURNVALUE_H -#define JUNGFRAUJOCH_ZEROCOPYRETURNVALUE_H +#pragma once #include "ImageBuffer.h" #include "ThreadSafeFIFO.h" @@ -32,5 +31,3 @@ public: void ReadyToSend(); void release(); }; - -#endif //JUNGFRAUJOCH_ZEROCOPYRETURNVALUE_H diff --git a/common/print_license.h b/common/print_license.h index aad15597..e5ca40cf 100644 --- a/common/print_license.h +++ b/common/print_license.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_PRINT_LICENSE_H -#define JFJOCH_PRINT_LICENSE_H +#pragma once #include @@ -16,4 +15,4 @@ inline void print_license(const std::string &component_name) { std::cout << "" << std::endl; } -#endif //JFJOCH_PRINT_LICENSE_H + diff --git a/compression/CompressionAlgorithmEnum.h b/compression/CompressionAlgorithmEnum.h index 769e3dc4..783ddb14 100644 --- a/compression/CompressionAlgorithmEnum.h +++ b/compression/CompressionAlgorithmEnum.h @@ -1,9 +1,6 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_COMPRESSIONALGORITHMENUM_H -#define JUNGFRAUJOCH_COMPRESSIONALGORITHMENUM_H +#pragma once enum class CompressionAlgorithm {BSHUF_LZ4, BSHUF_ZSTD, BSHUF_ZSTD_RLE, NO_COMPRESSION}; - -#endif //JUNGFRAUJOCH_COMPRESSIONALGORITHMENUM_H diff --git a/compression/JFJochCompressor.h b/compression/JFJochCompressor.h index 826b804b..0da07ce6 100644 --- a/compression/JFJochCompressor.h +++ b/compression/JFJochCompressor.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHCOMPRESSOR_H -#define JUNGFRAUJOCH_JFJOCHCOMPRESSOR_H +#pragma once #include @@ -45,7 +44,3 @@ template std::vector bitshuffle(const std::vector &input, size_t bshuf_bitshuffle(input.data(), ret.data(), input.size(), sizeof(T), block_size); return ret; } - - - -#endif //JUNGFRAUJOCH_JFJOCHCOMPRESSOR_H diff --git a/compression/JFJochDecompress.h b/compression/JFJochDecompress.h index 859e1cdd..a2479d04 100644 --- a/compression/JFJochDecompress.h +++ b/compression/JFJochDecompress.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHDECOMPRESS_H -#define JUNGFRAUJOCH_JFJOCHDECOMPRESS_H +#pragma once #include #include @@ -168,5 +167,3 @@ void JFJochDecompress(std::vector &output, CompressionAlgorithm algorithm, c size_t nelements, bool use_hperf = true) { JFJochDecompress(output, algorithm, source_v.data(), source_v.size() * sizeof(Ts), nelements, use_hperf); } - -#endif //JUNGFRAUJOCH_JFJOCHDECOMPRESS_H diff --git a/compression/JFJochZstdCompressor.h b/compression/JFJochZstdCompressor.h index 2cfd615c..568d7cdc 100644 --- a/compression/JFJochZstdCompressor.h +++ b/compression/JFJochZstdCompressor.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHZSTDCOMPRESSOR_H -#define JUNGFRAUJOCH_JFJOCHZSTDCOMPRESSOR_H +#pragma once #include #include @@ -17,6 +16,3 @@ public: static size_t RLEBlock(uint8_t *dst, uint8_t src, uint32_t src_size, bool last); size_t Compress(uint8_t *dst, const uint64_t *src, size_t src_size, size_t frame_sizes); }; - - -#endif //JUNGFRAUJOCH_JFJOCHZSTDCOMPRESSOR_H diff --git a/compression/MaxCompressedSize.h b/compression/MaxCompressedSize.h index 680ca951..29a6a1e5 100644 --- a/compression/MaxCompressedSize.h +++ b/compression/MaxCompressedSize.h @@ -1,12 +1,9 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_MAXCOMPRESSEDSIZE_H -#define JUNGFRAUJOCH_MAXCOMPRESSEDSIZE_H +#pragma once #include #include "CompressionAlgorithmEnum.h" int64_t MaxCompressedSize(CompressionAlgorithm algorithm, int64_t pixels_number, uint16_t pixel_depth); - -#endif //JUNGFRAUJOCH_MAXCOMPRESSEDSIZE_H diff --git a/detector_control/DectrisDetectorWrapper.h b/detector_control/DectrisDetectorWrapper.h index ef883e08..6217429b 100644 --- a/detector_control/DectrisDetectorWrapper.h +++ b/detector_control/DectrisDetectorWrapper.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DECTRISDETECTORWRAPPER_H -#define JFJOCH_DECTRISDETECTORWRAPPER_H +#pragma once #include "DetectorWrapper.h" #include "DectrisSimplonClient.h" @@ -28,4 +27,4 @@ public: }; -#endif //JFJOCH_DECTRISDETECTORWRAPPER_H + diff --git a/detector_control/DectrisSimplonClient.h b/detector_control/DectrisSimplonClient.h index 4cd35887..68340e90 100644 --- a/detector_control/DectrisSimplonClient.h +++ b/detector_control/DectrisSimplonClient.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DECTRISSIMPLONCLIENT_H -#define JFJOCH_DECTRISSIMPLONCLIENT_H +#pragma once #include #include @@ -62,4 +61,4 @@ public: }; -#endif //JFJOCH_DECTRISSIMPLONCLIENT_H + diff --git a/detector_control/DetectorWrapper.h b/detector_control/DetectorWrapper.h index dd763fde..d8fb1816 100644 --- a/detector_control/DetectorWrapper.h +++ b/detector_control/DetectorWrapper.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DETECTORWRAPPER_H -#define JFJOCH_DETECTORWRAPPER_H +#pragma once #include #include @@ -38,4 +37,4 @@ public: [[nodiscard]] virtual DetectorStatus GetStatus() const = 0; }; -#endif //JFJOCH_DETECTORWRAPPER_H + diff --git a/detector_control/SLSDetectorWrapper.h b/detector_control/SLSDetectorWrapper.h index 8615340e..03c44912 100644 --- a/detector_control/SLSDetectorWrapper.h +++ b/detector_control/SLSDetectorWrapper.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DETECTORWRAPPER_H -#define JUNGFRAUJOCH_DETECTORWRAPPER_H +#pragma once #include #include "../common/DiffractionExperiment.h" @@ -35,6 +34,3 @@ public: void LoadPixelMask(PixelMask &mask) override; DetectorStatus GetStatus() const override; }; - - -#endif //JUNGFRAUJOCH_DETECTORWRAPPER_H diff --git a/fpga/hls_simulation/HLSDevice.h b/fpga/hls_simulation/HLSDevice.h index b5ecc906..1e73b28b 100644 --- a/fpga/hls_simulation/HLSDevice.h +++ b/fpga/hls_simulation/HLSDevice.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_HLSDEVICE_H -#define JFJOCH_HLSDEVICE_H +#pragma once #include #include @@ -72,4 +71,4 @@ public: }; -#endif //JFJOCH_HLSDEVICE_H + diff --git a/fpga/hls_simulation/datamover_model.h b/fpga/hls_simulation/datamover_model.h index ca1ae88a..b6389b5e 100644 --- a/fpga/hls_simulation/datamover_model.h +++ b/fpga/hls_simulation/datamover_model.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DATAMOVER_MODEL_H -#define JUNGFRAUJOCH_DATAMOVER_MODEL_H +#pragma once #include #include "../hls/hls_jfjoch.h" @@ -94,5 +93,3 @@ public: hls::stream >& GetDataStream() { return data; } ~Datamover() { Stop(); } }; - -#endif //JUNGFRAUJOCH_DATAMOVER_MODEL_H diff --git a/fpga/hls_simulation/hls_cores.h b/fpga/hls_simulation/hls_cores.h index bab2b3a9..a0451790 100644 --- a/fpga/hls_simulation/hls_cores.h +++ b/fpga/hls_simulation/hls_cores.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_HLS_CORES_H -#define JFJOCH_HLS_CORES_H +#pragma once #include "../hls/hls_jfjoch.h" @@ -254,5 +253,3 @@ void pixel_mask(STREAM_768 &data_in, void pixel_calc(STREAM_768 &data_in, STREAM_768 &data_out, hls::stream> &calc_out); - -#endif //JFJOCH_HLS_CORES_H diff --git a/fpga/host_library/JungfraujochDevice.h b/fpga/host_library/JungfraujochDevice.h index 1f2fff33..c7f1bb5c 100644 --- a/fpga/host_library/JungfraujochDevice.h +++ b/fpga/host_library/JungfraujochDevice.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JUNGFRAUJOCHDEVICE_H -#define JUNGFRAUJOCH_JUNGFRAUJOCHDEVICE_H +#pragma once #include #include "../pcie_driver/jfjoch_fpga.h" @@ -105,5 +104,3 @@ public: uint8_t ReadClockConfig(uint8_t addr); void WriteClockConfig(uint8_t addr, uint8_t val); }; - -#endif //JUNGFRAUJOCH_JUNGFRAUJOCHDEVICE_H diff --git a/frame_serialize/CBORStream2Deserializer.h b/frame_serialize/CBORStream2Deserializer.h index 14671f3f..8cd5536b 100644 --- a/frame_serialize/CBORStream2Deserializer.h +++ b/frame_serialize/CBORStream2Deserializer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_CBORSTREAM2DESERIALIZER_H -#define JUNGFRAUJOCH_CBORSTREAM2DESERIALIZER_H +#pragma once #include #include @@ -43,5 +42,3 @@ struct CBORStream2DeserializerOutput { std::shared_ptr CBORStream2Deserialize(const uint8_t *msg, size_t msg_size); std::shared_ptr CBORStream2Deserialize(const std::vector& msg); std::shared_ptr CBORStream2Deserialize(const std::string& msg); - -#endif //JUNGFRAUJOCH_CBORSTREAM2DESERIALIZER_H diff --git a/frame_serialize/CBORStream2Serializer.h b/frame_serialize/CBORStream2Serializer.h index 350c56b9..dca67fe5 100644 --- a/frame_serialize/CBORStream2Serializer.h +++ b/frame_serialize/CBORStream2Serializer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_CBORSTREAM2SERIALIZER_H -#define JUNGFRAUJOCH_CBORSTREAM2SERIALIZER_H +#pragma once #include #include @@ -29,6 +28,3 @@ public: [[nodiscard]] size_t GetImageAppendOffset() const; void AppendImage(size_t image_size); }; - - -#endif //JUNGFRAUJOCH_CBORSTREAM2SERIALIZER_H diff --git a/frame_serialize/CborErr.h b/frame_serialize/CborErr.h index 6a92e4f3..176cf410 100644 --- a/frame_serialize/CborErr.h +++ b/frame_serialize/CborErr.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_CBORERR_H -#define JUNGFRAUJOCH_CBORERR_H +#pragma once #include "tinycbor/cbor.h" #include "../common/JFJochException.h" @@ -11,5 +10,3 @@ inline void cborErr(CborError err) { if (err != CborNoError) throw JFJochException(JFJochExceptionCategory::CBORError, cbor_error_string(err)); } - -#endif //JUNGFRAUJOCH_CBORERR_H diff --git a/frame_serialize/CborUtil.h b/frame_serialize/CborUtil.h index 2f2f3ea6..c9a63afb 100644 --- a/frame_serialize/CborUtil.h +++ b/frame_serialize/CborUtil.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_CBORUTIL_H -#define JUNGFRAUJOCH_CBORUTIL_H +#pragma once #include "tinycbor/cbor.h" @@ -25,5 +24,3 @@ constexpr const CborTag TagSignedInt32BitLE = 0b01001110; constexpr const CborTag TagUnsignedInt64BitLE = 0b01000111; constexpr const CborTag TagSignedInt64BitLE = 0b01001111; - -#endif //JUNGFRAUJOCH_CBORUTIL_H diff --git a/image_analysis/MXAnalysisAfterFPGA.h b/image_analysis/MXAnalysisAfterFPGA.h index 4ac36ea6..ccddf87a 100644 --- a/image_analysis/MXAnalysisAfterFPGA.h +++ b/image_analysis/MXAnalysisAfterFPGA.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_MXANALYZER_H -#define JUNGFRAUJOCH_MXANALYZER_H +#pragma once #include "../common/DiffractionExperiment.h" #include "bragg_prediction/BraggPrediction.h" @@ -43,6 +42,3 @@ public: void Process(DataMessage &message, const SpotFindingSettings& settings); }; - - -#endif //JUNGFRAUJOCH_MXANALYZER_H diff --git a/image_analysis/MXAnalysisWithoutFPGA.h b/image_analysis/MXAnalysisWithoutFPGA.h index 778e0953..e5864d41 100644 --- a/image_analysis/MXAnalysisWithoutFPGA.h +++ b/image_analysis/MXAnalysisWithoutFPGA.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_IMAGEANALYSISCPU_H -#define JFJOCH_IMAGEANALYSISCPU_H +#pragma once #include @@ -49,4 +48,4 @@ public: }; -#endif //JFJOCH_IMAGEANALYSISCPU_H + diff --git a/image_analysis/RotationParameters.h b/image_analysis/RotationParameters.h index 1eab2ead..7488a7e5 100644 --- a/image_analysis/RotationParameters.h +++ b/image_analysis/RotationParameters.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ROTATIONPARAMETERS_H -#define JFJOCH_ROTATIONPARAMETERS_H +#pragma once #include "../common/MovingAverage.h" @@ -17,4 +16,3 @@ public: }; -#endif //JFJOCH_ROTATIONPARAMETERS_H \ No newline at end of file diff --git a/image_analysis/bragg_integration/CalcISigma.h b/image_analysis/bragg_integration/CalcISigma.h index dda2914e..21102ff8 100644 --- a/image_analysis/bragg_integration/CalcISigma.h +++ b/image_analysis/bragg_integration/CalcISigma.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_CALCISIGMA_H -#define JFJOCH_CALCISIGMA_H +#pragma once #include "../../common/JFJochMessages.h" #include "../../common/Reflection.h" @@ -13,4 +12,3 @@ void CalcWilsonBFactor(DataMessage &msg, bool replace_b = true); void CalcISigma(DataMessage &msg, const std::vector &reflections); void CalcWilsonBFactor(DataMessage &msg, const std::vector &reflections, bool replace_b = true); -#endif //JFJOCH_CALCISIGMA_H \ No newline at end of file diff --git a/image_analysis/bragg_integration/Regression.h b/image_analysis/bragg_integration/Regression.h index 67a0af21..892a078a 100644 --- a/image_analysis/bragg_integration/Regression.h +++ b/image_analysis/bragg_integration/Regression.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_REGRESSION_H -#define JUNGFRAUJOCH_REGRESSION_H +#pragma once #include #include @@ -76,5 +75,3 @@ RegressionResult regression(std::vector &x, std::vector &y, const .r_square = static_cast(r_square) }; }; - -#endif //JUNGFRAUJOCH_REGRESSION_H diff --git a/image_analysis/bragg_prediction/BraggPrediction.h b/image_analysis/bragg_prediction/BraggPrediction.h index 218fc00e..6aaf4fc5 100644 --- a/image_analysis/bragg_prediction/BraggPrediction.h +++ b/image_analysis/bragg_prediction/BraggPrediction.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_BRAGGPREDICTION_H -#define JFJOCH_BRAGGPREDICTION_H +#pragma once #include @@ -35,4 +34,4 @@ public: }; -#endif //JFJOCH_BRAGGPREDICTION_H + diff --git a/image_analysis/bragg_prediction/BraggPredictionFactory.h b/image_analysis/bragg_prediction/BraggPredictionFactory.h index 8c5954cc..22c2fb2d 100644 --- a/image_analysis/bragg_prediction/BraggPredictionFactory.h +++ b/image_analysis/bragg_prediction/BraggPredictionFactory.h @@ -1,12 +1,10 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_BRAGGPREDICTIONFACTORY_H -#define JFJOCH_BRAGGPREDICTIONFACTORY_H +#pragma once #include "BraggPrediction.h" std::unique_ptr CreateBraggPrediction(bool rotation_indexing = false, int max_reflections = 10000); -#endif //JFJOCH_BRAGGPREDICTIONFACTORY_H \ No newline at end of file diff --git a/image_analysis/bragg_prediction/BraggPredictionGPU.h b/image_analysis/bragg_prediction/BraggPredictionGPU.h index 0a88cfe3..2bf7a27b 100644 --- a/image_analysis/bragg_prediction/BraggPredictionGPU.h +++ b/image_analysis/bragg_prediction/BraggPredictionGPU.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_BRAGGPREDICTIONGPU_H -#define JFJOCH_BRAGGPREDICTIONGPU_H +#pragma once #include @@ -47,4 +46,3 @@ public: }; -#endif //JFJOCH_BRAGGPREDICTIONGPU_H \ No newline at end of file diff --git a/image_analysis/dark_mask_analysis/DarkMaskAnalysis.h b/image_analysis/dark_mask_analysis/DarkMaskAnalysis.h index 997d69b4..c9e8bb4e 100644 --- a/image_analysis/dark_mask_analysis/DarkMaskAnalysis.h +++ b/image_analysis/dark_mask_analysis/DarkMaskAnalysis.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_DARKMASKANALYSIS_H -#define JFJOCH_DARKMASKANALYSIS_H +#pragma once #include #include @@ -27,4 +26,3 @@ public: }; -#endif //JFJOCH_MASKDARKANALYSIS_H \ No newline at end of file diff --git a/image_analysis/geom_refinement/AssignSpotsToRings.h b/image_analysis/geom_refinement/AssignSpotsToRings.h index 835f9e59..f4abff2e 100644 --- a/image_analysis/geom_refinement/AssignSpotsToRings.h +++ b/image_analysis/geom_refinement/AssignSpotsToRings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ASSIGNSPOTSTORINGS_H -#define JFJOCH_ASSIGNSPOTSTORINGS_H +#pragma once #include #include "../../common/UnitCell.h" @@ -37,4 +36,4 @@ std::vector GuessInitialGeometry(DiffractionGeometry &geom, const void GuessGeometry(DiffractionGeometry &geom, const std::vector &v, const UnitCell &calibrant); void OptimizeGeometry(DiffractionGeometry &geom, const std::vector &v, const UnitCell &calibrant); -#endif //JFJOCH_ASSIGNSPOTSTORINGS_H + diff --git a/image_analysis/geom_refinement/RingOptimizer.h b/image_analysis/geom_refinement/RingOptimizer.h index d870e2e5..59e646b1 100644 --- a/image_analysis/geom_refinement/RingOptimizer.h +++ b/image_analysis/geom_refinement/RingOptimizer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_RINGOPTIMIZER_H -#define JFJOCH_RINGOPTIMIZER_H +#pragma once #include #include "../../common/DiffractionGeometry.h" @@ -21,4 +20,4 @@ public: }; -#endif //JFJOCH_RINGOPTIMIZER_H + diff --git a/image_analysis/geom_refinement/XtalOptimizer.h b/image_analysis/geom_refinement/XtalOptimizer.h index 1c0c67dd..c472e8ab 100644 --- a/image_analysis/geom_refinement/XtalOptimizer.h +++ b/image_analysis/geom_refinement/XtalOptimizer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_XTALOPTIMIZER_H -#define JFJOCH_XTALOPTIMIZER_H +#pragma once #include @@ -60,4 +59,4 @@ CrystalLattice AngleAxisAndCellToLattice(const double rod[3], bool XtalOptimizer(XtalOptimizerData &data, const std::vector> &spots); bool XtalOptimizerRotationOnly(XtalOptimizerData &data, const std::vector &spots, float tolerance); -#endif //JFJOCH_XTALOPTIMIZER_H + diff --git a/image_analysis/indexing/AnalyzeIndexing.h b/image_analysis/indexing/AnalyzeIndexing.h index 0644bb6b..ae0213cc 100644 --- a/image_analysis/indexing/AnalyzeIndexing.h +++ b/image_analysis/indexing/AnalyzeIndexing.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ANALYZEINDEXING_H -#define JFJOCH_ANALYZEINDEXING_H +#pragma once #include "../../common/CrystalLattice.h" #include "../../common/DiffractionExperiment.h" @@ -15,4 +14,3 @@ bool AnalyzeIndexing(DataMessage &message, const CrystalLattice &latt); -#endif //JFJOCH_ANALYZEINDEXING_H \ No newline at end of file diff --git a/image_analysis/indexing/CUDAMemHelpers.h b/image_analysis/indexing/CUDAMemHelpers.h index ae8c3369..8eb25348 100644 --- a/image_analysis/indexing/CUDAMemHelpers.h +++ b/image_analysis/indexing/CUDAMemHelpers.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_CUDAMEMHELPERS_H -#define JFJOCH_CUDAMEMHELPERS_H +#pragma once #include #include @@ -235,4 +234,4 @@ public: bool isRegistered() const { return registered_; } }; -#endif //JFJOCH_CUDAMEMHELPERS_H + diff --git a/image_analysis/indexing/FFBIDXIndexer.h b/image_analysis/indexing/FFBIDXIndexer.h index cd0308a4..93609ec5 100644 --- a/image_analysis/indexing/FFBIDXIndexer.h +++ b/image_analysis/indexing/FFBIDXIndexer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_INDEXERWRAPPER_H -#define JUNGFRAUJOCH_INDEXERWRAPPER_H +#pragma once // This include should be only included in sections of the code, where it is certain that CUDA is present // so with JFJOCH_USE_CUDA preprocessor definition, given this file is included in the source only in this case @@ -40,5 +39,3 @@ public: std::vector RunInternal(const std::vector &coord, size_t nspots) override; }; - -#endif //JUNGFRAUJOCH_INDEXERWRAPPER_H diff --git a/image_analysis/indexing/FFTIndexer.h b/image_analysis/indexing/FFTIndexer.h index ad907080..47a0d8c1 100644 --- a/image_analysis/indexing/FFTIndexer.h +++ b/image_analysis/indexing/FFTIndexer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_FFTINDEXER_H -#define JFJOCH_FFTINDEXER_H +#pragma once #include "Indexer.h" #include "../../common/UnitCell.h" @@ -46,4 +45,3 @@ public: std::vector RunInternal(const std::vector &coord, size_t nspots) override; }; -#endif //JFJOCH_FFTINDEXER_H \ No newline at end of file diff --git a/image_analysis/indexing/FFTIndexerCPU.h b/image_analysis/indexing/FFTIndexerCPU.h index 4f756748..a784155c 100644 --- a/image_analysis/indexing/FFTIndexerCPU.h +++ b/image_analysis/indexing/FFTIndexerCPU.h @@ -2,8 +2,7 @@ // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_FFTINDEXERCPU_H -#define JFJOCH_FFTINDEXERCPU_H +#pragma once #include #include @@ -31,4 +30,4 @@ public: ~FFTIndexerCPU() override; }; -#endif //JFJOCH_FFTINDEXERCPU_H + diff --git a/image_analysis/indexing/FFTIndexerGPU.h b/image_analysis/indexing/FFTIndexerGPU.h index f6b8b18e..0a1bdbba 100644 --- a/image_analysis/indexing/FFTIndexerGPU.h +++ b/image_analysis/indexing/FFTIndexerGPU.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_FFTINDEXERGPU_H -#define JFJOCH_FFTINDEXERGPU_H +#pragma once // This include should be only included in sections of the code, where it is certain that CUDA is present // so with JFJOCH_USE_CUDA preprocessor definition, given this file is included in the source only in this case @@ -49,4 +48,4 @@ public: }; -#endif //JFJOCH_FFTINDEXERGPU_H + diff --git a/image_analysis/indexing/FFTResult.h b/image_analysis/indexing/FFTResult.h index 4cc2238f..323c9dbd 100644 --- a/image_analysis/indexing/FFTResult.h +++ b/image_analysis/indexing/FFTResult.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_FFTRESULT_H -#define JFJOCH_FFTRESULT_H +#pragma once #include @@ -12,4 +11,4 @@ struct FFTResult { float length; }; -#endif //JFJOCH_FFTRESULT_H + diff --git a/image_analysis/indexing/FitProfileRadius.h b/image_analysis/indexing/FitProfileRadius.h index 4794fa96..7348ab49 100644 --- a/image_analysis/indexing/FitProfileRadius.h +++ b/image_analysis/indexing/FitProfileRadius.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_FITPROFILERADIUS_H -#define JFJOCH_FITPROFILERADIUS_H +#pragma once #include #include @@ -12,4 +11,3 @@ std::optional FitProfileRadius_MAD(const std::vector& spots); std::optional FitProfileRadius(const std::vector& spots); -#endif //JFJOCH_FITPROFILERADIUS_H \ No newline at end of file diff --git a/image_analysis/indexing/Indexer.h b/image_analysis/indexing/Indexer.h index 1718136a..dc2dc783 100644 --- a/image_analysis/indexing/Indexer.h +++ b/image_analysis/indexing/Indexer.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_INDEXER_H -#define JFJOCH_INDEXER_H +#pragma once #include @@ -36,4 +35,4 @@ public: IndexerResult Run(const std::vector &coord); }; -#endif //JFJOCH_INDEXER_H + diff --git a/image_analysis/indexing/IndexerFactory.h b/image_analysis/indexing/IndexerFactory.h index ec6f44b2..206d1b05 100644 --- a/image_analysis/indexing/IndexerFactory.h +++ b/image_analysis/indexing/IndexerFactory.h @@ -1,12 +1,11 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_INDEXERFACTORY_H -#define JFJOCH_INDEXERFACTORY_H +#pragma once #include #include "Indexer.h" std::unique_ptr CreateIndexer(const DiffractionExperiment& experiment); -#endif //JFJOCH_INDEXERFACTORY_H + diff --git a/image_analysis/indexing/IndexerThreadPool.h b/image_analysis/indexing/IndexerThreadPool.h index bcd6fdc5..224e2943 100644 --- a/image_analysis/indexing/IndexerThreadPool.h +++ b/image_analysis/indexing/IndexerThreadPool.h @@ -1,7 +1,6 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_INDEXERTHREADPOOL_H -#define JFJOCH_INDEXERTHREADPOOL_H +#pragma once #include @@ -60,4 +59,4 @@ public: }; -#endif //JFJOCH_INDEXERTHREADPOOL_H + diff --git a/image_analysis/lattice_search/LatticeSearch.h b/image_analysis/lattice_search/LatticeSearch.h index b6866d48..422d1c50 100644 --- a/image_analysis/lattice_search/LatticeSearch.h +++ b/image_analysis/lattice_search/LatticeSearch.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_LATTICESEARCH_H -#define JFJOCH_LATTICESEARCH_H +#pragma once #include "../../common/CrystalLattice.h" #include "../../common/UnitCell.h" @@ -24,4 +23,3 @@ struct LatticeSearchResult { LatticeSearchResult LatticeSearch(const CrystalLattice& L, double dist_tolerance = 0.03, double angle_tolerance_deg = 3); -#endif //JFJOCH_LATTICESEARCH_H \ No newline at end of file diff --git a/image_analysis/spot_finding/DetModuleSpotFinder_cpu.h b/image_analysis/spot_finding/DetModuleSpotFinder_cpu.h index b3f40026..5506387c 100644 --- a/image_analysis/spot_finding/DetModuleSpotFinder_cpu.h +++ b/image_analysis/spot_finding/DetModuleSpotFinder_cpu.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_CPUSPOTFINDER_H -#define JUNGFRAUJOCH_CPUSPOTFINDER_H +#pragma once #include "../../common/DiffractionExperiment.h" #include "SpotFindingSettings.h" @@ -143,5 +142,3 @@ void FindSpots(DeviceOutput &output, FindSpots(output, j, i, N, LINES_TO_GO, settings, d_array, arr_mean, arr_stddev, arr_valid_count, arr_strong_pixel); } } - -#endif //JUNGFRAUJOCH_CPUSPOTFINDER_H diff --git a/image_analysis/spot_finding/ImageSpotFinder.h b/image_analysis/spot_finding/ImageSpotFinder.h index bf44245b..11691aee 100644 --- a/image_analysis/spot_finding/ImageSpotFinder.h +++ b/image_analysis/spot_finding/ImageSpotFinder.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_IMAGESPOTFINDER_H -#define JFJOCH_IMAGESPOTFINDER_H +#pragma once #include #include @@ -29,4 +28,4 @@ public: }; -#endif //JFJOCH_IMAGESPOTFINDER_H + diff --git a/image_analysis/spot_finding/ImageSpotFinderCPU.h b/image_analysis/spot_finding/ImageSpotFinderCPU.h index 497d09e4..29ae00f4 100644 --- a/image_analysis/spot_finding/ImageSpotFinderCPU.h +++ b/image_analysis/spot_finding/ImageSpotFinderCPU.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_IMAGESPOTFINDERCPU_H -#define JFJOCH_IMAGESPOTFINDERCPU_H +#pragma once #include @@ -24,4 +23,4 @@ public: std::vector Run(const ImagePreprocessorBuffer &image, const SpotFindingSettings &settings, const std::vector &res_mask); }; -#endif //JFJOCH_IMAGESPOTFINDER_H + diff --git a/image_analysis/spot_finding/ImageSpotFinderGPU.h b/image_analysis/spot_finding/ImageSpotFinderGPU.h index 92213a9d..c18afbe2 100644 --- a/image_analysis/spot_finding/ImageSpotFinderGPU.h +++ b/image_analysis/spot_finding/ImageSpotFinderGPU.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_IMAGEANALYSISGPU_H -#define JFJOCH_IMAGEANALYSISGPU_H +#pragma once #include @@ -27,4 +26,4 @@ public: std::vector Run(const ImagePreprocessorBuffer &image, const SpotFindingSettings &settings, const std::vector &res_mask) override; }; -#endif //JFJOCH_IMAGEANALYSISGPU_H + diff --git a/image_analysis/spot_finding/SpotFindingSettings.h b/image_analysis/spot_finding/SpotFindingSettings.h index a3d55f84..94de14a1 100644 --- a/image_analysis/spot_finding/SpotFindingSettings.h +++ b/image_analysis/spot_finding/SpotFindingSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_SPOTFINDINGSETTINGS_H -#define JUNGFRAUJOCH_SPOTFINDINGSETTINGS_H +#pragma once #include #include @@ -23,5 +22,3 @@ struct SpotFindingSettings { bool indexing = true; bool quick_integration = true; }; - -#endif //JUNGFRAUJOCH_SPOTFINDINGSETTINGS_H diff --git a/image_analysis/spot_finding/SpotUtils.h b/image_analysis/spot_finding/SpotUtils.h index 0404e2cf..05d183c8 100644 --- a/image_analysis/spot_finding/SpotUtils.h +++ b/image_analysis/spot_finding/SpotUtils.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_SPOTANALYSIS_H -#define JFJOCH_SPOTANALYSIS_H +#pragma once #include "../../common/DiffractionSpot.h" @@ -33,4 +32,4 @@ void SpotAnalyze(const DiffractionExperiment &experiment, const std::vector &spots, DataMessage &message); -#endif //JFJOCH_SPOTANALYSIS_H + diff --git a/image_analysis/spot_finding/StrongPixelSet.h b/image_analysis/spot_finding/StrongPixelSet.h index 06e05018..cbc322da 100644 --- a/image_analysis/spot_finding/StrongPixelSet.h +++ b/image_analysis/spot_finding/StrongPixelSet.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_STRONGPIXELSET_H -#define JUNGFRAUJOCH_STRONGPIXELSET_H +#pragma once #include "../../common/DiffractionExperiment.h" #include "../../common/DiffractionSpot.h" @@ -39,6 +38,3 @@ public: void FindSpotsImage(const SpotFindingSettings &settings, std::vector &spots); uint32_t GetStrongPixelCount() const; }; - - -#endif //JUNGFRAUJOCH_STRONGPIXELSET_H diff --git a/image_puller/ImagePuller.h b/image_puller/ImagePuller.h index 462f0736..41c8533d 100644 --- a/image_puller/ImagePuller.h +++ b/image_puller/ImagePuller.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_IMAGEPULLER_H -#define JFJOCH_IMAGEPULLER_H +#pragma once #include #include @@ -60,4 +59,4 @@ public: virtual void Disconnect() = 0; }; -#endif //JFJOCH_IMAGEPULLER_H + diff --git a/image_puller/TestImagePuller.h b/image_puller/TestImagePuller.h index 59556275..04b47fdc 100644 --- a/image_puller/TestImagePuller.h +++ b/image_puller/TestImagePuller.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_TESTIMAGEPULLER_H -#define JFJOCH_TESTIMAGEPULLER_H +#pragma once #include "ImagePuller.h" @@ -13,4 +12,4 @@ public: void Disconnect() override; }; -#endif //JFJOCH_TESTIMAGEPULLER_H + diff --git a/image_puller/ZMQImagePuller.h b/image_puller/ZMQImagePuller.h index 5c43feb3..071b5fc1 100644 --- a/image_puller/ZMQImagePuller.h +++ b/image_puller/ZMQImagePuller.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ZMQIMAGEPULLER_H -#define JUNGFRAUJOCH_ZMQIMAGEPULLER_H +#pragma once #include @@ -56,5 +55,3 @@ public: void Suspend(); void ResumeAndClear(); }; - -#endif //JUNGFRAUJOCH_ZMQIMAGEPULLER_H diff --git a/image_pusher/CBORFilePusher.h b/image_pusher/CBORFilePusher.h index e3eecf55..91b3b59d 100644 --- a/image_pusher/CBORFilePusher.h +++ b/image_pusher/CBORFilePusher.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_DUMPCBORTOFILEPUSHER_H -#define JUNGFRAUJOCH_DUMPCBORTOFILEPUSHER_H +#pragma once #include "ImagePusher.h" #include @@ -22,6 +21,3 @@ public: size_t GetConnectedWriters() const override; ImagePusherType GetType() const override { return ImagePusherType::CBOR; } }; - - -#endif //JUNGFRAUJOCH_DUMPCBORTOFILEPUSHER_H diff --git a/image_pusher/HDF5FilePusher.h b/image_pusher/HDF5FilePusher.h index 3d65c0a7..4039135e 100644 --- a/image_pusher/HDF5FilePusher.h +++ b/image_pusher/HDF5FilePusher.h @@ -1,9 +1,7 @@ - // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_HDF5FILEPUSHER_H -#define JFJOCH_HDF5FILEPUSHER_H +#pragma once #include @@ -45,5 +43,3 @@ public: size_t GetConnectedWriters() const override; ImagePusherType GetType() const override { return ImagePusherType::HDF5; } }; - -#endif //JFJOCH_HDF5FILEPUSHER_H diff --git a/image_pusher/ImagePusher.h b/image_pusher/ImagePusher.h index ac41375b..17d543ed 100644 --- a/image_pusher/ImagePusher.h +++ b/image_pusher/ImagePusher.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_IMAGEPUSHER_H -#define JUNGFRAUJOCH_IMAGEPUSHER_H +#pragma once #include @@ -67,6 +66,3 @@ public: }; } }; - - -#endif //JUNGFRAUJOCH_IMAGEPUSHER_H diff --git a/image_pusher/NonePusher.h b/image_pusher/NonePusher.h index 49ede5d0..cd6ae70e 100644 --- a/image_pusher/NonePusher.h +++ b/image_pusher/NonePusher.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_NONEPUSHER_H -#define JFJOCH_NONEPUSHER_H +#pragma once #include "ImagePusher.h" @@ -18,4 +17,4 @@ public: }; -#endif //JFJOCH_NONEPUSHER_H + diff --git a/image_pusher/TestImagePusher.h b/image_pusher/TestImagePusher.h index a1a65059..914d5b8b 100644 --- a/image_pusher/TestImagePusher.h +++ b/image_pusher/TestImagePusher.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_TESTIMAGEPUSHER_H -#define JUNGFRAUJOCH_TESTIMAGEPUSHER_H +#pragma once #include @@ -38,6 +37,3 @@ public: ImagePusherType GetType() const override { return ImagePusherType::Test; } }; - - -#endif //JUNGFRAUJOCH_TESTIMAGEPUSHER_H diff --git a/image_pusher/ZMQStream2Pusher.h b/image_pusher/ZMQStream2Pusher.h index aa5dbd36..9d58f7a3 100644 --- a/image_pusher/ZMQStream2Pusher.h +++ b/image_pusher/ZMQStream2Pusher.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_ZMQSTREAM2PUSHER_H -#define JUNGFRAUJOCH_ZMQSTREAM2PUSHER_H +#pragma once #include "ImagePusher.h" #include "../common/ZMQWrappers.h" @@ -50,5 +49,3 @@ public: ImagePusherType GetType() const override { return ImagePusherType::ZMQ; } }; - -#endif //JUNGFRAUJOCH_ZMQSTREAM2PUSHER_H diff --git a/image_pusher/ZMQStream2PusherSocket.h b/image_pusher/ZMQStream2PusherSocket.h index 76b6c2cb..d31165cc 100644 --- a/image_pusher/ZMQStream2PusherSocket.h +++ b/image_pusher/ZMQStream2PusherSocket.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ZMQSTREAM2PUSHERSOCKET_H -#define JFJOCH_ZMQSTREAM2PUSHERSOCKET_H +#pragma once #include #include @@ -38,5 +37,3 @@ public: // Thread-safe void SendImage(ZeroCopyReturnValue &z); }; - -#endif //JFJOCH_ZMQSTREAM2PUSHERSOCKET_H \ No newline at end of file diff --git a/image_pusher/ZMQWriterNotificationPuller.h b/image_pusher/ZMQWriterNotificationPuller.h index cf90c932..e9ca6224 100644 --- a/image_pusher/ZMQWriterNotificationPuller.h +++ b/image_pusher/ZMQWriterNotificationPuller.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ZMQWRITERNOTIFICATIONPULLER_H -#define JFJOCH_ZMQWRITERNOTIFICATIONPULLER_H +#pragma once #include @@ -25,4 +24,4 @@ public: }; -#endif //JFJOCH_ZMQWRITERNOTIFICATIONPULLER_H + diff --git a/jungfrau/JFCalibration.h b/jungfrau/JFCalibration.h index 3479d662..5aec8120 100644 --- a/jungfrau/JFCalibration.h +++ b/jungfrau/JFCalibration.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFCALIBRATION_H -#define JUNGFRAUJOCH_JFCALIBRATION_H +#pragma once #include "JFModulePedestal.h" #include "JFModuleGainCalibration.h" @@ -53,5 +52,3 @@ public: [[nodiscard]] std::vector GetPedestalRMS(size_t gain_level, size_t storage_cell = 0) const; }; - -#endif //JUNGFRAUJOCH_JFCALIBRATION_H diff --git a/jungfrau/JFConversionFloatingPoint.h b/jungfrau/JFConversionFloatingPoint.h index 2b6b4a73..cebbe049 100644 --- a/jungfrau/JFConversionFloatingPoint.h +++ b/jungfrau/JFConversionFloatingPoint.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFCONVERSIONFLOATINGPOINT_H -#define JUNGFRAUJOCH_JFCONVERSIONFLOATINGPOINT_H +#pragma once #include "JFCalibration.h" @@ -32,6 +31,3 @@ public: double energy, bool using_gain_hg0); void ConvertFP(double *dest, const uint16_t *source); }; - - -#endif //JUNGFRAUJOCH_JFCONVERSIONFLOATINGPOINT_H diff --git a/jungfrau/JFModuleGainCalibration.h b/jungfrau/JFModuleGainCalibration.h index adad5624..1521a4f9 100644 --- a/jungfrau/JFModuleGainCalibration.h +++ b/jungfrau/JFModuleGainCalibration.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFMODULEGAINCALIBRATION_H -#define JUNGFRAUJOCH_JFMODULEGAINCALIBRATION_H +#pragma once #include #include @@ -53,5 +52,3 @@ public: void LoadGain(const std::vector& filenames); const std::vector& GetCalibration() const; }; - -#endif //JUNGFRAUJOCH_JFMODULEGAINCALIBRATION_H diff --git a/jungfrau/JFModulePedestal.h b/jungfrau/JFModulePedestal.h index 0d69c473..5c5a40c2 100644 --- a/jungfrau/JFModulePedestal.h +++ b/jungfrau/JFModulePedestal.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFMODULEPEDESTAL_H -#define JUNGFRAUJOCH_JFMODULEPEDESTAL_H +#pragma once #include #include @@ -41,6 +40,3 @@ public: void SetFrameCount(int64_t input); [[nodiscard]] int64_t GetFrameCount() const; }; - - -#endif //JUNGFRAUJOCH_JFMODULEPEDESTAL_H diff --git a/jungfrau/JFPedestalCalc.h b/jungfrau/JFPedestalCalc.h index 071916cb..63398499 100644 --- a/jungfrau/JFPedestalCalc.h +++ b/jungfrau/JFPedestalCalc.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFPEDESTALCALC_H -#define JUNGFRAUJOCH_JFPEDESTALCALC_H +#pragma once #include #include @@ -25,5 +24,3 @@ public: void Export(JFModulePedestal& calibration, size_t allowed_wrong_gains = 0) const; JFPedestalCalc &operator+=(const JFPedestalCalc &other); }; - -#endif //JUNGFRAUJOCH_JFPEDESTALCALC_H diff --git a/preview/PreviewCounter.h b/preview/PreviewCounter.h index eddcc53f..88990aa4 100644 --- a/preview/PreviewCounter.h +++ b/preview/PreviewCounter.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_PREVIEWCOUNTER_H -#define JUNGFRAUJOCH_PREVIEWCOUNTER_H +#pragma once #include #include @@ -19,5 +18,3 @@ public: bool GeneratePreview(); std::optional GetPeriod() const; }; - -#endif //JUNGFRAUJOCH_PREVIEWCOUNTER_H diff --git a/preview/PreviewImage.h b/preview/PreviewImage.h index e625a766..2598ee06 100644 --- a/preview/PreviewImage.h +++ b/preview/PreviewImage.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_PREVIEWIMAGE_H -#define JUNGFRAUJOCH_PREVIEWIMAGE_H +#pragma once #include #include @@ -74,5 +73,3 @@ public: [[nodiscard]] std::string GenerateImage(const PreviewImageSettings& settings, const std::vector& cbor_format); [[nodiscard]] static std::string GenerateTIFF(const std::vector& cbor_format) ; }; - -#endif //JUNGFRAUJOCH_PREVIEWIMAGE_H diff --git a/preview/ZMQPreviewSettings.h b/preview/ZMQPreviewSettings.h index ec27c5c6..d05c49b4 100644 --- a/preview/ZMQPreviewSettings.h +++ b/preview/ZMQPreviewSettings.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ZMQPREVIEWSETTINGS_H -#define JFJOCH_ZMQPREVIEWSETTINGS_H +#pragma once #include #include @@ -13,4 +12,4 @@ struct ZMQPreviewSettings { }; -#endif //JFJOCH_ZMQPREVIEWSETTINGS_H + diff --git a/preview/ZMQPreviewSocket.h b/preview/ZMQPreviewSocket.h index 1b03db79..1b637819 100644 --- a/preview/ZMQPreviewSocket.h +++ b/preview/ZMQPreviewSocket.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_ZMQPREVIEWSOCKET_H -#define JFJOCH_ZMQPREVIEWSOCKET_H +#pragma once #include "PreviewCounter.h" #include "../common/ZMQWrappers.h" @@ -24,4 +23,4 @@ public: ZMQPreviewSettings GetSettings(); }; -#endif //JFJOCH_ZMQPREVIEWSOCKET_H + diff --git a/reader/JFJochHttpReader.h b/reader/JFJochHttpReader.h index dcbc955a..13dc6911 100644 --- a/reader/JFJochHttpReader.h +++ b/reader/JFJochHttpReader.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHHTTPREADER_H -#define JFJOCH_JFJOCHHTTPREADER_H +#pragma once #include "JFJochReader.h" #include "../common/BrokerStatus.h" @@ -40,4 +39,4 @@ public: }; -#endif //JFJOCH_JFJOCHHTTPREADER_H + diff --git a/reader/JFJochReaderDataset.h b/reader/JFJochReaderDataset.h index 0540c07c..d070bf32 100644 --- a/reader/JFJochReaderDataset.h +++ b/reader/JFJochReaderDataset.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHREADERDATASET_H -#define JFJOCH_JFJOCHREADERDATASET_H +#pragma once #include #include @@ -62,4 +61,4 @@ struct JFJochReaderDataset { }; -#endif //JFJOCH_JFJOCHREADERDATASET_H + diff --git a/reader/JFJochReaderImage.h b/reader/JFJochReaderImage.h index c0968fe8..bb7ebbe6 100644 --- a/reader/JFJochReaderImage.h +++ b/reader/JFJochReaderImage.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHREADERIMAGE_H -#define JFJOCH_JFJOCHREADERIMAGE_H +#pragma once #include #include @@ -79,4 +78,4 @@ public: std::vector GetHistogram() const; }; -#endif //JFJOCH_JFJOCHREADERIMAGE_H + diff --git a/receiver/FrameTransformation.h b/receiver/FrameTransformation.h index e75d1acc..e155f013 100644 --- a/receiver/FrameTransformation.h +++ b/receiver/FrameTransformation.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_FRAMETRANSFORMATION_H -#define JUNGFRAUJOCH_FRAMETRANSFORMATION_H +#pragma once #include "../common/DiffractionExperiment.h" #include "JFJochCompressor.h" @@ -28,5 +27,3 @@ public: size_t CompressImage(void *output); const void *GetImage() const; }; - -#endif //JUNGFRAUJOCH_FRAMETRANSFORMATION_H diff --git a/receiver/ImageMetadata.h b/receiver/ImageMetadata.h index 18856d5a..8107fbe7 100644 --- a/receiver/ImageMetadata.h +++ b/receiver/ImageMetadata.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_IMAGEMETADATA_H -#define JUNGFRAUJOCH_IMAGEMETADATA_H +#pragma once #include #include @@ -46,6 +45,3 @@ public: void Export(DataMessage &message, uint64_t packets_expected_per_image) const; bool IsBunchIDConsistent() const; }; - - -#endif //JUNGFRAUJOCH_IMAGEMETADATA_H diff --git a/receiver/JFJochReceiver.h b/receiver/JFJochReceiver.h index 05addc41..83918987 100644 --- a/receiver/JFJochReceiver.h +++ b/receiver/JFJochReceiver.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHRECEIVER_H -#define JFJOCH_JFJOCHRECEIVER_H +#pragma once #include #include @@ -124,4 +123,4 @@ public: }; -#endif //JFJOCH_JFJOCHRECEIVER_H + diff --git a/receiver/JFJochReceiverCurrentStatus.h b/receiver/JFJochReceiverCurrentStatus.h index 051825e4..030bbf11 100644 --- a/receiver/JFJochReceiverCurrentStatus.h +++ b/receiver/JFJochReceiverCurrentStatus.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHRECEIVERCURRENTSTATUS_H -#define JFJOCH_JFJOCHRECEIVERCURRENTSTATUS_H +#pragma once #include #include @@ -42,4 +41,4 @@ public: }; -#endif //JFJOCH_JFJOCHRECEIVERCURRENTSTATUS_H + diff --git a/receiver/JFJochReceiverFPGA.h b/receiver/JFJochReceiverFPGA.h index 79d0541b..c6146c91 100644 --- a/receiver/JFJochReceiverFPGA.h +++ b/receiver/JFJochReceiverFPGA.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHRECEIVER_H -#define JUNGFRAUJOCH_JFJOCHRECEIVER_H +#pragma once #include #include @@ -120,6 +119,3 @@ public: JFJochReceiverOutput GetFinalStatistics() const override; }; - -#endif //JUNGFRAUJOCH_JFJOCHRECEIVER_H - diff --git a/receiver/JFJochReceiverLite.h b/receiver/JFJochReceiverLite.h index 9e441336..b8c1b546 100644 --- a/receiver/JFJochReceiverLite.h +++ b/receiver/JFJochReceiverLite.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHRECEIVERLITE_H -#define JFJOCH_JFJOCHRECEIVERLITE_H +#pragma once #include #include @@ -73,4 +72,4 @@ public: JFJochReceiverOutput GetFinalStatistics() const override; }; -#endif //JFJOCH_JFJOCHRECEIVERLITE_H + diff --git a/receiver/JFJochReceiverOutput.h b/receiver/JFJochReceiverOutput.h index ccef9e57..ec755538 100644 --- a/receiver/JFJochReceiverOutput.h +++ b/receiver/JFJochReceiverOutput.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHRECEIVEROUTPUT_H -#define JFJOCH_JFJOCHRECEIVEROUTPUT_H +#pragma once #include #include @@ -29,4 +28,4 @@ struct JFJochReceiverOutput { MeanProcessingTime processing_time; }; -#endif //JFJOCH_JFJOCHRECEIVEROUTPUT_H + diff --git a/receiver/JFJochReceiverPlots.h b/receiver/JFJochReceiverPlots.h index 49bb4a40..ba5e2fe6 100644 --- a/receiver/JFJochReceiverPlots.h +++ b/receiver/JFJochReceiverPlots.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHRECEIVERPLOTS_H -#define JUNGFRAUJOCH_JFJOCHRECEIVERPLOTS_H +#pragma once #include #include @@ -128,5 +127,3 @@ public: void GetPlotRaw(std::vector &v, PlotType type, const std::string &roi); }; - -#endif //JUNGFRAUJOCH_JFJOCHRECEIVERPLOTS_H diff --git a/receiver/JFJochReceiverService.h b/receiver/JFJochReceiverService.h index 386d0e53..1edec952 100644 --- a/receiver/JFJochReceiverService.h +++ b/receiver/JFJochReceiverService.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_JFJOCHRECEIVERSERVICE_H -#define JUNGFRAUJOCH_JFJOCHRECEIVERSERVICE_H +#pragma once #include #include @@ -91,6 +90,3 @@ public: ImagePusherStatus GetImagePusherStatus() const; }; - - -#endif //JUNGFRAUJOCH_JFJOCHRECEIVERSERVICE_H diff --git a/receiver/JFJochReceiverTest.h b/receiver/JFJochReceiverTest.h index 237d0cf1..89281494 100644 --- a/receiver/JFJochReceiverTest.h +++ b/receiver/JFJochReceiverTest.h @@ -3,8 +3,7 @@ #include "JFJochReceiverFPGA.h" -#ifndef JUNGFRAUJOCH_JFJOCHRECEIVERTEST_H -#define JUNGFRAUJOCH_JFJOCHRECEIVERTEST_H +#pragma once bool JFJochReceiverTest(JFJochReceiverOutput &output, Logger &logger, AcquisitionDeviceGroup &aq_devices, @@ -24,5 +23,3 @@ bool JFJochReceiverTest(JFJochReceiverOutput &output, Logger &logger, const std::string &numa_policy = "", size_t send_buf_size_MiB = 1024, bool quick_integrate = false); - -#endif //JUNGFRAUJOCH_JFJOCHRECEIVERTEST_H diff --git a/receiver/LossyFilter.h b/receiver/LossyFilter.h index 9ddef221..bcfc278f 100644 --- a/receiver/LossyFilter.h +++ b/receiver/LossyFilter.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_LOSSYFILTER_H -#define JUNGFRAUJOCH_LOSSYFILTER_H +#pragma once #include #include @@ -28,6 +27,3 @@ public: explicit LossyFilter(const DiffractionExperiment& x); bool ApplyFilter(DataMessage& message); }; - - -#endif //JUNGFRAUJOCH_LOSSYFILTER_H diff --git a/tools/UDPSimulator.h b/tools/UDPSimulator.h index 9dc80a6d..162bb446 100644 --- a/tools/UDPSimulator.h +++ b/tools/UDPSimulator.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_UDPSIMULATOR_H -#define JUNGFRAUJOCH_UDPSIMULATOR_H +#pragma once #include #include diff --git a/tools/XdsIntegrateParser.h b/tools/XdsIntegrateParser.h index ea5c19f0..af2dc692 100644 --- a/tools/XdsIntegrateParser.h +++ b/tools/XdsIntegrateParser.h @@ -1,7 +1,6 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only - #pragma once #include diff --git a/viewer/JFJochImageReadingWorker.h b/viewer/JFJochImageReadingWorker.h index 17e6d2cb..4d419f9d 100644 --- a/viewer/JFJochImageReadingWorker.h +++ b/viewer/JFJochImageReadingWorker.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCHIMAGEREADINGWORKER_H -#define JFJOCHIMAGEREADINGWORKER_H +#pragma once #include #include @@ -155,6 +154,3 @@ public slots: void setAutoLoadMode(AutoloadMode mode); void setAutoLoadJump(int64_t val); }; - - -#endif //JFJOCHIMAGEREADINGWORKER_H diff --git a/viewer/JFJochViewerDatasetInfo.h b/viewer/JFJochViewerDatasetInfo.h index 381f2af7..f6eb8be5 100644 --- a/viewer/JFJochViewerDatasetInfo.h +++ b/viewer/JFJochViewerDatasetInfo.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERDATASETINFO_H -#define JFJOCH_JFJOCHVIEWERDATASETINFO_H +#pragma once #include #include @@ -45,4 +44,4 @@ public slots: }; -#endif //JFJOCH_JFJOCHVIEWERDATASETINFO_H + diff --git a/viewer/JFJochViewerMenu.h b/viewer/JFJochViewerMenu.h index ae3ec510..1bed4966 100644 --- a/viewer/JFJochViewerMenu.h +++ b/viewer/JFJochViewerMenu.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCHVIEWERMENU_H -#define JFJOCHVIEWERMENU_H +#pragma once #include @@ -43,7 +42,3 @@ private slots: void saveUserMaskAsTiffSelected(); void uploadUserMaskAction(); }; - - - -#endif //JFJOCHVIEWERMENU_H diff --git a/viewer/JFJochViewerSidePanel.h b/viewer/JFJochViewerSidePanel.h index 0e0c80c0..6eabf1bd 100644 --- a/viewer/JFJochViewerSidePanel.h +++ b/viewer/JFJochViewerSidePanel.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERSIDEPANEL_H -#define JFJOCH_JFJOCHVIEWERSIDEPANEL_H +#pragma once #include #include @@ -60,4 +59,4 @@ private slots: }; -#endif //JFJOCH_JFJOCHVIEWERSIDEPANEL_H + diff --git a/viewer/JFJochViewerStatusBar.h b/viewer/JFJochViewerStatusBar.h index 4663a2da..59d2de0a 100644 --- a/viewer/JFJochViewerStatusBar.h +++ b/viewer/JFJochViewerStatusBar.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERSTATUSBAR_H -#define JFJOCH_JFJOCHVIEWERSTATUSBAR_H +#pragma once #include @@ -15,4 +14,4 @@ public: }; -#endif //JFJOCH_JFJOCHVIEWERSTATUSBAR_H + diff --git a/viewer/JFJochViewerWindow.h b/viewer/JFJochViewerWindow.h index 61aff081..56011e19 100644 --- a/viewer/JFJochViewerWindow.h +++ b/viewer/JFJochViewerWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCHVIEWERWINDOW_H -#define JFJOCHVIEWERWINDOW_H +#pragma once #include #include @@ -50,6 +49,3 @@ signals: void setAutoForeground(bool val); }; - - -#endif //JFJOCHVIEWERWINDOW_H diff --git a/viewer/charts/JFJochDatasetInfoChartView.h b/viewer/charts/JFJochDatasetInfoChartView.h index 4537b80f..f26e5bea 100644 --- a/viewer/charts/JFJochDatasetInfoChartView.h +++ b/viewer/charts/JFJochDatasetInfoChartView.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHCHARTVIEW_H -#define JFJOCH_JFJOCHCHARTVIEW_H +#pragma once #include #include @@ -110,4 +109,4 @@ public: }; -#endif //JFJOCH_JFJOCHCHARTVIEW_H + diff --git a/viewer/charts/JFJochSimpleChartView.h b/viewer/charts/JFJochSimpleChartView.h index e6cdf64f..fcc10a83 100644 --- a/viewer/charts/JFJochSimpleChartView.h +++ b/viewer/charts/JFJochSimpleChartView.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHSIMPLECHARTVIEW_H -#define JFJOCH_JFJOCHSIMPLECHARTVIEW_H +#pragma once #include #include @@ -31,4 +30,4 @@ public: }; -#endif //JFJOCH_JFJOCHSIMPLECHARTVIEW_H + diff --git a/viewer/dbus/JFJochViewerAdaptor.h b/viewer/dbus/JFJochViewerAdaptor.h index 88a03002..ae5f0f84 100644 --- a/viewer/dbus/JFJochViewerAdaptor.h +++ b/viewer/dbus/JFJochViewerAdaptor.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCHVIEWERADAPTOR_H -#define JFJOCHVIEWERADAPTOR_H +#pragma once #include #include @@ -20,6 +19,3 @@ public slots: void LoadFile(const QString &filename, int image_number = 0, int summation = 1); void LoadImage(int image_number, int summation = 1); }; - - -#endif diff --git a/viewer/image_viewer/JFJochAzIntImage.h b/viewer/image_viewer/JFJochAzIntImage.h index e1e66362..08dff6d8 100644 --- a/viewer/image_viewer/JFJochAzIntImage.h +++ b/viewer/image_viewer/JFJochAzIntImage.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHAZINTIMAGEVIEW_H -#define JFJOCH_JFJOCHAZINTIMAGEVIEW_H +#pragma once #include @@ -37,4 +36,3 @@ public: }; -#endif //JFJOCH_JFJOCHAZINTIMAGEVIEW_H \ No newline at end of file diff --git a/viewer/image_viewer/JFJochGridScanImage.h b/viewer/image_viewer/JFJochGridScanImage.h index fd71c4d0..3853a01e 100644 --- a/viewer/image_viewer/JFJochGridScanImage.h +++ b/viewer/image_viewer/JFJochGridScanImage.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHGRIDSCANIMAGE_H -#define JFJOCH_JFJOCHGRIDSCANIMAGE_H +#pragma once #include "JFJochImage.h" #include "../../reader/JFJochReaderDataset.h" @@ -34,4 +33,3 @@ public slots: }; -#endif //JFJOCH_JFJOCHGRIDSCANIMAGE_H \ No newline at end of file diff --git a/viewer/toolbar/JFJochViewerToolbarDisplay.h b/viewer/toolbar/JFJochViewerToolbarDisplay.h index e39f7623..4db1efef 100644 --- a/viewer/toolbar/JFJochViewerToolbarDisplay.h +++ b/viewer/toolbar/JFJochViewerToolbarDisplay.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERTOOLBARDISPLAY_H -#define JFJOCH_JFJOCHVIEWERTOOLBARDISPLAY_H +#pragma once #include #include "../widgets/SliderPlusBox.h" @@ -40,4 +39,4 @@ private slots: }; -#endif //JFJOCH_JFJOCHVIEWERTOOLBARDISPLAY_H + diff --git a/viewer/toolbar/JFJochViewerToolbarImage.h b/viewer/toolbar/JFJochViewerToolbarImage.h index 19e4f699..c7679865 100644 --- a/viewer/toolbar/JFJochViewerToolbarImage.h +++ b/viewer/toolbar/JFJochViewerToolbarImage.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERTOOLBARIMAGE_H -#define JFJOCH_JFJOCHVIEWERTOOLBARIMAGE_H +#pragma once #include #include @@ -73,4 +72,3 @@ private slots: void reanalyzeButtonPressed(); }; -#endif //JFJOCH_JFJOCHVIEWERTOOLBARIMAGE_H \ No newline at end of file diff --git a/viewer/widgets/JFJochViewerImageROIStatistics.h b/viewer/widgets/JFJochViewerImageROIStatistics.h index 57c375e3..2d2a0118 100644 --- a/viewer/widgets/JFJochViewerImageROIStatistics.h +++ b/viewer/widgets/JFJochViewerImageROIStatistics.h @@ -2,8 +2,7 @@ // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_H -#define JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_H +#pragma once #include #include @@ -45,4 +44,3 @@ signals: }; -#endif //JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_H \ No newline at end of file diff --git a/viewer/widgets/JFJochViewerImageROIStatistics_Box.h b/viewer/widgets/JFJochViewerImageROIStatistics_Box.h index 7ec88ebe..80cc72cd 100644 --- a/viewer/widgets/JFJochViewerImageROIStatistics_Box.h +++ b/viewer/widgets/JFJochViewerImageROIStatistics_Box.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_BOX_H -#define JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_BOX_H +#pragma once #include @@ -29,4 +28,3 @@ public slots: }; -#endif //JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_BOX_H \ No newline at end of file diff --git a/viewer/widgets/JFJochViewerImageROIStatistics_Circle.h b/viewer/widgets/JFJochViewerImageROIStatistics_Circle.h index c88f0faf..dc7808b2 100644 --- a/viewer/widgets/JFJochViewerImageROIStatistics_Circle.h +++ b/viewer/widgets/JFJochViewerImageROIStatistics_Circle.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_CIRCLE_H -#define JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_CIRCLE_H +#pragma once #include @@ -30,4 +29,3 @@ signals: }; -#endif //JFJOCH_JFJOCHVIEWERIMAGEROISTATISTICS_CIRCLE_H \ No newline at end of file diff --git a/viewer/widgets/JFJochViewerImageStatistics.h b/viewer/widgets/JFJochViewerImageStatistics.h index 52e9af93..95459043 100644 --- a/viewer/widgets/JFJochViewerImageStatistics.h +++ b/viewer/widgets/JFJochViewerImageStatistics.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERIMAGESTATISTICS_H -#define JFJOCH_JFJOCHVIEWERIMAGESTATISTICS_H +#pragma once #include #include @@ -36,4 +35,4 @@ public slots: }; -#endif //JFJOCH_JFJOCHVIEWERIMAGESTATISTICS_H + diff --git a/viewer/widgets/JFJochViewerROIResult.h b/viewer/widgets/JFJochViewerROIResult.h index 154b386c..9e11aad5 100644 --- a/viewer/widgets/JFJochViewerROIResult.h +++ b/viewer/widgets/JFJochViewerROIResult.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERROIRESULT_H -#define JFJOCH_JFJOCHVIEWERROIRESULT_H +#pragma once #include #include @@ -29,4 +28,3 @@ public: }; -#endif //JFJOCH_JFJOCHVIEWERROIRESULT_H \ No newline at end of file diff --git a/viewer/widgets/JFJochViewerSidePanelChart.h b/viewer/widgets/JFJochViewerSidePanelChart.h index b7e63dbc..42e2ad4a 100644 --- a/viewer/widgets/JFJochViewerSidePanelChart.h +++ b/viewer/widgets/JFJochViewerSidePanelChart.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERSIDEPANELCHART_H -#define JFJOCH_JFJOCHVIEWERSIDEPANELCHART_H +#pragma once #include #include @@ -36,4 +35,4 @@ public slots: }; -#endif //JFJOCH_JFJOCHVIEWERSIDEPANELCHART_H + diff --git a/viewer/widgets/NumberLineEdit.h b/viewer/widgets/NumberLineEdit.h index 5111f7b2..6def0bd6 100644 --- a/viewer/widgets/NumberLineEdit.h +++ b/viewer/widgets/NumberLineEdit.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef NUMBERTEXTEDIT_H -#define NUMBERTEXTEDIT_H +#pragma once #include #include @@ -31,5 +30,3 @@ private slots: void onEditingFinished(); }; - -#endif // NUMBERLINEEDIT_H diff --git a/viewer/widgets/NumericComboBox.h b/viewer/widgets/NumericComboBox.h index 73b940fc..ab9b9f7f 100644 --- a/viewer/widgets/NumericComboBox.h +++ b/viewer/widgets/NumericComboBox.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_NUMERICCOMBOBOX_H -#define JFJOCH_NUMERICCOMBOBOX_H +#pragma once #include @@ -26,4 +25,4 @@ private slots: }; -#endif //JFJOCH_NUMERICCOMBOBOX_H + diff --git a/viewer/widgets/ResolutionRingWidget.h b/viewer/widgets/ResolutionRingWidget.h index 00779383..c790b33d 100644 --- a/viewer/widgets/ResolutionRingWidget.h +++ b/viewer/widgets/ResolutionRingWidget.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_RESOLUTIONRINGWIDGET_H -#define JFJOCH_RESOLUTIONRINGWIDGET_H +#pragma once #include #include @@ -44,4 +43,3 @@ private slots: }; -#endif //JFJOCH_RESOLUTIONRINGWIDGET_H \ No newline at end of file diff --git a/viewer/widgets/SliderPlusBox.h b/viewer/widgets/SliderPlusBox.h index adfdac72..a240bb39 100644 --- a/viewer/widgets/SliderPlusBox.h +++ b/viewer/widgets/SliderPlusBox.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_SLIDERPLUSBOX_H -#define JFJOCH_SLIDERPLUSBOX_H +#pragma once #include #include @@ -50,4 +49,4 @@ signals: }; -#endif //JFJOCH_SLIDERPLUSBOX_H + diff --git a/viewer/widgets/TitleLabel.h b/viewer/widgets/TitleLabel.h index 64583c4e..8de692fa 100644 --- a/viewer/widgets/TitleLabel.h +++ b/viewer/widgets/TitleLabel.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_TITLELABEL_H -#define JFJOCH_TITLELABEL_H +#pragma once #include @@ -12,4 +11,4 @@ public: }; -#endif //JFJOCH_TITLELABEL_H + diff --git a/viewer/windows/JFJoch2DAzintImageWindow.h b/viewer/windows/JFJoch2DAzintImageWindow.h index 5a291a7a..b8f29e2b 100644 --- a/viewer/windows/JFJoch2DAzintImageWindow.h +++ b/viewer/windows/JFJoch2DAzintImageWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCH2DAZINTIMAGEWINDOW_H -#define JFJOCH_JFJOCH2DAZINTIMAGEWINDOW_H +#pragma once #include @@ -31,6 +30,3 @@ public slots: void imageLoaded(std::shared_ptr in_dataset) override; void setColorMap(int color_map); }; - - -#endif //JFJOCH_JFJOCH2DAZINTIMAGEWINDOW_H \ No newline at end of file diff --git a/viewer/windows/JFJochAzIntWindow.h b/viewer/windows/JFJochAzIntWindow.h index 22ad6995..3e7d796b 100644 --- a/viewer/windows/JFJochAzIntWindow.h +++ b/viewer/windows/JFJochAzIntWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHAZINTWINDOW_H -#define JFJOCH_JFJOCHAZINTWINDOW_H +#pragma once #include "JFJochHelperWindow.h" #include "../widgets/SliderPlusBox.h" @@ -44,4 +43,3 @@ signals: void settingsChanged(const AzimuthalIntegrationSettings &settings); }; -#endif //JFJOCH_JFJOCHAZINTWINDOW_H \ No newline at end of file diff --git a/viewer/windows/JFJochHelperWindow.h b/viewer/windows/JFJochHelperWindow.h index 86329a8d..5bd4951c 100644 --- a/viewer/windows/JFJochHelperWindow.h +++ b/viewer/windows/JFJochHelperWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHHELPERWINDOW_H -#define JFJOCH_JFJOCHHELPERWINDOW_H +#pragma once #include #include "../../reader/JFJochReaderDataset.h" @@ -26,4 +25,3 @@ public: }; -#endif //JFJOCH_JFJOCHHELPERWINDOW_H \ No newline at end of file diff --git a/viewer/windows/JFJochViewerImageListWindow.h b/viewer/windows/JFJochViewerImageListWindow.h index 5670ad9c..a70bc448 100644 --- a/viewer/windows/JFJochViewerImageListWindow.h +++ b/viewer/windows/JFJochViewerImageListWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERIMAGELISTWINDOW_H -#define JFJOCH_JFJOCHVIEWERIMAGELISTWINDOW_H +#pragma once #include #include @@ -44,4 +43,4 @@ private slots: -#endif //JFJOCH_JFJOCHVIEWERIMAGELISTWINDOW_H + diff --git a/viewer/windows/JFJochViewerMetadataWindow.h b/viewer/windows/JFJochViewerMetadataWindow.h index 18220d82..56b8cf79 100644 --- a/viewer/windows/JFJochViewerMetadataWindow.h +++ b/viewer/windows/JFJochViewerMetadataWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERMETADATAWINDOW_H -#define JFJOCH_JFJOCHVIEWERMETADATAWINDOW_H +#pragma once #include @@ -54,4 +53,4 @@ public slots: }; -#endif //JFJOCH_JFJOCHVIEWERMETADATAWINDOW_H + diff --git a/viewer/windows/JFJochViewerProcessingWindow.h b/viewer/windows/JFJochViewerProcessingWindow.h index eafd0e4f..df6488de 100644 --- a/viewer/windows/JFJochViewerProcessingWindow.h +++ b/viewer/windows/JFJochViewerProcessingWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERPROCESSINGWIDGET_H -#define JFJOCH_JFJOCHVIEWERPROCESSINGWIDGET_H +#pragma once #include #include @@ -54,4 +53,4 @@ signals: }; -#endif //JFJOCH_JFJOCHVIEWERPROCESSINGWIDGET_H + diff --git a/viewer/windows/JFJochViewerReciprocalSpaceWindow.h b/viewer/windows/JFJochViewerReciprocalSpaceWindow.h index d4008969..67d5a6c1 100644 --- a/viewer/windows/JFJochViewerReciprocalSpaceWindow.h +++ b/viewer/windows/JFJochViewerReciprocalSpaceWindow.h @@ -1,5 +1,6 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only + #pragma once #include diff --git a/viewer/windows/JFJochViewerReflectionListWindow.h b/viewer/windows/JFJochViewerReflectionListWindow.h index cfd800bc..7faa7ff6 100644 --- a/viewer/windows/JFJochViewerReflectionListWindow.h +++ b/viewer/windows/JFJochViewerReflectionListWindow.h @@ -2,8 +2,7 @@ // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERREFLECTIONLISTWINDOW_H -#define JFJOCH_JFJOCHVIEWERREFLECTIONLISTWINDOW_H +#pragma once #include "JFJochHelperWindow.h" #include @@ -38,4 +37,3 @@ public slots: }; -#endif //JFJOCH_JFJOCHVIEWERREFLECTIONLISTWINDOW_H \ No newline at end of file diff --git a/viewer/windows/JFJochViewerSpotListWindow.h b/viewer/windows/JFJochViewerSpotListWindow.h index d9061b91..0111b8dd 100644 --- a/viewer/windows/JFJochViewerSpotListWindow.h +++ b/viewer/windows/JFJochViewerSpotListWindow.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_JFJOCHVIEWERSPOTLISTWINDOW_H -#define JFJOCH_JFJOCHVIEWERSPOTLISTWINDOW_H +#pragma once #include "JFJochHelperWindow.h" #include @@ -39,4 +38,3 @@ public slots: -#endif //JFJOCH_JFJOCHVIEWERSPOTLISTWINDOW_H \ No newline at end of file diff --git a/writer/CBFWriter.h b/writer/CBFWriter.h index 5deb6d43..4158f49c 100644 --- a/writer/CBFWriter.h +++ b/writer/CBFWriter.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_CBFWRITER_H -#define JFJOCH_CBFWRITER_H +#pragma once #include "../common/JFJochMessages.h" @@ -20,4 +19,4 @@ public: }; -#endif //JFJOCH_CBFWRITER_H + diff --git a/writer/FileWriter.h b/writer/FileWriter.h index 30857a22..d73c72f1 100644 --- a/writer/FileWriter.h +++ b/writer/FileWriter.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HDF5WRITER_H -#define JUNGFRAUJOCH_HDF5WRITER_H +#pragma once #include @@ -42,5 +41,3 @@ public: void SetupFinalizedFileSocket(const std::string &addr); std::optional GetZMQAddr(); }; - -#endif //JUNGFRAUJOCH_HDF5WRITER_H diff --git a/writer/HDF5DataFile.h b/writer/HDF5DataFile.h index aac77fb0..0979f99f 100644 --- a/writer/HDF5DataFile.h +++ b/writer/HDF5DataFile.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef HDF5DATAFILE_H -#define HDF5DATAFILE_H +#pragma once #include #include @@ -59,5 +58,3 @@ public: void CreateFile(const DataMessage& msg, std::shared_ptr data_file); }; - -#endif //HDF5DATAFILE_H diff --git a/writer/HDF5DataFilePlugin.h b/writer/HDF5DataFilePlugin.h index 08b3fb2c..7f7d5ddc 100644 --- a/writer/HDF5DataFilePlugin.h +++ b/writer/HDF5DataFilePlugin.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HDF5DATAFILEPLUGIN_H -#define JUNGFRAUJOCH_HDF5DATAFILEPLUGIN_H +#pragma once #include "../common/JFJochMessages.h" #include "HDF5Objects.h" @@ -16,5 +15,3 @@ public: virtual void WriteFinal(HDF5File &data_file) = 0; virtual ~HDF5DataFilePlugin() = default; }; - -#endif //JUNGFRAUJOCH_HDF5DATAFILEPLUGIN_H diff --git a/writer/HDF5DataFilePluginAzInt.h b/writer/HDF5DataFilePluginAzInt.h index 07b82942..41ace5dc 100644 --- a/writer/HDF5DataFilePluginAzInt.h +++ b/writer/HDF5DataFilePluginAzInt.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HDF5DATAFILEPLUGINAZINT_H -#define JUNGFRAUJOCH_HDF5DATAFILEPLUGINAZINT_H +#pragma once #include "HDF5DataFilePlugin.h" @@ -27,5 +26,3 @@ public: void Write(const DataMessage& msg, uint64_t image_number) override; void WriteFinal(HDF5File &data_file) override; }; - -#endif //JUNGFRAUJOCH_HDF5DATAFILEPLUGINAZINT_H diff --git a/writer/HDF5DataFilePluginDetector.h b/writer/HDF5DataFilePluginDetector.h index 99a8f6b6..9f1d3572 100644 --- a/writer/HDF5DataFilePluginDetector.h +++ b/writer/HDF5DataFilePluginDetector.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HDF5DATAFILEPLUGINJUNGFRAU_H -#define JUNGFRAUJOCH_HDF5DATAFILEPLUGINJUNGFRAU_H +#pragma once #include "HDF5DataFilePlugin.h" #include "../common/AutoIncrVector.h" @@ -22,5 +21,3 @@ public: void Write(const DataMessage& msg, uint64_t image_number) override; void WriteFinal(HDF5File &data_file) override; }; - -#endif //JUNGFRAUJOCH_HDF5DATAFILEPLUGINJUNGFRAU_H diff --git a/writer/HDF5DataFilePluginImageStats.h b/writer/HDF5DataFilePluginImageStats.h index b23e0ae5..5b6f1aaa 100644 --- a/writer/HDF5DataFilePluginImageStats.h +++ b/writer/HDF5DataFilePluginImageStats.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_HDF5DATAFILEPLUGINIMAGESTATS_H -#define JFJOCH_HDF5DATAFILEPLUGINIMAGESTATS_H +#pragma once #include "HDF5DataFilePlugin.h" @@ -21,5 +20,3 @@ public: ~HDF5DataFilePluginImageStats() override = default; }; - -#endif //JFJOCH_HDF5DATAFILEPLUGINIMAGESTATS_H diff --git a/writer/HDF5DataFilePluginMX.h b/writer/HDF5DataFilePluginMX.h index faae9da0..2c441561 100644 --- a/writer/HDF5DataFilePluginMX.h +++ b/writer/HDF5DataFilePluginMX.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HDF5DATAFILEPLUGINMX_H -#define JUNGFRAUJOCH_HDF5DATAFILEPLUGINMX_H +#pragma once #include "HDF5DataFilePlugin.h" #include "../common/AutoIncrVector.h" @@ -65,5 +64,3 @@ public: void Write(const DataMessage& msg, uint64_t image_number) override; void WriteFinal(HDF5File &data_file) override; }; - -#endif //JUNGFRAUJOCH_HDF5DATAFILEPLUGINMX_H diff --git a/writer/HDF5DataFilePluginROI.h b/writer/HDF5DataFilePluginROI.h index 00bbe492..3a8ae677 100644 --- a/writer/HDF5DataFilePluginROI.h +++ b/writer/HDF5DataFilePluginROI.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_HDF5DATAFILEPLUGINROI_H -#define JFJOCH_HDF5DATAFILEPLUGINROI_H +#pragma once #include #include "../common/AutoIncrVector.h" @@ -25,5 +24,3 @@ public: void Write(const DataMessage &msg, uint64_t image_number) override; void WriteFinal(HDF5File &data_file) override; }; - -#endif //JFJOCH_HDF5DATAFILEPLUGINROI_H diff --git a/writer/HDF5DataFilePluginReflection.h b/writer/HDF5DataFilePluginReflection.h index c43aa570..1e947aea 100644 --- a/writer/HDF5DataFilePluginReflection.h +++ b/writer/HDF5DataFilePluginReflection.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JFJOCH_HDF5DATAFILEPLUGINREFLECTION_H -#define JFJOCH_HDF5DATAFILEPLUGINREFLECTION_H +#pragma once #include "HDF5DataFilePlugin.h" @@ -14,6 +13,3 @@ public: void WriteFinal(HDF5File &data_file) override; ~HDF5DataFilePluginReflection() override = default; }; - - -#endif //JFJOCH_HDF5DATAFILEPLUGINREFLECTION_H \ No newline at end of file diff --git a/writer/HDF5DataFilePluginXFEL.h b/writer/HDF5DataFilePluginXFEL.h index c26a544d..f2529dd8 100644 --- a/writer/HDF5DataFilePluginXFEL.h +++ b/writer/HDF5DataFilePluginXFEL.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HDF5DATAFILEPLUGINXFEL_H -#define JUNGFRAUJOCH_HDF5DATAFILEPLUGINXFEL_H +#pragma once #include "HDF5DataFilePlugin.h" #include "../common/AutoIncrVector.h" @@ -15,6 +14,3 @@ public: void Write(const DataMessage& msg, uint64_t image_number) override; void WriteFinal(HDF5File &data_file) override; }; - - -#endif //JUNGFRAUJOCH_HDF5DATAFILEPLUGINXFEL_H diff --git a/writer/HDF5Objects.h b/writer/HDF5Objects.h index c2fe512b..d4945359 100644 --- a/writer/HDF5Objects.h +++ b/writer/HDF5Objects.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_HDF5OBJECTS_H -#define JUNGFRAUJOCH_HDF5OBJECTS_H +#pragma once #include #include @@ -542,5 +541,3 @@ inline std::string hdf5_version() { void RegisterHDF5Filter(); std::string ExtractFilename(const std::string& str); - -#endif //JUNGFRAUJOCH_HDF5OBJECTS_H diff --git a/writer/MakeDirectory.h b/writer/MakeDirectory.h index 44f81ad7..6d2052fe 100644 --- a/writer/MakeDirectory.h +++ b/writer/MakeDirectory.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_MAKEDIRECTORY_H -#define JUNGFRAUJOCH_MAKEDIRECTORY_H +#pragma once #include #include "../common/JFJochException.h" @@ -17,7 +16,3 @@ inline void MakeDirectory(const std::string &input) { "Cannot create subdirectory for file " + input + ": " + std::string(err.what())); } } - - - -#endif //JUNGFRAUJOCH_MAKEDIRECTORY_H diff --git a/writer/StreamWriter.h b/writer/StreamWriter.h index 301a4e6f..95c18bed 100644 --- a/writer/StreamWriter.h +++ b/writer/StreamWriter.h @@ -1,8 +1,7 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only -#ifndef JUNGFRAUJOCH_STREAMWRITER_H -#define JUNGFRAUJOCH_STREAMWRITER_H +#pragma once #include @@ -78,6 +77,3 @@ public: StreamWriterStatistics GetStatistics() const; void DebugSkipWriteNotification(bool input); }; - - -#endif //JUNGFRAUJOCH_STREAMWRITER_H -- 2.52.0 From 64e6b32e1d4767343ca05fafe4a53237cff3fc0a Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 11:22:31 +0200 Subject: [PATCH 21/46] UDPSimulator: Fix header guards --- tools/UDPSimulator.h | 3 --- 1 file changed, 3 deletions(-) diff --git a/tools/UDPSimulator.h b/tools/UDPSimulator.h index 162bb446..f976c607 100644 --- a/tools/UDPSimulator.h +++ b/tools/UDPSimulator.h @@ -16,6 +16,3 @@ public: ~UDPSimulator(); void SendImage(const std::string &ipv4_dest_addr, uint16_t udp_port, uint64_t frame_number, uint16_t module_number); }; - - -#endif //JUNGFRAUJOCH_UDPSIMULATOR_H -- 2.52.0 From 02ecf5c32e93fb803495d0ae916acdb3e1e964fd Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 11:36:23 +0200 Subject: [PATCH 22/46] MultiLatticeSearch: Explore all valid sign flips when comparing with reference cell --- common/CrystalLattice.cpp | 9 ++- common/CrystalLattice.h | 1 + .../indexing/MultiLatticeSearch.cpp | 68 +++++++++++++------ tests/MultiLatticeSearchTest.cpp | 15 ++++ 4 files changed, 73 insertions(+), 20 deletions(-) diff --git a/common/CrystalLattice.cpp b/common/CrystalLattice.cpp index 0172b8fa..17dbca65 100644 --- a/common/CrystalLattice.cpp +++ b/common/CrystalLattice.cpp @@ -80,9 +80,16 @@ void CrystalLattice::Sort() { std::swap(vec[0], vec[1]); } +void CrystalLattice::FlipSign(size_t i1) { + if (i1 >= 3) + throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, + "index out of range (0..2)"); + vec[i1] *= -1; +} + void CrystalLattice::FixHandedness() { if (CalcVolume() < 0) - vec[2] *= -1; + FlipSign(2); } diff --git a/common/CrystalLattice.h b/common/CrystalLattice.h index 5f4e6519..cb18b179 100644 --- a/common/CrystalLattice.h +++ b/common/CrystalLattice.h @@ -39,6 +39,7 @@ public: void Regularize(const gemmi::CrystalSystem &input); [[nodiscard]] std::vector GetUBMatrix() const; CrystalLattice NiggliReduce() const; + void FlipSign(size_t i1); }; inline std::ostream &operator<<( std::ostream &output, const CrystalLattice &in ) { diff --git a/image_analysis/indexing/MultiLatticeSearch.cpp b/image_analysis/indexing/MultiLatticeSearch.cpp index c799d9ab..11d0cf55 100644 --- a/image_analysis/indexing/MultiLatticeSearch.cpp +++ b/image_analysis/indexing/MultiLatticeSearch.cpp @@ -35,6 +35,30 @@ namespace { } } +CrystalLattice Transform(const CrystalLattice &in_latt, int i) { + CrystalLattice latt = in_latt; + switch (i) { + case 0: + break; + case 1: + latt.FlipSign(0); + latt.FlipSign(1); + break; + case 2: + latt.FlipSign(0); + latt.FlipSign(2); + break; + case 3: + latt.FlipSign(1); + latt.FlipSign(2); + break; + default: + break; + } + + return latt; +} + std::vector MultiLatticeSearch(const std::vector &lattices, float dist_tolerance, float angle_tolerance_deg) { @@ -48,29 +72,35 @@ std::vector MultiLatticeSearch(const std::vector(rod.x()), - static_cast(rod.y()), - static_cast(rod.z())); + const Eigen::AngleAxisd aa(R); + const Eigen::Vector3d rod = aa.angle() * aa.axis(); + const Coord rotation_vector(static_cast(rod.x()), + static_cast(rod.y()), + static_cast(rod.z())); - // output_lattice = R * reference, built straight from the Eigen matrix - // so it is exactly a proper rotation of the reference (full double precision). - const Eigen::Matrix3d out = R * LatticeMatrix(reference); - ret.push_back({ - latt, - CrystalLattice(Coord(out(0, 0), out(1, 0), out(2, 0)), - Coord(out(0, 1), out(1, 1), out(2, 1)), - Coord(out(0, 2), out(1, 2), out(2, 2))), - rotation_vector - }); + // output_lattice = R * reference, built straight from the Eigen matrix + // so it is exactly a proper rotation of the reference (full double precision). + const Eigen::Matrix3d out = R * LatticeMatrix(reference); + ret.push_back({ + latt, + CrystalLattice(Coord(out(0, 0), out(1, 0), out(2, 0)), + Coord(out(0, 1), out(1, 1), out(2, 1)), + Coord(out(0, 2), out(1, 2), out(2, 2))), + rotation_vector + }); + found = true; + } } return ret; diff --git a/tests/MultiLatticeSearchTest.cpp b/tests/MultiLatticeSearchTest.cpp index b40cc537..6e5df735 100644 --- a/tests/MultiLatticeSearchTest.cpp +++ b/tests/MultiLatticeSearchTest.cpp @@ -65,4 +65,19 @@ TEST_CASE("MultiLatticeSearch_SkipsDifferentCell") { TEST_CASE("MultiLatticeSearch_Empty") { auto result = MultiLatticeSearch({}); CHECK(result.empty()); +} + +TEST_CASE("MultiLatticeSearch_EP") { + // Real EP case + CrystalLattice cell1(Coord(-13.2, -30.0, -29.6), + Coord(70.1, -12.16, -18.6), + Coord(7.6, -23.9, 44.8)); + CrystalLattice cell2(Coord(-13.2, -29.9, -29.5), + Coord(-70.1, 12.15, 18.8), + Coord(1.8, 45.4, -23.7) + ); + + auto result = MultiLatticeSearch({cell1, cell2}, + 0.1, 5); + REQUIRE(result.size() == 2); } \ No newline at end of file -- 2.52.0 From 1fc8070118f21c351fd6014753b1a1f3d7425ee5 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 12:10:20 +0200 Subject: [PATCH 23/46] JFJochReceiver: Plot compression ratio --- common/JFJochMessages.h | 2 ++ common/Plot.h | 2 +- receiver/JFJochReceiverFPGA.cpp | 4 ++++ receiver/JFJochReceiverLite.cpp | 13 +++++++++++-- receiver/JFJochReceiverPlots.cpp | 8 ++++++++ receiver/JFJochReceiverPlots.h | 1 + 6 files changed, 27 insertions(+), 3 deletions(-) diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index 0fcd2868..83600b05 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -174,6 +174,8 @@ struct DataMessage { std::optional image_scale_cc; std::optional image_scale_mosaicity; std::optional image_scale_b_factor; + + std::optional compression_ratio; }; struct HDF5DataSourceMessage { diff --git a/common/Plot.h b/common/Plot.h index 7b12c8de..2ac99093 100644 --- a/common/Plot.h +++ b/common/Plot.h @@ -15,7 +15,7 @@ enum class PlotType { ROISum, ROIMean, ROIMaxCount, ROIPixels, ROIWeightedX, ROIWeightedY, PacketsReceived, MaxValue, ResolutionEstimate, ProfileRadius, Mosaicity, BFactor, PixelSum, StrongPixels, RefinementBeamX, RefinementBeamY, ImageProcessingTime, IntegratedReflections, - ImageScaleFactor, ImageScaleCC, ImageScaleBFactor + ImageScaleFactor, ImageScaleCC, ImageScaleBFactor, CompressionRatio }; enum class PlotAzintUnit { diff --git a/receiver/JFJochReceiverFPGA.cpp b/receiver/JFJochReceiverFPGA.cpp index 18dc2d12..802b7faf 100644 --- a/receiver/JFJochReceiverFPGA.cpp +++ b/receiver/JFJochReceiverFPGA.cpp @@ -488,6 +488,10 @@ void JFJochReceiverFPGA::FrameTransformationThread(uint32_t threadid) { serializer.AppendImage(image_size); compressed_size += image_size; + if (image_size > 0) + message.compression_ratio = + static_cast(experiment.GetPixelsNum() * experiment.GetByteDepthImage()) + / static_cast(image_size); loc->SetImageNumber(image_number); loc->SetImageSize(serializer.GetBufferSize()); diff --git a/receiver/JFJochReceiverLite.cpp b/receiver/JFJochReceiverLite.cpp index f3c9e1ec..e986956e 100644 --- a/receiver/JFJochReceiverLite.cpp +++ b/receiver/JFJochReceiverLite.cpp @@ -268,8 +268,13 @@ void JFJochReceiverLite::DataAnalysisThread(uint32_t id) { DataMessage data_msg = msg->cbor->data_message.value(); ++images_collected; - compressed_size += data_msg.image.GetCompressedSize(); - uncompressed_size += data_msg.image.GetUncompressedSize(); + + auto compressed_size_img = data_msg.image.GetCompressedSize(); + auto uncompressed_size_img = data_msg.image.GetUncompressedSize(); + + compressed_size += compressed_size_img; + uncompressed_size += uncompressed_size_img; + UpdateMaxImageReceived(data_msg.number); auto image_start_time = std::chrono::high_resolution_clock::now(); @@ -288,6 +293,10 @@ void JFJochReceiverLite::DataAnalysisThread(uint32_t id) { data_msg.receiver_buf_available = image_buffer.GetAvailSlots(); data_msg.receiver_aq_dev_delay = image_puller.GetCurrentFifoUtilization(); + if (data_msg.image.GetUncompressedSize() > 0) + data_msg.compression_ratio = static_cast(compressed_size_img) + / static_cast(uncompressed_size_img); + saturated_pixels.Add(data_msg.saturated_pixel_count); error_pixels.Add(data_msg.error_pixel_count); diff --git a/receiver/JFJochReceiverPlots.cpp b/receiver/JFJochReceiverPlots.cpp index b230c5e5..c87d9d69 100644 --- a/receiver/JFJochReceiverPlots.cpp +++ b/receiver/JFJochReceiverPlots.cpp @@ -121,6 +121,7 @@ void JFJochReceiverPlots::Setup(const DiffractionExperiment &experiment, const A azint_time.Clear(r); indexing_analysis_time.Clear(r); image_scale_time.Clear(r); + compression_ratio.Clear(r); } void JFJochReceiverPlots::Add(const DataMessage &msg, const AzimuthalIntegrationProfile &profile) { @@ -155,6 +156,7 @@ void JFJochReceiverPlots::Add(const DataMessage &msg, const AzimuthalIntegration azint_time.AddElement(msg.number, msg.azint_time_s); indexing_analysis_time.AddElement(msg.number, msg.index_analysis_time_s); image_scale_time.AddElement(msg.number, msg.image_scale_time_s); + compression_ratio.AddElement(msg.number, msg.compression_ratio); if (msg.indexing_unit_cell) { indexing_uc_a.AddElement(msg.number, msg.indexing_unit_cell->a); @@ -295,6 +297,9 @@ MultiLinePlot JFJochReceiverPlots::GetPlots(const PlotRequest &request) { case PlotType::ReceiverDelay: ret = receiver_delay.GetMeanPlot(nbins, start, incr, request.fill_value); break; + case PlotType::CompressionRatio: + ret = compression_ratio.GetMeanPlot(nbins, start, incr, request.fill_value); + break; case PlotType::ReceiverFreeSendBuf: { auto available = receiver_buf_available.GetMeanPerBin(nbins, start, incr, request.fill_value); auto sending = receiver_buf_in_sending.GetMeanPerBin(nbins, start, incr, request.fill_value); @@ -560,6 +565,9 @@ void JFJochReceiverPlots::GetPlotRaw(std::vector &v, PlotType type, const case PlotType::ImageScaleBFactor: v = image_scale_b.ExportArray(); break; + case PlotType::CompressionRatio: + v = compression_ratio.ExportArray(); + break; case PlotType::ROISum: case PlotType::ROIMaxCount: case PlotType::ROIPixels: diff --git a/receiver/JFJochReceiverPlots.h b/receiver/JFJochReceiverPlots.h index ba5e2fe6..9ef32efe 100644 --- a/receiver/JFJochReceiverPlots.h +++ b/receiver/JFJochReceiverPlots.h @@ -69,6 +69,7 @@ class JFJochReceiverPlots { StatusVector image_scale_factor; StatusVector image_scale_cc; StatusVector image_scale_b; + StatusVector compression_ratio; // StatusVector objects are fully thread-safe (protected by internal mutex) // It is OK to have concurrent access to StatusVector -- 2.52.0 From ae67b36160f7835924daf6207ac647ace4abbf19 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 13:34:13 +0200 Subject: [PATCH 24/46] Adding machinery to include indexing lattice count --- common/JFJochMessages.h | 1 + common/Plot.h | 2 +- docs/CBOR.md | 1 + frame_serialize/CBORStream2Deserializer.cpp | 2 ++ frame_serialize/CBORStream2Serializer.cpp | 1 + receiver/JFJochReceiverPlots.cpp | 8 ++++++++ receiver/JFJochReceiverPlots.h | 1 + 7 files changed, 15 insertions(+), 1 deletion(-) diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index 83600b05..9d9c2bbf 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -112,6 +112,7 @@ struct DataMessage { std::optional bkg_estimate; std::optional indexing_result; + std::optional indexing_lattice_count; std::optional indexing_lattice; std::optional indexing_unit_cell; std::optional spot_count_indexed; diff --git a/common/Plot.h b/common/Plot.h index 2ac99093..1075b5c4 100644 --- a/common/Plot.h +++ b/common/Plot.h @@ -15,7 +15,7 @@ enum class PlotType { ROISum, ROIMean, ROIMaxCount, ROIPixels, ROIWeightedX, ROIWeightedY, PacketsReceived, MaxValue, ResolutionEstimate, ProfileRadius, Mosaicity, BFactor, PixelSum, StrongPixels, RefinementBeamX, RefinementBeamY, ImageProcessingTime, IntegratedReflections, - ImageScaleFactor, ImageScaleCC, ImageScaleBFactor, CompressionRatio + ImageScaleFactor, ImageScaleCC, ImageScaleBFactor, CompressionRatio, IndexingLatticeCount }; enum class PlotAzintUnit { diff --git a/docs/CBOR.md b/docs/CBOR.md index 7731bc35..4fe098ee 100644 --- a/docs/CBOR.md +++ b/docs/CBOR.md @@ -161,6 +161,7 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s | az_int_std | Array(float) | Standard deviation for azimuthal integration. (NaN for less than 2 samples) | | | | az_int_count | Array(uint64) | Number of pixels contributing to azimuthal bin | | | | indexing_result | bool | Indexing successful | | | +| indexing_lattice_count | uint64 | Number of lattices found in indexing | | X | | indexing_lattice | Array(9 * float) | Indexing result real lattice; present only if indexed | | X | | indexing_unit_cell | object | Indexing result unit cell: a, b, c \[angstrom\] and alpha, beta, gamma \[degree\]; present only if indexed | | X | | | | Unit cell is redundant to lattice - yet to simplify downstream programs to analyze results, both are provided | | | diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp index 645059f2..fff2fa91 100644 --- a/frame_serialize/CBORStream2Deserializer.cpp +++ b/frame_serialize/CBORStream2Deserializer.cpp @@ -717,6 +717,8 @@ namespace { GetCBORUInt64Array(value, message.az_int_profile_count); else if (key == "indexing_result") message.indexing_result = GetCBORBool(value); + else if (key == "indexing_lattice_count") + message.indexing_lattice_count = GetCBORUInt(value); else if (key == "indexing_lattice") { std::vector tmp; GetCBORFloatArray(value, tmp); diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp index 1e255573..8f3cde3c 100644 --- a/frame_serialize/CBORStream2Serializer.cpp +++ b/frame_serialize/CBORStream2Serializer.cpp @@ -765,6 +765,7 @@ void CBORStream2Serializer::SerializeImageInternal(CborEncoder &mapEncoder, cons CBOR_ENC(mapEncoder, "az_int_profile_count", message.az_int_profile_count); CBOR_ENC(mapEncoder, "indexing_result", message.indexing_result); + CBOR_ENC(mapEncoder, "indexing_lattice_count", message.indexing_lattice_count); if (message.indexing_lattice) CBOR_ENC(mapEncoder, "indexing_lattice", message.indexing_lattice->GetVector()); CBOR_ENC(mapEncoder, "profile_radius", message.profile_radius); diff --git a/receiver/JFJochReceiverPlots.cpp b/receiver/JFJochReceiverPlots.cpp index c87d9d69..3f7e2599 100644 --- a/receiver/JFJochReceiverPlots.cpp +++ b/receiver/JFJochReceiverPlots.cpp @@ -122,6 +122,7 @@ void JFJochReceiverPlots::Setup(const DiffractionExperiment &experiment, const A indexing_analysis_time.Clear(r); image_scale_time.Clear(r); compression_ratio.Clear(r); + indexing_lattice_count.Clear(r); } void JFJochReceiverPlots::Add(const DataMessage &msg, const AzimuthalIntegrationProfile &profile) { @@ -167,6 +168,7 @@ void JFJochReceiverPlots::Add(const DataMessage &msg, const AzimuthalIntegration indexing_uc_gamma.AddElement(msg.number, msg.indexing_unit_cell->gamma); } + indexing_lattice_count.AddElement(msg.number, msg.indexing_lattice_count); beam_center_x.AddElement(msg.number, msg.beam_corr_x); beam_center_y.AddElement(msg.number, msg.beam_corr_y); @@ -300,6 +302,9 @@ MultiLinePlot JFJochReceiverPlots::GetPlots(const PlotRequest &request) { case PlotType::CompressionRatio: ret = compression_ratio.GetMeanPlot(nbins, start, incr, request.fill_value); break; + case PlotType::IndexingLatticeCount: + ret = indexing_lattice_count.GetMeanPlot(nbins, start, incr, request.fill_value); + break; case PlotType::ReceiverFreeSendBuf: { auto available = receiver_buf_available.GetMeanPerBin(nbins, start, incr, request.fill_value); auto sending = receiver_buf_in_sending.GetMeanPerBin(nbins, start, incr, request.fill_value); @@ -568,6 +573,9 @@ void JFJochReceiverPlots::GetPlotRaw(std::vector &v, PlotType type, const case PlotType::CompressionRatio: v = compression_ratio.ExportArray(); break; + case PlotType::IndexingLatticeCount: + v = indexing_lattice_count.ExportArray(); + break; case PlotType::ROISum: case PlotType::ROIMaxCount: case PlotType::ROIPixels: diff --git a/receiver/JFJochReceiverPlots.h b/receiver/JFJochReceiverPlots.h index 9ef32efe..ab04602d 100644 --- a/receiver/JFJochReceiverPlots.h +++ b/receiver/JFJochReceiverPlots.h @@ -48,6 +48,7 @@ class JFJochReceiverPlots { StatusVector spot_count_ice; StatusVector indexing_solution; + StatusVector indexing_lattice_count; StatusVector indexing_uc_a; StatusVector indexing_uc_b; StatusVector indexing_uc_c; -- 2.52.0 From 74c1a7a828eec41bae4b7633a6796a2013eec392 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 13:51:39 +0200 Subject: [PATCH 25/46] MultiLatticeSearch: Remove reduced function --- .../indexing/MultiLatticeSearch.cpp | 22 ------------------- image_analysis/indexing/MultiLatticeSearch.h | 10 +-------- 2 files changed, 1 insertion(+), 31 deletions(-) diff --git a/image_analysis/indexing/MultiLatticeSearch.cpp b/image_analysis/indexing/MultiLatticeSearch.cpp index 11d0cf55..78681e55 100644 --- a/image_analysis/indexing/MultiLatticeSearch.cpp +++ b/image_analysis/indexing/MultiLatticeSearch.cpp @@ -105,25 +105,3 @@ std::vector MultiLatticeSearch(const std::vector MultiLatticeSearchReduced(const std::vector &lattices, - float dist_tolerance, - float angle_tolerance_deg) { - if (lattices.empty()) - return {}; - - // Reduce lattice 0 to its primitive Niggli setting; that becomes the reference basis. - std::vector reduced; - reduced.reserve(lattices.size()); - - // Reduce every candidate the same way so metric comparison and rotation - // are all done in the reduced setting. - for (const auto & lattice : lattices) - reduced.push_back(lattice.NiggliReduce()); - - auto ret = MultiLatticeSearch(reduced, dist_tolerance, angle_tolerance_deg); - - // Keep input_lattice pointing at the original (un-reduced) lattices for debugging. - - return ret; -} \ No newline at end of file diff --git a/image_analysis/indexing/MultiLatticeSearch.h b/image_analysis/indexing/MultiLatticeSearch.h index 09eddabf..e5f341ae 100644 --- a/image_analysis/indexing/MultiLatticeSearch.h +++ b/image_analysis/indexing/MultiLatticeSearch.h @@ -22,12 +22,4 @@ struct MultiLatticeSearchResult { // proper rotation R mapping reference -> lattice and store output_lattice = R * reference. std::vector MultiLatticeSearch(const std::vector &lattices, float dist_tolerance = 0.03f, - float angle_tolerance_deg = 3.0f); - -// Same as above, but first runs LatticeSearch on lattice 0 to obtain a -// Niggli-reduced / conventional reference, and reduces every candidate the -// same way before comparing/rotating. Rotations are returned in the reduced -// reference setting. -std::vector MultiLatticeSearchReduced(const std::vector &lattices, - float dist_tolerance = 0.03f, - float angle_tolerance_deg = 3.0f); \ No newline at end of file + float angle_tolerance_deg = 3.0f); \ No newline at end of file -- 2.52.0 From 83f467d4dcebc4493d985d8f455d28849fd27212 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 14:17:19 +0200 Subject: [PATCH 26/46] Add mechanics to save per spot lattice information (WIP) --- common/DiffractionSpot.cpp | 5 +++-- common/SpotToSave.h | 8 ++++---- docs/CBOR.md | 1 + frame_serialize/CBORStream2Deserializer.cpp | 2 ++ frame_serialize/CBORStream2Serializer.cpp | 1 + image_analysis/indexing/AnalyzeIndexing.cpp | 5 +++-- reader/JFJochHDF5Reader.cpp | 13 +++++++++++-- writer/HDF5DataFilePluginMX.cpp | 6 +++++- writer/HDF5DataFilePluginMX.h | 1 + writer/HDF5NXmx.cpp | 5 +++-- 10 files changed, 34 insertions(+), 13 deletions(-) diff --git a/common/DiffractionSpot.cpp b/common/DiffractionSpot.cpp index a3e7789c..5e6a8857 100644 --- a/common/DiffractionSpot.cpp +++ b/common/DiffractionSpot.cpp @@ -82,9 +82,10 @@ std::optional DiffractionSpot::Export(const DiffractionGeometry &geo .phi = phi, .intensity = static_cast(photons), .maxc = max_photons, + .lattice = -1, + .image = image_num, .d_A = d, .ice_ring = false, - .indexed = false, - .image = image_num + .indexed = false }; } diff --git a/common/SpotToSave.h b/common/SpotToSave.h index 114a9995..d866acbc 100644 --- a/common/SpotToSave.h +++ b/common/SpotToSave.h @@ -11,13 +11,13 @@ struct SpotToSave { float phi = 0; float intensity = 0; int64_t maxc = 0; + int64_t lattice = -1; // -1 non indexed + int64_t image = 0; + int64_t h = 0, k = 0, l= 0; float d_A = 0.0; + float dist_ewald_sphere = 0.0; bool ice_ring = false; bool indexed = false; - int64_t image = 0; - - int64_t h = 0, k = 0, l= 0; - float dist_ewald_sphere = 0.0; Coord ReciprocalCoord(const DiffractionGeometry &experiment) const; }; diff --git a/docs/CBOR.md b/docs/CBOR.md index 4fe098ee..58fb8bb9 100644 --- a/docs/CBOR.md +++ b/docs/CBOR.md @@ -136,6 +136,7 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s | - maxc | int64 | max count (photons) | | | | - ice_ring | bool | spot in resolution range for ice rings | | | | - indexed | bool | indexed solution | | | +| - latt | int64 | Lattice to which the peak belongs (negative number = not indexed) | | | | reflections | Array(object) | Reflections: | | | | - h | int64 | Miller index | | | | - k | int64 | Miller index | | | diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp index fff2fa91..e566beb9 100644 --- a/frame_serialize/CBORStream2Deserializer.cpp +++ b/frame_serialize/CBORStream2Deserializer.cpp @@ -446,6 +446,8 @@ namespace { s.ice_ring = GetCBORBool(map_value); else if (key == "indexed") s.indexed = GetCBORBool(map_value); + else if (key == "latt") + s.lattice = GetCBORInt(map_value); else if (key == "h") s.h = GetCBORInt(map_value); else if (key == "k") diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp index 8f3cde3c..0d2eae87 100644 --- a/frame_serialize/CBORStream2Serializer.cpp +++ b/frame_serialize/CBORStream2Serializer.cpp @@ -224,6 +224,7 @@ inline void CBOR_ENC(CborEncoder &encoder, const SpotToSave& spot) { CBOR_ENC(mapEncoder, "maxc", spot.maxc); CBOR_ENC(mapEncoder, "ice_ring", spot.ice_ring); CBOR_ENC(mapEncoder, "indexed", spot.indexed); + CBOR_ENC(mapEncoder, "latt", spot.lattice); CBOR_ENC(mapEncoder, "image", spot.image); if (spot.indexed) { CBOR_ENC(mapEncoder, "h", spot.h); diff --git a/image_analysis/indexing/AnalyzeIndexing.cpp b/image_analysis/indexing/AnalyzeIndexing.cpp index 8d02357b..a8a682c8 100644 --- a/image_analysis/indexing/AnalyzeIndexing.cpp +++ b/image_analysis/indexing/AnalyzeIndexing.cpp @@ -354,9 +354,10 @@ bool AnalyzeIndexing(DataMessage &message, if (ok(uc.a) && ok(uc.b) && ok(uc.c) && ok(uc.alpha) && ok(uc.beta) && ok(uc.gamma)) { message.indexing_result = true; assert(indexed_spots.size() == message.spots.size()); - for (int i = 0; i < message.spots.size(); i++) + for (int i = 0; i < message.spots.size(); i++) { message.spots[i].indexed = indexed_spots[i]; - + message.spots[i].lattice = 0; + } message.profile_radius = FitProfileRadius(message.spots); message.spot_count_indexed = nspots_indexed; message.indexing_lattice = latt; diff --git a/reader/JFJochHDF5Reader.cpp b/reader/JFJochHDF5Reader.cpp index 0a4e4dce..2df28081 100644 --- a/reader/JFJochHDF5Reader.cpp +++ b/reader/JFJochHDF5Reader.cpp @@ -785,6 +785,13 @@ static void ReadSpotsFromFiles(HDF5Object &master_file, "/entry/MX/peakL", {master_image, 0}, {source_image, 0}, {1, spot_count} ); + + auto spot_lattice = ReadVectorMasterFirst( + master_file, source_file, + "/entry/MX/peakLattice", + {master_image, 0}, {source_image, 0}, {1, spot_count} + ); + auto spot_dist_ewald_sphere = ReadVectorMasterFirst( master_file, source_file, "/entry/MX/peakDistEwaldSphere", @@ -800,8 +807,8 @@ static void ReadSpotsFromFiles(HDF5Object &master_file, .x = x, .y = y, .intensity = spot_intensity.at(i), - .d_A = geom.PxlToRes(x, y), - .image = image_number + .image = image_number, + .d_A = geom.PxlToRes(x, y) }; if (spot_indexed.size() > i) s.indexed = (spot_indexed.at(i) != 0); @@ -815,6 +822,8 @@ static void ReadSpotsFromFiles(HDF5Object &master_file, s.dist_ewald_sphere = spot_dist_ewald_sphere.at(i); if (spot_ice.size() > i) s.ice_ring = (spot_ice.at(i) != 0); + if (spot_lattice.size() > i) + s.lattice = spot_lattice.at(i); message.spots.emplace_back(s); } diff --git a/writer/HDF5DataFilePluginMX.cpp b/writer/HDF5DataFilePluginMX.cpp index 7f7ab6bb..e49ac866 100644 --- a/writer/HDF5DataFilePluginMX.cpp +++ b/writer/HDF5DataFilePluginMX.cpp @@ -72,6 +72,7 @@ void HDF5DataFilePluginMX::OpenFile(HDF5File &data_file, const DataMessage &msg, spot_h.reserve(max_spots * images_per_file); spot_k.reserve(max_spots * images_per_file); spot_l.reserve(max_spots * images_per_file); + spot_lattice.reserve(max_spots * images_per_file); spot_dist_ewald.reserve(max_spots * images_per_file); if (indexing) spot_indexed.reserve(max_spots * images_per_file); @@ -118,7 +119,8 @@ void HDF5DataFilePluginMX::Write(const DataMessage &msg, uint64_t image_number) spot_h.resize(max_spots * (max_image_number + 1)); spot_k.resize(max_spots * (max_image_number + 1)); spot_l.resize(max_spots * (max_image_number + 1)); - spot_dist_ewald.resize(max_spots * (max_image_number + 1)); + spot_lattice.resize(max_spots * (max_image_number + 1), -1); + spot_dist_ewald.resize(max_spots * (max_image_number + 1), NAN); if (indexing) spot_indexed.resize(max_spots * (max_image_number + 1)); @@ -134,6 +136,7 @@ void HDF5DataFilePluginMX::Write(const DataMessage &msg, uint64_t image_number) spot_int[max_spots * image_number + i] = msg.spots[i].intensity; if (indexing) { spot_indexed[max_spots * image_number + i] = msg.spots[i].indexed; + spot_lattice[max_spots * image_number + i] = msg.spots[i].lattice; spot_h[max_spots * image_number + i] = msg.spots[i].h; spot_k[max_spots * image_number + i] = msg.spots[i].k; spot_l[max_spots * image_number + i] = msg.spots[i].l; @@ -204,6 +207,7 @@ void HDF5DataFilePluginMX::WriteFinal(HDF5File &data_file) { data_file.SaveVector("/entry/MX/peakDistEwaldSphere", spot_dist_ewald, {(hsize_t) (max_image_number + 1), max_spots}); data_file.SaveVector("/entry/MX/peakIndexed", spot_indexed, {(hsize_t) (max_image_number + 1), max_spots}); + data_file.SaveVector("/entry/MX/peakLattice", spot_lattice, {(hsize_t) (max_image_number + 1), max_spots}); } } diff --git a/writer/HDF5DataFilePluginMX.h b/writer/HDF5DataFilePluginMX.h index 2c441561..c239de96 100644 --- a/writer/HDF5DataFilePluginMX.h +++ b/writer/HDF5DataFilePluginMX.h @@ -15,6 +15,7 @@ class HDF5DataFilePluginMX : public HDF5DataFilePlugin { std::vector spot_int; std::vector spot_indexed; std::vector spot_ice_ring; + std::vector spot_lattice; std::vector spot_h; std::vector spot_k; std::vector spot_l; diff --git a/writer/HDF5NXmx.cpp b/writer/HDF5NXmx.cpp index 5a45a78c..45d6849f 100644 --- a/writer/HDF5NXmx.cpp +++ b/writer/HDF5NXmx.cpp @@ -126,12 +126,13 @@ void NXmx::LinkToData_VDS(const StartMessage &start, const EndMessage &end) { VDS(start, "/entry/MX/peakXPosRaw",{total_images, start.max_spot_count}, HDF5DataType(0.0f)); VDS(start, "/entry/MX/peakYPosRaw",{total_images, start.max_spot_count}, HDF5DataType(0.0f)); VDS(start, "/entry/MX/peakTotalIntensity",{total_images, start.max_spot_count}, HDF5DataType(0.0f)); - VDS(start, "/entry/MX/peakIceRingRes", {total_images, start.max_spot_count}, HDF5DataType((uint8_t) 0)); + VDS(start, "/entry/MX/peakIceRingRes", {total_images, start.max_spot_count}, HDF5DataType(static_cast(0))); VDS(start, "/entry/MX/nPeaks", {total_images}, HDF5DataType((uint32_t) 0)); } if (start.indexing_algorithm != IndexingAlgorithmEnum::None) { - VDS(start, "/entry/MX/peakIndexed", {total_images, start.max_spot_count}, HDF5DataType((uint8_t) 0)); + VDS(start, "/entry/MX/peakIndexed", {total_images, start.max_spot_count}, HDF5DataType(static_cast(0))); + VDS(start, "/entry/MX/peakLattice", {total_images, start.max_spot_count}, HDF5DataType(static_cast(-1))); VDS(start, "/entry/MX/peakH", {total_images, start.max_spot_count}, HDF5DataType((int32_t) 0)); VDS(start, "/entry/MX/peakK", {total_images, start.max_spot_count}, HDF5DataType((int32_t) 0)); VDS(start, "/entry/MX/peakL", {total_images, start.max_spot_count}, HDF5DataType((int32_t) 0)); -- 2.52.0 From b49c7a766d21ffa05ecf25e5c6847f7d8e78b8b5 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 14:31:47 +0200 Subject: [PATCH 27/46] MultiLatticeSearch: Work in progress --- .../indexing/MultiLatticeSearch.cpp | 21 ++++------ image_analysis/indexing/MultiLatticeSearch.h | 5 +-- tests/JFJochReaderTest.cpp | 18 ++++---- tests/MultiLatticeSearchTest.cpp | 42 ++++++------------- 4 files changed, 29 insertions(+), 57 deletions(-) diff --git a/image_analysis/indexing/MultiLatticeSearch.cpp b/image_analysis/indexing/MultiLatticeSearch.cpp index 78681e55..07da2edb 100644 --- a/image_analysis/indexing/MultiLatticeSearch.cpp +++ b/image_analysis/indexing/MultiLatticeSearch.cpp @@ -3,6 +3,7 @@ #include "MultiLatticeSearch.h" +#include #include namespace { @@ -69,13 +70,9 @@ std::vector MultiLatticeSearch(const std::vector MultiLatticeSearch(const std::vector(rod.y()), static_cast(rod.z())); - // output_lattice = R * reference, built straight from the Eigen matrix - // so it is exactly a proper rotation of the reference (full double precision). - const Eigen::Matrix3d out = R * LatticeMatrix(reference); - ret.push_back({ - latt, - CrystalLattice(Coord(out(0, 0), out(1, 0), out(2, 0)), - Coord(out(0, 1), out(1, 1), out(2, 1)), - Coord(out(0, 2), out(1, 2), out(2, 2))), - rotation_vector - }); + std::cout << rotation_vector << std::endl; + std::cout << rotation_vector.Length() * 180.0 / M_PI << " deg\n" << std::endl; + + if (found) + continue; + ret.push_back({rotation_vector}); found = true; } } diff --git a/image_analysis/indexing/MultiLatticeSearch.h b/image_analysis/indexing/MultiLatticeSearch.h index e5f341ae..af369bb5 100644 --- a/image_analysis/indexing/MultiLatticeSearch.h +++ b/image_analysis/indexing/MultiLatticeSearch.h @@ -7,11 +7,8 @@ #include "../common/CrystalLattice.h" #include "../common/Coord.h" -#include "../lattice_search/LatticeSearch.h" struct MultiLatticeSearchResult { - CrystalLattice input_lattice; // lattice as it came in (kept for debugging only) - CrystalLattice output_lattice; // R * reference - a proper rotation of the first lattice Coord rotation_vector; // Rodrigues vector: axis * angle, magnitude == angle [rad] }; @@ -19,7 +16,7 @@ struct MultiLatticeSearchResult { // only by orientation, and describing non-overlapping sets of spots. // The first lattice is the reference. A subsequent lattice is kept only if its unit // cell matches the reference (within tolerances); for each kept lattice we find the -// proper rotation R mapping reference -> lattice and store output_lattice = R * reference. +// proper rotation R mapping reference -> lattice std::vector MultiLatticeSearch(const std::vector &lattices, float dist_tolerance = 0.03f, float angle_tolerance_deg = 3.0f); \ No newline at end of file diff --git a/tests/JFJochReaderTest.cpp b/tests/JFJochReaderTest.cpp index 7da8584e..8c865ad4 100644 --- a/tests/JFJochReaderTest.cpp +++ b/tests/JFJochReaderTest.cpp @@ -1211,10 +1211,10 @@ TEST_CASE("JFJochReader_Spots_OldMasterFormat", "[HDF5][Full]") { std::vector spots; spots.push_back(SpotToSave{ .x = 1, .y = 2, .intensity = 376, - .ice_ring = true, - .indexed = true, .h = 11, .k = -3, .l = -5, - .dist_ewald_sphere = 0.1234f + .dist_ewald_sphere = 0.1234f, + .ice_ring = true, + .indexed = true }); spots.push_back(SpotToSave{ .x = 7, .y = -3, .intensity = 0.156f, @@ -1308,10 +1308,10 @@ TEST_CASE("JFJochReader_Spots_VDS", "[HDF5][Full]") { std::vector spots; spots.push_back(SpotToSave{ .x = 1, .y = 2, .intensity = 376, - .ice_ring = true, - .indexed = true, .h = 11, .k = -3, .l = -5, - .dist_ewald_sphere = 0.1234f + .dist_ewald_sphere = 0.1234f, + .ice_ring = true, + .indexed = true }); spots.push_back(SpotToSave{ .x = 7, .y = -3, .intensity = 0.156f, @@ -2127,10 +2127,10 @@ static std::vector MakeTestSpots(int i) { return { SpotToSave{ .x = 1, .y = 2, .intensity = 376, - .ice_ring = true, - .indexed = true, .h = 11, .k = -3, .l = -5, - .dist_ewald_sphere = 0.1234f + .dist_ewald_sphere = 0.1234f, + .ice_ring = true, + .indexed = true }, SpotToSave{ .x = 7, .y = static_cast(-3 - i), .intensity = 0.156f, diff --git a/tests/MultiLatticeSearchTest.cpp b/tests/MultiLatticeSearchTest.cpp index 6e5df735..4f94b868 100644 --- a/tests/MultiLatticeSearchTest.cpp +++ b/tests/MultiLatticeSearchTest.cpp @@ -5,17 +5,6 @@ #include "../image_analysis/indexing/MultiLatticeSearch.h" -namespace { - // Rotation-invariant comparison via Gram matrix G = L^T L - void check_same_cell(const CrystalLattice &a, const CrystalLattice &b, double margin) { - const Coord av[3] = {a.Vec0(), a.Vec1(), a.Vec2()}; - const Coord bv[3] = {b.Vec0(), b.Vec1(), b.Vec2()}; - for (int i = 0; i < 3; i++) - for (int j = 0; j < 3; j++) - CHECK((av[i] * av[j]) == Catch::Approx(bv[i] * bv[j]).margin(margin)); - } -} - TEST_CASE("MultiLatticeSearch_RecoversRotation") { CrystalLattice reference(40, 50, 80, 90, 95, 90); @@ -30,36 +19,24 @@ TEST_CASE("MultiLatticeSearch_RecoversRotation") { auto result = MultiLatticeSearch({reference, rotated}); - REQUIRE(result.size() == 2); - - // First entry: identity - CHECK(result[0].rotation_vector.Length() == Catch::Approx(0.0).margin(1e-6)); - check_same_cell(result[0].output_lattice, reference, 1e-3); + REQUIRE(result.size() == 1); // Second entry: angle and axis recovered - CHECK(result[1].rotation_vector.Length() == Catch::Approx(angle).margin(1e-4)); - const Coord recovered_axis = result[1].rotation_vector.Normalize(); + CHECK(result[0].rotation_vector.Length() == Catch::Approx(angle).margin(1e-4)); + const Coord recovered_axis = result[0].rotation_vector.Normalize(); CHECK(recovered_axis.x == Catch::Approx(axis.x).margin(1e-3)); CHECK(recovered_axis.y == Catch::Approx(axis.y).margin(1e-3)); CHECK(recovered_axis.z == Catch::Approx(axis.z).margin(1e-3)); - - // output_lattice is a proper rotation of the reference => same metric - check_same_cell(result[1].output_lattice, reference, 1e-2); - - // and output equals the rotated input (same orientation) - check_same_cell(result[1].output_lattice, rotated, 1e-2); } TEST_CASE("MultiLatticeSearch_SkipsDifferentCell") { CrystalLattice reference(40, 50, 80, 90, 90, 90); CrystalLattice other_cell(45, 50, 80, 90, 90, 90); // a differs by 5 A - auto result = MultiLatticeSearch({reference, other_cell}); // Only the reference survives - REQUIRE(result.size() == 1); - CHECK(result[0].rotation_vector.Length() == Catch::Approx(0.0).margin(1e-6)); + REQUIRE(result.empty()); } TEST_CASE("MultiLatticeSearch_Empty") { @@ -67,6 +44,8 @@ TEST_CASE("MultiLatticeSearch_Empty") { CHECK(result.empty()); } +#include + TEST_CASE("MultiLatticeSearch_EP") { // Real EP case CrystalLattice cell1(Coord(-13.2, -30.0, -29.6), @@ -77,7 +56,10 @@ TEST_CASE("MultiLatticeSearch_EP") { Coord(1.8, 45.4, -23.7) ); - auto result = MultiLatticeSearch({cell1, cell2}, - 0.1, 5); - REQUIRE(result.size() == 2); + auto result = MultiLatticeSearch({cell1, cell2}, 0.1, 3); + + + REQUIRE(result.size() == 1); + std::cout << result[0].rotation_vector << std::endl; + std::cout << result[0].rotation_vector.Length() * 180.0 / M_PI << std::endl; } \ No newline at end of file -- 2.52.0 From 3522568d49d4db723103d2adce0e064e2d44c171 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 15:05:11 +0200 Subject: [PATCH 28/46] MultiLatticeSearch: Works --- image_analysis/indexing/MultiLatticeSearch.cpp | 4 ---- tests/MultiLatticeSearchTest.cpp | 12 +++++++----- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/image_analysis/indexing/MultiLatticeSearch.cpp b/image_analysis/indexing/MultiLatticeSearch.cpp index 07da2edb..3080fc31 100644 --- a/image_analysis/indexing/MultiLatticeSearch.cpp +++ b/image_analysis/indexing/MultiLatticeSearch.cpp @@ -3,7 +3,6 @@ #include "MultiLatticeSearch.h" -#include #include namespace { @@ -86,9 +85,6 @@ std::vector MultiLatticeSearch(const std::vector(rod.y()), static_cast(rod.z())); - std::cout << rotation_vector << std::endl; - std::cout << rotation_vector.Length() * 180.0 / M_PI << " deg\n" << std::endl; - if (found) continue; ret.push_back({rotation_vector}); diff --git a/tests/MultiLatticeSearchTest.cpp b/tests/MultiLatticeSearchTest.cpp index 4f94b868..a068537a 100644 --- a/tests/MultiLatticeSearchTest.cpp +++ b/tests/MultiLatticeSearchTest.cpp @@ -44,8 +44,6 @@ TEST_CASE("MultiLatticeSearch_Empty") { CHECK(result.empty()); } -#include - TEST_CASE("MultiLatticeSearch_EP") { // Real EP case CrystalLattice cell1(Coord(-13.2, -30.0, -29.6), @@ -58,8 +56,12 @@ TEST_CASE("MultiLatticeSearch_EP") { auto result = MultiLatticeSearch({cell1, cell2}, 0.1, 3); - REQUIRE(result.size() == 1); - std::cout << result[0].rotation_vector << std::endl; - std::cout << result[0].rotation_vector.Length() * 180.0 / M_PI << std::endl; + + RotMatrix matrix(result[0].rotation_vector.Length(), result[0].rotation_vector.Normalize()); + auto cell2_rot = cell1.Multiply(matrix); + + CHECK((cell2_rot.Vec0() - cell2.Vec0()).Length() < cell2.Vec0().Length() / 100); + CHECK((cell2_rot.Vec1() - cell2.Vec1()).Length() < cell2.Vec1().Length() / 100); + CHECK((cell2_rot.Vec2() - cell2.Vec2()).Length() < cell2.Vec2().Length() / 100); } \ No newline at end of file -- 2.52.0 From 3bcfc08b21edeab6d6c553e7920e1bcb7b31805a Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 15:39:13 +0200 Subject: [PATCH 29/46] RotationIndexer: Identify and save additional lattices --- .../rotation_indexer/RotationIndexer.cpp | 33 +++++++++++++++++-- .../rotation_indexer/RotationIndexer.h | 2 ++ 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/image_analysis/rotation_indexer/RotationIndexer.cpp b/image_analysis/rotation_indexer/RotationIndexer.cpp index e9919377..dddc0c24 100644 --- a/image_analysis/rotation_indexer/RotationIndexer.cpp +++ b/image_analysis/rotation_indexer/RotationIndexer.cpp @@ -6,7 +6,7 @@ #include "../geom_refinement/XtalOptimizer.h" #include "../indexing/FFTIndexer.h" #include "../lattice_search/LatticeSearch.h" -#include +#include "../indexing/MultiLatticeSearch.h" RotationIndexer::RotationIndexer(const DiffractionExperiment &x, IndexerThreadPool &indexer) : experiment(x), @@ -43,6 +43,7 @@ void RotationIndexer::RunIndexing() { .conventional = indexer_result.lattice[0], // If lattice provided, it is for now primitive == conventional .system = sg->crystal_system(), .centering = sg->centring_type(), + .reindex = gemmi::Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1), }; } else { // Find lattice type based on cell @@ -75,6 +76,33 @@ void RotationIndexer::RunIndexing() { updated_geom_ = data.geom; axis_ = data.axis; } + + if (indexer_result.lattice.size() > 1) { + auto ml_latt = MultiLatticeSearch(indexer_result.lattice); + for (auto &l : ml_latt) { + + // Ignore lattices oriented by less then 3.0 degree + if (l.rotation_vector.Length() < 3.0 * M_PI / 180.0) + continue; + + RotMatrix rot(l.rotation_vector.Length(), l.rotation_vector.Normalize()); + + XtalOptimizerData data_multi{ + .geom = experiment_copy.GetDiffractionGeometry(), + .latt = data.latt.Multiply(rot), + .crystal_system = search_result_.system, + .min_spots = experiment.GetIndexingSettings().GetViableCellMinSpots(), + .refine_beam_center = false, + .refine_distance_mm = false, + .refine_detector_angles = false, + .refine_unit_cell = false, + .refine_rotation_axis = false, + .index_ice_rings = experiment.GetIndexingSettings().GetIndexIceRings(), + .axis = axis_ + }; + extra_lattices_.push_back(data_multi.latt); + } + } } } @@ -121,9 +149,10 @@ std::optional RotationIndexer::GetLattice() const { return {}; return RotationIndexerResult{ .lattice = indexed_lattice.value(), + .extra_lattices = extra_lattices_, .search_result = search_result_, .geom = updated_geom_, - .axis = axis_ + .axis = axis_, }; } diff --git a/image_analysis/rotation_indexer/RotationIndexer.h b/image_analysis/rotation_indexer/RotationIndexer.h index 73bc8901..ca6f4023 100644 --- a/image_analysis/rotation_indexer/RotationIndexer.h +++ b/image_analysis/rotation_indexer/RotationIndexer.h @@ -13,6 +13,7 @@ struct RotationIndexerResult { CrystalLattice lattice; + std::vector extra_lattices; LatticeSearchResult search_result; DiffractionGeometry geom; std::optional axis; @@ -33,6 +34,7 @@ class RotationIndexer { const DiffractionGeometry geom_; DiffractionGeometry updated_geom_; LatticeSearchResult search_result_; + std::vector extra_lattices_; IndexerThreadPool &indexer_; -- 2.52.0 From 5780548964b5352c750400e5a1315e2ad1e6330e Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 15:56:51 +0200 Subject: [PATCH 30/46] IndexingSettings: Define limit for extra lattices --- common/IndexingSettings.cpp | 4 ++++ common/IndexingSettings.h | 1 + 2 files changed, 5 insertions(+) diff --git a/common/IndexingSettings.cpp b/common/IndexingSettings.cpp index 7cd61a83..3905085c 100644 --- a/common/IndexingSettings.cpp +++ b/common/IndexingSettings.cpp @@ -213,3 +213,7 @@ IndexingSettings &IndexingSettings::BlockingBehavior(bool input) { blocking_behavior = input; return *this; } + +int64_t IndexingSettings::GetMaxExtraLattices() const { + return 3; +} diff --git a/common/IndexingSettings.h b/common/IndexingSettings.h index 577e2ed3..cca6ba92 100644 --- a/common/IndexingSettings.h +++ b/common/IndexingSettings.h @@ -70,4 +70,5 @@ public: [[nodiscard]] float GetRotationIndexingMinAngularRange_deg() const; [[nodiscard]] float GetRotationIndexingAngularStride_deg() const; [[nodiscard]] bool GetBlockingBehavior() const; + [[nodiscard]] int64_t GetMaxExtraLattices() const; }; -- 2.52.0 From c3bb5e1f5ffa30cb0bf9aaf1ce8810b985b72900 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 15:57:22 +0200 Subject: [PATCH 31/46] RotationIndexer: Add refinement of extra lattices + limit number of extra lattices --- image_analysis/rotation_indexer/RotationIndexer.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/image_analysis/rotation_indexer/RotationIndexer.cpp b/image_analysis/rotation_indexer/RotationIndexer.cpp index dddc0c24..f004959a 100644 --- a/image_analysis/rotation_indexer/RotationIndexer.cpp +++ b/image_analysis/rotation_indexer/RotationIndexer.cpp @@ -80,8 +80,10 @@ void RotationIndexer::RunIndexing() { if (indexer_result.lattice.size() > 1) { auto ml_latt = MultiLatticeSearch(indexer_result.lattice); for (auto &l : ml_latt) { + if (extra_lattices_.size() >= experiment.GetIndexingSettings().GetMaxExtraLattices()) + break; - // Ignore lattices oriented by less then 3.0 degree + // Ignore lattices oriented by less than 3.0 degree if (l.rotation_vector.Length() < 3.0 * M_PI / 180.0) continue; @@ -100,6 +102,12 @@ void RotationIndexer::RunIndexing() { .index_ice_rings = experiment.GetIndexingSettings().GetIndexIceRings(), .axis = axis_ }; + + // Quick refinement: orientation only. Cell size/angles, beam center, + // detector angles and rotation axis are all kept from the first lattice. + // XtalOptimizer always refines orientation; everything else is frozen above. + XtalOptimizer(data_multi, v_); + extra_lattices_.push_back(data_multi.latt); } } -- 2.52.0 From c1e9babe13a746c77290cda31fe90a62b3d1f456 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 15:59:08 +0200 Subject: [PATCH 32/46] Messages: Add extra information on additional lattices --- common/JFJochMessages.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index 9d9c2bbf..94d3fa83 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -114,6 +114,7 @@ struct DataMessage { std::optional indexing_result; std::optional indexing_lattice_count; std::optional indexing_lattice; + std::vector extra_lattices; std::optional indexing_unit_cell; std::optional spot_count_indexed; @@ -222,6 +223,7 @@ struct StartMessage { std::optional unit_cell; // user data std::optional space_group_number; // user data uint64_t max_spot_count; // user data + uint64_t max_extra_lattices; std::optional storage_cell_number; uint64_t storage_cell_delay_ns; @@ -328,6 +330,7 @@ struct EndMessage { std::optional rotation_lattice_type; std::optional rotation_lattice; + std::vector extra_lattices; std::optional unit_cell; // Vectors with end result: -- 2.52.0 From 4c45d1c835b03bb517c49617d06c3d54eb2090c6 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 16:22:35 +0200 Subject: [PATCH 33/46] Multi lattice search: WIP - Integration added by Claude Opus (doesn't work :) ) --- common/JFJochMessages.h | 2 +- docs/CBOR.md | 207 ++++++++++---------- frame_serialize/CBORStream2Deserializer.cpp | 26 ++- frame_serialize/CBORStream2Serializer.cpp | 24 ++- image_analysis/IndexAndRefine.cpp | 46 ++++- image_analysis/IndexAndRefine.h | 1 + image_analysis/indexing/AnalyzeIndexing.cpp | 59 +++++- image_analysis/indexing/AnalyzeIndexing.h | 3 +- receiver/JFJochReceiver.cpp | 1 + writer/HDF5DataFilePluginMX.cpp | 32 ++- writer/HDF5DataFilePluginMX.h | 2 + 11 files changed, 286 insertions(+), 117 deletions(-) diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index 94d3fa83..ccc45015 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -223,7 +223,7 @@ struct StartMessage { std::optional unit_cell; // user data std::optional space_group_number; // user data uint64_t max_spot_count; // user data - uint64_t max_extra_lattices; + uint64_t max_extra_lattices = 0; std::optional storage_cell_number; uint64_t storage_cell_delay_ns; diff --git a/docs/CBOR.md b/docs/CBOR.md index 58fb8bb9..2c4c8869 100644 --- a/docs/CBOR.md +++ b/docs/CBOR.md @@ -64,6 +64,7 @@ There are minor differences at the moment: | pixel_mask | Map(string -> Image) | Pixel mask - multiple in case of storage cells | X | | channels | Array(string) | List of image channels | X | | max_spot_count | uint64 | Maximum number of spots identified in spot finding | | +| max_extra_lattices | uint64 | Maximum number of extra lattices | | | storage_cell_number | uint64 (optional) | Number of storage cells used by JUNGFRAU | | | storage_cell_delay | Rational | Delay of storage cells in JUNGFRAU | | | threshold_energy | float | Threshold energy for EIGER detector \[eV\] | | @@ -118,108 +119,109 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s ## Image message -| Field name | Type | Description | Present in DECTRIS format | Optional | -|-----------------------------|----------------------|-----------------------------------------------------------------------------------------------------------------------------------|:-------------------------:|:--------:| -| type | String | value "image" | X | | -| magic_number | uint64 | Number used to describe version of the Jungfraujoch data interface - to allow to detect inconsistency between sender and receiver | | | -| series_unique_id | string | Unique text ID of the series (run_name parameter) | X | | -| series_id | uint64 | Unique numeric ID of the series (run_number parameter) | X | | -| image_id | uint64 | Number of image within the series; for MX lossy compression this is sequential excluding removed frames | X | | -| original_image_id | uint64 | Number of image within the series; for MX lossy compression this includes removed frames in the count | | | -| real_time | Rational | Exposure time | X | | -| start_time | Rational | Exposure start time (highly approximate) | X | | -| end_time | Rational | Exposure end time (highly approximate) | X | | -| spots | Array(object) | Spots: | | | -| - x | float | observed position in x (pixels) | | | -| - y | float | observed position in y (pixels) | | | -| - I | float | intensity (photons) | | | -| - maxc | int64 | max count (photons) | | | -| - ice_ring | bool | spot in resolution range for ice rings | | | -| - indexed | bool | indexed solution | | | -| - latt | int64 | Lattice to which the peak belongs (negative number = not indexed) | | | -| reflections | Array(object) | Reflections: | | | -| - h | int64 | Miller index | | | -| - k | int64 | Miller index | | | -| - l | int64 | Miller index | | | -| - x | float | prediced position in x (pixels) | | | -| - y | float | predicted position in y (pixels) | | | -| - obs_x | float | observed position in x (pixels) | | | -| - obs_y | float | observed position in y (pixels) | | | -| - d | float | resolution \[Angstrom\] | | | -| - I | float | integrated intensity (photons) | | | -| - bkg | float | mean background value (photons) | | | -| - sigma | float | standard deviation, estimated from counting statistics (photons) | | | -| - image | float | image number (present for each spot) | | | -| - dist_ewald | float | distance to Ewald sphere (present only for indexed spots) | | | -| - rlp | float | Reciprocal Lorentz and polarization corrections | | | -| - partiality | float | Partiality of the reflection | | | -| spot_count | uint64 | Spot count | | | -| spot_count_ice_rings | uint64 | Number of spots within identified rings (experimental) | | | -| spot_count_low_res | uint64 | Number of spots in low resolution (prior to filtering) | | | -| spot_count_indexed | uint64 | Number of spots which fit indexing solution within a given tolerance | | | -| az_int_profile | Array(float) | Azimuthal integration results, use az_int_bin_to_q from start message for legend | | | -| | | NaN is used for empty bins and has to be taken care by the receiver | | | -| az_int_std | Array(float) | Standard deviation for azimuthal integration. (NaN for less than 2 samples) | | | -| az_int_count | Array(uint64) | Number of pixels contributing to azimuthal bin | | | -| indexing_result | bool | Indexing successful | | | -| indexing_lattice_count | uint64 | Number of lattices found in indexing | | X | -| indexing_lattice | Array(9 * float) | Indexing result real lattice; present only if indexed | | X | -| indexing_unit_cell | object | Indexing result unit cell: a, b, c \[angstrom\] and alpha, beta, gamma \[degree\]; present only if indexed | | X | -| | | Unit cell is redundant to lattice - yet to simplify downstream programs to analyze results, both are provided | | | -| profile_radius | float | Profile radius of the image - describes distance of observed reflections from the Ewald sphere \[Angstrom^-1\] | | | -| integrated_reflections | int64 | Count of integrated reflections | | | -| mosaicity | float | Angular range of spots in image from a rotation scan \[degree\] | | | -| b_factor | float | Estimated B-factor (Angstrom^2) | | | -| compression_time | float | Time spent on compression/decompressing image \[s\] | | | -| preprocessing_time | float | Time spent on preparing the image for analysis \[s\] | | | -| azint_time | float | Time spent on azimuthal integration \[s\] | | | -| spot_finding_time | float | Time spent on spot finding \[s\] | | | -| indexing_time | float | Time spent on indexing \[s\] | | | -| refinement_time | float | Time spent on refinement of indexing solution and experimental geometry \[s\] | | | -| index_analysis_time | float | Time spent on analyzing idnexing solution, calculating profile radius and mosaicity \[s\] | | | -| bragg_prediction_time | float | Time spent on predicting Bragg spots \[s\] | | | -| integration_time | float | Time spent on Bragg integration \[s\] | | | -| image_scale_time | float | Time spent on on-the-fly scaling \[s\] | | | -| processing_time | float | Total processing time \[s\] | | | -| xfel_pulse_id | uint64 | Bunch ID (for pulsed source, e.g., SwissFEL) | | X | -| xfel_event_code | uint64 | Event code (for pulsed source, e.g., SwissFEL) | | X | -| lattice_type | object | Bravais lattice classification of the indexing result (present only if available) | | X | -| - centering | string | One-letter centering code: P, A, B, C, I, F, or R | | | -| - niggli_class | int64 | Integer identifier for the Niggli-reduced Bravais class | | | -| - system | string | Crystal system: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, cubic | | | -| jf_info | uint64 | Detector info field | | | -| receiver_aq_dev_delay | uint64 | Receiver internal delay | | | -| receiver_free_send_buf | uint64 | Receiver internal number of available buffer locations | | | -| receiver_buf_in_sending | uint64 | Receiver internal number of buffer locations currently in sending/writing | | | -| receiver_buf_in_preparation | uint64 | Receiver internal number of buffer locations currently in processing | | | -| storage_cell | uint64 | Storage cell number | | | -| saturated_pixel_count | uint64 | Saturated pixel count | | | -| pixel_sum | uint64 | Sum of all pixels, excl. error and saturation | | | -| error_pixel_count | uint64 | Error pixel count | | | -| strong_pixel_count | uint64 | Strong pixel count (first stage of spot finding) | | | -| min_viable_pixel_value | int64 | Minimal pixel value, excl. error and saturation | | | -| max_viable_pixel_value | int64 | Maximal pixel value, excl. error and saturation | | | -| resolution_estimate | float | Diffraction resolution estimation \[Angstrom\] | | X | -| data_collection_efficiency | float | Image collection efficiency \[\] | | | -| packets_expected | uint64 | Number of packets expected per image (in units of 2 kB) | | | -| packets_received | uint64 | Number of packets received per image (in units of 2 kB) | | | -| bkg_estimate | float | Mean value for pixels in resolution range from 3.0 to 5.0 A \[photons\] | | | -| beam_corr_x | float | Beam center correction X applied during processing \[pixel\] | | X | -| beam_corr_y | float | Beam center correction Y applied during processing \[pixel\] | | X | -| image_scale_factor | float | Scaling result: Image scale factor (g) | | X | -| image_scale_mosaicity | float | Scaling result: Image scale mosaicity \[deg\] | | X | -| image_scale_b_factor | float | Scaling result: Image scale B factor \[Angstrom^2\] | | X | -| image_scale_cc | float | Scaling result: Image scale CC | | X | -| adu_histogram | Array(uint64) | ADU histogram | | | -| roi_integrals | object | Results of ROI calculation | | X | -| - sum | int64 | Sum of pixels in ROI area \[photons\] | | | -| - sum_square | int64 | Sum of squares of pixels in ROI area \[photons\] | | | -| - pixels | uint64 | Valid pixels in ROI area | | | -| - max_count | int64 | Highest count in ROI area \[photons\] | | | -| - x_weighted_sum | int64 | ROI pixel X position multiplied by photon count \[photons * pixels\] | | | -| - y_weighted_sum | int64 | ROI pixel Y position multiplied by photon count \[photons * pixels\] | | | -| user_data | string | Optional user defined text information - this is image_appendix serialized to JSON format | X | | -| data | Map(string -> Image) | Image | X | | +| Field name | Type | Description | Present in DECTRIS format | Optional | +|-----------------------------|-----------------------|-----------------------------------------------------------------------------------------------------------------------------------|:-------------------------:|:--------:| +| type | String | value "image" | X | | +| magic_number | uint64 | Number used to describe version of the Jungfraujoch data interface - to allow to detect inconsistency between sender and receiver | | | +| series_unique_id | string | Unique text ID of the series (run_name parameter) | X | | +| series_id | uint64 | Unique numeric ID of the series (run_number parameter) | X | | +| image_id | uint64 | Number of image within the series; for MX lossy compression this is sequential excluding removed frames | X | | +| original_image_id | uint64 | Number of image within the series; for MX lossy compression this includes removed frames in the count | | | +| real_time | Rational | Exposure time | X | | +| start_time | Rational | Exposure start time (highly approximate) | X | | +| end_time | Rational | Exposure end time (highly approximate) | X | | +| spots | Array(object) | Spots: | | | +| - x | float | observed position in x (pixels) | | | +| - y | float | observed position in y (pixels) | | | +| - I | float | intensity (photons) | | | +| - maxc | int64 | max count (photons) | | | +| - ice_ring | bool | spot in resolution range for ice rings | | | +| - indexed | bool | indexed solution | | | +| - latt | int64 | Lattice to which the peak belongs (negative number = not indexed) | | | +| reflections | Array(object) | Reflections: | | | +| - h | int64 | Miller index | | | +| - k | int64 | Miller index | | | +| - l | int64 | Miller index | | | +| - x | float | prediced position in x (pixels) | | | +| - y | float | predicted position in y (pixels) | | | +| - obs_x | float | observed position in x (pixels) | | | +| - obs_y | float | observed position in y (pixels) | | | +| - d | float | resolution \[Angstrom\] | | | +| - I | float | integrated intensity (photons) | | | +| - bkg | float | mean background value (photons) | | | +| - sigma | float | standard deviation, estimated from counting statistics (photons) | | | +| - image | float | image number (present for each spot) | | | +| - dist_ewald | float | distance to Ewald sphere (present only for indexed spots) | | | +| - rlp | float | Reciprocal Lorentz and polarization corrections | | | +| - partiality | float | Partiality of the reflection | | | +| spot_count | uint64 | Spot count | | | +| spot_count_ice_rings | uint64 | Number of spots within identified rings (experimental) | | | +| spot_count_low_res | uint64 | Number of spots in low resolution (prior to filtering) | | | +| spot_count_indexed | uint64 | Number of spots which fit indexing solution within a given tolerance | | | +| az_int_profile | Array(float) | Azimuthal integration results, use az_int_bin_to_q from start message for legend | | | +| | | NaN is used for empty bins and has to be taken care by the receiver | | | +| az_int_std | Array(float) | Standard deviation for azimuthal integration. (NaN for less than 2 samples) | | | +| az_int_count | Array(uint64) | Number of pixels contributing to azimuthal bin | | | +| indexing_result | bool | Indexing successful | | | +| indexing_lattice_count | uint64 | Number of lattices found in indexing | | X | +| indexing_lattice | Array(9 * float) | Indexing result real lattice; present only if indexed | | X | +| extra_lattices | Array(Array(9*float)) | Additional indexed lattices (orientation variants); present only if found | | | +| indexing_unit_cell | object | Indexing result unit cell: a, b, c \[angstrom\] and alpha, beta, gamma \[degree\]; present only if indexed | | X | +| | | Unit cell is redundant to lattice - yet to simplify downstream programs to analyze results, both are provided | | | +| profile_radius | float | Profile radius of the image - describes distance of observed reflections from the Ewald sphere \[Angstrom^-1\] | | | +| integrated_reflections | int64 | Count of integrated reflections | | | +| mosaicity | float | Angular range of spots in image from a rotation scan \[degree\] | | | +| b_factor | float | Estimated B-factor (Angstrom^2) | | | +| compression_time | float | Time spent on compression/decompressing image \[s\] | | | +| preprocessing_time | float | Time spent on preparing the image for analysis \[s\] | | | +| azint_time | float | Time spent on azimuthal integration \[s\] | | | +| spot_finding_time | float | Time spent on spot finding \[s\] | | | +| indexing_time | float | Time spent on indexing \[s\] | | | +| refinement_time | float | Time spent on refinement of indexing solution and experimental geometry \[s\] | | | +| index_analysis_time | float | Time spent on analyzing idnexing solution, calculating profile radius and mosaicity \[s\] | | | +| bragg_prediction_time | float | Time spent on predicting Bragg spots \[s\] | | | +| integration_time | float | Time spent on Bragg integration \[s\] | | | +| image_scale_time | float | Time spent on on-the-fly scaling \[s\] | | | +| processing_time | float | Total processing time \[s\] | | | +| xfel_pulse_id | uint64 | Bunch ID (for pulsed source, e.g., SwissFEL) | | X | +| xfel_event_code | uint64 | Event code (for pulsed source, e.g., SwissFEL) | | X | +| lattice_type | object | Bravais lattice classification of the indexing result (present only if available) | | X | +| - centering | string | One-letter centering code: P, A, B, C, I, F, or R | | | +| - niggli_class | int64 | Integer identifier for the Niggli-reduced Bravais class | | | +| - system | string | Crystal system: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, cubic | | | +| jf_info | uint64 | Detector info field | | | +| receiver_aq_dev_delay | uint64 | Receiver internal delay | | | +| receiver_free_send_buf | uint64 | Receiver internal number of available buffer locations | | | +| receiver_buf_in_sending | uint64 | Receiver internal number of buffer locations currently in sending/writing | | | +| receiver_buf_in_preparation | uint64 | Receiver internal number of buffer locations currently in processing | | | +| storage_cell | uint64 | Storage cell number | | | +| saturated_pixel_count | uint64 | Saturated pixel count | | | +| pixel_sum | uint64 | Sum of all pixels, excl. error and saturation | | | +| error_pixel_count | uint64 | Error pixel count | | | +| strong_pixel_count | uint64 | Strong pixel count (first stage of spot finding) | | | +| min_viable_pixel_value | int64 | Minimal pixel value, excl. error and saturation | | | +| max_viable_pixel_value | int64 | Maximal pixel value, excl. error and saturation | | | +| resolution_estimate | float | Diffraction resolution estimation \[Angstrom\] | | X | +| data_collection_efficiency | float | Image collection efficiency \[\] | | | +| packets_expected | uint64 | Number of packets expected per image (in units of 2 kB) | | | +| packets_received | uint64 | Number of packets received per image (in units of 2 kB) | | | +| bkg_estimate | float | Mean value for pixels in resolution range from 3.0 to 5.0 A \[photons\] | | | +| beam_corr_x | float | Beam center correction X applied during processing \[pixel\] | | X | +| beam_corr_y | float | Beam center correction Y applied during processing \[pixel\] | | X | +| image_scale_factor | float | Scaling result: Image scale factor (g) | | X | +| image_scale_mosaicity | float | Scaling result: Image scale mosaicity \[deg\] | | X | +| image_scale_b_factor | float | Scaling result: Image scale B factor \[Angstrom^2\] | | X | +| image_scale_cc | float | Scaling result: Image scale CC | | X | +| adu_histogram | Array(uint64) | ADU histogram | | | +| roi_integrals | object | Results of ROI calculation | | X | +| - sum | int64 | Sum of pixels in ROI area \[photons\] | | | +| - sum_square | int64 | Sum of squares of pixels in ROI area \[photons\] | | | +| - pixels | uint64 | Valid pixels in ROI area | | | +| - max_count | int64 | Highest count in ROI area \[photons\] | | | +| - x_weighted_sum | int64 | ROI pixel X position multiplied by photon count \[photons * pixels\] | | | +| - y_weighted_sum | int64 | ROI pixel Y position multiplied by photon count \[photons * pixels\] | | | +| user_data | string | Optional user defined text information - this is image_appendix serialized to JSON format | X | | +| data | Map(string -> Image) | Image | X | | ## Metadata message @@ -286,6 +288,7 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s | - niggli_class | int64 | Integer identifier for the Niggli-reduced Bravais class | | | - system | string | Crystal system: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, cubic | | | rotation_lattice | Array(9 * float) | Real-space lattice basis, flattened 3x3 in row-major order | | +| extra_lattices | Array(Array(9*float)) | Additional indexed lattices (orientation variants); present only if found | | | data_collection_efficiency_image | Array(float) | Per-image data collection efficiency. Missing values are encoded as 0 or 1 depending on producer context | | | spot_count | Array(int32) | Per-image spot count | | | spot_count_ice_ring | Array(int32) | Per-image number of spots within identified ice-ring resolution ranges | | diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp index e566beb9..c3c5769f 100644 --- a/frame_serialize/CBORStream2Deserializer.cpp +++ b/frame_serialize/CBORStream2Deserializer.cpp @@ -725,6 +725,17 @@ namespace { std::vector tmp; GetCBORFloatArray(value, tmp); message.indexing_lattice = CrystalLattice(tmp); + } else if (key == "extra_lattices") { + size_t array_len = GetCBORArrayLen(value); + CborValue array_value; + cborErr(cbor_value_enter_container(&value, &array_value)); + for (size_t i = 0; i < array_len; i++) { + std::vector tmp; + GetCBORFloatArray(array_value, tmp); + if (tmp.size() == 9) + message.extra_lattices.emplace_back(tmp); + } + cborErr(cbor_value_leave_container(&value, &array_value)); } else if (key == "indexing_time") message.indexing_time_s = GetCBORFloat(value); else if (key == "spot_finding_time") @@ -1225,6 +1236,8 @@ namespace { message.unit_cell = ProcessUnitCellElement(value); else if (key == "max_spot_count") message.max_spot_count = GetCBORUInt(value); + else if (key == "max_extra_lattices") + message.max_extra_lattices = GetCBORUInt(value); else if (key == "threshold_energy") message.threshold_energy = ProcessThresholdEnergy(value); else if (key == "image_dtype") { @@ -1408,7 +1421,18 @@ namespace { message.rotation_lattice = CrystalLattice(tmp); } else if (key == "rotation_lattice_type") message.rotation_lattice_type = GetCBORLatticeMessage(value); - else + else if (key == "extra_lattices") { + size_t array_len = GetCBORArrayLen(value); + CborValue array_value; + cborErr(cbor_value_enter_container(&value, &array_value)); + for (size_t i = 0; i < array_len; i++) { + std::vector tmp; + GetCBORFloatArray(array_value, tmp); + if (tmp.size() == 9) + message.extra_lattices.emplace_back(tmp); + } + cborErr(cbor_value_leave_container(&value, &array_value)); + } else cbor_value_advance(&value); return true; } catch (const JFJochException &e) { diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp index 0d2eae87..6c9bc346 100644 --- a/frame_serialize/CBORStream2Serializer.cpp +++ b/frame_serialize/CBORStream2Serializer.cpp @@ -153,6 +153,11 @@ inline void CBOR_ENC(CborEncoder &encoder, const char* key, const std::vector& v) { + cborErr(cbor_encode_tag(&encoder, TagFloatLE)); + cborErr(cbor_encode_byte_string(&encoder, (uint8_t *) v.data(), v.size() * sizeof(float))); +} + inline void CBOR_ENC(CborEncoder &encoder, const char* key, const std::vector& v) { cborErr(cbor_encode_text_stringz(&encoder, key)); cborErr(cbor_encode_tag(&encoder, TagUnsignedInt8Bit)); @@ -659,7 +664,7 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message) CBOR_ENC(mapEncoder, "channels", message.channels); CBOR_ENC(mapEncoder, "max_spot_count", message.max_spot_count); - + CBOR_ENC(mapEncoder, "max_extra_lattices", message.max_extra_lattices); CBOR_ENC(mapEncoder, "storage_cell_number", message.storage_cell_number); CBOR_ENC_RATIONAL(mapEncoder, "storage_cell_delay", message.storage_cell_delay_ns, 1000*1000*1000UL); CBOR_ENC(mapEncoder, "threshold_energy", message.threshold_energy); @@ -717,7 +722,14 @@ void CBORStream2Serializer::SerializeSequenceEnd(const EndMessage& message) { CBOR_ENC(mapEncoder, "rotation_lattice_type", message.rotation_lattice_type); if (message.rotation_lattice.has_value()) CBOR_ENC(mapEncoder, "rotation_lattice", message.rotation_lattice->GetVector()); - + if (!message.extra_lattices.empty()) { + CborEncoder arrayEncoder; + cborErr(cbor_encode_text_stringz(&mapEncoder, "extra_lattices")); + cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.extra_lattices.size())); + for (const auto &el : message.extra_lattices) + CBOR_ENC_FLOAT_ARRAY_NOKEY(arrayEncoder, el.GetVector()); + cborErr(cbor_encoder_close_container(&mapEncoder, &arrayEncoder)); + } CBOR_ENC(mapEncoder, "data_collection_efficiency_image", message.data_collection_efficiency); CBOR_ENC(mapEncoder, "spot_count", message.spot_count); CBOR_ENC(mapEncoder, "spot_count_ice_ring", message.spot_count_ice_ring); @@ -769,6 +781,14 @@ void CBORStream2Serializer::SerializeImageInternal(CborEncoder &mapEncoder, cons CBOR_ENC(mapEncoder, "indexing_lattice_count", message.indexing_lattice_count); if (message.indexing_lattice) CBOR_ENC(mapEncoder, "indexing_lattice", message.indexing_lattice->GetVector()); + if (!message.extra_lattices.empty()) { + CborEncoder arrayEncoder; + cborErr(cbor_encode_text_stringz(&mapEncoder, "extra_lattices")); + cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.extra_lattices.size())); + for (const auto &el : message.extra_lattices) + CBOR_ENC_FLOAT_ARRAY_NOKEY(arrayEncoder, el.GetVector()); + cborErr(cbor_encoder_close_container(&mapEncoder, &arrayEncoder)); + } CBOR_ENC(mapEncoder, "profile_radius", message.profile_radius); CBOR_ENC(mapEncoder, "mosaicity", message.mosaicity_deg); CBOR_ENC(mapEncoder, "integrated_reflections", message.integrated_reflections); diff --git a/image_analysis/IndexAndRefine.cpp b/image_analysis/IndexAndRefine.cpp index b72712d4..82598783 100644 --- a/image_analysis/IndexAndRefine.cpp +++ b/image_analysis/IndexAndRefine.cpp @@ -8,6 +8,7 @@ #include "geom_refinement/XtalOptimizer.h" #include "indexing/AnalyzeIndexing.h" #include "indexing/FFTIndexer.h" +#include "indexing/MultiLatticeSearch.h" #include "lattice_search/LatticeSearch.h" #include "scale_merge/ScaleOnTheFly.h" @@ -56,7 +57,12 @@ IndexAndRefine::IndexingOutcome IndexAndRefine::DetermineLatticeAndSymmetryRotat auto gon = result->axis; if (gon) { const float angle_deg = gon->GetAngle_deg(msg.number) + gon->GetWedge_deg() / 2.0f; - outcome.lattice_candidate = result->lattice.Multiply(gon->GetTransformationAngle(-angle_deg)); + const auto rot_to_image = gon->GetTransformationAngle(-angle_deg); + outcome.lattice_candidate = result->lattice.Multiply(rot_to_image); + + outcome.extra_lattice_candidates.reserve(result->extra_lattices.size()); + for (const auto &el : result->extra_lattices) + outcome.extra_lattice_candidates.push_back(el.Multiply(rot_to_image)); } outcome.experiment.BeamX_pxl(result->geom.GetBeamX_pxl()) @@ -113,6 +119,20 @@ IndexAndRefine::IndexingOutcome IndexAndRefine::DetermineLatticeAndSymmetry(Data }; outcome.lattice_candidate = sym_result.conventional; } + + // Multi-lattice search for stills: keep extra lattices that share the + // reference unit cell but differ only in orientation. Quick refinement + // (orientation only) is done later in RefineGeometryIfNeeded. + if (indexer_result.lattice.size() > 1) { + auto ml_latt = MultiLatticeSearch(indexer_result.lattice); + for (auto &ml : ml_latt) { + if (outcome.extra_lattice_candidates.size() >= experiment.GetIndexingSettings().GetMaxExtraLattices()) + break; + RotMatrix rot(ml.rotation_vector.Length(), ml.rotation_vector.Normalize()); + outcome.extra_lattice_candidates.push_back(outcome.lattice_candidate->Multiply(rot)); + } + } + } } @@ -166,6 +186,28 @@ void IndexAndRefine::RefineGeometryIfNeeded(DataMessage &msg, IndexAndRefine::In if (outcome.symmetry.crystal_system == gemmi::CrystalSystem::Monoclinic) outcome.lattice_candidate->ReorderMonoclinic(); + // Quick orientation-only refinement of extra lattices (stills path). + // Cell, beam center, detector geometry are taken from the first lattice. + if (!experiment.IsRotationIndexing() && !outcome.extra_lattice_candidates.empty()) { + for (auto &el : outcome.extra_lattice_candidates) { + XtalOptimizerData data_extra{ + .geom = data.geom, + .latt = el, + .crystal_system = data.crystal_system, + .min_spots = experiment.GetIndexingSettings().GetViableCellMinSpots(), + .refine_beam_center = false, + .refine_distance_mm = false, + .refine_detector_angles = false, + .refine_unit_cell = false, + .refine_rotation_axis = false, + .index_ice_rings = experiment.GetIndexingSettings().GetIndexIceRings(), + .max_time = 0.02 + }; + XtalOptimizerRotationOnly(data_extra, msg.spots, 0.1); + el = data_extra.latt; + } + } + if (outcome.beam_center_updated) { msg.beam_corr_x = data.beam_corr_x; msg.beam_corr_y = data.beam_corr_y; @@ -296,7 +338,7 @@ void IndexAndRefine::ProcessImage(DataMessage &msg, if (!outcome.lattice_candidate.has_value()) return; - if (!AnalyzeIndexing(msg, outcome.experiment, *outcome.lattice_candidate)) + if (!AnalyzeIndexing(msg, outcome.experiment, *outcome.lattice_candidate, outcome.extra_lattice_candidates)) return; { diff --git a/image_analysis/IndexAndRefine.h b/image_analysis/IndexAndRefine.h index eab212a0..8df60d21 100644 --- a/image_analysis/IndexAndRefine.h +++ b/image_analysis/IndexAndRefine.h @@ -35,6 +35,7 @@ class IndexAndRefine { struct IndexingOutcome { std::optional lattice_candidate; + std::vector extra_lattice_candidates; DiffractionExperiment experiment; LatticeMessage symmetry{ .centering = 'P', diff --git a/image_analysis/indexing/AnalyzeIndexing.cpp b/image_analysis/indexing/AnalyzeIndexing.cpp index a8a682c8..a85bd286 100644 --- a/image_analysis/indexing/AnalyzeIndexing.cpp +++ b/image_analysis/indexing/AnalyzeIndexing.cpp @@ -295,7 +295,8 @@ namespace { bool AnalyzeIndexing(DataMessage &message, const DiffractionExperiment &experiment, - const CrystalLattice &latt) { + const CrystalLattice &latt, + const std::vector &extra_lattices) { auto start_time = std::chrono::steady_clock::now(); std::vector indexed_spots(message.spots.size()); @@ -356,13 +357,67 @@ bool AnalyzeIndexing(DataMessage &message, assert(indexed_spots.size() == message.spots.size()); for (int i = 0; i < message.spots.size(); i++) { message.spots[i].indexed = indexed_spots[i]; - message.spots[i].lattice = 0; + message.spots[i].lattice = indexed_spots[i] ? 0 : -1; } message.profile_radius = FitProfileRadius(message.spots); message.spot_count_indexed = nspots_indexed; message.indexing_lattice = latt; message.indexing_unit_cell = latt.GetUnitCell(); message.mosaicity_deg = CalcMosaicityXDS(experiment, message.spots, astar, bstar, cstar); + + // Assign remaining (unindexed) spots to extra lattices, in order. + // Spots already assigned to the main lattice (lattice == 0) are never + // overwritten. Each extra lattice gets index 1, 2, 3, ... + const size_t n_extra = std::min(extra_lattices.size(), experiment.GetIndexingSettings().GetMaxExtraLattices()); + message.extra_lattices.clear(); + message.extra_lattices.reserve(n_extra); + + for (size_t li = 0; li < n_extra; li++) { + const CrystalLattice &el = extra_lattices[li]; + + const Coord ea = el.Vec0(); + const Coord eb = el.Vec1(); + const Coord ec = el.Vec2(); + const Coord east = el.Astar(); + const Coord ebst = el.Bstar(); + const Coord ecst = el.Cstar(); + + const int64_t lattice_id = static_cast(li) + 1; + + for (int i = 0; i < message.spots.size(); i++) { + // Do not overwrite spots already assigned to a lattice + if (message.spots[i].lattice >= 0) + continue; + + auto recip = message.spots[i].ReciprocalCoord(geom); + + float h_fp = recip * ea; + float k_fp = recip * eb; + float l_fp = recip * ec; + + float h_frac = h_fp - std::round(h_fp); + float k_frac = k_fp - std::round(k_fp); + float l_frac = l_fp - std::round(l_fp); + + float norm_sq = h_frac * h_frac + k_frac * k_frac + l_frac * l_frac; + + if (norm_sq < indexing_tolerance_sq) { + Coord recip_pred = std::round(h_fp) * east + + std::round(k_fp) * ebst + + std::round(l_fp) * ecst; + message.spots[i].indexed = true; + message.spots[i].lattice = lattice_id; + message.spots[i].dist_ewald_sphere = geom.DistFromEwaldSphere(recip_pred); + message.spots[i].h = std::lround(h_fp); + message.spots[i].k = std::lround(k_fp); + message.spots[i].l = std::lround(l_fp); + } + } + + message.extra_lattices.push_back(el); + } + + message.indexing_lattice_count = static_cast(1 + message.extra_lattices.size()); outcome = true; } } diff --git a/image_analysis/indexing/AnalyzeIndexing.h b/image_analysis/indexing/AnalyzeIndexing.h index ae0213cc..a2b347be 100644 --- a/image_analysis/indexing/AnalyzeIndexing.h +++ b/image_analysis/indexing/AnalyzeIndexing.h @@ -11,6 +11,7 @@ constexpr static float min_percentage_spots = 0.20f; bool AnalyzeIndexing(DataMessage &message, const DiffractionExperiment &experiment, - const CrystalLattice &latt); + const CrystalLattice &latt, + const std::vector &extra_lattices = {}); diff --git a/receiver/JFJochReceiver.cpp b/receiver/JFJochReceiver.cpp index da9367c9..ebc92658 100644 --- a/receiver/JFJochReceiver.cpp +++ b/receiver/JFJochReceiver.cpp @@ -172,6 +172,7 @@ void JFJochReceiver::SendEndMessage() { .niggli_class = rotation_indexer_ret->search_result.niggli_class, .crystal_system = rotation_indexer_ret->search_result.system }; + message.extra_lattices = rotation_indexer_ret->extra_lattices; rotation_indexing_lattice = rotation_indexer_ret->lattice; } message.unit_cell = indexer.GetConsensusUnitCell(); diff --git a/writer/HDF5DataFilePluginMX.cpp b/writer/HDF5DataFilePluginMX.cpp index e49ac866..e0318c4f 100644 --- a/writer/HDF5DataFilePluginMX.cpp +++ b/writer/HDF5DataFilePluginMX.cpp @@ -46,7 +46,9 @@ inline std::string to_bravais_code(const std::optional &lm_opt) } HDF5DataFilePluginMX::HDF5DataFilePluginMX(const StartMessage &msg) - : max_spots(msg.max_spot_count), indexing(msg.indexing_algorithm != IndexingAlgorithmEnum::None) { + : max_spots(msg.max_spot_count), + max_extra_lattices(msg.max_extra_lattices), + indexing(msg.indexing_algorithm != IndexingAlgorithmEnum::None) { } void HDF5DataFilePluginMX::OpenFile(HDF5File &data_file, const DataMessage &msg, size_t images_per_file) { @@ -74,11 +76,11 @@ void HDF5DataFilePluginMX::OpenFile(HDF5File &data_file, const DataMessage &msg, spot_l.reserve(max_spots * images_per_file); spot_lattice.reserve(max_spots * images_per_file); spot_dist_ewald.reserve(max_spots * images_per_file); - if (indexing) + if (indexing) { spot_indexed.reserve(max_spots * images_per_file); - if (indexing) indexed_lattice.reserve(images_per_file * 9); - + extra_lattices.reserve(images_per_file * max_extra_lattices * 9); + } beam_corr_x.reserve(images_per_file); beam_corr_y.reserve(images_per_file); @@ -122,10 +124,11 @@ void HDF5DataFilePluginMX::Write(const DataMessage &msg, uint64_t image_number) spot_lattice.resize(max_spots * (max_image_number + 1), -1); spot_dist_ewald.resize(max_spots * (max_image_number + 1), NAN); - if (indexing) + if (indexing) { spot_indexed.resize(max_spots * (max_image_number + 1)); - if (indexing) indexed_lattice.resize((max_image_number + 1) * 9, NAN); + extra_lattices.resize((max_image_number + 1) * max_extra_lattices * 9, NAN); + } } uint32_t spot_cnt = std::min(msg.spots.size(), max_spots); @@ -172,6 +175,18 @@ void HDF5DataFilePluginMX::Write(const DataMessage &msg, uint64_t image_number) indexed_lattice[image_number * 9 + i] = NAN; } + for (size_t li = 0; li < max_extra_lattices; li++) { + const size_t base = (image_number * max_extra_lattices + li) * 9; + if (li < msg.extra_lattices.size()) { + auto tmp = msg.extra_lattices[li].GetVector(); + for (int i = 0; i < 9; i++) + extra_lattices[base + i] = tmp[i]; + } else { + for (int i = 0; i < 9; i++) + extra_lattices[base + i] = NAN; + } + } + if (msg.lattice_type) { bravais_lattice[image_number] = to_bravais_code(msg.lattice_type); niggli_class[image_number] = msg.lattice_type->niggli_class; @@ -228,6 +243,11 @@ void HDF5DataFilePluginMX::WriteFinal(HDF5File &data_file) { if (!indexed_lattice.empty()) data_file.SaveVector("/entry/MX/latticeIndexed", indexed_lattice, {(hsize_t) (max_image_number + 1), 9}) ->Units("Angstrom"); + if (!extra_lattices.empty()) + data_file.SaveVector("/entry/MX/extraLattices", extra_lattices, + {(hsize_t) (max_image_number + 1), (hsize_t) max_extra_lattices, 9}) + ->Units("Angstrom"); + if (!bkg_estimate.empty()) data_file.SaveVector("/entry/MX/bkgEstimate", bkg_estimate.vec()); if (!profile_radius.empty()) diff --git a/writer/HDF5DataFilePluginMX.h b/writer/HDF5DataFilePluginMX.h index c239de96..8a5dd6ef 100644 --- a/writer/HDF5DataFilePluginMX.h +++ b/writer/HDF5DataFilePluginMX.h @@ -8,6 +8,7 @@ class HDF5DataFilePluginMX : public HDF5DataFilePlugin { const size_t max_spots; + const size_t max_extra_lattices; const bool indexing; // spots std::vector spot_x; @@ -35,6 +36,7 @@ class HDF5DataFilePluginMX : public HDF5DataFilePlugin { // indexing AutoIncrVector indexed; std::vector indexed_lattice; + std::vector extra_lattices; // [nimages, max_extra_lattices, 9], NaN-filled // crystal AutoIncrVector profile_radius{NAN}; -- 2.52.0 From f9eee954de300954161a0e785bcc54b41a671675 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 16:29:54 +0200 Subject: [PATCH 34/46] Multi lattice search: Small changes (WIP) --- common/JFJochMessages.h | 5 ++--- frame_serialize/CBORStream2Deserializer.cpp | 4 ++-- frame_serialize/CBORStream2Serializer.cpp | 12 ++++++------ image_analysis/indexing/AnalyzeIndexing.cpp | 8 ++++---- receiver/JFJochReceiver.cpp | 2 +- receiver/JFJochReceiverPlots.cpp | 2 +- writer/HDF5DataFilePluginMX.cpp | 4 ++-- 7 files changed, 18 insertions(+), 19 deletions(-) diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index ccc45015..4aaf580a 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -112,9 +112,8 @@ struct DataMessage { std::optional bkg_estimate; std::optional indexing_result; - std::optional indexing_lattice_count; std::optional indexing_lattice; - std::vector extra_lattices; + std::vector indexing_extra_lattices; std::optional indexing_unit_cell; std::optional spot_count_indexed; @@ -330,7 +329,7 @@ struct EndMessage { std::optional rotation_lattice_type; std::optional rotation_lattice; - std::vector extra_lattices; + std::vector rotation_extra_lattices; std::optional unit_cell; // Vectors with end result: diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp index c3c5769f..6c26151d 100644 --- a/frame_serialize/CBORStream2Deserializer.cpp +++ b/frame_serialize/CBORStream2Deserializer.cpp @@ -733,7 +733,7 @@ namespace { std::vector tmp; GetCBORFloatArray(array_value, tmp); if (tmp.size() == 9) - message.extra_lattices.emplace_back(tmp); + message.indexing_extra_lattices.emplace_back(tmp); } cborErr(cbor_value_leave_container(&value, &array_value)); } else if (key == "indexing_time") @@ -1429,7 +1429,7 @@ namespace { std::vector tmp; GetCBORFloatArray(array_value, tmp); if (tmp.size() == 9) - message.extra_lattices.emplace_back(tmp); + message.rotation_extra_lattices.emplace_back(tmp); } cborErr(cbor_value_leave_container(&value, &array_value)); } else diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp index 6c9bc346..8b636427 100644 --- a/frame_serialize/CBORStream2Serializer.cpp +++ b/frame_serialize/CBORStream2Serializer.cpp @@ -722,11 +722,11 @@ void CBORStream2Serializer::SerializeSequenceEnd(const EndMessage& message) { CBOR_ENC(mapEncoder, "rotation_lattice_type", message.rotation_lattice_type); if (message.rotation_lattice.has_value()) CBOR_ENC(mapEncoder, "rotation_lattice", message.rotation_lattice->GetVector()); - if (!message.extra_lattices.empty()) { + if (!message.rotation_extra_lattices.empty()) { CborEncoder arrayEncoder; cborErr(cbor_encode_text_stringz(&mapEncoder, "extra_lattices")); - cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.extra_lattices.size())); - for (const auto &el : message.extra_lattices) + cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.rotation_extra_lattices.size())); + for (const auto &el : message.rotation_extra_lattices) CBOR_ENC_FLOAT_ARRAY_NOKEY(arrayEncoder, el.GetVector()); cborErr(cbor_encoder_close_container(&mapEncoder, &arrayEncoder)); } @@ -781,11 +781,11 @@ void CBORStream2Serializer::SerializeImageInternal(CborEncoder &mapEncoder, cons CBOR_ENC(mapEncoder, "indexing_lattice_count", message.indexing_lattice_count); if (message.indexing_lattice) CBOR_ENC(mapEncoder, "indexing_lattice", message.indexing_lattice->GetVector()); - if (!message.extra_lattices.empty()) { + if (!message.indexing_extra_lattices.empty()) { CborEncoder arrayEncoder; cborErr(cbor_encode_text_stringz(&mapEncoder, "extra_lattices")); - cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.extra_lattices.size())); - for (const auto &el : message.extra_lattices) + cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.indexing_extra_lattices.size())); + for (const auto &el : message.indexing_extra_lattices) CBOR_ENC_FLOAT_ARRAY_NOKEY(arrayEncoder, el.GetVector()); cborErr(cbor_encoder_close_container(&mapEncoder, &arrayEncoder)); } diff --git a/image_analysis/indexing/AnalyzeIndexing.cpp b/image_analysis/indexing/AnalyzeIndexing.cpp index a85bd286..964269d8 100644 --- a/image_analysis/indexing/AnalyzeIndexing.cpp +++ b/image_analysis/indexing/AnalyzeIndexing.cpp @@ -369,8 +369,8 @@ bool AnalyzeIndexing(DataMessage &message, // Spots already assigned to the main lattice (lattice == 0) are never // overwritten. Each extra lattice gets index 1, 2, 3, ... const size_t n_extra = std::min(extra_lattices.size(), experiment.GetIndexingSettings().GetMaxExtraLattices()); - message.extra_lattices.clear(); - message.extra_lattices.reserve(n_extra); + message.indexing_extra_lattices.clear(); + message.indexing_extra_lattices.reserve(n_extra); for (size_t li = 0; li < n_extra; li++) { const CrystalLattice &el = extra_lattices[li]; @@ -414,10 +414,10 @@ bool AnalyzeIndexing(DataMessage &message, } } - message.extra_lattices.push_back(el); + message.indexing_extra_lattices.push_back(el); } - message.indexing_lattice_count = static_cast(1 + message.extra_lattices.size()); + message.indexing_lattice_count = static_cast(1 + message.indexing_extra_lattices.size()); outcome = true; } } diff --git a/receiver/JFJochReceiver.cpp b/receiver/JFJochReceiver.cpp index ebc92658..64e82e33 100644 --- a/receiver/JFJochReceiver.cpp +++ b/receiver/JFJochReceiver.cpp @@ -172,7 +172,7 @@ void JFJochReceiver::SendEndMessage() { .niggli_class = rotation_indexer_ret->search_result.niggli_class, .crystal_system = rotation_indexer_ret->search_result.system }; - message.extra_lattices = rotation_indexer_ret->extra_lattices; + message.rotation_extra_lattices = rotation_indexer_ret->extra_lattices; rotation_indexing_lattice = rotation_indexer_ret->lattice; } message.unit_cell = indexer.GetConsensusUnitCell(); diff --git a/receiver/JFJochReceiverPlots.cpp b/receiver/JFJochReceiverPlots.cpp index 3f7e2599..987d1015 100644 --- a/receiver/JFJochReceiverPlots.cpp +++ b/receiver/JFJochReceiverPlots.cpp @@ -168,7 +168,7 @@ void JFJochReceiverPlots::Add(const DataMessage &msg, const AzimuthalIntegration indexing_uc_gamma.AddElement(msg.number, msg.indexing_unit_cell->gamma); } - indexing_lattice_count.AddElement(msg.number, msg.indexing_lattice_count); + indexing_lattice_count.AddElement(msg.number, msg.indexing_extra_lattices.size()); beam_center_x.AddElement(msg.number, msg.beam_corr_x); beam_center_y.AddElement(msg.number, msg.beam_corr_y); diff --git a/writer/HDF5DataFilePluginMX.cpp b/writer/HDF5DataFilePluginMX.cpp index e0318c4f..f8473200 100644 --- a/writer/HDF5DataFilePluginMX.cpp +++ b/writer/HDF5DataFilePluginMX.cpp @@ -177,8 +177,8 @@ void HDF5DataFilePluginMX::Write(const DataMessage &msg, uint64_t image_number) for (size_t li = 0; li < max_extra_lattices; li++) { const size_t base = (image_number * max_extra_lattices + li) * 9; - if (li < msg.extra_lattices.size()) { - auto tmp = msg.extra_lattices[li].GetVector(); + if (li < msg.indexing_extra_lattices.size()) { + auto tmp = msg.indexing_extra_lattices[li].GetVector(); for (int i = 0; i < 9; i++) extra_lattices[base + i] = tmp[i]; } else { -- 2.52.0 From ac7e0e5145ff304b1cc9ee93f0c93d972c1a78ad Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 16:36:18 +0200 Subject: [PATCH 35/46] CBOR: Fixes --- docs/CBOR.md | 5 ++--- frame_serialize/CBORStream2Deserializer.cpp | 6 ++---- frame_serialize/CBORStream2Serializer.cpp | 5 ++--- 3 files changed, 6 insertions(+), 10 deletions(-) diff --git a/docs/CBOR.md b/docs/CBOR.md index 2c4c8869..bdca03d4 100644 --- a/docs/CBOR.md +++ b/docs/CBOR.md @@ -163,9 +163,8 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s | az_int_std | Array(float) | Standard deviation for azimuthal integration. (NaN for less than 2 samples) | | | | az_int_count | Array(uint64) | Number of pixels contributing to azimuthal bin | | | | indexing_result | bool | Indexing successful | | | -| indexing_lattice_count | uint64 | Number of lattices found in indexing | | X | | indexing_lattice | Array(9 * float) | Indexing result real lattice; present only if indexed | | X | -| extra_lattices | Array(Array(9*float)) | Additional indexed lattices (orientation variants); present only if found | | | +| indexing_extra_lattices | Array(Array(9*float)) | Additional indexed lattices (orientation variants); present only if found | | | | indexing_unit_cell | object | Indexing result unit cell: a, b, c \[angstrom\] and alpha, beta, gamma \[degree\]; present only if indexed | | X | | | | Unit cell is redundant to lattice - yet to simplify downstream programs to analyze results, both are provided | | | | profile_radius | float | Profile radius of the image - describes distance of observed reflections from the Ewald sphere \[Angstrom^-1\] | | | @@ -288,7 +287,7 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s | - niggli_class | int64 | Integer identifier for the Niggli-reduced Bravais class | | | - system | string | Crystal system: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, cubic | | | rotation_lattice | Array(9 * float) | Real-space lattice basis, flattened 3x3 in row-major order | | -| extra_lattices | Array(Array(9*float)) | Additional indexed lattices (orientation variants); present only if found | | +| rotation_extra_lattices | Array(Array(9*float)) | Additional indexed lattices (orientation variants); present only if found | | | data_collection_efficiency_image | Array(float) | Per-image data collection efficiency. Missing values are encoded as 0 or 1 depending on producer context | | | spot_count | Array(int32) | Per-image spot count | | | spot_count_ice_ring | Array(int32) | Per-image number of spots within identified ice-ring resolution ranges | | diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp index 6c26151d..ac8bcdd8 100644 --- a/frame_serialize/CBORStream2Deserializer.cpp +++ b/frame_serialize/CBORStream2Deserializer.cpp @@ -719,13 +719,11 @@ namespace { GetCBORUInt64Array(value, message.az_int_profile_count); else if (key == "indexing_result") message.indexing_result = GetCBORBool(value); - else if (key == "indexing_lattice_count") - message.indexing_lattice_count = GetCBORUInt(value); else if (key == "indexing_lattice") { std::vector tmp; GetCBORFloatArray(value, tmp); message.indexing_lattice = CrystalLattice(tmp); - } else if (key == "extra_lattices") { + } else if (key == "indexing_extra_lattices") { size_t array_len = GetCBORArrayLen(value); CborValue array_value; cborErr(cbor_value_enter_container(&value, &array_value)); @@ -1421,7 +1419,7 @@ namespace { message.rotation_lattice = CrystalLattice(tmp); } else if (key == "rotation_lattice_type") message.rotation_lattice_type = GetCBORLatticeMessage(value); - else if (key == "extra_lattices") { + else if (key == "rotation_extra_lattices") { size_t array_len = GetCBORArrayLen(value); CborValue array_value; cborErr(cbor_value_enter_container(&value, &array_value)); diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp index 8b636427..5312ab08 100644 --- a/frame_serialize/CBORStream2Serializer.cpp +++ b/frame_serialize/CBORStream2Serializer.cpp @@ -724,7 +724,7 @@ void CBORStream2Serializer::SerializeSequenceEnd(const EndMessage& message) { CBOR_ENC(mapEncoder, "rotation_lattice", message.rotation_lattice->GetVector()); if (!message.rotation_extra_lattices.empty()) { CborEncoder arrayEncoder; - cborErr(cbor_encode_text_stringz(&mapEncoder, "extra_lattices")); + cborErr(cbor_encode_text_stringz(&mapEncoder, "rotation_extra_lattices")); cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.rotation_extra_lattices.size())); for (const auto &el : message.rotation_extra_lattices) CBOR_ENC_FLOAT_ARRAY_NOKEY(arrayEncoder, el.GetVector()); @@ -778,12 +778,11 @@ void CBORStream2Serializer::SerializeImageInternal(CborEncoder &mapEncoder, cons CBOR_ENC(mapEncoder, "az_int_profile_count", message.az_int_profile_count); CBOR_ENC(mapEncoder, "indexing_result", message.indexing_result); - CBOR_ENC(mapEncoder, "indexing_lattice_count", message.indexing_lattice_count); if (message.indexing_lattice) CBOR_ENC(mapEncoder, "indexing_lattice", message.indexing_lattice->GetVector()); if (!message.indexing_extra_lattices.empty()) { CborEncoder arrayEncoder; - cborErr(cbor_encode_text_stringz(&mapEncoder, "extra_lattices")); + cborErr(cbor_encode_text_stringz(&mapEncoder, "indexing_extra_lattices")); cborErr(cbor_encoder_create_array(&mapEncoder, &arrayEncoder, message.indexing_extra_lattices.size())); for (const auto &el : message.indexing_extra_lattices) CBOR_ENC_FLOAT_ARRAY_NOKEY(arrayEncoder, el.GetVector()); -- 2.52.0 From bf305b33d170c25f367b5a65791fefdb8b9205d4 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 16:38:06 +0200 Subject: [PATCH 36/46] CBOR: Fixes --- image_analysis/indexing/AnalyzeIndexing.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/image_analysis/indexing/AnalyzeIndexing.cpp b/image_analysis/indexing/AnalyzeIndexing.cpp index 964269d8..99b8c18b 100644 --- a/image_analysis/indexing/AnalyzeIndexing.cpp +++ b/image_analysis/indexing/AnalyzeIndexing.cpp @@ -416,8 +416,6 @@ bool AnalyzeIndexing(DataMessage &message, message.indexing_extra_lattices.push_back(el); } - - message.indexing_lattice_count = static_cast(1 + message.indexing_extra_lattices.size()); outcome = true; } } -- 2.52.0 From fa9b5c685f3fdf9814770cbc689600f41c728c4f Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Fri, 5 Jun 2026 16:39:44 +0200 Subject: [PATCH 37/46] Fix --- receiver/JFJochReceiverPlots.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/receiver/JFJochReceiverPlots.cpp b/receiver/JFJochReceiverPlots.cpp index 987d1015..f084a098 100644 --- a/receiver/JFJochReceiverPlots.cpp +++ b/receiver/JFJochReceiverPlots.cpp @@ -167,8 +167,12 @@ void JFJochReceiverPlots::Add(const DataMessage &msg, const AzimuthalIntegration indexing_uc_beta.AddElement(msg.number, msg.indexing_unit_cell->beta); indexing_uc_gamma.AddElement(msg.number, msg.indexing_unit_cell->gamma); } - - indexing_lattice_count.AddElement(msg.number, msg.indexing_extra_lattices.size()); + if (msg.indexing_result.has_value()) { + if (!msg.indexing_result.value()) + indexing_lattice_count.AddElement(msg.number, 0); + else + indexing_lattice_count.AddElement(msg.number, msg.indexing_extra_lattices.size()); + } beam_center_x.AddElement(msg.number, msg.beam_corr_x); beam_center_y.AddElement(msg.number, msg.beam_corr_y); -- 2.52.0 From 83377ef3d8dcdd566b9c008ca93ad6706eb4016a Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Sat, 6 Jun 2026 22:29:42 +0200 Subject: [PATCH 38/46] Fixes from Claude Code (to be tested) --- image_analysis/IndexAndRefine.cpp | 21 +++++- image_analysis/IndexAndRefine.h | 1 + .../indexing/MultiLatticeSearch.cpp | 74 +++++++++++-------- 3 files changed, 60 insertions(+), 36 deletions(-) diff --git a/image_analysis/IndexAndRefine.cpp b/image_analysis/IndexAndRefine.cpp index 82598783..d436f2a7 100644 --- a/image_analysis/IndexAndRefine.cpp +++ b/image_analysis/IndexAndRefine.cpp @@ -120,14 +120,16 @@ IndexAndRefine::IndexingOutcome IndexAndRefine::DetermineLatticeAndSymmetry(Data outcome.lattice_candidate = sym_result.conventional; } - // Multi-lattice search for stills: keep extra lattices that share the - // reference unit cell but differ only in orientation. Quick refinement - // (orientation only) is done later in RefineGeometryIfNeeded. + // Multi-lattice search for stills: store rotations that map the reference + // lattice to each accepted extra lattice. Candidates are materialized later + // in RefineGeometryIfNeeded so they're rooted in the refined (and, for + // monoclinic, reordered) main lattice. if (indexer_result.lattice.size() > 1) { auto ml_latt = MultiLatticeSearch(indexer_result.lattice); for (auto &ml : ml_latt) { - if (outcome.extra_lattice_candidates.size() >= experiment.GetIndexingSettings().GetMaxExtraLattices()) + if (outcome.extra_lattice_rotations.size() >= experiment.GetIndexingSettings().GetMaxExtraLattices()) break; + outcome.extra_lattice_rotations.push_back(ml.rotation_vector); RotMatrix rot(ml.rotation_vector.Length(), ml.rotation_vector.Normalize()); outcome.extra_lattice_candidates.push_back(outcome.lattice_candidate->Multiply(rot)); } @@ -186,6 +188,17 @@ void IndexAndRefine::RefineGeometryIfNeeded(DataMessage &msg, IndexAndRefine::In if (outcome.symmetry.crystal_system == gemmi::CrystalSystem::Monoclinic) outcome.lattice_candidate->ReorderMonoclinic(); + // Rebuild extra-lattice candidates from the refined (and possibly reordered) main + // lattice so they share its cell and obtuse-beta convention. + if (!outcome.extra_lattice_rotations.empty()) { + outcome.extra_lattice_candidates.clear(); + outcome.extra_lattice_candidates.reserve(outcome.extra_lattice_rotations.size()); + for (const auto &rv : outcome.extra_lattice_rotations) { + RotMatrix rot(rv.Length(), rv.Normalize()); + outcome.extra_lattice_candidates.push_back(outcome.lattice_candidate->Multiply(rot)); + } + } + // Quick orientation-only refinement of extra lattices (stills path). // Cell, beam center, detector geometry are taken from the first lattice. if (!experiment.IsRotationIndexing() && !outcome.extra_lattice_candidates.empty()) { diff --git a/image_analysis/IndexAndRefine.h b/image_analysis/IndexAndRefine.h index 8df60d21..0f03ee97 100644 --- a/image_analysis/IndexAndRefine.h +++ b/image_analysis/IndexAndRefine.h @@ -36,6 +36,7 @@ class IndexAndRefine { struct IndexingOutcome { std::optional lattice_candidate; std::vector extra_lattice_candidates; + std::vector extra_lattice_rotations; DiffractionExperiment experiment; LatticeMessage symmetry{ .centering = 'P', diff --git a/image_analysis/indexing/MultiLatticeSearch.cpp b/image_analysis/indexing/MultiLatticeSearch.cpp index 3080fc31..d40bc3fb 100644 --- a/image_analysis/indexing/MultiLatticeSearch.cpp +++ b/image_analysis/indexing/MultiLatticeSearch.cpp @@ -3,6 +3,9 @@ #include "MultiLatticeSearch.h" +#include +#include + #include namespace { @@ -33,30 +36,42 @@ namespace { } return R; } -} -CrystalLattice Transform(const CrystalLattice &in_latt, int i) { - CrystalLattice latt = in_latt; - switch (i) { - case 0: - break; - case 1: - latt.FlipSign(0); - latt.FlipSign(1); - break; - case 2: - latt.FlipSign(0); - latt.FlipSign(2); - break; - case 3: - latt.FlipSign(1); - latt.FlipSign(2); - break; - default: - break; + struct BasisOp { + std::array perm; + std::array signs; // each +1 or -1 + }; + + // The 24 right-handed (det=+1) sign+permutation reparametrizations of a basis (a,b,c). + // Identity (perm 0,1,2; signs +,+,+) is first so it's preferred when several ops match + // the reference cell. For low-symmetry cells, only a handful pass is_close; for cubic, + // all 24 may pass and the first-match rule keeps behavior deterministic. + const std::vector &RightHandedOps() { + static const std::vector ops = []() { + std::vector v; + const std::array, 6> perms = {{ + {0, 1, 2}, {1, 2, 0}, {2, 0, 1}, // even + {0, 2, 1}, {2, 1, 0}, {1, 0, 2} // odd + }}; + for (size_t p = 0; p < perms.size(); p++) { + const int parity = (p < 3) ? +1 : -1; + for (int s0 : {+1, -1}) + for (int s1 : {+1, -1}) + for (int s2 : {+1, -1}) + if (parity * s0 * s1 * s2 == +1) + v.push_back({perms[p], {s0, s1, s2}}); + } + return v; + }(); + return ops; } - return latt; + CrystalLattice ApplyBasisOp(const CrystalLattice &in, const BasisOp &op) { + const Coord v[3] = {in.Vec0(), in.Vec1(), in.Vec2()}; + return CrystalLattice(v[op.perm[0]] * static_cast(op.signs[0]), + v[op.perm[1]] * static_cast(op.signs[1]), + v[op.perm[2]] * static_cast(op.signs[2])); + } } std::vector MultiLatticeSearch(const std::vector &lattices, @@ -70,9 +85,8 @@ std::vector MultiLatticeSearch(const std::vector MultiLatticeSearch(const std::vector(rod.x()), - static_cast(rod.y()), - static_cast(rod.z())); - - if (found) - continue; - ret.push_back({rotation_vector}); - found = true; + ret.push_back({Coord(static_cast(rod.x()), + static_cast(rod.y()), + static_cast(rod.z()))}); + break; } } -- 2.52.0 From 2bffb38c8217aed16d438633165dd4b97c370dbc Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Sun, 7 Jun 2026 13:43:47 +0200 Subject: [PATCH 39/46] IndexingSettings: Figure out max extra lattices in StartMessage + make it changeable --- common/DiffractionExperiment.cpp | 1 + common/IndexingSettings.cpp | 9 ++++++++- common/IndexingSettings.h | 3 +++ 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/common/DiffractionExperiment.cpp b/common/DiffractionExperiment.cpp index c3c22788..ffd5f4ad 100644 --- a/common/DiffractionExperiment.cpp +++ b/common/DiffractionExperiment.cpp @@ -667,6 +667,7 @@ void DiffractionExperiment::FillMessage(StartMessage &message) const { message.pixel_signed = IsPixelSigned(); message.sample_name = GetSampleName(); message.max_spot_count = GetMaxSpotCount(); + message.max_extra_lattices = indexing.GetMaxExtraLattices(); message.pixel_mask_enabled = IsApplyPixelMask(); message.detector_description = GetDetectorDescription(); message.space_group_number = GetSpaceGroupNumber(); diff --git a/common/IndexingSettings.cpp b/common/IndexingSettings.cpp index 3905085c..2de46bcb 100644 --- a/common/IndexingSettings.cpp +++ b/common/IndexingSettings.cpp @@ -215,5 +215,12 @@ IndexingSettings &IndexingSettings::BlockingBehavior(bool input) { } int64_t IndexingSettings::GetMaxExtraLattices() const { - return 3; + return max_extra_lattices; +} + +IndexingSettings &IndexingSettings::MaxExtraLattices(int64_t input) { + check_min("Max extra lattices", input, 0); + check_max("Max extra lattices", input, 10); + max_extra_lattices = input; + return *this; } diff --git a/common/IndexingSettings.h b/common/IndexingSettings.h index cca6ba92..6e900440 100644 --- a/common/IndexingSettings.h +++ b/common/IndexingSettings.h @@ -23,6 +23,8 @@ class IndexingSettings { int64_t indexing_threads = 4; int64_t viable_cell_min_spots = 9; + int64_t max_extra_lattices = 2; + bool blocking_behavior = true; bool index_ice_rings = false; @@ -51,6 +53,7 @@ public: IndexingSettings& RotationIndexingMinAngularRange_deg(float input); IndexingSettings& RotationIndexingAngularStride_deg(float input); IndexingSettings& BlockingBehavior(bool input); + IndexingSettings& MaxExtraLattices(int64_t input); [[nodiscard]] int64_t GetViableCellMinSpots() const; [[nodiscard]] IndexingAlgorithmEnum GetAlgorithm() const; -- 2.52.0 From f40197561c1d789968b012910711066092b9a1ca Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Sun, 7 Jun 2026 13:52:12 +0200 Subject: [PATCH 40/46] AzIntEngine: Fix member initialization order UB Members are constructed in declaration order, not initializer-list order. azint_bins and npixel were computed from the integration reference before that reference member was bound, which is undefined behavior and could leave both with garbage values (propagating to GPU buffer sizes). Reorder declarations so integration is bound first. Co-Authored-By: Claude Opus 4.8 --- image_analysis/azint/AzIntEngine.cpp | 4 ++-- image_analysis/azint/AzIntEngine.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/image_analysis/azint/AzIntEngine.cpp b/image_analysis/azint/AzIntEngine.cpp index 99cb8aab..361b4942 100644 --- a/image_analysis/azint/AzIntEngine.cpp +++ b/image_analysis/azint/AzIntEngine.cpp @@ -5,8 +5,8 @@ AzIntEngine::AzIntEngine(const AzimuthalIntegrationMapping &integration) : integration(integration), +azint_bins(integration.GetBinNumber()), npixel(integration.GetPixelToBin().size()), azint_sum(integration.GetBinNumber(), 0.0f), azint_sum2(integration.GetBinNumber(), 0.0f), -azint_count(integration.GetBinNumber(), 0.0f), -azint_bins(integration.GetBinNumber()){} +azint_count(integration.GetBinNumber(), 0.0f){} diff --git a/image_analysis/azint/AzIntEngine.h b/image_analysis/azint/AzIntEngine.h index f8e32096..abe52fcd 100644 --- a/image_analysis/azint/AzIntEngine.h +++ b/image_analysis/azint/AzIntEngine.h @@ -9,9 +9,9 @@ class AzIntEngine { protected: + const AzimuthalIntegrationMapping& integration; const uint16_t azint_bins; const size_t npixel; - const AzimuthalIntegrationMapping& integration; std::vector azint_sum; std::vector azint_sum2; std::vector azint_count; -- 2.52.0 From 1d6d50c162798851832a72187420eb210ccadf0a Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Sun, 7 Jun 2026 13:54:48 +0200 Subject: [PATCH 41/46] AzIntEngineCPU: Skip masked/saturated pixels The GPU kernels exclude sentinel pixels (saturated/masked), but the CPU path summed them blindly, corrupting the azimuthal integration result and diverging from the GPU output. Skip them on the CPU too, deriving the sentinels from the pixel type via std::numeric_limits: the max value (saturated) for any type, plus the min value (masked/bad) for signed types. Co-Authored-By: Claude Opus 4.8 --- image_analysis/azint/AzIntEngineCPU.h | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/image_analysis/azint/AzIntEngineCPU.h b/image_analysis/azint/AzIntEngineCPU.h index 3089cd45..d667a5a1 100644 --- a/image_analysis/azint/AzIntEngineCPU.h +++ b/image_analysis/azint/AzIntEngineCPU.h @@ -3,6 +3,9 @@ #pragma once +#include +#include + #include "AzIntEngine.h" class AzIntEngineCPU : public AzIntEngine { @@ -22,8 +25,19 @@ public: const uint16_t *pixel_to_bin = integration.GetPixelToBin().data(); const float *corrections = integration.Corrections().data(); + using pixel_t = std::remove_cv_t>; + for (int i = 0; i < image.size(); i++) { - const float val = static_cast(image[i]) * corrections[i]; + const pixel_t v = image[i]; + // saturated pixels use the type's max value; for signed types + // masked/bad pixels additionally use the min value + if (v == std::numeric_limits::max()) + continue; + if constexpr (std::is_signed_v) { + if (v == std::numeric_limits::min()) + continue; + } + const float val = static_cast(v) * corrections[i]; const float val_sq = val * val; const uint16_t bin = pixel_to_bin[i]; if (bin < azint_bins) { -- 2.52.0 From 8e4cf98f8ac5e28fda9d18b1d73f761e66730a57 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Sun, 7 Jun 2026 13:55:02 +0200 Subject: [PATCH 42/46] AzIntEngine: Use integer fill value for azint_count azint_count is std::vector; initialize it with 0u instead of the float literal 0.0f. Co-Authored-By: Claude Opus 4.8 --- image_analysis/azint/AzIntEngine.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/image_analysis/azint/AzIntEngine.cpp b/image_analysis/azint/AzIntEngine.cpp index 361b4942..6d68cee0 100644 --- a/image_analysis/azint/AzIntEngine.cpp +++ b/image_analysis/azint/AzIntEngine.cpp @@ -9,4 +9,4 @@ azint_bins(integration.GetBinNumber()), npixel(integration.GetPixelToBin().size()), azint_sum(integration.GetBinNumber(), 0.0f), azint_sum2(integration.GetBinNumber(), 0.0f), -azint_count(integration.GetBinNumber(), 0.0f){} +azint_count(integration.GetBinNumber(), 0u){} -- 2.52.0 From aa50e60f3c1c674bbe03febf59a0644f076bb486 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Sun, 7 Jun 2026 14:00:33 +0200 Subject: [PATCH 43/46] AzIntEngineGPU: Check CUDA errors in constructor cudaGetDeviceProperties and the two host-to-device cudaMemcpy calls in the constructor were not error-checked, unlike the calls in Run(). Wrap them in cuda_err() so failures throw instead of passing silently. Co-Authored-By: Claude Opus 4.8 --- image_analysis/azint/AzIntEngineGPU.cu | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/image_analysis/azint/AzIntEngineGPU.cu b/image_analysis/azint/AzIntEngineGPU.cu index 132f9761..dfd59e32 100644 --- a/image_analysis/azint/AzIntEngineGPU.cu +++ b/image_analysis/azint/AzIntEngineGPU.cu @@ -101,17 +101,17 @@ AzIntEngineGPU::AzIntEngineGPU(const AzimuthalIntegrationMapping &integration, s cpu_count_reg(azint_count) { cudaDeviceProp prop{}; - cudaGetDeviceProperties(&prop, 0); + cuda_err(cudaGetDeviceProperties(&prop, 0)); threads = 128; blocks = 4 * prop.multiProcessorCount; shared_size = prop.sharedMemPerBlock; shared_needed = azint_bins * (2 * sizeof(float) + sizeof(uint32_t)); - cudaMemcpy(gpu_azint_correction, integration.Corrections().data(), sizeof(float) * npixel, - cudaMemcpyHostToDevice); - cudaMemcpy(gpu_pixel_to_bin, integration.GetPixelToBin().data(), sizeof(uint16_t) * npixel, - cudaMemcpyHostToDevice); + cuda_err(cudaMemcpy(gpu_azint_correction, integration.Corrections().data(), sizeof(float) * npixel, + cudaMemcpyHostToDevice)); + cuda_err(cudaMemcpy(gpu_pixel_to_bin, integration.GetPixelToBin().data(), sizeof(uint16_t) * npixel, + cudaMemcpyHostToDevice)); } void AzIntEngineGPU::Run(const ImagePreprocessorBuffer &image, AzimuthalIntegrationProfile &profile) { -- 2.52.0 From 5edf7c7907d444d8bfe311f279f2a55f8526821b Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Sun, 7 Jun 2026 19:10:45 +0200 Subject: [PATCH 44/46] VERSION: 1.0.0-rc.148 --- VERSION | 2 +- broker/gen/model/Azim_int_settings.cpp | 2 +- broker/gen/model/Azim_int_settings.h | 2 +- broker/gen/model/Broker_status.cpp | 2 +- broker/gen/model/Broker_status.h | 2 +- broker/gen/model/Calibration_statistics_inner.cpp | 2 +- broker/gen/model/Calibration_statistics_inner.h | 2 +- broker/gen/model/Dark_mask_settings.cpp | 2 +- broker/gen/model/Dark_mask_settings.h | 2 +- broker/gen/model/Dataset_settings.cpp | 2 +- broker/gen/model/Dataset_settings.h | 2 +- .../model/Dataset_settings_xray_fluorescence_spectrum.cpp | 2 +- .../model/Dataset_settings_xray_fluorescence_spectrum.h | 2 +- broker/gen/model/Detector.cpp | 2 +- broker/gen/model/Detector.h | 2 +- broker/gen/model/Detector_list.cpp | 2 +- broker/gen/model/Detector_list.h | 2 +- broker/gen/model/Detector_list_element.cpp | 2 +- broker/gen/model/Detector_list_element.h | 2 +- broker/gen/model/Detector_module.cpp | 2 +- broker/gen/model/Detector_module.h | 2 +- broker/gen/model/Detector_module_direction.cpp | 2 +- broker/gen/model/Detector_module_direction.h | 2 +- broker/gen/model/Detector_power_state.cpp | 2 +- broker/gen/model/Detector_power_state.h | 2 +- broker/gen/model/Detector_selection.cpp | 2 +- broker/gen/model/Detector_selection.h | 2 +- broker/gen/model/Detector_settings.cpp | 2 +- broker/gen/model/Detector_settings.h | 2 +- broker/gen/model/Detector_state.cpp | 2 +- broker/gen/model/Detector_state.h | 2 +- broker/gen/model/Detector_status.cpp | 2 +- broker/gen/model/Detector_status.h | 2 +- broker/gen/model/Detector_timing.cpp | 2 +- broker/gen/model/Detector_timing.h | 2 +- broker/gen/model/Detector_type.cpp | 2 +- broker/gen/model/Detector_type.h | 2 +- broker/gen/model/Error_message.cpp | 2 +- broker/gen/model/Error_message.h | 2 +- broker/gen/model/File_writer_format.cpp | 2 +- broker/gen/model/File_writer_format.h | 2 +- broker/gen/model/File_writer_settings.cpp | 2 +- broker/gen/model/File_writer_settings.h | 2 +- broker/gen/model/Fpga_status_inner.cpp | 2 +- broker/gen/model/Fpga_status_inner.h | 2 +- broker/gen/model/Geom_refinement_algorithm.cpp | 2 +- broker/gen/model/Geom_refinement_algorithm.h | 2 +- broker/gen/model/Grid_scan.cpp | 2 +- broker/gen/model/Grid_scan.h | 2 +- broker/gen/model/Helpers.cpp | 2 +- broker/gen/model/Helpers.h | 2 +- broker/gen/model/Image_buffer_status.cpp | 2 +- broker/gen/model/Image_buffer_status.h | 2 +- broker/gen/model/Image_format_settings.cpp | 2 +- broker/gen/model/Image_format_settings.h | 2 +- broker/gen/model/Image_pusher_status.cpp | 2 +- broker/gen/model/Image_pusher_status.h | 2 +- broker/gen/model/Image_pusher_type.cpp | 2 +- broker/gen/model/Image_pusher_type.h | 2 +- broker/gen/model/Indexing_algorithm.cpp | 2 +- broker/gen/model/Indexing_algorithm.h | 2 +- broker/gen/model/Indexing_settings.cpp | 2 +- broker/gen/model/Indexing_settings.h | 2 +- broker/gen/model/Instrument_metadata.cpp | 2 +- broker/gen/model/Instrument_metadata.h | 2 +- broker/gen/model/Jfjoch_settings.cpp | 2 +- broker/gen/model/Jfjoch_settings.h | 2 +- broker/gen/model/Jfjoch_statistics.cpp | 2 +- broker/gen/model/Jfjoch_statistics.h | 2 +- broker/gen/model/Measurement_statistics.cpp | 2 +- broker/gen/model/Measurement_statistics.h | 2 +- broker/gen/model/Pcie_devices_inner.cpp | 2 +- broker/gen/model/Pcie_devices_inner.h | 2 +- broker/gen/model/Pixel_mask_statistics.cpp | 2 +- broker/gen/model/Pixel_mask_statistics.h | 2 +- broker/gen/model/Plot.cpp | 2 +- broker/gen/model/Plot.h | 2 +- broker/gen/model/Plot_unit_x.cpp | 2 +- broker/gen/model/Plot_unit_x.h | 2 +- broker/gen/model/Plots.cpp | 2 +- broker/gen/model/Plots.h | 2 +- broker/gen/model/Roi_azim_list.cpp | 2 +- broker/gen/model/Roi_azim_list.h | 2 +- broker/gen/model/Roi_azimuthal.cpp | 2 +- broker/gen/model/Roi_azimuthal.h | 2 +- broker/gen/model/Roi_box.cpp | 2 +- broker/gen/model/Roi_box.h | 2 +- broker/gen/model/Roi_box_list.cpp | 2 +- broker/gen/model/Roi_box_list.h | 2 +- broker/gen/model/Roi_circle.cpp | 2 +- broker/gen/model/Roi_circle.h | 2 +- broker/gen/model/Roi_circle_list.cpp | 2 +- broker/gen/model/Roi_circle_list.h | 2 +- broker/gen/model/Roi_definitions.cpp | 2 +- broker/gen/model/Roi_definitions.h | 2 +- broker/gen/model/Rotation_axis.cpp | 2 +- broker/gen/model/Rotation_axis.h | 2 +- broker/gen/model/Scan_result.cpp | 2 +- broker/gen/model/Scan_result.h | 2 +- broker/gen/model/Scan_result_images_inner.cpp | 2 +- broker/gen/model/Scan_result_images_inner.h | 2 +- broker/gen/model/Spot_finding_settings.cpp | 2 +- broker/gen/model/Spot_finding_settings.h | 2 +- broker/gen/model/Standard_detector_geometry.cpp | 2 +- broker/gen/model/Standard_detector_geometry.h | 2 +- broker/gen/model/Tcp_settings.cpp | 2 +- broker/gen/model/Tcp_settings.h | 2 +- broker/gen/model/Unit_cell.cpp | 2 +- broker/gen/model/Unit_cell.h | 2 +- broker/gen/model/Zeromq_metadata_settings.cpp | 2 +- broker/gen/model/Zeromq_metadata_settings.h | 2 +- broker/gen/model/Zeromq_preview_settings.cpp | 2 +- broker/gen/model/Zeromq_preview_settings.h | 2 +- broker/gen/model/Zeromq_settings.cpp | 2 +- broker/gen/model/Zeromq_settings.h | 2 +- broker/jfjoch_api.yaml | 2 +- broker/redoc-static.html | 4 ++-- docs/CHANGELOG.md | 7 +++++++ docs/conf.py | 2 +- docs/python_client/README.md | 4 ++-- fpga/hdl/action_config.v | 2 +- fpga/pcie_driver/dkms.conf | 2 +- fpga/pcie_driver/install_dkms.sh | 2 +- fpga/pcie_driver/jfjoch_drv.c | 2 +- fpga/pcie_driver/postinstall.sh | 2 +- fpga/pcie_driver/preuninstall.sh | 2 +- frontend/package.json | 2 +- frontend/src/openapi/core/OpenAPI.ts | 2 +- frontend/src/version.ts | 2 +- 129 files changed, 137 insertions(+), 130 deletions(-) diff --git a/VERSION b/VERSION index 52fce327..818acfb8 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.0-rc.147 +1.0.0-rc.148 diff --git a/broker/gen/model/Azim_int_settings.cpp b/broker/gen/model/Azim_int_settings.cpp index 4f1418c6..11fe9c65 100644 --- a/broker/gen/model/Azim_int_settings.cpp +++ b/broker/gen/model/Azim_int_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Azim_int_settings.h b/broker/gen/model/Azim_int_settings.h index 59ca3f74..5cd01b33 100644 --- a/broker/gen/model/Azim_int_settings.h +++ b/broker/gen/model/Azim_int_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.cpp b/broker/gen/model/Broker_status.cpp index 079ef60c..8a251d56 100644 --- a/broker/gen/model/Broker_status.cpp +++ b/broker/gen/model/Broker_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.h b/broker/gen/model/Broker_status.h index 676ae6e9..97da3933 100644 --- a/broker/gen/model/Broker_status.h +++ b/broker/gen/model/Broker_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.cpp b/broker/gen/model/Calibration_statistics_inner.cpp index 505ed9ad..e197bc72 100644 --- a/broker/gen/model/Calibration_statistics_inner.cpp +++ b/broker/gen/model/Calibration_statistics_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.h b/broker/gen/model/Calibration_statistics_inner.h index f7c980d7..af46c06a 100644 --- a/broker/gen/model/Calibration_statistics_inner.h +++ b/broker/gen/model/Calibration_statistics_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.cpp b/broker/gen/model/Dark_mask_settings.cpp index 68e30d67..73bca11b 100644 --- a/broker/gen/model/Dark_mask_settings.cpp +++ b/broker/gen/model/Dark_mask_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.h b/broker/gen/model/Dark_mask_settings.h index f1e0a446..91e88b23 100644 --- a/broker/gen/model/Dark_mask_settings.h +++ b/broker/gen/model/Dark_mask_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.cpp b/broker/gen/model/Dataset_settings.cpp index bb3ae59c..c01a52e2 100644 --- a/broker/gen/model/Dataset_settings.cpp +++ b/broker/gen/model/Dataset_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.h b/broker/gen/model/Dataset_settings.h index e3c68252..c9e5d574 100644 --- a/broker/gen/model/Dataset_settings.h +++ b/broker/gen/model/Dataset_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp index 3039284e..f9a257ea 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp +++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h index f1dd6854..c8579a9b 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h +++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.cpp b/broker/gen/model/Detector.cpp index 7bfd2715..1d842e81 100644 --- a/broker/gen/model/Detector.cpp +++ b/broker/gen/model/Detector.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.h b/broker/gen/model/Detector.h index 11c8d637..f93a0ff1 100644 --- a/broker/gen/model/Detector.h +++ b/broker/gen/model/Detector.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.cpp b/broker/gen/model/Detector_list.cpp index 0bddd3b6..9b941fe8 100644 --- a/broker/gen/model/Detector_list.cpp +++ b/broker/gen/model/Detector_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.h b/broker/gen/model/Detector_list.h index abf37779..e9fee5f8 100644 --- a/broker/gen/model/Detector_list.h +++ b/broker/gen/model/Detector_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.cpp b/broker/gen/model/Detector_list_element.cpp index 3f692cf2..ffa80164 100644 --- a/broker/gen/model/Detector_list_element.cpp +++ b/broker/gen/model/Detector_list_element.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.h b/broker/gen/model/Detector_list_element.h index 31c00b1b..54fa13d5 100644 --- a/broker/gen/model/Detector_list_element.h +++ b/broker/gen/model/Detector_list_element.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.cpp b/broker/gen/model/Detector_module.cpp index 01ce8e49..2b9dc59a 100644 --- a/broker/gen/model/Detector_module.cpp +++ b/broker/gen/model/Detector_module.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.h b/broker/gen/model/Detector_module.h index adf4befe..d7a34aba 100644 --- a/broker/gen/model/Detector_module.h +++ b/broker/gen/model/Detector_module.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.cpp b/broker/gen/model/Detector_module_direction.cpp index 7e741399..23187315 100644 --- a/broker/gen/model/Detector_module_direction.cpp +++ b/broker/gen/model/Detector_module_direction.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.h b/broker/gen/model/Detector_module_direction.h index e3baf78f..9cb45c98 100644 --- a/broker/gen/model/Detector_module_direction.h +++ b/broker/gen/model/Detector_module_direction.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.cpp b/broker/gen/model/Detector_power_state.cpp index 4a40e0a5..2b892a01 100644 --- a/broker/gen/model/Detector_power_state.cpp +++ b/broker/gen/model/Detector_power_state.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.h b/broker/gen/model/Detector_power_state.h index c2d41a28..31de8446 100644 --- a/broker/gen/model/Detector_power_state.h +++ b/broker/gen/model/Detector_power_state.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.cpp b/broker/gen/model/Detector_selection.cpp index 50720cc9..4415d3f3 100644 --- a/broker/gen/model/Detector_selection.cpp +++ b/broker/gen/model/Detector_selection.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.h b/broker/gen/model/Detector_selection.h index a989e1d7..ba7bddd5 100644 --- a/broker/gen/model/Detector_selection.h +++ b/broker/gen/model/Detector_selection.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.cpp b/broker/gen/model/Detector_settings.cpp index 65a2f50e..e20bddcb 100644 --- a/broker/gen/model/Detector_settings.cpp +++ b/broker/gen/model/Detector_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.h b/broker/gen/model/Detector_settings.h index 9feeb53f..5eb002b5 100644 --- a/broker/gen/model/Detector_settings.h +++ b/broker/gen/model/Detector_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.cpp b/broker/gen/model/Detector_state.cpp index 782b4d37..e3dcf3dd 100644 --- a/broker/gen/model/Detector_state.cpp +++ b/broker/gen/model/Detector_state.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.h b/broker/gen/model/Detector_state.h index 3a0fee59..132ebac4 100644 --- a/broker/gen/model/Detector_state.h +++ b/broker/gen/model/Detector_state.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.cpp b/broker/gen/model/Detector_status.cpp index 71afd850..764c261b 100644 --- a/broker/gen/model/Detector_status.cpp +++ b/broker/gen/model/Detector_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.h b/broker/gen/model/Detector_status.h index 6b299ece..db0d32cc 100644 --- a/broker/gen/model/Detector_status.h +++ b/broker/gen/model/Detector_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.cpp b/broker/gen/model/Detector_timing.cpp index aa429a5f..cd9755fa 100644 --- a/broker/gen/model/Detector_timing.cpp +++ b/broker/gen/model/Detector_timing.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.h b/broker/gen/model/Detector_timing.h index a9dac232..884f9c5b 100644 --- a/broker/gen/model/Detector_timing.h +++ b/broker/gen/model/Detector_timing.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.cpp b/broker/gen/model/Detector_type.cpp index fcd3b699..d35154fd 100644 --- a/broker/gen/model/Detector_type.cpp +++ b/broker/gen/model/Detector_type.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.h b/broker/gen/model/Detector_type.h index 88af7002..8067859c 100644 --- a/broker/gen/model/Detector_type.h +++ b/broker/gen/model/Detector_type.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.cpp b/broker/gen/model/Error_message.cpp index 6781be92..d9112175 100644 --- a/broker/gen/model/Error_message.cpp +++ b/broker/gen/model/Error_message.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.h b/broker/gen/model/Error_message.h index 692ccbf4..aa34fcd5 100644 --- a/broker/gen/model/Error_message.h +++ b/broker/gen/model/Error_message.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.cpp b/broker/gen/model/File_writer_format.cpp index 5ba59185..5ef68364 100644 --- a/broker/gen/model/File_writer_format.cpp +++ b/broker/gen/model/File_writer_format.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.h b/broker/gen/model/File_writer_format.h index 88d32bb7..debcdc08 100644 --- a/broker/gen/model/File_writer_format.h +++ b/broker/gen/model/File_writer_format.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.cpp b/broker/gen/model/File_writer_settings.cpp index c4d0adf0..20713375 100644 --- a/broker/gen/model/File_writer_settings.cpp +++ b/broker/gen/model/File_writer_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.h b/broker/gen/model/File_writer_settings.h index b17ffc19..4576af17 100644 --- a/broker/gen/model/File_writer_settings.h +++ b/broker/gen/model/File_writer_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.cpp b/broker/gen/model/Fpga_status_inner.cpp index ec1575b1..e13dac3f 100644 --- a/broker/gen/model/Fpga_status_inner.cpp +++ b/broker/gen/model/Fpga_status_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.h b/broker/gen/model/Fpga_status_inner.h index 26e04be6..d3ebc99c 100644 --- a/broker/gen/model/Fpga_status_inner.h +++ b/broker/gen/model/Fpga_status_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.cpp b/broker/gen/model/Geom_refinement_algorithm.cpp index 3f2ea484..7f3597f4 100644 --- a/broker/gen/model/Geom_refinement_algorithm.cpp +++ b/broker/gen/model/Geom_refinement_algorithm.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.h b/broker/gen/model/Geom_refinement_algorithm.h index 65a5dd1c..68fd567c 100644 --- a/broker/gen/model/Geom_refinement_algorithm.h +++ b/broker/gen/model/Geom_refinement_algorithm.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.cpp b/broker/gen/model/Grid_scan.cpp index 0d596dee..7d9804c7 100644 --- a/broker/gen/model/Grid_scan.cpp +++ b/broker/gen/model/Grid_scan.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.h b/broker/gen/model/Grid_scan.h index 58ece0e1..addb5cc4 100644 --- a/broker/gen/model/Grid_scan.h +++ b/broker/gen/model/Grid_scan.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.cpp b/broker/gen/model/Helpers.cpp index 32a753f1..3a4c3cd2 100644 --- a/broker/gen/model/Helpers.cpp +++ b/broker/gen/model/Helpers.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.h b/broker/gen/model/Helpers.h index 7bbd0424..d48cbd4d 100644 --- a/broker/gen/model/Helpers.h +++ b/broker/gen/model/Helpers.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.cpp b/broker/gen/model/Image_buffer_status.cpp index e823ccdc..e0d4e013 100644 --- a/broker/gen/model/Image_buffer_status.cpp +++ b/broker/gen/model/Image_buffer_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.h b/broker/gen/model/Image_buffer_status.h index 3ed1aca0..83e7747f 100644 --- a/broker/gen/model/Image_buffer_status.h +++ b/broker/gen/model/Image_buffer_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.cpp b/broker/gen/model/Image_format_settings.cpp index 2af077df..9a72444c 100644 --- a/broker/gen/model/Image_format_settings.cpp +++ b/broker/gen/model/Image_format_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.h b/broker/gen/model/Image_format_settings.h index 293a463b..61048dba 100644 --- a/broker/gen/model/Image_format_settings.h +++ b/broker/gen/model/Image_format_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_status.cpp b/broker/gen/model/Image_pusher_status.cpp index 1dcc32de..9427b73b 100644 --- a/broker/gen/model/Image_pusher_status.cpp +++ b/broker/gen/model/Image_pusher_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_status.h b/broker/gen/model/Image_pusher_status.h index fa83e947..ee960329 100644 --- a/broker/gen/model/Image_pusher_status.h +++ b/broker/gen/model/Image_pusher_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.cpp b/broker/gen/model/Image_pusher_type.cpp index cc758507..0b33bb14 100644 --- a/broker/gen/model/Image_pusher_type.cpp +++ b/broker/gen/model/Image_pusher_type.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.h b/broker/gen/model/Image_pusher_type.h index 6fc054e6..819a23de 100644 --- a/broker/gen/model/Image_pusher_type.h +++ b/broker/gen/model/Image_pusher_type.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.cpp b/broker/gen/model/Indexing_algorithm.cpp index ee7cbbe8..d7f48020 100644 --- a/broker/gen/model/Indexing_algorithm.cpp +++ b/broker/gen/model/Indexing_algorithm.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.h b/broker/gen/model/Indexing_algorithm.h index 07c3bdb8..b381876c 100644 --- a/broker/gen/model/Indexing_algorithm.h +++ b/broker/gen/model/Indexing_algorithm.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.cpp b/broker/gen/model/Indexing_settings.cpp index e9f38675..293969de 100644 --- a/broker/gen/model/Indexing_settings.cpp +++ b/broker/gen/model/Indexing_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.h b/broker/gen/model/Indexing_settings.h index 4f19e8f5..d12c1a78 100644 --- a/broker/gen/model/Indexing_settings.h +++ b/broker/gen/model/Indexing_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.cpp b/broker/gen/model/Instrument_metadata.cpp index 535b0151..b18dddfe 100644 --- a/broker/gen/model/Instrument_metadata.cpp +++ b/broker/gen/model/Instrument_metadata.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.h b/broker/gen/model/Instrument_metadata.h index 2f58c1df..85cd903e 100644 --- a/broker/gen/model/Instrument_metadata.h +++ b/broker/gen/model/Instrument_metadata.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.cpp b/broker/gen/model/Jfjoch_settings.cpp index 4602d939..764aa74b 100644 --- a/broker/gen/model/Jfjoch_settings.cpp +++ b/broker/gen/model/Jfjoch_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.h b/broker/gen/model/Jfjoch_settings.h index 2380d36d..e1e2ab26 100644 --- a/broker/gen/model/Jfjoch_settings.h +++ b/broker/gen/model/Jfjoch_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.cpp b/broker/gen/model/Jfjoch_statistics.cpp index 54bbbd5c..99b97aa6 100644 --- a/broker/gen/model/Jfjoch_statistics.cpp +++ b/broker/gen/model/Jfjoch_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.h b/broker/gen/model/Jfjoch_statistics.h index e0deb5b0..7d05b599 100644 --- a/broker/gen/model/Jfjoch_statistics.h +++ b/broker/gen/model/Jfjoch_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.cpp b/broker/gen/model/Measurement_statistics.cpp index cb560518..e36e5d5c 100644 --- a/broker/gen/model/Measurement_statistics.cpp +++ b/broker/gen/model/Measurement_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.h b/broker/gen/model/Measurement_statistics.h index 76fac830..a622844b 100644 --- a/broker/gen/model/Measurement_statistics.h +++ b/broker/gen/model/Measurement_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.cpp b/broker/gen/model/Pcie_devices_inner.cpp index 809e86bd..845dc96f 100644 --- a/broker/gen/model/Pcie_devices_inner.cpp +++ b/broker/gen/model/Pcie_devices_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.h b/broker/gen/model/Pcie_devices_inner.h index 3b8c8f51..52d7f7be 100644 --- a/broker/gen/model/Pcie_devices_inner.h +++ b/broker/gen/model/Pcie_devices_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.cpp b/broker/gen/model/Pixel_mask_statistics.cpp index 81380576..8005a60e 100644 --- a/broker/gen/model/Pixel_mask_statistics.cpp +++ b/broker/gen/model/Pixel_mask_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.h b/broker/gen/model/Pixel_mask_statistics.h index 01d54f8a..502ecd8c 100644 --- a/broker/gen/model/Pixel_mask_statistics.h +++ b/broker/gen/model/Pixel_mask_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.cpp b/broker/gen/model/Plot.cpp index df98313f..aff7e323 100644 --- a/broker/gen/model/Plot.cpp +++ b/broker/gen/model/Plot.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.h b/broker/gen/model/Plot.h index 17c3ef40..f2c7b0a1 100644 --- a/broker/gen/model/Plot.h +++ b/broker/gen/model/Plot.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.cpp b/broker/gen/model/Plot_unit_x.cpp index ba7eb86b..8def75ea 100644 --- a/broker/gen/model/Plot_unit_x.cpp +++ b/broker/gen/model/Plot_unit_x.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.h b/broker/gen/model/Plot_unit_x.h index 46e0eb07..c3bc9cc9 100644 --- a/broker/gen/model/Plot_unit_x.h +++ b/broker/gen/model/Plot_unit_x.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.cpp b/broker/gen/model/Plots.cpp index 00329d07..c7a9ce3a 100644 --- a/broker/gen/model/Plots.cpp +++ b/broker/gen/model/Plots.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.h b/broker/gen/model/Plots.h index 84daae86..10681b74 100644 --- a/broker/gen/model/Plots.h +++ b/broker/gen/model/Plots.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.cpp b/broker/gen/model/Roi_azim_list.cpp index 426765a5..cc8d8ac6 100644 --- a/broker/gen/model/Roi_azim_list.cpp +++ b/broker/gen/model/Roi_azim_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.h b/broker/gen/model/Roi_azim_list.h index 35daf81e..1bc426ea 100644 --- a/broker/gen/model/Roi_azim_list.h +++ b/broker/gen/model/Roi_azim_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.cpp b/broker/gen/model/Roi_azimuthal.cpp index a2b572bf..b7d567b8 100644 --- a/broker/gen/model/Roi_azimuthal.cpp +++ b/broker/gen/model/Roi_azimuthal.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.h b/broker/gen/model/Roi_azimuthal.h index 57c44b7f..5b3788b8 100644 --- a/broker/gen/model/Roi_azimuthal.h +++ b/broker/gen/model/Roi_azimuthal.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.cpp b/broker/gen/model/Roi_box.cpp index 80d05f46..8354c923 100644 --- a/broker/gen/model/Roi_box.cpp +++ b/broker/gen/model/Roi_box.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.h b/broker/gen/model/Roi_box.h index 2edca114..8b608614 100644 --- a/broker/gen/model/Roi_box.h +++ b/broker/gen/model/Roi_box.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.cpp b/broker/gen/model/Roi_box_list.cpp index 20b90218..dd8cb65e 100644 --- a/broker/gen/model/Roi_box_list.cpp +++ b/broker/gen/model/Roi_box_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.h b/broker/gen/model/Roi_box_list.h index d55bf885..28dc334c 100644 --- a/broker/gen/model/Roi_box_list.h +++ b/broker/gen/model/Roi_box_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.cpp b/broker/gen/model/Roi_circle.cpp index 6ba8c4bd..d4539e11 100644 --- a/broker/gen/model/Roi_circle.cpp +++ b/broker/gen/model/Roi_circle.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.h b/broker/gen/model/Roi_circle.h index ae6affc0..2e0728ea 100644 --- a/broker/gen/model/Roi_circle.h +++ b/broker/gen/model/Roi_circle.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.cpp b/broker/gen/model/Roi_circle_list.cpp index 41722cd4..cabc0702 100644 --- a/broker/gen/model/Roi_circle_list.cpp +++ b/broker/gen/model/Roi_circle_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.h b/broker/gen/model/Roi_circle_list.h index 92277278..b24cbaf6 100644 --- a/broker/gen/model/Roi_circle_list.h +++ b/broker/gen/model/Roi_circle_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.cpp b/broker/gen/model/Roi_definitions.cpp index dccd95a0..3839afe2 100644 --- a/broker/gen/model/Roi_definitions.cpp +++ b/broker/gen/model/Roi_definitions.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.h b/broker/gen/model/Roi_definitions.h index 345ec04d..bc15799d 100644 --- a/broker/gen/model/Roi_definitions.h +++ b/broker/gen/model/Roi_definitions.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.cpp b/broker/gen/model/Rotation_axis.cpp index 1ad0e10f..82cb2d4b 100644 --- a/broker/gen/model/Rotation_axis.cpp +++ b/broker/gen/model/Rotation_axis.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.h b/broker/gen/model/Rotation_axis.h index 5223e732..2fac1a45 100644 --- a/broker/gen/model/Rotation_axis.h +++ b/broker/gen/model/Rotation_axis.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.cpp b/broker/gen/model/Scan_result.cpp index e594f2f8..249a2238 100644 --- a/broker/gen/model/Scan_result.cpp +++ b/broker/gen/model/Scan_result.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.h b/broker/gen/model/Scan_result.h index 0ef93dcd..1a0c28c7 100644 --- a/broker/gen/model/Scan_result.h +++ b/broker/gen/model/Scan_result.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.cpp b/broker/gen/model/Scan_result_images_inner.cpp index f414eac0..e7e25c10 100644 --- a/broker/gen/model/Scan_result_images_inner.cpp +++ b/broker/gen/model/Scan_result_images_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.h b/broker/gen/model/Scan_result_images_inner.h index 93da2f57..1718d5fe 100644 --- a/broker/gen/model/Scan_result_images_inner.h +++ b/broker/gen/model/Scan_result_images_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.cpp b/broker/gen/model/Spot_finding_settings.cpp index a1b09f86..fbd3b2fb 100644 --- a/broker/gen/model/Spot_finding_settings.cpp +++ b/broker/gen/model/Spot_finding_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.h b/broker/gen/model/Spot_finding_settings.h index b996d931..c2ab8e57 100644 --- a/broker/gen/model/Spot_finding_settings.h +++ b/broker/gen/model/Spot_finding_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.cpp b/broker/gen/model/Standard_detector_geometry.cpp index f65dc9b4..9853f727 100644 --- a/broker/gen/model/Standard_detector_geometry.cpp +++ b/broker/gen/model/Standard_detector_geometry.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.h b/broker/gen/model/Standard_detector_geometry.h index ce1b497d..cab273e4 100644 --- a/broker/gen/model/Standard_detector_geometry.h +++ b/broker/gen/model/Standard_detector_geometry.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Tcp_settings.cpp b/broker/gen/model/Tcp_settings.cpp index fea40813..2298d5e0 100644 --- a/broker/gen/model/Tcp_settings.cpp +++ b/broker/gen/model/Tcp_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Tcp_settings.h b/broker/gen/model/Tcp_settings.h index 2b125fd6..ea32daa9 100644 --- a/broker/gen/model/Tcp_settings.h +++ b/broker/gen/model/Tcp_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.cpp b/broker/gen/model/Unit_cell.cpp index 0bba9eb9..74824c80 100644 --- a/broker/gen/model/Unit_cell.cpp +++ b/broker/gen/model/Unit_cell.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.h b/broker/gen/model/Unit_cell.h index 9485dae4..c5209ab4 100644 --- a/broker/gen/model/Unit_cell.h +++ b/broker/gen/model/Unit_cell.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.cpp b/broker/gen/model/Zeromq_metadata_settings.cpp index 6cf3db7b..9b40be24 100644 --- a/broker/gen/model/Zeromq_metadata_settings.cpp +++ b/broker/gen/model/Zeromq_metadata_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.h b/broker/gen/model/Zeromq_metadata_settings.h index 4c6e6c4c..7ee36eff 100644 --- a/broker/gen/model/Zeromq_metadata_settings.h +++ b/broker/gen/model/Zeromq_metadata_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.cpp b/broker/gen/model/Zeromq_preview_settings.cpp index 5e60a91c..52011ac9 100644 --- a/broker/gen/model/Zeromq_preview_settings.cpp +++ b/broker/gen/model/Zeromq_preview_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.h b/broker/gen/model/Zeromq_preview_settings.h index 4f70198b..d536729d 100644 --- a/broker/gen/model/Zeromq_preview_settings.h +++ b/broker/gen/model/Zeromq_preview_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.cpp b/broker/gen/model/Zeromq_settings.cpp index 4675c302..640a084c 100644 --- a/broker/gen/model/Zeromq_settings.cpp +++ b/broker/gen/model/Zeromq_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.h b/broker/gen/model/Zeromq_settings.h index c80b23b5..3182ccc1 100644 --- a/broker/gen/model/Zeromq_settings.h +++ b/broker/gen/model/Zeromq_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.147 +* The version of the OpenAPI document: 1.0.0-rc.148 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/jfjoch_api.yaml b/broker/jfjoch_api.yaml index cac02daf..505c0118 100644 --- a/broker/jfjoch_api.yaml +++ b/broker/jfjoch_api.yaml @@ -22,7 +22,7 @@ info: requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. - version: 1.0.0-rc.147 + version: 1.0.0-rc.148 contact: name: Filip Leonarski (Paul Scherrer Institute) email: filip.leonarski@psi.ch diff --git a/broker/redoc-static.html b/broker/redoc-static.html index 8a904e81..aed78ca3 100644 --- a/broker/redoc-static.html +++ b/broker/redoc-static.html @@ -399,7 +399,7 @@ This format doesn't transmit information about X-axis, only values, so it i 55.627 l 55.6165,55.627 -231.245496,231.24803 c -127.185,127.1864 -231.5279,231.248 -231.873,231.248 -0.3451,0 -104.688, -104.0616 -231.873,-231.248 z - " fill="currentColor">

Jungfraujoch (1.0.0-rc.147)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). + " fill="currentColor">

Jungfraujoch (1.0.0-rc.148)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.

License Clarification

While this API definition is licensed under GPL-3.0, the GPL copyleft provisions do not apply @@ -933,7 +933,7 @@ then image might be replaced in the buffer between calling /images and /image.cb