Files
Jungfraujoch/tests/AtomGradientMetalTest.cpp
leonarski_f 4809c1622c
Build Packages / build:portable:linux-x86_64:nocuda (push) Successful in 16m43s
Build Packages / build:jfjoch:ubuntu2404:nocuda (push) Successful in 28m46s
Build Packages / build:jfjoch:rocky8:cuda-sls9 (push) Successful in 32m5s
Build Packages / build:jfjoch:rocky9:cuda (push) Successful in 39m44s
Build Packages / build:portable:macos-arm64:nocuda (push) Successful in 5m7s
Build Packages / Create release (push) Successful in 8s
Build Packages / Build documentation (push) Successful in 49s
Build Packages / build:portable:linux-x86_64:cuda (push) Successful in 22m30s
Build Packages / build:jfjoch:rocky8:nocuda (push) Successful in 31m54s
Build Packages / build:rugnux:linux-aarch64:cuda (push) Successful in 11m29s
Build Packages / build:portable:windows-x86_64:nocuda (push) Successful in 23m51s
Build Packages / build:jfjoch:ubuntu2204:nocuda (push) Successful in 26m7s
Build Packages / build:jfjoch:ubuntu2204:cuda (push) Successful in 29m38s
Build Packages / build:portable:windows-x86_64:cuda (push) Successful in 28m6s
Build Packages / HDF5 consumer tests (DIALS, XDS) (push) Successful in 29m44s
Build Packages / build:jfjoch:rocky9:nocuda (push) Successful in 33m22s
Build Packages / Generate python client (push) Successful in 47s
Build Packages / build:jfjoch:rocky9:cuda-sls9 (push) Successful in 34m6s
Build Packages / Unit tests (push) Successful in 1h2m47s
Build Packages / build:jfjoch:rocky8:cuda (push) Successful in 35m59s
Build Packages / build:jfjoch:ubuntu2404:cuda (push) Successful in 34m8s
Build Packages / Validation Battery (push) Successful in 38m31s
v1.0.0-rc.187 (#98)
* Rugnux: Refinement several times faster, one protocol on the CPU and the GPU, parts of it on the Apple GPU; its random draws are the same on every platform.
* Rugnux: Refinement follows common practice: the free set decides only the restraint weights and the displacement model (isotropic, TLS or anisotropic, by Hamilton's test), everything else is decided on the working set; lower R-free for placed and predicted models.
* Rugnux: Restraint dictionaries via `--restraints` (or among the inputs) and more built-in ligands; a model whose space group is a subgroup of the data's is refined in its own group; reflections plus a model select `--mode refine` on their own.
* Rugnux: `-C` fixes the crystal system on the axes as typed; `-S` alone fixes the space group only, the cell is still found and reduced; a space group or cell stored in the input file is ignored, with a line in the log.
* Rugnux: More reliable multi-sweep merging; `--mode scale` merges several stills runs as one; `_plot.txt` and the report name each input; a second crystal form is reported for stills given a cell.
* jfjoch_broker (experimental): Live Rugnux on FPGA detectors (JUNGFRAU) takes the same path as a DECTRIS stream, rotation and serial alike, model step included, with analysis threads per GPU; frames waiting for the analysis can be viewed; no host stage drops a frame - a source faster than the analysis is held at the card.
* jfjoch_broker: Summation of more than 256 frames per image is split between the card and the host (`summation_mode` is then `hybrid`), and live Rugnux runs on such collections; pedestal runs take a receiver of their own.
* jfjoch_broker (experimental): `stills_downsample` analyses 1 of every N serial images (chosen by a hash; the first 2000 all; the others written without analysis; reset to 1 by `/initialize`); `max_spot_count` left out means 250 for per-image indexing and up to 1000 for live stills; the live status gives the merge before the model work, the fitted resolution and the anomalous peak height of each unexplained blob.
* jfjoch_broker: Without a `pcie` entry the broker runs on a mock of the card instead of the HLS simulation; its spot, ROI and azimuthal results are zero then.
* Web frontend: Redesigned Rugnux live page; Vite 8, TypeScript 6, Mol* 5.13 and dependency security updates.
* Tools: `jfjoch_fpga_stills_test` measures live stills on the cards with a stored dataset; `jfjoch_fpga_test` loses the HLS-simulation option.
* Other: FFTW no longer fetched or linked (the CPU FFT indexer keeps the name `FFTW`); PCIe driver now GPL-2.0-or-later and third-party notices complete; several crash fixes.

Reviewed-on: #98
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>
2026-11-19 20:49:28 +01:00

103 lines
4.5 KiB
C++

// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#include <catch2/catch_all.hpp>
#ifdef __APPLE__
#include <cmath>
#include <random>
#include <vector>
#include <gemmi/model.hpp>
#include "../image_analysis/structure_refinement/AtomGradientMetal.h"
#include "../image_analysis/structure_refinement/RefinementXray.h"
#include "../image_analysis/structure_refinement/RigidBodyRefine.h"
// The refinement gradient's sums on the Apple GPU (AtomGradientMetal.h) against the CPU's: the same points, summed
// in single precision on the GPU and in double on the CPU. A Mac without a Metal device fails rather than skips, as
// in ModelDensityMetalTest.cpp.
namespace {
// Atoms scattered over the whole cell - so that boxes wrap at every face - of a few elements, a quarter of them
// anisotropic, with occupancies below one.
gemmi::Model random_atoms(const gemmi::UnitCell &cell) {
std::mt19937 rng(17);
std::uniform_real_distribution<double> frac(0.0, 1.0), b(8.0, 60.0), occ(0.3, 1.0), u(0.05, 0.4);
const gemmi::El elements[] = {gemmi::El::C, gemmi::El::N, gemmi::El::O, gemmi::El::S};
gemmi::Model model(1);
gemmi::Chain chain("A");
gemmi::Residue res;
res.name = "UNK";
res.seqid = gemmi::SeqId(1, ' ');
for (int i = 0; i < 2000; i++) {
gemmi::Atom a;
a.name = "X";
a.element = elements[i % 4];
a.pos = cell.orthogonalize(gemmi::Fractional(frac(rng), frac(rng), frac(rng)));
a.b_iso = static_cast<float>(b(rng));
a.occ = static_cast<float>(occ(rng));
if (i % 4 == 3) {
const float d1 = static_cast<float>(u(rng)), d2 = static_cast<float>(u(rng)),
d3 = static_cast<float>(u(rng));
a.aniso = {d1, d2, d3, 0.3f * std::min(d1, d2), -0.2f * std::min(d1, d3), 0.1f * std::min(d2, d3)};
}
res.atoms.push_back(a);
}
chain.residues.push_back(res);
model.chains.push_back(chain);
return model;
}
// The largest difference of a derivative between the two, over the largest of that derivative on the CPU.
template <size_t N>
double worst(const std::vector<std::array<double, N>> &cpu, const std::vector<std::array<double, N>> &gpu) {
double out = 0;
for (size_t c = 0; c < N; c++) {
double max_g = 0, max_d = 0;
for (size_t i = 0; i < cpu.size(); i++) {
max_g = std::max(max_g, std::fabs(cpu[i][c]));
max_d = std::max(max_d, std::fabs(gpu[i][c] - cpu[i][c]));
}
out = std::max(out, max_d / max_g);
}
return out;
}
void check_gradient(const gemmi::UnitCell &cell, const char *group, double d_min) {
const gemmi::SpaceGroup &sg = *gemmi::find_spacegroup_by_name(group);
gemmi::Grid<float> map = RigidBodyZoneGrid(cell, sg, d_min);
map.data.resize(map.point_count());
// a smooth map with both signs, as the FFT method's derivative map is
for (int w = 0; w < map.nw; w++)
for (int v = 0; v < map.nv; v++)
for (int u = 0; u < map.nu; u++)
map.data[map.index_q(u, v, w)] = static_cast<float>(
std::sin(2 * M_PI * (3.0 * u / map.nu + 1.0 * v / map.nv)) +
std::cos(2 * M_PI * (2.0 * v / map.nv - 4.0 * w / map.nw)) +
0.5 * std::sin(2 * M_PI * (5.0 * u / map.nu + 3.0 * w / map.nw)));
const gemmi::Model model = random_atoms(cell);
const double blur = 10.0;
std::vector<std::array<double, 4>> gc, gg;
std::vector<std::array<double, 6>> uc, ug;
AtomGradientsFromMap(map, model, blur, 4, gc, &uc, false);
const size_t before = AtomGradientMetalCalls();
AtomGradientsFromMap(map, model, blur, 4, gg, &ug, true);
REQUIRE(AtomGradientMetalCalls() == before + 1); // the GPU summed it
REQUIRE(gg.size() == gc.size());
const double g = worst(gc, gg), u = worst(uc, ug);
CAPTURE(group, g, u);
CHECK(g < 1e-5);
CHECK(u < 5e-5);
}
}
TEST_CASE("AtomGradientMetal_MatchesCPU", "[portable][Metal]") {
// Triclinic, so that every term of the orthogonalization is there; then an orthorhombic group.
check_gradient(gemmi::UnitCell(41, 46, 52, 81, 96, 107), "P 1", 2.0);
check_gradient(gemmi::UnitCell(50, 56, 63, 90, 90, 90), "P 21 21 21", 1.6);
}
#endif