v1.0.0-rc.146 (#56)

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.

jfjoch_process: Generate a dedicated file (_process.h5), which can be used as a replacement for the _master.h5 file for a reanalyzed dataset.
jfjoch_process: Improve the performance of scaling and merging, implement on the fly scaling.
jfjoch_writer: All final data analysis results are repopulated in the _master.h5 file.
jfjoch_scale: Dedicated tool for rescaling/merging existing data.
jfjoch_viewer: Fix bugs where pixel labels where displayed on a wrong pixel.

WARNING! Scaling and merging are experimental at the moment, and may not provide reasonable results for the time being.

Reviewed-on: #56

common/UnitCell.cpp

@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "UnitCell.h"
+
+#include <algorithm>
+#include <cmath>
+
+bool UnitCell::is_finite() const {
+    return std::isfinite(a)
+           && std::isfinite(b)
+           && std::isfinite(c)
+           && std::isfinite(alpha)
+           && std::isfinite(beta)
+           && std::isfinite(gamma);
+}
+
+bool UnitCell::is_close(const UnitCell &ref, float dist_tolerance, float angle_tolerance_deg) const {
+    if (!is_finite() || !ref.is_finite())
+        return false;
+
+    constexpr float min_length = 1e-6f;
+
+    if (std::fabs(a - ref.a) / std::max(std::fabs(ref.a), min_length) > dist_tolerance)
+        return false;
+    if (std::fabs(b - ref.b) / std::max(std::fabs(ref.b), min_length) > dist_tolerance)
+        return false;
+    if (std::fabs(c - ref.c) / std::max(std::fabs(ref.c), min_length) > dist_tolerance)
+        return false;
+
+    if (std::fabs(alpha - ref.alpha) > angle_tolerance_deg)
+        return false;
+    if (std::fabs(beta - ref.beta) > angle_tolerance_deg)
+        return false;
+    if (std::fabs(gamma - ref.gamma) > angle_tolerance_deg)
+        return false;
+
+    return true;
+}
+
+std::ostream &operator<<(std::ostream &output, const UnitCell &in) {
+    output << in.a << " " << in.b << " " << in.c;
+    output << " " << in.alpha << " " << in.beta << " " << in.gamma;
+    return output;
+}
+
+std::optional<UnitCell> MeanUnitCell(const std::vector<UnitCell> &cells) {
+    if (cells.empty())
+        return {};
+
+    UnitCell ret{};
+    for (const auto &cell: cells) {
+        ret.a += cell.a;
+        ret.b += cell.b;
+        ret.c += cell.c;
+        ret.alpha += cell.alpha;
+        ret.beta += cell.beta;
+        ret.gamma += cell.gamma;
+    }
+
+    const auto scale = 1.0f / static_cast<float>(cells.size());
+    ret.a *= scale;
+    ret.b *= scale;
+    ret.c *= scale;
+    ret.alpha *= scale;
+    ret.beta *= scale;
+    ret.gamma *= scale;
+
+    return ret;
+}
+
+UnitCell::operator gemmi::UnitCell() const {
+    return {a, b, c, alpha, beta, gamma};
+}