// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only #include "ModelFFT.h" #include #include #include #include #include #include "gemmi/fail.hpp" #include "../../common/CpuFFT.h" #include "../../common/ParallelFor.h" // An (nu, nv, nw) map is stored u fastest - row-major (nw, nv, nu) - and its half-l coefficients // likewise as (nw/2 + 1, nv, nu): the layout gemmi's own transforms read and write. The real transform // halves w, so w is the last axis transformed. static const cpu_fft::Shape kUVW{2, 1, 0}; static cpu_fft::Shape MapShape(int nu, int nv, int nw) { return {static_cast(nw), static_cast(nv), static_cast(nu)}; } gemmi::FPhiGrid MapToFPhi(const gemmi::Grid &map, size_t nthreads) { if (map.axis_order == gemmi::AxisOrder::ZYX) gemmi::fail("MapToFPhi(): ZYX order is not supported"); gemmi::FPhiGrid hkl; hkl.unit_cell = map.unit_cell; hkl.spacegroup = map.spacegroup; hkl.axis_order = map.axis_order; hkl.half_l = true; hkl.set_size_without_checking(map.nu, map.nv, map.nw / 2 + 1); const float norm = static_cast(map.unit_cell.volume / map.point_count()); cpu_fft::R2C(MapShape(map.nu, map.nv, map.nw), kUVW, map.data.data(), hkl.data.data(), nthreads); // Conjugated, as gemmi does: the forward transform carries exp(-2 pi i h.x), and a structure // factor is the sum over exp(+2 pi i h.x). const int n = static_cast(hkl.data.size()); ParallelChunks(n, nthreads, [&](int lo, int hi) { for (int i = lo; i < hi; i++) hkl.data[i] = std::conj(hkl.data[i]) * norm; }); return hkl; } void MapFromFPhiExecute(int nu, int nv, int nw, std::complex *in, float *out, size_t nthreads) { cpu_fft::C2R(MapShape(nu, nv, nw), kUVW, in, out, nthreads); } gemmi::FPhiGrid MapToFPhiInParallel(const gemmi::Grid &map, int reach, size_t nthreads) { if (map.axis_order == gemmi::AxisOrder::ZYX) gemmi::fail("MapToFPhiInParallel(): ZYX order is not supported"); const int nu = map.nu, nv = map.nv, nw = map.nw, nwh = nw / 2 + 1, nk = 2 * reach + 1; const size_t plane = static_cast(nu) * nv; std::vector> half(plane * nwh); // The r2c along w of every (u, v) column, then the 2D transform of the planes l <= reach only - the // rest are never read. Each is one call split over the threads by lines. cpu_fft::R2C({static_cast(nw), plane}, {0}, map.data.data(), half.data(), nthreads); cpu_fft::C2C({static_cast(reach) + 1, static_cast(nv), static_cast(nu)}, {1, 2}, true, half.data(), nthreads); gemmi::FPhiGrid hkl; hkl.unit_cell = map.unit_cell; hkl.spacegroup = map.spacegroup; hkl.axis_order = map.axis_order; hkl.half_l = true; hkl.set_size_without_checking(nu, nk, reach + 1); const float norm = static_cast(map.unit_cell.volume / map.point_count()); // Conjugated and scaled as MapToFPhi does it, and cropped as CropHalfL crops it. ParallelFor(reach + 1, nthreads, [&](int l) { for (int k = -reach; k <= reach; k++) { const std::complex *row = &half[l * plane + static_cast(nu) * gemmi::modulo(k, nv)]; std::complex *out = &hkl.data[static_cast(nu) * (gemmi::modulo(k, nk) + static_cast(nk) * l)]; for (int u = 0; u < nu; u++) out[u] = std::conj(row[u]) * norm; } }); return hkl; } gemmi::Grid MapFromFPhi(const gemmi::FPhiGrid &hkl) { if (hkl.axis_order == gemmi::AxisOrder::ZYX || !hkl.half_l) gemmi::fail("MapFromFPhi(): only an XYZ half-l grid is supported"); gemmi::Grid map; map.spacegroup = hkl.spacegroup; map.unit_cell = hkl.unit_cell; map.set_size(hkl.nu, hkl.nv, 2 * (hkl.nw - 1)); map.axis_order = hkl.axis_order; const float norm = static_cast(1.0 / hkl.unit_cell.volume); // Conjugated, as gemmi does: rho(x) = 1/V sum F exp(-2 pi i h.x), and the backward transform // carries exp(+2 pi i h.x). A missing coefficient (NaN) counts as zero, also as gemmi does. std::vector> in(hkl.data.size()); for (size_t i = 0; i < in.size(); ++i) in[i] = std::isnan(hkl.data[i].imag()) ? 0.0f : std::conj(hkl.data[i]); cpu_fft::C2R(MapShape(map.nu, map.nv, map.nw), kUVW, in.data(), map.data.data()); for (auto &x : map.data) x *= norm; return map; } // The rows keep their length: cut to 2 reach + 1 as well, the rotation function read them 15% slower on the // GPU (measured on a large cell). gemmi::FPhiGrid CropHalfL(const gemmi::FPhiGrid &full, int reach) { gemmi::FPhiGrid out; out.unit_cell = full.unit_cell; out.spacegroup = full.spacegroup; out.axis_order = full.axis_order; out.half_l = true; const int nu = full.nu, n = 2 * reach + 1; out.set_size_without_checking(nu, n, reach + 1); for (int l = 0; l <= reach; l++) for (int k = -reach; k <= reach; k++) std::copy_n(&full.data[static_cast(nu) * (gemmi::modulo(k, full.nv) + static_cast(full.nv) * l)], nu, &out.data[static_cast(nu) * (gemmi::modulo(k, n) + static_cast(n) * l)]); return out; }