The CPU engine and the bulk-solvent mask kept the thread count they were made with: the main slot's all of them, every other weight-trial slot's one (settings.nthreads / slots). RunTrials and the stages that hand the threads back set Context::nthreads, which the engine never read - so where fewer trials ran than there were slots (the trajectory's steps run 4, TLS/U hypotheses, the last trial of a set) the trials in the other slots ran on one thread each and the step waited for them; top showed the process at 100-500% for most of a run on 16 threads. Context::SetThreads() now passes the count on (RefinementEngine::SetThreads, a no-op on a GPU engine, and BulkSolventMask::SetThreads), and the engine's and the mask's FFTs are split over the same threads (MapToFPhi/MapFromFPhiExecute take nthreads; pocketfft splits lines, the result is the same). The outcome does not depend on the threads: cytC --mode refine --no-gpu -N 16 writes the same refined model and maps bit for bit, R-free 0.3400 / 0.3366 (two hypotheses) as before. Refinement time, with the gradient commit before it: 909.6 + 700.7 s -> 224.7 + 219.7 s (wall 1611 -> 445 s). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
36 lines
2.3 KiB
C++
36 lines
2.3 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include "gemmi/grid.hpp"
|
|
#include "gemmi/recgrid.hpp"
|
|
|
|
// The structure factors of a real-space map on the model path (Fcalc from the model density, Fmask
|
|
// from the bulk-solvent mask): what gemmi::transform_map_to_f_phi(map, true) returns - the
|
|
// conjugated forward transform (F = sum rho exp(+2 pi i h.x)) scaled by V/N, kept for l >= 0 on an (nu, nv, nw/2+1) grid in the map's own XYZ order,
|
|
// ready for prepare_asu_data() - computed with common/CpuFFT, its lines split over `nthreads` (the same result on any
|
|
// number). Safe to call from several threads at once.
|
|
gemmi::FPhiGrid<float> MapToFPhi(const gemmi::Grid<float> &map, size_t nthreads = 1);
|
|
|
|
// The inverse: the real-space map of an (nu, nv, nw/2+1) half-l coefficient grid in XYZ order, as
|
|
// get_f_phi_on_grid() fills it - what gemmi::transform_f_phi_grid_to_map() returns (rho = 1/V sum F
|
|
// exp(-2 pi i h.x) on an (nu, nv, 2*(nw-1)) grid, NaN coefficients read as zero).
|
|
gemmi::Grid<float> MapFromFPhi(const gemmi::FPhiGrid<float> &hkl);
|
|
|
|
// MapFromFPhi's transform itself, for a caller that fills its input: `in`, the (nu, nv, nw/2+1) half-l coefficients
|
|
// u fastest as MapFromFPhi transforms them (conjugated, a NaN as zero), is overwritten, and `out` receives the
|
|
// (nu, nv, nw) map before MapFromFPhi's 1/V.
|
|
void MapFromFPhiExecute(int nu, int nv, int nw, std::complex<float> *in, float *out, size_t nthreads = 1);
|
|
|
|
// CropHalfL(MapToFPhi(map), reach) on `nthreads` threads, for a map of hundreds of millions of points (the
|
|
// molecular transform's box), whose single-threaded transform is minutes of CPU: the r2c along w of every
|
|
// (u, v) column, then the 2D transform of every plane l <= reach. The threads split the lines of a transform, each
|
|
// line transformed as it would be alone, so the result does not depend on the thread count.
|
|
gemmi::FPhiGrid<float> MapToFPhiInParallel(const gemmi::Grid<float> &map, int reach, size_t nthreads);
|
|
|
|
// The half-l grid `full` with only the indices |k|, l <= reach kept, on a grid of full.nu x (2 reach + 1) x
|
|
// (reach + 1) that an index wraps into as it wraps into the whole one (the molecular transform's, which is
|
|
// read no further out).
|
|
gemmi::FPhiGrid<float> CropHalfL(const gemmi::FPhiGrid<float> &full, int reach);
|