Refinement: L-BFGS on the Gauss-Newton normal matrix, one protocol on the CPU and the GPU

The minimiser's initial inverse Hessian is the target's sparse normal matrix, solved by conjugate
gradients: the restraints' Gauss-Newton J^T J in full (RestraintNormalMatrix, on the slot's threads or
its GPU), the X-ray target's curvature per atom on the diagonal (calibrated once per trial), the U
restraints' exact Hessian, and per TLS body a dense 20 x 20 block. The L-BFGS pairs learn what the
matrix leaves out (the X-ray coupling of neighbouring atoms). 10 iterations for the positions and 7
for B, U and TLS per macro-cycle, instead of 30 and 20.

The protocol is the same on both paths: no population (kept as a setting, off by default), two
rounds; lean_on_cpu is gone.

Measured, refine-only, 19 sets on the GPU against the former GPU protocol (population, 2 rounds,
plain L-BFGS): R-free -0.0005 mean, -0.0012 median, worse by > 0.002 on 2 and better on 6, -LL free
lower on 11; 158k -> 49k evaluations. The same protocol with the plain L-BFGS on the CPU's former
protocol took 76k. Quiet single runs at 32 threads: cytc CPU 113 s (was 114 s with one round), GPU
6.1 s (10.9 s); myob CPU 41.5 s (53.1 s), GPU 4.1 s (5.1 s).

The damped Newton steps, the joint xyz+B target, the X-ray coupling term, the adaptive stop and the
experiment switches of the prototype are removed: pure Gauss-Newton steps converged each trial further
than the protocol's decisions were made for, R-free +0.0005 to +0.0022 in the mean of the 19 sets. BRestraintCurvature and
the L-BFGS's diagonal and Oren-Shanno scaling are gone with them.

Tests: RefinementMinimiser_quadratic on the new interface, RefinementMinimiser_conjugate_gradients,
RefinementRestraints_gauss_newton (J^T J against the Hessian near the ideal geometry).
Docs: CPU_DATA_ANALYSIS_REFINEMENT 15.6 and the population, references, ACKNOWLEDGEMENT (Hestenes &
Stiefel 1952, the normal matrix after Murshudov, Vagin & Dodson 1997).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
This commit is contained in:
leonarski_fandClaude Opus 5.5 committed 2026-11-16 13:03:40 +01:00
1 parent 714016ac2c
commit 959f8ae739
9 files changed
+329 -927

No files matched your search

+6 -14
View File
@@ -598,20 +598,12 @@ Cryst. A34, 791-809 [doi:10.1107/S0567739478001618](https://doi.org/10.1107/S056
memory BFGS method for large scale optimization" (1989), Math. Program. 45, 503-528
[doi:10.1007/BF01589116](https://doi.org/10.1007/BF01589116); its two-loop recursion: J. Nocedal,
"Updating quasi-Newton matrices with limited storage" (1980), Math. Comp. 35, 773-782
[doi:10.1090/S0025-5718-1980-0572855-7](https://doi.org/10.1090/S0025-5718-1980-0572855-7). The
initial inverse Hessian is rescaled at each iteration by the latest pair, the self-scaling of
S. S. Oren and D. G. Luenberger, "Self-scaling variable metric (SSVM) algorithms. Part I" (1974),
Management Sci. 20, 845-862 [doi:10.1287/mnsc.20.5.845](https://doi.org/10.1287/mnsc.20.5.845), and
D. F. Shanno and K.-H. Phua, "Matrix conditioning and nonlinear optimization" (1978), Math. Program.
14, 149-160 [doi:10.1007/BF01588962](https://doi.org/10.1007/BF01588962).
**Newton minimiser (experimental)** — damped Newton steps on a sparse normal matrix: the X-ray
target's curvature per atom on the diagonal and the restraints' Gauss-Newton matrix in full, as
REFMAC refines (Murshudov, Vagin & Dodson 1997, above), solved by conjugate gradients with the
damping of K. Levenberg, "A method for the solution of certain non-linear problems in least squares"
(1944), Q. Appl. Math. 2, 164-168 [doi:10.1090/qam/10666](https://doi.org/10.1090/qam/10666), and
D. W. Marquardt, "An algorithm for least-squares estimation of nonlinear parameters" (1963), J. Soc.
Ind. Appl. Math. 11, 431-441 [doi:10.1137/0111030](https://doi.org/10.1137/0111030).
[doi:10.1090/S0025-5718-1980-0572855-7](https://doi.org/10.1090/S0025-5718-1980-0572855-7). Its
initial inverse Hessian is the target's sparse normal matrix - the X-ray target's curvature per atom
on the diagonal and the restraints' Gauss-Newton matrix in full - as REFMAC refines on its normal
matrix (Murshudov, Vagin & Dodson 1997, above), solved by conjugate gradients: M. R. Hestenes and
E. Stiefel, "Methods of conjugate gradients for solving linear systems" (1952), J. Res. Natl. Bur.
Stand. 49, 409-436 [doi:10.6028/jres.049.044](https://doi.org/10.6028/jres.049.044).
**Geometry restraints** — those of the CCP4 Monomer Library, a subset of which rugnux carries (see
[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)). A. A. Vagin, R. A. Steiner, A. A. Lebedev,
+2 -2
View File
@@ -66,12 +66,13 @@ The methods draw on, and in places reimplement, solutions from:
- H. F. Walker & P. Ni, "Anderson acceleration for fixed-point iterations", *SIAM J. Numer. Anal.* **49** (2011), 1715-1735, after D. G. Anderson, "Iterative procedures for nonlinear integral equations", *J. ACM* **12** (1965), 547-560 (the acceleration of the per-frame scaling loops, §10.6).
- R. A. Fisher, "Frequency distribution of the values of the correlation coefficient in samples from an indefinitely large population", *Biometrika* **10** (1915), 507-521 (the z-transformation on which the correction surfaces' held-out half-set CC1/2 is compared).
- R. C. Agarwal, "A new least-squares refinement technique based on the fast Fourier transform algorithm", *Acta Cryst.* **A34** (1978), 791-809 (the gradient of the refinement target, §15).
- N. S. Pannu & R. J. Read, "Improved structure refinement through maximum likelihood", *Acta Cryst.* **A52** (1996), 659-668, and G. N. Murshudov, A. A. Vagin & E. J. Dodson, "Refinement of macromolecular structures by the maximum-likelihood method", *Acta Cryst.* **D53** (1997), 240-255 (the maximum-likelihood amplitude target and the B restraints, §15).
- N. S. Pannu & R. J. Read, "Improved structure refinement through maximum likelihood", *Acta Cryst.* **A52** (1996), 659-668, and G. N. Murshudov, A. A. Vagin & E. J. Dodson, "Refinement of macromolecular structures by the maximum-likelihood method", *Acta Cryst.* **D53** (1997), 240-255 (the maximum-likelihood amplitude target, the B restraints and the minimiser's sparse normal matrix, §15).
- V. Y. Lunin & T. P. Skovoroda, "R-free likelihood-based estimates of errors for phases calculated from atomic models", *Acta Cryst.* **A51** (1995), 880-887 (the likelihood parameters from the free set, §15).
- A. A. Vagin et al., "REFMAC5 dictionary: organization of prior chemical knowledge and guidelines for its use", *Acta Cryst.* **D60** (2004), 2184-2195 (the restraint dictionary, §15).
- P. V. Afonine et al., "Towards automated crystallographic structure refinement with phenix.refine", *Acta Cryst.* **D68** (2012), 352-367 (the weight chosen among refinements by R-free, §15).
- D. C. Liu & J. Nocedal, "On the limited memory BFGS method for large scale optimization", *Math. Program.* **45** (1989), 503-528 (the minimiser, §15).
- J. Nocedal, "Updating quasi-Newton matrices with limited storage", *Math. Comp.* **35** (1980), 773-782 (the two-loop recursion of the minimiser, §15.6).
- M. R. Hestenes & E. Stiefel, "Methods of conjugate gradients for solving linear systems", *J. Res. Natl. Bur. Stand.* **49** (1952), 409-436 (the normal equations of the minimiser, §15.6).
- G. N. Murshudov, P. Skubák, A. A. Lebedev et al., "REFMAC5 for the refinement of macromolecular crystal structures", *Acta Cryst.* **D67** (2011), 355-367 (the likelihood's D from the working set and its variance from the free, and the Kullback-Leibler B restraints, §15.3, §15.5).
- P. Roversi, E. Blanc, S. Johnson & S. M. Lea, "Tetartohedral twinning could happen to you too", *Acta Cryst.* **D68** (2012), 418-424 (twin refinement with more than two domains, and the free set closed under the twin domains, §15.12).
- K. A. Sultana, I. Alexeev, I. Kursula, P. Mäntsälä, J. Niemi & G. Schneider, "Structure determination by multiwavelength anomalous diffraction of aclacinomycin oxidoreductase: indications of multidomain pseudomerohedral twinning", *Acta Cryst.* **D63** (2007), 149-159 (a six-domain twin of a monoclinic crystal on a hexagonal metric, §15.12).
@@ -120,7 +121,6 @@ The methods draw on, and in places reimplement, solutions from:
- V. Luzzati, "Traitement statistique des erreurs dans la détermination des structures cristallines", *Acta Cryst.* **5** (1952), 802-810 (the fall-off of $\sigma_A$ with resolution for a model's coordinate error, Luzzati's $D$, in the likelihood of a placement, §14.10).
- D. Liebschner, P. V. Afonine, A. G. Urzhumtsev & P. D. Adams, "Implementation of the riding hydrogen model in CCTBX to support the next generation of X-ray and neutron joint refinement in Phenix", *Methods Enzymol.* **634** (2020), 177-199 (the riding hydrogens, placed by GEMMI's code, §15.2).
- D. L. Theobald, "Rapid calculation of RMSDs using a quaternion-based characteristic polynomial", *Acta Cryst.* **A61** (2005), 478-480, and P. Liu, D. K. Agrafiotis & D. L. Theobald, *J. Comput. Chem.* **31** (2010), 1561-1563 (the QCP superposition behind the NCS rms criterion, via GEMMI, §15.5).
- S. S. Oren & D. G. Luenberger, "Self-scaling variable metric (SSVM) algorithms. Part I", *Management Sci.* **20** (1974), 845-862, and D. F. Shanno & K.-H. Phua, "Matrix conditioning and nonlinear optimization", *Math. Program.* **14** (1978), 149-160 (the rescaling of the L-BFGS initial inverse Hessian by the latest pair, §15.6).
(list is not exhaustive; the full citations, with DOIs, are in [ACKNOWLEDGEMENT.md](ACKNOWLEDGEMENT.md))
+39 -21
View File
@@ -286,26 +286,41 @@ Whether the restraints are used at all, and how tightly ($\sigma$), the weight t
### 15.6 The minimiser
Positions and B factors are minimised in turn, each by an L-BFGS of rugnux's own (`RefinementMinimiser`),
with the two-loop recursion of Nocedal and of Liu and Nocedal, a memory of 20 pairs and a backtracking line
search from the full step to sufficient decrease, its first trial moving no position by more than 0.3 Å and
no B by more than 10 Ų. What sets it apart from a textbook L-BFGS:
Positions, B factors, anisotropic U and TLS parameters are minimised in turn, each by an L-BFGS of rugnux's own
(`RefinementMinimiser`), with the two-loop recursion of Nocedal and of Liu and Nocedal, a memory of 20 pairs and a
backtracking line search from the full step to sufficient decrease, its first trial moving no position by more
than 0.3 Šand no B by more than 10 Ų. What sets it apart from a textbook L-BFGS is its **initial inverse
Hessian: the target's Gauss-Newton normal matrix**, as REFMAC refines on its sparse normal matrix (Murshudov,
Vagin & Dodson 1997). The matrix holds what is known of the curvature in advance; the L-BFGS pairs add what it
leaves out.
- **Its memory is kept from one macro-cycle to the next.** A macro-cycle is a few dozen iterations on a target
whose scale and likelihood parameters were refitted in between; starting each from what the earlier ones
learnt of the curvature, instead of from a steepest-descent step, is what lets two macro-cycles of a
weight trial get as far as many restarted ones. Each weight trial starts with an empty memory.
- **The B steps are scaled by their curvature.** The initial inverse Hessian of the B factors is a
diagonal: the X-ray target's curvature in each atom's B - its shape from the likelihood's curvature in
$|F_\mathrm{model}|$ and the atom's own scattering, summed in resolution shells, calibrated once per trial
against central differences of the gradient along a random $\pm1$ direction - plus the B restraints'
curvature, each element at least a thousandth of the median. The positions take none: their restraints'
curvature is that of stiff bonds and angles, which move atoms together, and as a diagonal it slows the soft
(torsion and X-ray) directions rather than scaling them.
- **The restraints' part is their Gauss-Newton matrix $J^\mathsf{T}J$, in full.** Every restraint is the square of
a residual (or close to it: the NCS distances' robust loss), so its gradient is $2r\,\nabla r$ and
$J = \nabla E / \sqrt{2E}$ is its row of the Jacobian, $\sqrt2\,\nabla r$; a plane contributes one row per
atom. $J^\mathsf{T}J$ is positive semi-definite where the exact Hessian is not (torsions, repulsions), and near
the ideal geometry it is the exact Hessian. Its products $J^\mathsf{T}(Jv)$ are two gathers - over the rows,
then over each atom's entries - on the slot's threads, or on its GPU.
- **The X-ray part is per atom, on the diagonal.** The X-ray target's curvature in an atom's $x$, $y$ and $z$ is
the likelihood's curvature in $|F_\mathrm{model}|$ summed in resolution shells against the atom's own part of
it, $(2\pi)^2 s^2/3\,f(s)^2\,e^{-Bs^2/2}$ (the reflections taken as spread evenly over directions); in its B,
$(s^2/4)^2 f(s)^2 e^{-Bs^2/2}$, a third of it to each element of a U; and a TLS body's dense $20\times20$ block
is that curvature carried through the derivatives of its atoms' U in the body's parameters. Each is calibrated
once per trial against central differences of the gradient along a random $\pm1$ direction. The coupling of
neighbouring atoms through the X-ray target is not in it; the pairs learn it.
- **The anisotropic U restraints** are quadratic in U, so their Hessian is exact by one difference of their
gradient.
- **The matrix is solved, not inverted.** Each L-BFGS direction solves the normal equations by conjugate
gradients to a tenth of the residual (at most 50 iterations), preconditioned by each atom's $3\times3$ block for
the positions and by the diagonal elsewhere. The Jacobian is taken again at each point the minimiser stands on.
- **Its memory is kept from one macro-cycle to the next.** Each weight trial starts with an empty memory.
The diagonal is rescaled at each iteration by the latest pair (Oren-Shanno scaling in that metric). A solve
stops after its iteration budget (30 for the positions and 20 for the B factors per macro-cycle) or where an
iteration lowers the target by less than $10^{-7}$ of it.
A solve stops after its iteration budget (10 for the positions and 7 for the B factors, U or TLS per
macro-cycle) or where an iteration lowers the target by less than $10^{-7}$ of it. Against the plain L-BFGS this
replaced (a diagonal initial inverse Hessian for the B factors, none for the positions, 30 and 20 iterations), a
trial takes about a third of the evaluations. With it the population (§15.7) no longer gains, and the protocol
is the same on the CPU and the GPU - two rounds, no population - at a third of the evaluations the GPU's protocol
took before and R-free 0.0005 lower in the mean over 19 refinements (-LL free lower on 11 of them), and at fewer
evaluations than the CPU's former one-round protocol.
### 15.7 The weights, decided by trial
@@ -337,8 +352,10 @@ are:
stays within 0.001 of the best so far, and the trajectory ends at its best step. On a deposited model,
whose free set the depositor's refinement has already fitted, R-work falls while R-free rises, and the
trajectory ends where it began.
3. **The population**, from where the trajectory ended: twelve members (at most as many as the trial slots, so
that they run in one wave; none below two) refined side by side, each a trial at the
3. **The population** (off by default, `RefinementSettings::population`: with the minimiser of §15.6 its members
took nothing off R-free over 19 refinements that the second round did not), from where the trajectory ended:
up to twelve members (at most as many as the trial slots, so that they run in one wave; none below two) refined
side by side, each a trial at the
trajectory's weights but on its own path - the positions as they are or kicked at random by up to 0.2-0.3 Å
in each coordinate, on the data as they are or **blurred** along a schedule, 60 then 20 Ų (the landscape of
4 Å, then of 2.2 Å), 100 then 30, or 30 then 10. The blur raises the likelihood's variance of each reflection
@@ -741,7 +758,7 @@ What the refinement does not do yet - each a known gap, not a design choice:
- L. Piela, J. Kostrowicki & H. A. Scheraga, "On the multiple-minima problem in the conformational analysis of molecules: deformation of the potential energy hypersurface by the diffusion equation method", *J. Phys. Chem.* **93** (1989), 3339-3346, and A. Jack & M. Levitt, "Refinement of large structures by simultaneous minimization of energy and R factor", *Acta Cryst.* **A34** (1978), 931-935 (the members refined on blurred data, §15.7).
- J. Praznikar, P. V. Afonine, G. Guncar, P. D. Adams & D. Turk, "Averaged kick maps: less noise, more signal... and probably less bias", *Acta Cryst.* **D65** (2009), 921-931, and J. C. Nwachukwu, M. R. Southern, J. R. Kiefer, P. V. Afonine, P. D. Adams, T. C. Terwilliger & K. W. Nettles, "Improved crystallographic structures using extensive combinatorial refinement", *Structure* **21** (2013), 1923-1930 (the kicked members, their averaged map and the crossover residue by residue, §15.7).
- J. Desmet, M. De Maeyer, B. Hazes & I. Lasters, "The dead-end elimination theorem and its use in protein side-chain positioning", *Nature* **356** (1992), 539-542; J. Besag, "On the statistical analysis of dirty pictures", *J. R. Statist. Soc.* **B48** (1986), 259-279; R. P. Joosten, K. Joosten, S. X. Cohen, G. Vriend & A. Perrakis, "Automatic rebuilding and optimization of crystallographic structures in the Protein Data Bank", *Bioinformatics* **27** (2011), 3392-3398 (the side-chain field: states, the conditional-modes solver and its order, §15.5).
- N. S. Pannu & R. J. Read, "Improved structure refinement through maximum likelihood", *Acta Cryst.* **A52** (1996), 659-668, and G. N. Murshudov, A. A. Vagin & E. J. Dodson, "Refinement of macromolecular structures by the maximum-likelihood method", *Acta Cryst.* **D53** (1997), 240-255 (the maximum-likelihood amplitude target and its figure of merit, §15.2, §15.8).
- N. S. Pannu & R. J. Read, "Improved structure refinement through maximum likelihood", *Acta Cryst.* **A52** (1996), 659-668, and G. N. Murshudov, A. A. Vagin & E. J. Dodson, "Refinement of macromolecular structures by the maximum-likelihood method", *Acta Cryst.* **D53** (1997), 240-255 (the maximum-likelihood amplitude target and its figure of merit, §15.2, §15.8; the minimiser's sparse normal matrix, §15.6).
- G. N. Murshudov, P. Skubák, A. A. Lebedev, N. S. Pannu, R. A. Steiner, R. A. Nicholls, M. D. Winn, F. Long & A. A. Vagin, "REFMAC5 for the refinement of macromolecular crystal structures", *Acta Cryst.* **D67** (2011), 355-367 (D from the working set and the variance from the free, §15.3; the Kullback-Leibler form of the B restraints, §15.5; the twinned refinement §15.12 simplifies, its twin laws pruned by fraction and its fractions refined by least squares).
- R. J. Read, "Improved Fourier coefficients for maps using phases from partial structures with errors", *Acta Cryst.* **A42** (1986), 140-149 (the m, D weighting of the map coefficients, §15.8).
- T. O. Yeates, "Detecting and overcoming crystal twinning", *Methods Enzymol.* **276** (1997), 344-358 (the twinned intensity, §15.12).
@@ -762,6 +779,7 @@ What the refinement does not do yet - each a known gap, not a design choice:
- Z. Dauter & M. Dauter, "Entering a new phase: using solvent halide ions in protein structure determination", *Structure* **9** (2001), R21-R26 (halides at sites with few donors, §15.10).
- N. Echols et al., "Automated identification of elemental ions in macromolecular crystal structures", *Acta Cryst.* **D70** (2014), 1104-1114 (a light ion flagged by its density above the waters', §15.10).
- J. Nocedal, "Updating quasi-Newton matrices with limited storage", *Math. Comp.* **35** (1980), 773-782, and D. C. Liu & J. Nocedal, "On the limited memory BFGS method for large scale optimization", *Math. Program.* **45** (1989), 503-528 (the minimiser, §15.6).
- M. R. Hestenes & E. Stiefel, "Methods of conjugate gradients for solving linear systems", *J. Res. Natl. Bur. Stand.* **49** (1952), 409-436 (the normal equations of the minimiser, §15.6).
- A. T. Brünger, M. Karplus & G. A. Petsko, "Crystallographic refinement by simulated annealing: application to crambin", *Acta Cryst.* **A45** (1989), 50-61 (the starting weight from the ratio of the gradients, §15.7).
- P. V. Afonine et al., "Towards automated crystallographic structure refinement with phenix.refine", *Acta Cryst.* **D68** (2012), 352-367 (weights chosen among refinements by R-free within geometry bounds, and the overall B moved into the atoms, §15.3, §15.7).
- A. T. Brünger, "Free R value: a novel statistical quantity for assessing the accuracy of crystal structures", *Nature* **355** (1992), 472-475 (R-free).
+120 -602
View File
@@ -6,7 +6,6 @@
#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <future>
@@ -100,12 +99,6 @@ constexpr double MAX_STEP_XYZ = 0.3, MAX_STEP_B = 10.0;
// The loosest NCS restraint a trajectory step tries (A); looser than that, the copies are refined independently.
constexpr double NCS_SIGMA_MAX = 0.4;
// PROTOTYPE instrumentation (lane k): MINSTAT/TRIALSTAT/... lines on stderr where RUGNUX_REFINE_STATS is set.
bool RefineStats() {
static const bool on = getenv("RUGNUX_REFINE_STATS") != nullptr;
return on;
}
// The figure of merit of the likelihood, <cos(dphi)>, at X = 2 Fo D Fc / var: I1(X)/I0(X) for an acentric
// reflection, tanh(X / 2) for a centric one.
// Following Murshudov, Vagin & Dodson (1997) Acta Cryst. D53, 240-255
@@ -619,8 +612,7 @@ struct Context {
std::vector<double> XrayBCurvatureShape() const { return XrayCurvatureShape(rows, false); }
// The same for each of an atom's x, y and z: its own part of the likelihood's curvature in |F_model| is then
// (2 pi)^2 s^2 / 3 f(s)^2 exp(-B s^2 / 2), the reflections taken as spread evenly over directions - the X-ray
// block of the normal matrix as a multiple of I per atom (Murshudov, Vagin & Dodson 1997 keep the X-ray blocks
// of atoms on the diagonal). `r`: the row model the engine has (blurred or not).
// block of the normal matrix as a multiple of I per atom. `r`: the row model the engine has (blurred or not).
std::vector<double> XrayXyzCurvatureShape(const XrayRowModel &r) const { return XrayCurvatureShape(r, true); }
std::vector<double> XrayCurvatureShape(const XrayRowModel &rows, bool xyz) const {
constexpr int SHELLS = 32;
@@ -665,144 +657,6 @@ struct Context {
return shape;
}
// The X-ray normal matrix between the positions of neighbouring atoms of `params` (riders left out), in the units of
// XrayXyzCurvatureShape(): for atoms k and l a vector r apart, the sum over the shells of
// w f_k f_l exp(-(B_k + B_l) s^2 / 4) (2 pi s)^2 [(j1(x) / x) I - j2(x) r r^T / r^2], x = 2 pi s r - the overlap of
// their density derivatives, the reflections spread evenly over directions; at r = 0 the shape's own (2 pi)^2 s^2 / 3.
// Out to where it has fallen below a hundredth of its value at 0 for two carbons at the median B, and stays there.
// Per parameter index its neighbours and blocks (xx yy zz xy xz yz), both ways round.
struct XrayCoupling {
std::vector<int> start, other;
std::vector<std::array<double, 6>> block;
};
XrayCoupling XrayXyzCoupling(const XrayRowModel &rows, const std::vector<int> &params) const {
constexpr int SHELLS = 32;
double s2_max = 0;
for (double s2 : refl.inv_d2)
s2_max = std::max(s2_max, s2);
std::vector<double> w(SHELLS, 0), s2_sum(SHELLS, 0);
std::vector<int> n(SHELLS, 0);
for (size_t m = 0; m < refl.Size(); m++) {
if (refl.free[m])
continue;
const int k = std::min(SHELLS - 1, static_cast<int>(refl.inv_d2[m] / s2_max * SHELLS));
const double kd = rows.k_total[m] * rows.d[m];
w[k] += 2.0 * kd * kd / rows.var[m];
s2_sum[k] += refl.inv_d2[m];
n[k]++;
}
std::vector<double> s(SHELLS, 0);
for (int k = 0; k < SHELLS; k++)
s[k] = n[k] > 0 ? std::sqrt(s2_sum[k] / n[k]) : 0.0;
std::map<std::pair<int, signed char>, std::vector<double>> fs; // per element and charge, f per shell
auto form = [&](const gemmi::Atom &a) -> const std::vector<double> & {
std::vector<double> &f = fs[{static_cast<int>(a.element.elem), a.charge}];
if (f.empty()) {
const auto &coef = IonFormFactor<double>(a.element.elem, a.charge);
f.resize(SHELLS, 0);
for (int k = 0; k < SHELLS; k++)
f[k] = coef.calculate_sf(s[k] * s[k] / 4.0);
}
return f;
};
// a = j1(x) / x and b = j2(x) per shell at distance r, for f_k f_l exp(-(B_k + B_l) s^2 / 4) given per shell
auto kernel = [&](const std::vector<double> &ff, double r, double &a_sum, double &b_sum) {
a_sum = b_sum = 0;
for (int k = 0; k < SHELLS; k++) {
if (n[k] == 0)
continue;
const double x = 2 * M_PI * s[k] * r, c = w[k] * ff[k] * 4 * M_PI * M_PI * s[k] * s[k];
double a, b;
if (x < 1e-3) {
a = 1.0 / 3.0 - x * x / 30.0;
b = x * x / 15.0;
} else {
const double sx = std::sin(x), cx = std::cos(x);
a = (sx / (x * x) - cx / x) / x;
b = (3.0 / (x * x) - 1.0) * sx / x - 3.0 * cx / (x * x);
}
a_sum += c * a;
b_sum += c * b;
}
};
// the cutoff, for two carbons at the median B
std::vector<double> bs;
for (int i : params)
bs.push_back(atoms[i]->b_iso);
XrayCoupling out;
out.start.assign(params.size() + 1, 0);
if (bs.empty())
return out;
std::nth_element(bs.begin(), bs.begin() + bs.size() / 2, bs.end());
const double b_med = bs[bs.size() / 2];
gemmi::Atom carbon;
carbon.element = gemmi::El::C;
std::vector<double> ff(SHELLS);
const std::vector<double> &fc = form(carbon);
for (int k = 0; k < SHELLS; k++)
ff[k] = fc[k] * fc[k] * std::exp(-b_med * s[k] * s[k] / 2.0);
double a0, b0;
kernel(ff, 0.0, a0, b0);
double cutoff = 1.0;
for (double r = 1.0; r <= 8.0; r += 0.1) {
double a, b;
kernel(ff, r, a, b);
if (std::max(std::fabs(a), std::fabs(a - b)) > 0.01 * a0)
cutoff = r + 0.1;
}
// the neighbours by a grid of cells one cutoff wide
std::map<std::array<int, 3>, std::vector<int>> cells;
auto cell_of = [&](const gemmi::Position &p) {
return std::array<int, 3>{static_cast<int>(std::floor(p.x / cutoff)), static_cast<int>(std::floor(p.y / cutoff)),
static_cast<int>(std::floor(p.z / cutoff))};
};
auto is_param = [&](int i) { return rider_parent.empty() || rider_parent[i] < 0; };
for (size_t k = 0; k < params.size(); k++)
if (is_param(params[k]))
cells[cell_of(atoms[params[k]]->pos)].push_back(static_cast<int>(k));
std::vector<std::vector<std::pair<int, std::array<double, 6>>>> rows_of(params.size());
for (size_t k = 0; k < params.size(); k++) {
const gemmi::Atom &ak = *atoms[params[k]];
if (!is_param(params[k]))
continue;
const std::array<int, 3> c = cell_of(ak.pos);
const std::vector<double> &fk = form(ak);
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++)
for (int dz = -1; dz <= 1; dz++) {
const auto it = cells.find({c[0] + dx, c[1] + dy, c[2] + dz});
if (it == cells.end())
continue;
for (int l : it->second) {
if (l == static_cast<int>(k))
continue;
const gemmi::Atom &al = *atoms[params[l]];
const gemmi::Position d = al.pos - ak.pos;
const double r = d.length();
if (r >= cutoff || r <= 0)
continue;
const std::vector<double> &fl = form(al);
for (int q = 0; q < SHELLS; q++)
ff[q] = fk[q] * fl[q] * ak.occ * al.occ * std::exp(-(ak.b_iso + al.b_iso) * s[q] * s[q] / 4.0);
double a, b;
kernel(ff, r, a, b);
const double u[3] = {d.x / r, d.y / r, d.z / r};
rows_of[k].push_back({l, {a - b * u[0] * u[0], a - b * u[1] * u[1], a - b * u[2] * u[2],
-b * u[0] * u[1], -b * u[0] * u[2], -b * u[1] * u[2]}});
}
}
std::sort(rows_of[k].begin(), rows_of[k].end(), [](const auto &x, const auto &y) { return x.first < y.first; });
}
for (size_t k = 0; k < params.size(); k++) {
out.start[k + 1] = out.start[k] + static_cast<int>(rows_of[k].size());
for (const auto &[l, blk] : rows_of[k]) {
out.other.push_back(l);
out.block.push_back(blk);
}
}
return out;
}
// The factor that turns XrayBCurvatureShape() into the X-ray target's curvature: its second derivative along a
// random +-1 direction of the B factors of `params`, by central differences of the gradient, over what the shape
// predicts for it.
@@ -953,7 +807,6 @@ public:
gradient != nullptr ? &gr : nullptr, restraints);
}
*cost = weight_ * xray + restraints;
last_xray_ = xray;
if (gradient == nullptr)
return std::isfinite(*cost);
ctx_.FoldRiders(gx);
@@ -981,9 +834,6 @@ public:
}
Mode GetMode() const { return mode_; }
// The X-ray target and its gradient per atom (riders folded) at the last Evaluate().
double LastXray() const { return last_xray_; }
const std::vector<std::array<double, 4>> &LastXrayGradient() const { return gx_; }
double Weight() const { return weight_; }
const std::vector<int> &Atoms() const { return param_atoms_; }
@@ -1002,66 +852,6 @@ private:
// the gradients per atom, kept from evaluation to evaluation (7 MB each on a large model: made anew, their
// pages fault in every time)
mutable std::vector<std::array<double, 4>> gx_, gr_;
mutable double last_xray_ = 0;
};
// PROTOTYPE (RUGNUX_NEWTON_JOINT=1): the positions and the B factors at once, against X + R_geometry / w + R_B / adp_w -
// stationary where the positions' target (w X + R_geometry) and the B factors' (adp_w X + R_B) both are, so that one
// evaluation moves both. The parameters: x y z of every atom, then its B in units of B_UNIT (one step bound for all).
class XyzBTarget {
public:
static constexpr double B_UNIT = MAX_STEP_B / MAX_STEP_XYZ;
XyzBTarget(Context &ctx, const std::vector<int> &param_atoms, double w, double adp_w, const RefinementTopology &topo)
: ctx_(ctx), xyz_(ctx, AtomTarget::Mode::Xyz, param_atoms, w, 0, topo),
b_(ctx, AtomTarget::Mode::B, param_atoms, adp_w, 1, topo), n_(param_atoms.size()), w_(w), adp_w_(adp_w) {}
std::vector<double> Get() const {
std::vector<double> p = xyz_.Get();
for (double b : b_.Get())
p.push_back(b / B_UNIT);
return p;
}
void Set(const double *p) const {
std::vector<double> b(p + 3 * n_, p + 4 * n_);
for (double &x : b)
x *= B_UNIT;
xyz_.Set(p);
b_.Set(b.data());
}
double MaxStep() const { return MAX_STEP_XYZ; }
bool Evaluate(const double *p, double *cost, double *gradient) const {
// each part's own evaluation at the same point gives w X + R_geometry and adp_w X + R_B, and their gradients
std::vector<double> g_xyz(3 * n_), g_b(n_), b(p + 3 * n_, p + 4 * n_);
for (double &x : b)
x *= B_UNIT;
b_.Set(b.data());
double f_xyz = 0;
if (!xyz_.Evaluate(p, &f_xyz, g_xyz.data()))
return false;
// the B part at the same model: its X-ray target is the same one, only its restraints are added
std::vector<std::array<double, 4>> gr;
const double r_b = ctx_.engine->EvaluateRestraints(1, ctx_.XyzB(), &gr);
const double xray = xyz_.LastXray();
*cost = xray + (f_xyz - w_ * xray) / w_ + r_b / adp_w_;
const std::vector<std::array<double, 4>> &gx = xyz_.LastXrayGradient();
for (size_t k = 0; k < 3 * n_; k++)
gradient[k] = g_xyz[k] / w_;
for (size_t k = 0; k < n_; k++) {
const int i = xyz_.Atoms()[k];
const double g = gx[i][3] + gr[i][3] / adp_w_;
const double bk = b[k];
const bool held = (bk <= ctx_.BLow(i) && g > 0) || (bk >= ctx_.BHigh(i) && g < 0);
gradient[3 * n_ + k] = held ? 0.0 : g * B_UNIT;
}
return std::isfinite(*cost);
}
private:
Context &ctx_;
AtomTarget xyz_, b_;
size_t n_;
double w_, adp_w_;
};
// The X-ray target's derivatives in U of every atom, with what the target says of a riding hydrogen's B (its parent's
@@ -1203,114 +993,6 @@ private:
std::vector<double> radius_;
};
// The minimiser's diagonal for the B factors of `param_atoms` (RefinementMinimiser::SetDiagonal): weight times the
// X-ray target's curvature in B plus the B restraints', each element at least a thousandth of the median. The
// positions take none: their restraints' curvature is that of stiff bonds and angles, which move atoms together, so
// as a diagonal it slows rather than scales the minimiser.
std::vector<double> BDiagonal(const std::vector<double> &xray, const std::vector<double> &restraints,
const std::vector<int> &param_atoms, double weight) {
std::vector<double> h;
for (int i : param_atoms)
h.push_back(weight * xray[i] + restraints[i]);
if (h.empty()) // no atom the dictionary describes
return h;
std::vector<double> sorted = h;
std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end());
const double floor = std::max(1e-3 * sorted[sorted.size() / 2], 1e-12);
for (double &v : h)
v = std::max(v, floor);
return h;
}
// `minimiser` carries its memory from the call before; `diagonal` is the curvature it scales the steps by (none: 1).
template <typename Target>
void Minimise(Context &ctx, const Target &target, int iterations, RefinementMinimiser &minimiser,
std::vector<double> diagonal = {}, const char *tag = "?") {
std::vector<double> p = target.Get();
if (p.empty())
return;
minimiser.SetDiagonal(diagonal.empty() ? std::vector<double>(p.size(), 1.0) : std::move(diagonal));
const RefinementMinimiser::Outcome o = minimiser.Minimise([&](const std::vector<double> &x, double &f, std::vector<double> &g) {
return target.Evaluate(x.data(), &f, g.data());
},
p, iterations, MINIMISER_F_TOLERANCE, target.MaxStep(), [&]() { return ctx.Cancelled(); });
target.Set(p.data()); // where the minimiser ended, not where its last line search probed
if (RefineStats()) fprintf(stderr, "MINSTAT lbfgs.%s it=%d ev=%d lim=%d n=%zu f0=%.6g f1=%.6g\n", tag, o.iterations, o.evaluations,
iterations, p.size(), o.f_start, o.f_end);
}
// PROTOTYPE (RUGNUX_NEWTON=1): the minimisation by damped Newton steps (RefinementNewton) on the Gauss-Newton normal
// matrix, as REFMAC refines on its sparse normal matrix: the X-ray target's curvature per parameter on the diagonal (no
// coupling between atoms), the restraints' J^T J in full.
// Following Murshudov, Vagin & Dodson (1997) Acta Cryst. D53, 240-255
struct NewtonSettings {
int xyz_iterations = 30, b_iterations = 20; // the most per macro-cycle, as the L-BFGS's
double relative_stop = 0.0;
double step_scale = 1.0; // the step bound, times the L-BFGS's
};
const NewtonSettings &Newton() {
static const NewtonSettings s = [] {
NewtonSettings n;
if (const char *e = getenv("RUGNUX_NEWTON_XYZ"))
n.xyz_iterations = std::atoi(e);
if (const char *e = getenv("RUGNUX_NEWTON_B"))
n.b_iterations = std::atoi(e);
if (const char *e = getenv("RUGNUX_NEWTON_RELSTOP"))
n.relative_stop = std::atof(e);
if (const char *e = getenv("RUGNUX_NEWTON_STEPSCALE"))
n.step_scale = std::atof(e);
return n;
}();
return s;
}
bool NewtonQuasi();
// `target` by `newton` from where it is, with H v = product and D = diagonal (each element > 0).
template <typename Target>
void MinimiseNewton(Context &ctx, const Target &target, RefinementNewton &newton, const RefinementNewton::Product &product,
const std::vector<double> &diagonal, int iterations, const char *tag,
const RefinementNewton::Preconditioner &precondition = nullptr) {
std::vector<double> p = target.Get();
if (p.empty())
return;
if (NewtonQuasi() && newton.lbfgs != nullptr) {
// RUGNUX_NEWTON=2: the L-BFGS, its initial inverse Hessian the Gauss-Newton matrix solved by CG
RefinementMinimiser &m = *newton.lbfgs;
if (const char *e = getenv("RUGNUX_NEWTON_CGTOL"))
newton.cg_tolerance = std::atof(e);
const int cg_before = newton.cg_iterations;
m.SetPreconditioner([&](const std::vector<double> &x, std::vector<double> &q) {
std::vector<double> z;
newton.SolveUndamped(product, diagonal, precondition, x, q, z);
q.swap(z);
});
const RefinementMinimiser::Outcome o = m.Minimise(
[&](const std::vector<double> &x, double &f, std::vector<double> &g) { return target.Evaluate(x.data(), &f, g.data()); },
p, iterations, MINIMISER_F_TOLERANCE, target.MaxStep(), [&]() { return ctx.Cancelled(); });
m.SetPreconditioner(nullptr);
target.Set(p.data());
if (RefineStats())
fprintf(stderr, "MINSTAT qn.%s it=%d ev=%d lim=%d cg=%d f0=%.6g f1=%.6g\n", tag, o.iterations, o.evaluations,
iterations, newton.cg_iterations - cg_before, o.f_start, o.f_end);
return;
}
newton.relative_stop = Newton().relative_stop;
newton.trace = getenv("RUGNUX_NEWTON_TRACE") != nullptr;
if (const char *e = getenv("RUGNUX_NEWTON_CGMAX"))
newton.cg_max = std::atoi(e);
if (const char *e = getenv("RUGNUX_NEWTON_CGTOL"))
newton.cg_tolerance = std::atof(e);
const int cg_before = newton.cg_iterations;
const RefinementMinimiser::Outcome o = newton.Minimise(
[&](const std::vector<double> &x, double &f, std::vector<double> &g) { return target.Evaluate(x.data(), &f, g.data()); },
product, diagonal, p, iterations, MINIMISER_F_TOLERANCE, target.MaxStep() * Newton().step_scale,
[&]() { return ctx.Cancelled(); }, precondition);
target.Set(p.data());
if (RefineStats())
fprintf(stderr, "MINSTAT newton.%s it=%d ev=%d lim=%d cg=%d f0=%.6g f1=%.6g\n", tag, o.iterations, o.evaluations,
iterations, newton.cg_iterations - cg_before, o.f_start, o.f_end);
}
// Each element at least a thousandth of the median (a parameter the target does not see still takes a finite step).
std::vector<double> FlooredDiagonal(std::vector<double> d) {
if (d.empty())
@@ -1323,6 +1005,37 @@ std::vector<double> FlooredDiagonal(std::vector<double> d) {
return d;
}
// The minimisers' initial inverse Hessian (RefinementMinimiser::SetInverseHessian) is the Gauss-Newton normal matrix of
// the target, as REFMAC refines on its sparse normal matrix: the X-ray target's curvature per atom on the diagonal and
// the restraints' J^T J in full, solved for each direction by conjugate gradients to a tenth of the residual.
// Following Murshudov, Vagin & Dodson (1997) Acta Cryst. D53, 240-255
constexpr int NORMAL_CG_ITERATIONS = 50;
constexpr double NORMAL_CG_TOLERANCE = 0.1;
// `target` by `minimiser` (its memory from the call before) from where it is, H0 the inverse of the normal matrix:
// hv = H v at x (product), z = M^-1 r for a preconditioner M of it (precondition).
template <typename Target>
void MinimiseWithNormalMatrix(Context &ctx, const Target &target, RefinementMinimiser &minimiser, int iterations,
const std::function<void(const std::vector<double> &, const std::vector<double> &,
std::vector<double> &)> &product,
const std::function<void(const std::vector<double> &, std::vector<double> &)> &precondition) {
std::vector<double> p = target.Get();
if (p.empty())
return;
minimiser.SetInverseHessian([&](const std::vector<double> &x, std::vector<double> &q) {
std::vector<double> z;
ConjugateGradients([&](const std::vector<double> &v, std::vector<double> &hv) { product(x, v, hv); }, precondition,
q, z, NORMAL_CG_ITERATIONS, NORMAL_CG_TOLERANCE);
q.swap(z);
});
minimiser.Minimise([&](const std::vector<double> &x, double &f, std::vector<double> &g) {
return target.Evaluate(x.data(), &f, g.data());
},
p, iterations, MINIMISER_F_TOLERANCE, target.MaxStep(), [&]() { return ctx.Cancelled(); });
minimiser.SetInverseHessian(nullptr);
target.Set(p.data()); // where the minimiser ended, not where its last line search probed
}
// The restraints' Gauss-Newton normal matrix J^T J (RestraintGaussNewton) on the x y z or the B of `param_atoms`, at the
// point last given to At(); an atom that is not a parameter (a rider, an atom held) drops out of it. With the engine on
// a GPU, on its card (RestraintNormalMatrixGPU).
@@ -1340,7 +1053,7 @@ public:
}
void At(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb) {
const RefinementStage stage("newton.jacobian");
const RefinementStage stage("normal.jacobian");
#ifdef JFJOCH_USE_CUDA
if (gpu_)
return gpu_->At(set, xyzb);
@@ -1371,7 +1084,7 @@ public:
// hv = J^T J v: J v per row, then per parameter atom the sum over its entries
void Multiply(const std::vector<double> &v, std::vector<double> &hv) {
const RefinementStage stage("newton.product");
const RefinementStage stage("normal.product");
#ifdef JFJOCH_USE_CUDA
if (gpu_)
return gpu_->Multiply(v, hv);
@@ -1444,27 +1157,6 @@ private:
#endif
};
// hv[offset + 3k ..] += scale sum over the neighbours l of k of the X-ray block (k, l) times v[offset + 3l ..].
void AddXrayCoupling(const Context::XrayCoupling &c, double scale, const std::vector<double> &v, size_t offset,
std::vector<double> &hv, size_t nthreads) {
const int n = static_cast<int>(c.start.size()) - 1;
ParallelChunks(n, ThreadsForWork(n, nthreads, 4096), [&](int lo, int hi) {
for (int k = lo; k < hi; k++) {
double s0 = 0, s1 = 0, s2 = 0;
for (int q = c.start[k]; q < c.start[k + 1]; q++) {
const std::array<double, 6> &m = c.block[q];
const double *x = &v[offset + 3 * c.other[q]];
s0 += m[0] * x[0] + m[3] * x[1] + m[4] * x[2];
s1 += m[3] * x[0] + m[1] * x[1] + m[5] * x[2];
s2 += m[4] * x[0] + m[5] * x[1] + m[2] * x[2];
}
hv[offset + 3 * k] += scale * s0;
hv[offset + 3 * k + 1] += scale * s1;
hv[offset + 3 * k + 2] += scale * s2;
}
});
}
// z = M^-1 r for M symmetric positive definite (xx yy zz xy xz yz), by its adjugate.
std::array<double, 3> Solve3(const std::array<double, 6> &m, double r0, double r1, double r2) {
const double a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];
@@ -1475,43 +1167,40 @@ std::array<double, 3> Solve3(const std::array<double, 6> &m, double r0, double r
(c02 * r0 + c12 * r1 + c22 * r2) / det};
}
// The positions' preconditioner: per atom its 3 x 3 block of H (`blocks`, the restraints' over `scale`, plus the X-ray
// curvature `h`) and lambda times the damping's diagonal `diagonal`; parameters 3k..3k+2 of atom k from `offset` on.
void PreconditionBlocks(const std::vector<std::array<double, 6>> &blocks, double scale, const std::vector<double> &h,
const std::vector<double> &diagonal, size_t offset, const std::vector<double> &r, double lambda,
std::vector<double> &z) {
// The positions' preconditioner: per atom its 3 x 3 block of H, the restraints' (`blocks`) plus the X-ray curvature `h`.
void PreconditionBlocks(const std::vector<std::array<double, 6>> &blocks, const std::vector<double> &h,
const std::vector<double> &r, std::vector<double> &z) {
for (size_t k = 0; k < blocks.size(); k++) {
const size_t o = offset + 3 * k;
std::array<double, 6> m;
for (int c = 0; c < 6; c++)
m[c] = blocks[k][c] / scale;
std::array<double, 6> m = blocks[k];
for (int c = 0; c < 3; c++)
m[c] += h[o + c] + lambda * diagonal[o + c];
const std::array<double, 3> s = Solve3(m, r[o], r[o + 1], r[o + 2]);
z[o] = s[0];
z[o + 1] = s[1];
z[o + 2] = s[2];
m[c] += h[3 * k + c];
const std::array<double, 3> s = Solve3(m, r[3 * k], r[3 * k + 1], r[3 * k + 2]);
z[3 * k] = s[0];
z[3 * k + 1] = s[1];
z[3 * k + 2] = s[2];
}
}
// The positions or the B factors: H = diag(xray) (per atom, already times the weight) + the restraints' J^T J of `set`.
void MinimiseAtomsNewton(Context &ctx, const AtomTarget &target, RefinementNewton &newton, const std::vector<double> &xray,
const RestraintSet &set, int iterations, const Context::XrayCoupling *coupling = nullptr,
double coupling_scale = 0) {
// The positions or the B factors: H = diag(xray) (per atom, already times the weight) + the restraints' J^T J of `set`,
// the Jacobian at the point of the product. Preconditioned per atom: by its 3 x 3 block of H at the start for the
// positions, by the diagonal for the B factors.
void MinimiseAtoms(Context &ctx, const AtomTarget &target, RefinementMinimiser &minimiser, const std::vector<double> &xray,
const RestraintSet &set, int iterations) {
const bool xyz = target.GetMode() == AtomTarget::Mode::Xyz;
const int per = xyz ? 3 : 1;
std::vector<double> p = target.Get();
const size_t n = p.size();
std::vector<double> x_at = target.Get();
const size_t n = x_at.size();
std::vector<double> h(n);
for (size_t k = 0; k < n; k++)
h[k] = xray[target.Atoms()[k / per]];
RestraintNormalMatrix normal(ctx, target.Atoms(), xyz);
std::vector<double> x_at = p;
target.Set(p.data());
target.Set(x_at.data());
normal.At(set, ctx.XyzB());
std::vector<double> diagonal = normal.Diagonal();
for (size_t k = 0; k < n; k++)
diagonal[k] += h[k];
diagonal = FlooredDiagonal(diagonal);
const std::vector<std::array<double, 6>> blocks = xyz ? normal.Blocks() : std::vector<std::array<double, 6>>();
auto product = [&](const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv) {
if (x != x_at) {
x_at = x;
@@ -1521,86 +1210,22 @@ void MinimiseAtomsNewton(Context &ctx, const AtomTarget &target, RefinementNewto
normal.Multiply(v, hv);
for (size_t k = 0; k < n; k++)
hv[k] += h[k] * v[k];
if (coupling != nullptr)
AddXrayCoupling(*coupling, coupling_scale, v, 0, hv, ctx.nthreads);
};
diagonal = FlooredDiagonal(diagonal);
if (!xyz) {
MinimiseNewton(ctx, target, newton, product, diagonal, iterations, "b");
return;
}
// each atom's 3 x 3 block of H at the start, fixed for the call
const std::vector<std::array<double, 6>> blocks = normal.Blocks();
MinimiseNewton(ctx, target, newton, product, diagonal, iterations, "xyz",
[&](const std::vector<double> &r, double lambda, std::vector<double> &z) {
PreconditionBlocks(blocks, 1.0, h, diagonal, 0, r, lambda, z);
});
}
// The positions and the B factors at once (XyzBTarget): H the two blocks of MinimiseAtomsNewton(), each over its weight
// (`xray_xyz`, `xray_b`: per atom, the X-ray curvature alone), no coupling between them.
void MinimiseJointNewton(Context &ctx, const XyzBTarget &target, const std::vector<int> &atoms, RefinementNewton &newton,
const std::vector<double> &xray_xyz, const std::vector<double> &xray_b, const RestraintSet &set_xyz,
const RestraintSet &set_b, double w, double adp_w, int iterations,
const Context::XrayCoupling *coupling = nullptr, double coupling_scale = 0) {
const size_t n = atoms.size();
const double u2 = XyzBTarget::B_UNIT * XyzBTarget::B_UNIT;
RestraintNormalMatrix normal_xyz(ctx, atoms, true), normal_b(ctx, atoms, false);
std::vector<double> x_at = target.Get();
auto at = [&](const std::vector<double> &x) {
target.Set(x.data());
const std::vector<std::array<double, 4>> xyzb = ctx.XyzB();
normal_xyz.At(set_xyz, xyzb);
normal_b.At(set_b, xyzb);
auto precondition = [&](const std::vector<double> &r, std::vector<double> &z) {
z.resize(r.size());
if (xyz)
PreconditionBlocks(blocks, h, r, z);
else
for (size_t k = 0; k < n; k++)
z[k] = r[k] / diagonal[k];
};
at(x_at);
std::vector<double> diagonal(4 * n);
{
const std::vector<double> dx = normal_xyz.Diagonal(), db = normal_b.Diagonal();
for (size_t k = 0; k < n; k++) {
for (int c = 0; c < 3; c++)
diagonal[3 * k + c] = xray_xyz[atoms[k]] + dx[3 * k + c] / w;
diagonal[3 * n + k] = u2 * (xray_b[atoms[k]] + db[k] / adp_w);
}
}
std::vector<double> vx(3 * n), vb(n), hx, hb;
auto product = [&](const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv) {
if (x != x_at) {
x_at = x;
at(x);
}
std::copy(v.begin(), v.begin() + 3 * n, vx.begin());
std::copy(v.begin() + 3 * n, v.end(), vb.begin());
normal_xyz.Multiply(vx, hx);
normal_b.Multiply(vb, hb);
hv.resize(4 * n);
for (size_t k = 0; k < n; k++) {
for (int c = 0; c < 3; c++)
hv[3 * k + c] = hx[3 * k + c] / w + xray_xyz[atoms[k]] * v[3 * k + c];
hv[3 * n + k] = u2 * (hb[k] / adp_w + xray_b[atoms[k]] * v[3 * n + k]);
}
if (coupling != nullptr)
AddXrayCoupling(*coupling, coupling_scale, v, 0, hv, ctx.nthreads);
};
diagonal = FlooredDiagonal(diagonal);
// the positions' 3 x 3 blocks of H at the start, fixed for the call; the B factors' diagonal
const std::vector<std::array<double, 6>> blocks = normal_xyz.Blocks();
std::vector<double> h(3 * n);
for (size_t k = 0; k < n; k++)
for (int c = 0; c < 3; c++)
h[3 * k + c] = xray_xyz[atoms[k]];
MinimiseNewton(ctx, target, newton, product, diagonal, iterations, "xyzb",
[&](const std::vector<double> &r, double lambda, std::vector<double> &z) {
PreconditionBlocks(blocks, w, h, diagonal, 0, r, lambda, z);
for (size_t k = 3 * n; k < 4 * n; k++)
z[k] = r[k] / ((1 + lambda) * diagonal[k]);
});
MinimiseWithNormalMatrix(ctx, target, minimiser, iterations, product, precondition);
}
// Each atom's U (in 8 pi^2 U): H = diag(xray) per element + the U restraints' Hessian, exact by differences of their
// gradient (they are quadratic in U); D the diagonal the L-BFGS takes.
void MinimiseUNewton(Context &ctx, const AdpTarget &target, RefinementNewton &newton, const std::vector<double> &xray,
const std::vector<double> &diagonal, int iterations) {
// gradient (they are quadratic in U); preconditioned by `diagonal`.
void MinimiseU(Context &ctx, const AdpTarget &target, RefinementMinimiser &minimiser, const std::vector<double> &xray,
const std::vector<double> &diagonal, int iterations) {
const size_t n = xray.size();
std::vector<double> x_at, g_at(n), xp(n), gp(n);
auto product = [&](const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv) {
@@ -1623,13 +1248,19 @@ void MinimiseUNewton(Context &ctx, const AdpTarget &target, RefinementNewton &ne
for (size_t k = 0; k < n; k++)
hv[k] += xray[k] * v[k];
};
MinimiseNewton(ctx, target, newton, product, diagonal, iterations, "u");
auto precondition = [&](const std::vector<double> &r, std::vector<double> &z) {
z.resize(n);
for (size_t k = 0; k < n; k++)
z[k] = r[k] / diagonal[k];
};
MinimiseWithNormalMatrix(ctx, target, minimiser, iterations, product, precondition);
}
// The TLS bodies: X-ray only, H = sum over each body's atoms of A^T C A, A the derivatives of the atom's U in the body's
// parameters (linear in them), C the X-ray curvature of its U per element (`xray_b`: of its B, a third of it to each).
void MinimiseTlsNewton(Context &ctx, const AdpTarget &target, RefinementNewton &newton, const std::vector<double> &xray_b,
int iterations) {
// parameters (linear in them), C the X-ray curvature of its U per element (`xray_b`: of its B, a third of it to each);
// one dense block per body, preconditioned by its diagonal.
void MinimiseTls(Context &ctx, const AdpTarget &target, RefinementMinimiser &minimiser, const std::vector<double> &xray_b,
int iterations) {
constexpr int P = TlsBody::PARAMETERS;
const size_t nb = ctx.tls.size();
std::vector<std::array<double, P * P>> blocks(nb);
@@ -1654,6 +1285,7 @@ void MinimiseTlsNewton(Context &ctx, const AdpTarget &target, RefinementNewton &
for (size_t b = 0; b < nb; b++)
for (int k = 0; k < P; k++)
diagonal[b * P + k] = blocks[b][k * P + k];
diagonal = FlooredDiagonal(diagonal);
auto product = [&](const std::vector<double> &, const std::vector<double> &v, std::vector<double> &hv) {
hv.assign(v.size(), 0.0);
for (size_t b = 0; b < nb; b++)
@@ -1661,7 +1293,12 @@ void MinimiseTlsNewton(Context &ctx, const AdpTarget &target, RefinementNewton &
for (int l = 0; l < P; l++)
hv[b * P + k] += blocks[b][k * P + l] * v[b * P + l];
};
MinimiseNewton(ctx, target, newton, product, FlooredDiagonal(diagonal), iterations, "tls");
auto precondition = [&](const std::vector<double> &r, std::vector<double> &z) {
z.resize(r.size());
for (size_t k = 0; k < r.size(); k++)
z[k] = r[k] / diagonal[k];
};
MinimiseWithNormalMatrix(ctx, target, minimiser, iterations, product, precondition);
}
// Groups of atoms that move as rigid bodies (one per chain) against the X-ray target: per body an angle-axis
@@ -1840,18 +1477,6 @@ double BalancedWeight(Context &ctx, const std::vector<int> &refinable) {
std::vector<std::array<double, 4>> gx, gr;
ctx.engine->Evaluate(ctx.Model(), &gx);
std::vector<std::array<double, 4>> xyzb = ctx.XyzB();
{ // MEASUREMENT (lane k): the ratio of the gradients' norms at the model as given, unshaken
std::vector<std::array<double, 4>> g0;
ctx.engine->EvaluateRestraints(0, xyzb, &g0);
double a = 0, b = 0;
for (int i : refinable)
for (int c = 0; c < 3; c++) {
a += gx[i][c] * gx[i][c];
b += g0[i][c] * g0[i][c];
}
if (RefineStats()) fprintf(stderr, "WEIGHTSTAT unshaken_ratio=%.4g |gx|=%.4g |gr0|=%.4g\n", a > 0 ? std::sqrt(b / a) : 0.0,
std::sqrt(a), std::sqrt(b));
}
std::mt19937 rng(1);
std::normal_distribution<double> shake(0.0, 0.1);
for (std::array<double, 4> &a : xyzb)
@@ -2496,40 +2121,13 @@ double XrayGradientNorm(Context &ctx, const std::vector<int> &refinable) {
return n;
}
// PROTOTYPE switch: RUGNUX_NEWTON=1 the positions, the B factors, the U and the TLS bodies by damped Newton steps.
bool NewtonOn() {
static const bool on = getenv("RUGNUX_NEWTON") != nullptr && std::string(getenv("RUGNUX_NEWTON")) != "0";
return on;
}
// RUGNUX_NEWTON_PARTS (default "xyz,b,tls,u"): which of the minimisations take the Newton steps.
bool NewtonOn(const char *part) {
static const std::string parts = getenv("RUGNUX_NEWTON_PARTS") != nullptr ? getenv("RUGNUX_NEWTON_PARTS") : "xyz,b,tls,u";
return NewtonOn() && parts.find(part) != std::string::npos;
}
// RUGNUX_NEWTON=2: the L-BFGS on top of the Gauss-Newton matrix (MinimiseNewton).
bool NewtonQuasi() {
static const bool on = getenv("RUGNUX_NEWTON") != nullptr && std::string(getenv("RUGNUX_NEWTON")) == "2";
return on;
}
// RUGNUX_NEWTON_COUPLING=1: the X-ray normal matrix between neighbouring atoms' positions in H (XrayXyzCoupling).
bool NewtonCoupling() {
static const bool on = getenv("RUGNUX_NEWTON_COUPLING") != nullptr;
return on;
}
// RUGNUX_NEWTON_JOINT=1: where the B factors are refined isotropically, they and the positions at once (XyzBTarget).
bool NewtonJoint() {
static const bool on = getenv("RUGNUX_NEWTON_JOINT") != nullptr;
return on;
}
// The X-ray curvature per atom in each of x, y, z at weight w, for the row model `rows` the engine has; `scale`
// calibrated at the first call of the trial (negative: not yet).
std::vector<double> NewtonXyzCurvature(Context &ctx, const std::vector<int> &refinable, const XrayRowModel &rows,
double w, double &scale) {
std::vector<double> XyzCurvature(Context &ctx, const std::vector<int> &refinable, const XrayRowModel &rows, double w,
double &scale) {
std::vector<double> shape = ctx.XrayXyzCurvatureShape(rows);
if (scale < 0) {
if (scale < 0)
scale = ctx.CalibrateXyzCurvature(refinable, shape);
if (RefineStats()) fprintf(stderr, "NEWTONCAL xyz_scale=%.4g\n", scale);
}
for (double &x : shape)
x *= w * scale;
return shape;
@@ -2584,13 +2182,9 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
b(ctx, AtomTarget::Mode::B, refinable, adp_w, 1, topo);
const AdpTarget tls_target(ctx, AdpTarget::Mode::Tls, refinable, 1.0, nullptr);
const AdpTarget u_target(ctx, AdpTarget::Mode::U, u_atoms, adp_w, &u_restraints);
RefinementMinimiser xyz_minimiser(20, ctx.nthreads), b_minimiser(20, ctx.nthreads), tls_minimiser(20, ctx.nthreads);
RefinementNewton xyz_newton, b_newton, tls_newton, u_newton;
xyz_newton.lbfgs = &xyz_minimiser;
b_newton.lbfgs = &b_minimiser;
tls_newton.lbfgs = &tls_minimiser;
u_newton.lbfgs = &b_minimiser;
double xray_scale = 0, xyz_scale = -1, tls_scale = -1;
RefinementMinimiser xyz_minimiser, b_minimiser, tls_minimiser;
// the X-ray curvature's calibrations (CalibrateXyzCurvature, CalibrateBCurvature), once per trial
double xyz_scale = -1, b_scale = -1;
for (int cycle = 0; cycle < cycles && !ctx.Cancelled(); cycle++) {
PlaceRiders(ctx, topo);
if (cycle == 0 && fit != nullptr)
@@ -2603,15 +2197,11 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
}
if (adp_w > 0)
ctx.MoveOverallB();
bool joint_done = false; // the B factors refined with the positions (MinimiseJointNewton)
if (!hold_positions) {
RestraintSet xyz_set;
const RestraintSet set = RestraintsNow(ctx, topo, ncs, ncs_sigma);
{
const RestraintSet set = RestraintsNow(ctx, topo, ncs, ncs_sigma);
const RefinementStage s1("set_restraints");
ctx.engine->SetRestraints(0, set);
if (NewtonOn())
xyz_set = set;
}
const RefinementStage s2("minimise.xyz");
const double b_h = cycle < static_cast<int>(tw.blur.size()) ? tw.blur[cycle] : 0.0;
@@ -2626,62 +2216,33 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
ctx.engine->SetRowModel(blurred);
const double nh = XrayGradientNorm(ctx, refinable);
const AtomTarget xyz_h(ctx, AtomTarget::Mode::Xyz, refinable, nh > 0 ? w * std::sqrt(n0 / nh) : w, 0, topo);
if (NewtonOn("xyz")) {
const std::vector<double> h = NewtonXyzCurvature(ctx, refinable, blurred, xyz_h.Weight(), xyz_scale);
const Context::XrayCoupling c = NewtonCoupling() ? ctx.XrayXyzCoupling(blurred, refinable)
: Context::XrayCoupling();
MinimiseAtomsNewton(ctx, xyz_h, xyz_newton, h, xyz_set, Newton().xyz_iterations,
NewtonCoupling() ? &c : nullptr, xyz_h.Weight() * xyz_scale);
}
else
Minimise(ctx, xyz_h, settings.xyz_iterations, xyz_minimiser, {}, "xyz_blur");
MinimiseAtoms(ctx, xyz_h, xyz_minimiser, XyzCurvature(ctx, refinable, blurred, xyz_h.Weight(), xyz_scale),
set, settings.xyz_iterations);
ctx.engine->SetRowModel(ctx.rows);
} else if (NewtonOn() && NewtonJoint() && kind == AdpHypothesis::Kind::Isotropic && adp_w > 0) {
const RestraintSet b_set = BRestraintsNow(ctx, topo);
ctx.engine->SetRestraints(1, b_set);
std::vector<double> xray_b = ctx.XrayBCurvatureShape();
if (cycle == 0)
xray_scale = ctx.CalibrateBCurvature(refinable, xray_b);
for (double &x : xray_b)
x *= xray_scale;
const XyzBTarget xyz_b(ctx, refinable, w, adp_w, topo);
const std::vector<double> h = NewtonXyzCurvature(ctx, refinable, ctx.rows, 1.0, xyz_scale);
const Context::XrayCoupling c = NewtonCoupling() ? ctx.XrayXyzCoupling(ctx.rows, refinable)
: Context::XrayCoupling();
MinimiseJointNewton(ctx, xyz_b, refinable, xyz_newton, h, xray_b, xyz_set, b_set, w, adp_w,
Newton().xyz_iterations, NewtonCoupling() ? &c : nullptr, xyz_scale);
joint_done = true;
} else if (NewtonOn("xyz")) {
const std::vector<double> h = NewtonXyzCurvature(ctx, refinable, ctx.rows, w, xyz_scale);
const Context::XrayCoupling c = NewtonCoupling() ? ctx.XrayXyzCoupling(ctx.rows, refinable)
: Context::XrayCoupling();
MinimiseAtomsNewton(ctx, xyz, xyz_newton, h, xyz_set, Newton().xyz_iterations,
NewtonCoupling() ? &c : nullptr, w * xyz_scale);
}
else
Minimise(ctx, xyz, settings.xyz_iterations, xyz_minimiser, {}, "xyz");
} else
MinimiseAtoms(ctx, xyz, xyz_minimiser, XyzCurvature(ctx, refinable, ctx.rows, w, xyz_scale), set,
settings.xyz_iterations);
}
// the X-ray curvature in B for the atoms as they are, which TLS, U and B take a share of
auto b_curvature = [&]() {
std::vector<double> c = ctx.XrayBCurvatureShape();
if (b_scale < 0)
b_scale = ctx.CalibrateBCurvature(refinable, c);
for (double &x : c)
x *= b_scale;
return c;
};
if (kind == AdpHypothesis::Kind::Tls) {
ctx.ApplyTls(); // the bodies' U at the atoms as they are
const RefinementStage s4("minimise.tls");
if (NewtonOn("tls")) {
std::vector<double> xray = ctx.XrayBCurvatureShape();
if (tls_scale < 0)
tls_scale = ctx.CalibrateBCurvature(refinable, xray);
for (double &x : xray)
x *= tls_scale;
MinimiseTlsNewton(ctx, tls_target, tls_newton, xray, Newton().b_iterations);
} else
Minimise(ctx, tls_target, settings.b_iterations, tls_minimiser, {}, "tls");
MinimiseTls(ctx, tls_target, tls_minimiser, b_curvature(), settings.b_iterations);
}
if (adp_w > 0 && kind == AdpHypothesis::Kind::Anisotropic) {
// each U's six elements take a third of the curvature of its B
std::vector<double> xray = ctx.XrayBCurvatureShape();
if (cycle == 0)
xray_scale = ctx.CalibrateBCurvature(refinable, xray);
// and the restraints' curvature in 8 pi^2 U: per pair 2 / sigma^2 of the similarity and about a third of
// the rigid bond's, per isotropic atom 2 / sigma^2
std::vector<double> restraint(xray.size(), 0.0);
const std::vector<double> xray_b = b_curvature();
// each U's six elements take a third of the curvature of its B; and the restraints' curvature in 8 pi^2 U:
// per pair 2 / sigma^2 of the similarity and about a third of the rigid bond's, per isotropic atom
// 2 / sigma^2 - the preconditioner's diagonal
std::vector<double> restraint(xray_b.size(), 0.0);
const double u2 = gemmi::u_to_b() * gemmi::u_to_b();
const double per_pair = (2.0 / (URestraints::SIGMA_SIMILAR * URestraints::SIGMA_SIMILAR) +
2.0 / (3.0 * URestraints::SIGMA_RIGID * URestraints::SIGMA_RIGID)) / u2;
@@ -2691,35 +2252,21 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
}
for (int i : u_restraints.isotropic)
restraint[i] += 2.0 / (URestraints::SIGMA_ISOTROPIC * URestraints::SIGMA_ISOTROPIC) / u2;
for (double &x : xray)
x *= xray_scale / 3.0;
std::vector<double> diagonal;
for (double h : BDiagonal(xray, restraint, u_atoms, adp_w))
diagonal.insert(diagonal.end(), 6, h);
std::vector<double> h, diagonal;
for (int i : u_atoms) {
h.insert(h.end(), 6, adp_w * xray_b[i] / 3.0);
diagonal.insert(diagonal.end(), 6, adp_w * xray_b[i] / 3.0 + restraint[i]);
}
const RefinementStage s3("minimise.u");
if (NewtonOn("u")) {
std::vector<double> h;
for (int i : u_atoms)
h.insert(h.end(), 6, adp_w * xray[i]);
MinimiseUNewton(ctx, u_target, u_newton, h, diagonal, Newton().b_iterations);
} else
Minimise(ctx, u_target, settings.b_iterations, b_minimiser, diagonal, "u");
} else if (adp_w > 0 && !joint_done) {
MinimiseU(ctx, u_target, b_minimiser, h, FlooredDiagonal(diagonal), settings.b_iterations);
} else if (adp_w > 0) {
const RestraintSet b_set = BRestraintsNow(ctx, topo);
ctx.engine->SetRestraints(1, b_set);
std::vector<double> xray = ctx.XrayBCurvatureShape();
if (cycle == 0)
xray_scale = ctx.CalibrateBCurvature(refinable, xray);
for (double &x : xray)
x *= xray_scale;
std::vector<double> xray_b = b_curvature();
for (double &x : xray_b)
x *= adp_w;
const RefinementStage s3("minimise.b");
if (NewtonOn("b")) {
for (double &x : xray)
x *= adp_w;
MinimiseAtomsNewton(ctx, b, b_newton, xray, b_set, Newton().b_iterations);
} else
Minimise(ctx, b, settings.b_iterations, b_minimiser,
BDiagonal(xray, BRestraintCurvature(b_set, ctx.XyzB()), refinable, adp_w), "b");
MinimiseAtoms(ctx, b, b_minimiser, xray_b, b_set, settings.b_iterations);
}
}
PlaceRiders(ctx, topo);
@@ -2764,8 +2311,6 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
out.fit = ctx.Fitted();
out.ran = true;
out.evaluations = ctx.evaluations - evaluations_before;
if (RefineStats()) fprintf(stderr, "TRIALSTAT kind=%d adp_w=%.3g w=%.3g cycles=%d ev=%d rfree=%.4f\n", static_cast<int>(kind), adp_w, w, cycles,
out.evaluations, t.r_free);
return out;
}
@@ -2831,11 +2376,6 @@ std::vector<TrialOutcome> RunTrials(const std::vector<TrialSlot> &trial_slots,
for (const std::exception_ptr &e : errors)
if (e)
std::rethrow_exception(e);
int ev = 0;
for (const TrialOutcome &o : out)
ev += o.evaluations;
if (RefineStats()) fprintf(stderr, "TRIALSSET t=%.3f n=%zu cycles=%d ev=%d\n",
std::chrono::duration<double>(std::chrono::system_clock::now().time_since_epoch()).count(), out.size(), cycles, ev);
return out;
}
@@ -3862,10 +3402,7 @@ RefinementResult RefineOnce(const gemmi::Structure &placed, const std::vector<Me
// the members, whose best on the free set would be the best of N.
// The members are at most as many as the trial slots, one wave: on a large model, where the card holds
// few, more members would cost a wave each.
// PROTOTYPE (lane k): under RUGNUX_REFINE_PROTOCOL the members are as many as asked for, whatever the slots
const size_t population = getenv("RUGNUX_REFINE_PROTOCOL") != nullptr
? static_cast<size_t>(std::max(settings.population, 0))
: std::min<size_t>(settings.population, trial_slots.size());
const size_t population = std::min<size_t>(std::max(settings.population, 0), trial_slots.size());
if (population > 1 && state.ran && !ctx.Cancelled()) {
const RefinementStage pop_stage("population");
const double w = state.trial.weight, adp = state.trial.adp_weight, ncs_s = state.trial.ncs_sigma;
@@ -5027,30 +4564,11 @@ RefinementResult RefineModel(const gemmi::Structure &placed, const std::vector<M
"reflections in one set - {} reflections changed set", moved);
}
const std::vector<MergedReflection> &data = moved > 0 ? closed : merged;
// RefinementSettings::lean_on_cpu
#ifdef JFJOCH_USE_CUDA
const bool on_cpu = !settings.gpu || get_gpu_count() == 0;
#else
const bool on_cpu = true;
#endif
if (settings.lean_on_cpu && on_cpu) {
settings.population = 0;
settings.rounds = 1;
logger.Info("Refinement on the CPU: no population and one round (half of the evaluations)");
}
// PROTOTYPE (lane k): RUGNUX_REFINE_PROTOCOL=<population>,<rounds>[,<macro-cycles>] on the CPU and the GPU alike
if (const char *e = getenv("RUGNUX_REFINE_PROTOCOL")) {
int v[5] = {settings.population, settings.rounds, settings.macro_cycles, settings.xyz_iterations,
settings.b_iterations};
sscanf(e, "%d,%d,%d,%d,%d", &v[0], &v[1], &v[2], &v[3], &v[4]);
settings.population = v[0];
settings.rounds = v[1];
settings.macro_cycles = v[2];
settings.xyz_iterations = v[3];
settings.b_iterations = v[4];
logger.Info("Refinement EXPERIMENT protocol: population {}, {} rounds, {} macro-cycles", settings.population,
settings.rounds, settings.macro_cycles);
}
// Each arm, untwinned and twinned, is a whole refinement - the solvent built and the displacement model chosen
// against its own target - and the decision is taken on where they ended. A model only scored is scored both
// ways and decided by the same rule, so the R-free it reports is not an untwinned one by default.
@@ -48,8 +48,10 @@ struct RefinementSettings {
bool score_only = false; // only score the model as given (RefinementResult::score_start), no stage
bool group_b = true; // the placement stage's B shift per residue
int macro_cycles = 2; // per weight trial, from the model the trial starts from
int xyz_iterations = 30; // L-BFGS iterations per macro-cycle
int b_iterations = 20;
// L-BFGS iterations per macro-cycle (on the Gauss-Newton normal matrix: RefinementMinimiser), of the positions and of
// the B factors, U and TLS
int xyz_iterations = 10;
int b_iterations = 7;
// The first trials, from the placed model: the positions' X-ray weight, times the gradient-balanced one
// (BalancedWeight), each with the B factors' X-ray weight their own balanced one times each of adp_ladder (0: B
// held).
@@ -84,8 +86,9 @@ struct RefinementSettings {
// The population (RefineOnce, 2a.): this many members at most, refined from where the weight trajectory ended in
// one wave, each on the data blurred along a schedule of its own and its positions kicked or not, then crossed
// residue by residue on their averaged map and refined once more; the child kept where the free set prefers it.
// Capped at the trial slots; fewer than two: no population.
int population = 12;
// Capped at the trial slots; fewer than two: no population (the default: with the positions minimised on the
// Gauss-Newton matrix, the members took nothing off R-free over 19 sets that the two rounds did not).
int population = 0;
// A refinement against the data as twinned by each twin law the lattice admits (RefinementTwinLaws), beside the
// untwinned one, and the model of whichever the evidence favours (RefineModel).
bool twin = true;
@@ -97,11 +100,6 @@ struct RefinementSettings {
// model of this crystal scored on a free set drawn here).
bool as_given_competes = true;
bool gpu = true;
// Where the refinement runs on the CPU (no GPU wanted, or none to run on), where an evaluation costs some thirty
// times a GPU's: no population and one round, for about half of the evaluations, at an R-free 0.001 higher in the
// median of 19 sets (at most 0.015, a placed prediction the population helps). The twinned data are still refined
// against: without that arm a crystal 30% twinned is refined as untwinned.
bool lean_on_cpu = true;
size_t nthreads = 1;
size_t gpu_resident_bytes = 0; // held on the card by what runs beside
// The most weight trials run side by side, 0 for as many as the ladders and the cards take; the result does not
@@ -4,41 +4,34 @@
#pragma once
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <deque>
#include <functional>
#include <vector>
#include "../../common/ParallelFor.h"
// Limited-memory BFGS whose memory outlives one call, so that a refinement's macro-cycles - each a few dozen
// iterations on a target whose scale and likelihood parameters were refitted in between - go on from what the
// earlier ones learnt of the curvature instead of starting each from a steepest-descent step. The initial inverse
// Hessian is a diagonal the caller gives (SetDiagonal: an estimate of the Hessian's diagonal, so that a parameter
// with ten times the curvature of another takes a tenth of its step), scaled each iteration by the latest pair
// (Oren-Shanno in that metric). The line search backtracks from the full step to sufficient decrease.
// Limited-memory BFGS whose initial inverse Hessian is the caller's (SetInverseHessian: H0 q, here the Gauss-Newton
// normal matrix solved by ConjugateGradients), and whose memory outlives one call, so that a refinement's
// macro-cycles - each a few iterations on a target whose scale and likelihood parameters were refitted in between -
// go on from what the earlier ones learnt. The normal matrix holds what is known of the curvature in advance (the
// restraints exactly, the X-ray target per atom); the pairs add what it leaves out (the X-ray target's coupling of
// neighbouring atoms). The line search backtracks from the full step to sufficient decrease.
// Following Nocedal (1980) Math. Comp. 35, 773-782 and Liu & Nocedal (1989) Math. Program. 45, 503-528
class RefinementMinimiser {
public:
// f(x, g): the target at x, and its gradient in g (sized as x); false where it cannot be evaluated there.
using Target = std::function<bool(const std::vector<double> &x, double &f, std::vector<double> &g)>;
// q = H0 q at x.
using InverseHessian = std::function<void(const std::vector<double> &x, std::vector<double> &q)>;
// `nthreads`: the threads the sweeps over the parameters run on (the dot products stay serial chains).
explicit RefinementMinimiser(size_t memory = 20, size_t nthreads = 1) : memory_(memory), nthreads_(nthreads) {}
explicit RefinementMinimiser(size_t memory = 20) : memory_(memory) {}
// Forget the pairs (the target changed beyond what the memory still describes, e.g. another weight).
// Forget the pairs (the target changed beyond what the memory still describes).
void Reset() {
s_.clear();
y_.clear();
sy_.clear();
}
// The estimated diagonal of the Hessian; every element > 0.
void SetDiagonal(std::vector<double> h) { h_ = std::move(h); }
// The initial inverse Hessian as an operator instead of the diagonal: q = H0 q at x (null: the diagonal). It is
// taken as it is, without the Oren-Shanno factor.
using Preconditioner = std::function<void(const std::vector<double> &x, std::vector<double> &q)>;
void SetPreconditioner(Preconditioner p) { precondition_ = std::move(p); }
void SetInverseHessian(InverseHessian h0) { h0_ = std::move(h0); }
struct Outcome {
int iterations = 0;
@@ -52,8 +45,6 @@ public:
Outcome Minimise(const Target &target, std::vector<double> &x, int iterations, double f_tolerance, double max_step,
const std::function<bool()> &stop = nullptr) {
const size_t n = x.size();
if (h_.size() != n)
h_.assign(n, 1.0);
Outcome out;
double f = 0;
std::vector<double> g(n), d(n), x_new(n), g_new(n);
@@ -66,7 +57,7 @@ public:
break;
Direction(x, g, d);
double gd = Dot(g, d);
if (!(gd < 0)) { // not a descent direction: the memory no longer fits, start again from the diagonal
if (!(gd < 0)) { // not a descent direction: the memory no longer fits, start again from H0
Reset();
Direction(x, g, d);
gd = Dot(g, d);
@@ -80,7 +71,8 @@ public:
double f_new = 0;
bool accepted = false;
for (int ls = 0; ls < 10; ls++) {
Sweep(n, [&](size_t k) { x_new[k] = x[k] + alpha * d[k]; });
for (size_t k = 0; k < n; k++)
x_new[k] = x[k] + alpha * d[k];
const bool ok = target(x_new, f_new, g_new);
out.evaluations++;
if (ok && f_new <= f + 1e-4 * alpha * gd) {
@@ -93,29 +85,21 @@ public:
}
if (!accepted)
break;
// the pair's vectors are the ones the memory last let go, where it did: made anew, their pages fault in
std::vector<double> s = std::move(spare_s_), y = std::move(spare_y_);
s.resize(n);
y.resize(n);
Sweep(n, [&](size_t k) {
std::vector<double> s(n), y(n);
for (size_t k = 0; k < n; k++) {
s[k] = x_new[k] - x[k];
y[k] = g_new[k] - g[k];
});
}
const double sy = Dot(s, y);
if (sy > 1e-10 * std::sqrt(Dot(s, s) * Dot(y, y))) {
s_.push_back(std::move(s));
y_.push_back(std::move(y));
sy_.push_back(sy);
if (s_.size() > memory_) {
spare_s_ = std::move(s_.front());
spare_y_ = std::move(y_.front());
s_.pop_front();
y_.pop_front();
sy_.pop_front();
}
} else {
spare_s_ = std::move(s);
spare_y_ = std::move(y);
}
const double decrease = f - f_new;
x.swap(x_new);
@@ -137,82 +121,8 @@ private:
return s;
}
// fn(k) for every k below n on the threads, each element on its own: the serial loop's bits.
template <typename Fn>
void Sweep(size_t n, Fn fn) const {
ParallelChunks(static_cast<int>(n), ThreadsForWork(n, nthreads_), [&](int lo, int hi) {
for (int k = lo; k < hi; k++)
fn(static_cast<size_t>(k));
});
}
// d = -H g by the two-loop recursion, H0 = gamma diag(1/h). Every dot product is a serial chain of n
// additions, so each sweep over the parameters takes the next pair's dot product while it applies the
// previous pair's update to q - the same operations on each element in the same order as a sweep for
// each would do, with the update's memory traffic hidden under the chain.
// d = -H g by the two-loop recursion, H0 the caller's.
void Direction(const std::vector<double> &x, const std::vector<double> &g, std::vector<double> &d) const {
if (precondition_) {
DirectionPreconditioned(x, g, d);
return;
}
const size_t n = g.size(), m = s_.size();
std::vector<double> &q = q_; // kept from call to call: made anew, its pages fault in every time
q.assign(g.begin(), g.end());
std::vector<double> a(m), rho(m);
for (size_t i = 0; i < m; i++)
rho[i] = 1.0 / sy_[i];
double dot = m > 0 ? Dot(s_[m - 1], q) : 0.0, yhy = 0.0;
for (size_t i = m; i-- > 0;) {
a[i] = rho[i] * dot;
const double ai = a[i];
const double *y = y_[i].data();
dot = 0.0;
if (i > 0) {
const double *s = s_[i - 1].data();
for (size_t k = 0; k < n; k++) {
q[k] -= ai * y[k];
dot += s[k] * q[k];
}
} else {
const double *yl = y_[m - 1].data();
for (size_t k = 0; k < n; k++) {
q[k] -= ai * y[k];
yhy += yl[k] * yl[k] / h_[k];
}
}
}
const double gamma = m > 0 ? sy_[m - 1] / yhy : 1.0;
if (m > 0) {
const double *y = y_[0].data();
for (size_t k = 0; k < n; k++) {
q[k] *= gamma / h_[k];
dot += y[k] * q[k];
}
} else
for (size_t k = 0; k < n; k++)
q[k] *= gamma / h_[k];
for (size_t i = 0; i < m; i++) {
// b on its own and (a[i] - b) in the loop, as before: written as a[i] - rho[i] * dot the compiler
// contracts it into a fused multiply-add, and the bits change
const double b = rho[i] * dot;
const double *s = s_[i].data();
dot = 0.0;
if (i + 1 < m) {
const double *y = y_[i + 1].data();
for (size_t k = 0; k < n; k++) {
q[k] += s[k] * (a[i] - b);
dot += y[k] * q[k];
}
} else
for (size_t k = 0; k < n; k++)
q[k] += s[k] * (a[i] - b);
}
for (size_t k = 0; k < n; k++)
d[k] = -q[k];
}
// The two-loop recursion with H0 the preconditioner.
void DirectionPreconditioned(const std::vector<double> &x, const std::vector<double> &g, std::vector<double> &d) const {
const size_t m = s_.size(), n = g.size();
std::vector<double> q = g, a(m);
for (size_t i = m; i-- > 0;) {
@@ -220,7 +130,7 @@ private:
for (size_t k = 0; k < n; k++)
q[k] -= a[i] * y_[i][k];
}
precondition_(x, q);
h0_(x, q);
for (size_t i = 0; i < m; i++) {
const double b = Dot(y_[i], q) / sy_[i];
for (size_t k = 0; k < n; k++)
@@ -231,159 +141,50 @@ private:
d[k] = -q[k];
}
Preconditioner precondition_;
size_t memory_, nthreads_;
size_t memory_;
InverseHessian h0_;
std::deque<std::vector<double>> s_, y_;
std::deque<double> sy_; // s.y of each pair, as taken when it was kept
std::vector<double> spare_s_, spare_y_; // the pair the memory last let go, for the next one to reuse
mutable std::vector<double> q_; // Direction()'s working vector
std::vector<double> h_;
};
// Damped Newton steps (Levenberg-Marquardt) on a positive semi-definite approximation of the Hessian: each iteration
// solves (H + lambda D) d = -g by conjugate gradients preconditioned with (1 + lambda) D - H v the caller's product at
// the point of the last accepted evaluation, D H's diagonal - and takes d where it lowers f. lambda falls after a
// step the quadratic model predicted well and rises after one it did not; a step that does not lower f is solved again
// with the larger lambda, without a new gradient. An iteration is one evaluation of the target where its step is
// taken. A solve stops where an iteration lowers f by less than `relative_stop` of what the call has lowered it by.
// Following Levenberg (1944) Q. Appl. Math. 2, 164-168 and Marquardt (1963) J. SIAM 11, 431-441
class RefinementNewton {
public:
using Target = RefinementMinimiser::Target;
// hv = H v at x, the point of the last accepted evaluation.
using Product = std::function<void(const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv)>;
using Outcome = RefinementMinimiser::Outcome;
int cg_iterations = 0; // summed over the calls, for the log
RefinementMinimiser *lbfgs = nullptr; // PROTOTYPE (RUGNUX_NEWTON=2): the L-BFGS the GN matrix preconditions
int cg_max = 50;
double cg_tolerance = 0.1;
double relative_stop = 0.0;
bool trace = false;
// z = M^-1 r for M an approximation of H + lambda D that is cheap to solve (null: (1 + lambda) D).
using Preconditioner = std::function<void(const std::vector<double> &r, double lambda, std::vector<double> &z)>;
Outcome Minimise(const Target &target, const Product &product, const std::vector<double> &diagonal,
std::vector<double> &x, int iterations, double f_tolerance, double max_step,
const std::function<bool()> &stop = nullptr, const Preconditioner &precondition = nullptr) {
const size_t n = x.size();
Outcome out;
double f = 0;
std::vector<double> g(n), d(n), x_new(n), g_new(n), hd(n);
if (!target(x, f, g))
return out;
out.evaluations++;
out.f_start = out.f_end = f;
for (int it = 0; it < iterations; it++) {
if (stop && stop())
break;
bool accepted = false;
double f_new = 0;
for (int attempt = 0; attempt < 6 && !accepted; attempt++) {
Solve(product, diagonal, precondition, x, g, d);
double d_max = 0;
for (double v : d)
d_max = std::max(d_max, std::fabs(v));
if (d_max > max_step)
for (double &v : d)
v *= max_step / d_max;
product(x, d, hd);
const double gd = Dot(g, d), predicted = -(gd + 0.5 * Dot(d, hd));
if (!(gd < 0))
break;
for (size_t k = 0; k < n; k++)
x_new[k] = x[k] + d[k];
const bool ok = target(x_new, f_new, g_new);
out.evaluations++;
const double rho = ok ? (f - f_new) / predicted : -1.0;
if (trace)
fprintf(stderr, "NTRACE it=%d att=%d dmax=%.3g lambda=%.3g pred=%.4g act=%.4g rho=%.3f\n", it, attempt,
d_max, lambda_, predicted, f - f_new, rho);
if (ok && f_new <= f + 1e-4 * gd) {
accepted = true;
if (rho > 0.75)
lambda_ = std::max(lambda_ / 3.0, 1e-4);
else if (rho < 0.25)
lambda_ *= 2.0;
} else
lambda_ = std::max(4.0 * lambda_, 0.1);
}
if (!accepted)
break;
const double decrease = f - f_new;
x.swap(x_new);
g.swap(g_new);
f = f_new;
out.iterations++;
out.f_end = f;
if (decrease <= f_tolerance * std::max(std::fabs(f), 1.0) || decrease < relative_stop * (out.f_start - f))
break;
}
return out;
}
// z = H^-1 q (lambda 0), by the same conjugate gradients: H0 for the L-BFGS (RefinementMinimiser::SetPreconditioner).
void SolveUndamped(const Product &product, const std::vector<double> &diagonal, const Preconditioner &precondition,
const std::vector<double> &x, const std::vector<double> &q, std::vector<double> &z) {
const double l = lambda_;
lambda_ = 0;
std::vector<double> minus(q.size());
for (size_t k = 0; k < q.size(); k++)
minus[k] = -q[k];
Solve(product, diagonal, precondition, x, minus, z);
lambda_ = l;
}
private:
static double Dot(const std::vector<double> &a, const std::vector<double> &b) {
// z with H z = b to `tolerance` of |b| (at most `max_iterations`), by conjugate gradients preconditioned with M:
// hv = H v (product), z = M^-1 r (precondition), both symmetric positive definite. Returns the iterations taken.
// Following Hestenes & Stiefel (1952) J. Res. Natl. Bur. Stand. 49, 409-436
inline int ConjugateGradients(const std::function<void(const std::vector<double> &v, std::vector<double> &hv)> &product,
const std::function<void(const std::vector<double> &r, std::vector<double> &z)> &precondition,
const std::vector<double> &b, std::vector<double> &x, int max_iterations, double tolerance) {
auto dot = [](const std::vector<double> &u, const std::vector<double> &v) {
double s = 0;
for (size_t k = 0; k < a.size(); k++)
s += a[k] * b[k];
for (size_t k = 0; k < u.size(); k++)
s += u[k] * v[k];
return s;
}
// d with (H + lambda D) d = -g to `cg_tolerance` of |g|, by preconditioned conjugate gradients.
void Solve(const Product &product, const std::vector<double> &diagonal, const Preconditioner &precondition,
const std::vector<double> &x, const std::vector<double> &g, std::vector<double> &d) {
const size_t n = g.size();
d.assign(n, 0.0);
std::vector<double> r(n), z(n), p(n), hp(n);
auto apply = [&]() {
if (precondition)
precondition(r, lambda_, z);
else
for (size_t j = 0; j < n; j++)
z[j] = r[j] / ((1 + lambda_) * diagonal[j]);
};
for (size_t k = 0; k < n; k++)
r[k] = -g[k];
apply();
p = z;
double rz = Dot(r, z);
const double r0 = std::sqrt(Dot(r, r));
for (int k = 0; k < cg_max; k++) {
cg_iterations++;
product(x, p, hp);
for (size_t j = 0; j < n; j++)
hp[j] += lambda_ * diagonal[j] * p[j];
const double php = Dot(p, hp);
if (!(php > 0))
break;
const double a = rz / php;
for (size_t j = 0; j < n; j++) {
d[j] += a * p[j];
r[j] -= a * hp[j];
}
if (std::sqrt(Dot(r, r)) < cg_tolerance * r0)
break;
apply();
const double rz_new = Dot(r, z);
for (size_t j = 0; j < n; j++)
p[j] = z[j] + rz_new / rz * p[j];
rz = rz_new;
};
const size_t n = b.size();
x.assign(n, 0.0);
std::vector<double> r = b, z(n), p, hp(n);
precondition(r, z);
p = z;
double rz = dot(r, z);
const double r0 = std::sqrt(dot(r, r));
int k = 0;
while (k < max_iterations) {
k++;
product(p, hp);
const double php = dot(p, hp);
if (!(php > 0))
break;
const double a = rz / php;
for (size_t j = 0; j < n; j++) {
x[j] += a * p[j];
r[j] -= a * hp[j];
}
if (std::sqrt(dot(r, r)) < tolerance * r0)
break;
precondition(r, z);
const double rz_new = dot(r, z);
for (size_t j = 0; j < n; j++)
p[j] = z[j] + rz_new / rz * p[j];
rz = rz_new;
}
double lambda_ = 0.01; // kept from call to call, as the L-BFGS memory is
};
return k;
}
@@ -551,18 +551,6 @@ RestraintJacobian RestraintGaussNewton(const RestraintSet &set, const std::vecto
return jac;
}
std::vector<double> BRestraintCurvature(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb) {
std::vector<double> h(xyzb.size(), 0.0);
for (const RestraintRecord &r : set.records)
if (r.kind == static_cast<int>(RestraintKind::BSimilarity)) {
// d2E/dB_i^2 of BSimilarityTerm = 2 B_j / (kappa^2 B_i^3)
const double bi = xyzb[r.atom[0]][3], bj = xyzb[r.atom[1]][3], k2 = double(r.sigma) * r.sigma;
h[r.atom[0]] += 2.0 * bj / (k2 * bi * bi * bi);
h[r.atom[1]] += 2.0 * bi / (k2 * bj * bj * bj);
}
return h;
}
gemmi::Position SpecialPosition::OnSite(const gemmi::Position &p) const {
gemmi::Vec3 sum = p;
for (const gemmi::Transform &t : ops)
@@ -49,7 +49,7 @@ double RestraintValue(const RestraintSet &set, const RestraintRecord &r, const s
double EvaluateRestraints(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb,
std::vector<std::array<double, 4>> *grad);
// PROTOTYPE: the Gauss-Newton approximation of the set's Hessian, sum over rows of J J^T: per row (a restraint's
// The Gauss-Newton approximation of the set's Hessian, sum over rows of J J^T: per row (a restraint's
// residual) its derivatives in (x, y, z, B) of the atoms atom[start[r] ... start[r + 1]).
struct RestraintJacobian {
std::vector<int> start;
@@ -58,9 +58,6 @@ struct RestraintJacobian {
};
RestraintJacobian RestraintGaussNewton(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb);
// The diagonal of the Hessian of the set's B similarity restraints with respect to each atom's B, at `xyzb`.
std::vector<double> BRestraintCurvature(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb);
// An atom on a crystallographic special position: one that some symmetry operations of the group, each with a
// lattice translation, take onto itself - the site's symmetry. Its position moves only within the subspace those
// operations leave as it is (a 2-fold axis: along the axis; a 4-fold's: along it; a centre of inversion: not at all),
+96 -6
View File
@@ -788,6 +788,55 @@ TEST_CASE("RefinementRestraints_deposited_ligands", "[Refinement]") {
}
}
TEST_CASE("RefinementRestraints_gauss_newton", "[Refinement]") {
// near the ideal geometry the restraints' Hessian is their Gauss-Newton J^T J (the residuals' own curvature times
// residuals that are small): v.J^T J v against central differences of the gradient along v, for random v
const gemmi::UnitCell cell(14, 15, 16, 90, 90, 90);
gemmi::Structure st = residue_crystal({"TYR", "DG"}, cell, "P 21 21 21", 5);
st.models[0] = shaken(st.models[0], 0.005, 0.0, 2);
const RefinementTopology topo = BuildRefinementTopology(st);
RestraintSet set = topo.geometry;
set.Finalize(atoms_of(st.models[0]).size());
std::vector<std::array<double, 4>> xyzb;
for (gemmi::Atom *a : atoms_of(st.models[0]))
xyzb.push_back({a->pos.x, a->pos.y, a->pos.z, a->b_iso});
const RestraintJacobian jac = RestraintGaussNewton(set, xyzb);
REQUIRE(jac.start.size() > 10);
std::mt19937 rng(4);
std::normal_distribution<double> normal(0.0, 1.0);
for (int trial = 0; trial < 5; trial++) {
std::vector<std::array<double, 4>> v(xyzb.size(), {0, 0, 0, 0});
for (auto &e : v)
for (int c = 0; c < 3; c++)
e[c] = normal(rng);
double gn = 0;
for (size_t r = 0; r + 1 < jac.start.size(); r++) {
double jv = 0;
for (int e = jac.start[r]; e < jac.start[r + 1]; e++)
for (int c = 0; c < 3; c++)
jv += jac.j[e][c] * v[jac.atom[e]][c];
gn += jv * jv;
}
const double h = 1e-5;
std::array<std::vector<std::array<double, 4>>, 2> g;
for (int side = 0; side < 2; side++) {
auto x = xyzb;
for (size_t i = 0; i < x.size(); i++)
for (int c = 0; c < 3; c++)
x[i][c] += (side == 0 ? h : -h) * v[i][c];
g[side].assign(x.size(), {0, 0, 0, 0});
EvaluateRestraints(set, x, &g[side]);
}
double exact = 0;
for (size_t i = 0; i < xyzb.size(); i++)
for (int c = 0; c < 3; c++)
exact += v[i][c] * (g[0][i][c] - g[1][i][c]) / (2 * h);
CAPTURE(trial, gn, exact);
CHECK(gn > 0);
CHECK(gn == Catch::Approx(exact).epsilon(0.1));
}
}
TEST_CASE("RefinementRestraints_gradient", "[Refinement]") {
const gemmi::UnitCell cell(14, 15, 16, 90, 90, 90);
gemmi::Structure st = residue_crystal({"TYR", "DG"}, cell, "P 21 21 21", 5);
@@ -1161,18 +1210,21 @@ TEST_CASE("RefinementMinimiser_quadratic", "[Refinement]") {
return d;
};
// the exact diagonal: one step
// the exact inverse Hessian: one step
RefinementMinimiser exact;
std::vector<double> h(n);
for (size_t k = 0; k < n; k++)
h[k] = 2 * a[k];
exact.SetDiagonal(h);
exact.SetInverseHessian([&](const std::vector<double> &, std::vector<double> &q) {
for (size_t k = 0; k < n; k++)
q[k] /= 2 * a[k];
});
std::vector<double> x(n, 0.0);
exact.Minimise(target, x, 1, 0.0, 10.0);
CHECK(distance(x) < 1e-9);
// without it, the memory carried from one call to the next does what one long call does
// with the identity, the memory carried from one call to the next does what one long call does
RefinementMinimiser split, whole;
const RefinementMinimiser::InverseHessian identity = [](const std::vector<double> &, std::vector<double> &) {};
split.SetInverseHessian(identity);
whole.SetInverseHessian(identity);
std::vector<double> xs(n, 0.0), xw(n, 0.0);
for (int call = 0; call < 6; call++)
split.Minimise(target, xs, 10, 0.0, 10.0);
@@ -1182,6 +1234,44 @@ TEST_CASE("RefinementMinimiser_quadratic", "[Refinement]") {
CHECK(xs[k] == Catch::Approx(xw[k]).margin(1e-12));
}
TEST_CASE("RefinementMinimiser_conjugate_gradients", "[Refinement]") {
// a tridiagonal positive definite system, solved to the tolerance with and without a (Jacobi) preconditioner
const size_t n = 200;
auto product = [&](const std::vector<double> &v, std::vector<double> &hv) {
hv.assign(n, 0.0);
for (size_t k = 0; k < n; k++) {
hv[k] = (2.0 + 0.01 * k) * v[k];
if (k > 0)
hv[k] -= v[k - 1];
if (k + 1 < n)
hv[k] -= v[k + 1];
}
};
std::vector<double> b(n);
for (size_t k = 0; k < n; k++)
b[k] = std::sin(0.1 * k);
auto residual = [&](const std::vector<double> &x) {
std::vector<double> hx;
product(x, hx);
double r = 0, b2 = 0;
for (size_t k = 0; k < n; k++) {
r += (hx[k] - b[k]) * (hx[k] - b[k]);
b2 += b[k] * b[k];
}
return std::sqrt(r / b2);
};
std::vector<double> x;
ConjugateGradients(product, [](const std::vector<double> &r, std::vector<double> &z) { z = r; }, b, x, 500, 1e-8);
CHECK(residual(x) < 1e-8);
const int jacobi = ConjugateGradients(product, [&](const std::vector<double> &r, std::vector<double> &z) {
z.resize(n);
for (size_t k = 0; k < n; k++)
z[k] = r[k] / (2.0 + 0.01 * k);
}, b, x, 500, 0.1);
CHECK(residual(x) < 0.1);
CHECK(jacobi < 50);
}
TEST_CASE("Refinement_restrained_recovers_model", "[Refinement]") {
const gemmi::UnitCell cell(36, 40, 44, 90, 90, 90);
const gemmi::SpaceGroup &sg = *gemmi::find_spacegroup_by_name("P 21 21 21");