Loading...
Searching...
No Matches
OHTSTJob.cpp
Go to the documentation of this file.
1/*
2** This file is part of eOn.
3**
4** SPDX-License-Identifier: BSD-3-Clause
5**
6** Copyright (c) 2010--present, eOn Development Team
7** All rights reserved.
8**
9** Repo:
10** https://github.com/TheochemUI/eOn
11*/
12#include <algorithm>
13#include <cmath>
14#include <format>
15#include <fstream>
16#include <memory>
17#include <stdexcept>
18#include <string>
19
20#include "eon/ConFileIO.h"
21#include "eon/EonLogger.h"
22#include "eon/GleThermostat.h"
23#include "eon/HelperFunctions.h"
24#include "eon/OHTSTJob.h"
25
26namespace eonc {
27
28// Optimal-hyperplane TST. Johánnesson and Jónsson, "Optimization of
29// hyperplanar transition states", J. Chem. Phys. 115, 9644 (2001),
30// doi:10.1063/1.1415499. The colored-noise thermostat option follows
31// Ceriotti, Bussi and Parrinello, Phys. Rev. Lett. 102, 020601 (2009),
32// doi:10.1103/PhysRevLett.102.020601.
33//
34// This lifts the harmonic-TST rate of adaptive KMC (Henkelman and
35// Jónsson, J. Chem. Phys. 115, 9657 (2001), doi:10.1063/1.1415500;
36// Pedersen and Jónsson, Math. Comput. Simul. 80, 1487 (2010),
37// doi:10.1016/j.matcom.2009.02.010) to a free-energy barrier, which
38// matters where a barrier is not large against kT: harmonic TST is
39// quoted as reliable only for dE > ~5 kT.
40//
41// The dividing
42// surface is the hyperplane n.(x - Gamma(s)) = 0 in the 3N_free
43// configuration space, with Gamma(s) = R + s*u on the straight
44// reactant->product guideline u = (P - R)/|P - R|. Sign conventions
45// follow Appendix A: the plane translates along the driving force
46// -<F.n> and its normal is driven along +<(n.F) R/(alpha |R|^2)>
47// (verified to tilt the normal onto the ridge normal for a tilted-
48// ridge model), so both damped Verlet integrations climb the free
49// energy and settle where the mean forces vanish.
50
52 // Deterministic LCG: the job must be reproducible for a given
53 // random_seed across MPI farm workers.
54 m_seedState = (1664525L * m_seedState + 1013904223L) & 0x7fffffffL;
55 return static_cast<double>(m_seedState) / 2147483648.0;
56}
57
59 if (m_gaussHave) {
60 m_gaussHave = false;
61 return m_gaussSpare;
62 }
63 double u1 = std::max(uniformDraw(), 1e-12);
64 double u2 = uniformDraw();
65 double r = std::sqrt(-2.0 * std::log(u1));
66 m_gaussSpare = r * std::sin(2.0 * helpers::pi * u2);
67 m_gaussHave = true;
68 return r * std::cos(2.0 * helpers::pi * u2);
69}
70
72 Eigen::RowVector3d *totalDrift) {
73 // AV-embedded frames ride the defect (drift = one hop vector, a/2<011>
74 // observed). Atoms near a cell boundary min-image inconsistently until
75 // that drift is gone, so min-image and de-drift iterate to a fixed point.
76 // The residual is the localized reaction coordinate.
77 Eigen::RowVector3d total = Eigen::RowVector3d::Zero();
78 for (int pass = 0; pass < 6; ++pass) {
79 diff = reference.pbc(diff);
80 const Eigen::RowVector3d drift =
81 diff.colwise().sum() / static_cast<double>(diff.rows());
82 diff.rowwise() -= drift;
83 total += drift;
84 if (drift.norm() < 1e-6) {
85 break;
86 }
87 }
88 if (totalDrift != nullptr) {
89 *totalDrift = total;
90 }
91 return diff;
92}
93
94void OHTSTJob::drawThermalVelocities(VectorXd &vel, const VectorXd *normal) {
95 for (long k = 0; k < vel.size(); ++k) {
96 vel[k] = std::sqrt(m_kbt / m_masses3N[k]) * gaussDraw();
97 }
98 if (normal != nullptr) {
99 vel -= (*normal) * normal->dot(vel);
100 }
101}
102
103bool OHTSTJob::symmetryReflect(const VectorXd &xR, VectorXd &x, VectorXd &v,
104 const VectorXd &xOld, const VectorXd *normal) {
105 if (m_symDirs.size() < 2) {
106 return false;
107 }
108 // Eq 15: distance from the configuration to each half-line
109 // l_i = { R + t p_i, t >= 0 }. For t < 0 the closest point is the
110 // reactant endpoint, not the foot on the infinite line.
111 const VectorXd rel = x - xR;
112 const double rel2 = rel.squaredNorm();
113 double dPrimary = 0.0;
114 size_t closest = 0;
115 double dMin = 0.0;
116 for (size_t i = 0; i < m_symDirs.size(); ++i) {
117 const double proj = rel.dot(m_symDirs[i]);
118 const double d2 = (proj < 0.0) ? rel2 : std::max(0.0, rel2 - proj * proj);
119 const double d = std::sqrt(d2);
120 if (i == 0) {
121 dPrimary = d;
122 dMin = d;
123 } else if (d < dMin) {
124 dMin = d;
125 closest = i;
126 }
127 }
128 if (closest == 0 || dPrimary <= dMin) {
129 return false;
130 }
131 // Eqs 16-17: step back and reflect the velocity about the mirror
132 // that maps p_1 onto the offending p_i; the component of the mirror
133 // normal along the hyperplane normal is removed so the reflected
134 // velocity stays within the plane.
135 VectorXd q = m_symDirs[0] - m_symDirs[closest];
136 if (normal != nullptr) {
137 q -= (*normal) * normal->dot(q);
138 }
139 const double qn = q.norm();
140 if (qn < 1e-12) {
141 return false;
142 }
143 q /= qn;
144 x = xOld;
145 v -= 2.0 * v.dot(q) * q;
146 return true;
147}
148
150 const VectorXd &gamma,
151 const VectorXd &normal) {
152 const long equilSteps = params.oh_tst_options().equil_steps;
153 const long sampleSteps = params.oh_tst_options().sample_steps;
154 const double alphaRot = params.oh_tst_options().alpha_rot;
155
156 // Constrain the unwrapped free coordinates onto the plane. Matter
157 // stores the periodic image: a coordinate just outside the cell comes
158 // back from getPositionsFreeV shifted by a lattice vector, and
159 // projecting that image lands on a different 3N point.
160 x -= normal * normal.dot(x - gamma);
161 matter.setPositionsFreeV(x);
162
163 VectorXd v(x.size());
164 drawThermalVelocities(v, &normal);
165
166 // Colored-noise option: an exact OU half-step before and after each
167 // Verlet step (the auxiliary momenta start fresh per sampling
168 // block); velocities re-project onto the plane after every kick.
169 std::unique_ptr<GleThermostat> gle;
170 if (params.oh_tst_options().thermostat == "gle") {
171 const MatrixXd a =
172 GleThermostat::loadDriftMatrix(params.oh_tst_options().gle_a_file);
173 gle = std::make_unique<GleThermostat>(a, m_kbt, 0.5 * m_dt, x.size());
174 if (!gle->valid()) {
175 EONC_LOG_CRITICAL("OH-TST gle thermostat unusable (gle_a_file = {})",
176 params.oh_tst_options().gle_a_file);
177 throw std::runtime_error("oh_tst: gle thermostat unusable");
178 }
179 }
180 const auto gauss = [this]() { return gaussDraw(); };
181
182 VectorXd f = matter.getForcesFreeV();
183 VectorXd fPlane = f - normal * normal.dot(f);
184
185 PlaneAverages avg;
186 avg.rotNorm = VectorXd::Zero(x.size());
187 avg.rotRaw = VectorXd::Zero(x.size());
188 avg.pos = VectorXd::Zero(x.size());
189 long nAccum = 0;
190
191 VectorXd xPrev = x;
192 for (long step = 0; step < equilSteps + sampleSteps; ++step) {
193 // Velocity Verlet on the plane: forces and velocities projected,
194 // positions corrected back onto the constraint (RATTLE for a
195 // linear constraint is an exact projection).
196 xPrev = x;
197 if (gle) {
198 gle->apply(v, m_masses3N, gauss);
199 v -= normal * normal.dot(v);
200 }
201 VectorXd a = fPlane.cwiseQuotient(m_masses3N);
202 x += m_dt * v + 0.5 * m_dt * m_dt * a;
203 x -= normal * normal.dot(x - gamma);
204 matter.setPositionsFreeV(x);
205 f = matter.getForcesFreeV();
206 fPlane = f - normal * normal.dot(f);
207 VectorXd aNew = fPlane.cwiseQuotient(m_masses3N);
208 v += 0.5 * m_dt * (a + aNew);
209 v -= normal * normal.dot(v);
210 // Eqs 14-17: keep the sampling in the primary product subregion.
211 if (symmetryReflect(m_symXR, x, v, xPrev, &normal)) {
212 x -= normal * normal.dot(x - gamma);
213 matter.setPositionsFreeV(x);
214 f = matter.getForcesFreeV();
215 fPlane = f - normal * normal.dot(f);
216 }
217 if (gle) {
218 gle->apply(v, m_masses3N, gauss);
219 v -= normal * normal.dot(v);
220 } else if (uniformDraw() < m_andersenProb) {
221 // Andersen collisions keep the constrained ensemble canonical.
222 drawThermalVelocities(v, &normal);
223 }
224 if (step >= equilSteps) {
225 const double fn = normal.dot(f);
226 const VectorXd arm = x - gamma;
227 const double arm2 = arm.squaredNorm();
228 avg.fn += fn;
229 if (arm2 > 1e-16) {
230 avg.rotNorm.noalias() += (fn / (alphaRot * arm2)) * arm;
231 }
232 avg.rotRaw.noalias() += fn * arm;
233 avg.pos.noalias() += x;
234 ++nAccum;
235 }
236 }
237 if (nAccum > 0) {
238 const double inv = 1.0 / static_cast<double>(nAccum);
239 avg.fn *= inv;
240 avg.rotNorm *= inv;
241 avg.rotRaw *= inv;
242 avg.pos *= inv;
243 }
244 return avg;
245}
246
247double OHTSTJob::reactantQRatio(Matter &matter, const VectorXd &gammaR,
248 const VectorXd &normal) {
249 // Eq 22: Q^ZR/Q^R = (dt / t_tot) * sum over plane crossings of
250 // 1 / |(r_{i+1} - r_i).n|. The trajectory is unconstrained,
251 // thermostatted, and stays in the reactant basin by construction
252 // (it starts there and the barrier is >> kT).
253 const long steps = params.oh_tst_options().reactant_md_steps;
254 const long equilSteps = params.oh_tst_options().equil_steps;
255 VectorXd x = matter.getPositionsFreeV();
256 VectorXd v(x.size());
257 drawThermalVelocities(v, nullptr);
258 std::unique_ptr<GleThermostat> gle;
259 if (params.oh_tst_options().thermostat == "gle") {
260 const MatrixXd a =
261 GleThermostat::loadDriftMatrix(params.oh_tst_options().gle_a_file);
262 gle = std::make_unique<GleThermostat>(a, m_kbt, 0.5 * m_dt, x.size());
263 if (!gle->valid()) {
264 throw std::runtime_error("oh_tst: gle thermostat unusable");
265 }
266 }
267 const auto gauss = [this]() { return gaussDraw(); };
268 VectorXd f = matter.getForcesFreeV();
269 double side = normal.dot(x - gammaR);
270 double crossingSum = 0.0;
271 long counted = 0;
272 for (long step = 0; step < equilSteps + steps; ++step) {
273 const VectorXd xOld = x;
274 if (gle) {
275 gle->apply(v, m_masses3N, gauss);
276 }
277 VectorXd a = f.cwiseQuotient(m_masses3N);
278 x += m_dt * v + 0.5 * m_dt * m_dt * a;
279 matter.setPositionsFreeV(x);
280 f = matter.getForcesFreeV();
281 VectorXd aNew = f.cwiseQuotient(m_masses3N);
282 v += 0.5 * m_dt * (a + aNew);
283 if (symmetryReflect(m_symXR, x, v, xOld, nullptr)) {
284 matter.setPositionsFreeV(x);
285 f = matter.getForcesFreeV();
286 }
287 if (gle) {
288 gle->apply(v, m_masses3N, gauss);
289 } else if (uniformDraw() < m_andersenProb) {
290 drawThermalVelocities(v, nullptr);
291 }
292 const double sideNew = normal.dot(x - gammaR);
293 if (step >= equilSteps) {
294 if (side * sideNew < 0.0) {
295 const double proj = std::fabs(normal.dot(x - xOld));
296 if (proj > 1e-14) {
297 crossingSum += 1.0 / proj;
298 }
299 }
300 ++counted;
301 }
302 side = sideNew;
303 }
304 return counted > 0 ? crossingSum / static_cast<double>(counted) : 0.0;
305}
306
307std::vector<std::string> OHTSTJob::run(void) {
308 auto reactant = std::make_shared<Matter>(pot, params);
309 auto product = std::make_shared<Matter>(pot, params);
310 if (!eonc::io::io_ok(
311 reactant->con2matter(params.oh_tst_options().reactant_filename))) {
312 EONC_LOG_CRITICAL("OH-TST failed to load {}",
313 params.oh_tst_options().reactant_filename);
314 throw std::runtime_error("oh_tst: failed to load reactant");
315 }
316 if (!eonc::io::io_ok(
317 product->con2matter(params.oh_tst_options().product_filename))) {
318 EONC_LOG_CRITICAL("OH-TST failed to load {}",
319 params.oh_tst_options().product_filename);
320 throw std::runtime_error("oh_tst: failed to load product");
321 }
322
323 const double temperature = params.main_options().temperature;
325 "[oh_tst] thermostat = {}{}", params.oh_tst_options().thermostat,
326 params.oh_tst_options().thermostat == "gle"
327 ? std::string(" (drift: ") + params.oh_tst_options().gle_a_file + ")"
328 : std::string());
329 m_kbt = params.constants().kB * temperature;
330 m_dt = params.oh_tst_options().time_step / params.constants().timeUnit;
331 m_seedState = (params.main_options().randomSeed > 0)
332 ? params.main_options().randomSeed
333 : 12345;
334 // Per-step collision probability from the Andersen collision period.
335 const double tcol = params.thermostat_options().andersen_tcol_input /
336 params.constants().timeUnit;
337 m_andersenProb = (tcol > 0.0) ? std::min(1.0, m_dt / tcol) : 0.1;
338
339 // Free-DOF mass vector (amu per coordinate).
340 const long nAtoms = reactant->numberOfAtoms();
341 auto masses = reactant->getMasses();
342 std::vector<double> m3;
343 m3.reserve(3 * nAtoms);
344 for (long i = 0; i < nAtoms; ++i) {
345 if (!reactant->getFixed(i)) {
346 for (int j = 0; j < 3; ++j)
347 m3.push_back(masses[i]);
348 }
349 }
350 m_masses3N = VectorXd::Map(m3.data(), static_cast<long>(m3.size()));
351
352 // Straight guideline in 3N space, minimum-image on the endpoint
353 // difference so the plane never strides a cell boundary.
354 const VectorXd xR = reactant->getPositionsFreeV();
355 VectorXd diff = product->getPositionsFreeV() - xR;
356 {
357 AtomMatrix d(AtomMatrix::Map(diff.data(), diff.size() / 3, 3));
358 Eigen::RowVector3d total_drift = Eigen::RowVector3d::Zero();
359 d = minImageRemoveRigidDrift(*reactant, std::move(d), &total_drift);
360 EONC_LOG_INFO("[oh_tst] rigid drift removed: ({:.4f}, {:.4f}, "
361 "{:.4f}) A per atom",
362 total_drift[0], total_drift[1], total_drift[2]);
363 diff = VectorXd::Map(d.data(), diff.size());
364 }
365 const double guideLen = diff.norm();
366 EONC_LOG_INFO("[oh_tst] guideline length |P - R| = {:.4f} A over {} free "
367 "DOF",
368 guideLen, xR.size());
369 // A sub-Angstrom guideline is an on-site shuffle (dumbbell rotation,
370 // flicker partner): the plane progression has no room to climb and
371 // the run would "converge" at s = 0 measuring nothing.
372 if (guideLen < 0.5) {
373 EONC_LOG_CRITICAL("[oh_tst] guideline too short ({:.4f} A) -- pick a "
374 "translation-class endpoint pair",
375 guideLen);
376 throw std::runtime_error("oh_tst: degenerate guideline");
377 }
378 const VectorXd u = diff / guideLen;
379
380 // Eqs 13-14: unit vectors to every symmetry-equivalent product;
381 // index 0 is the primary product the guideline points to.
382 m_symXR = xR;
383 m_symDirs.clear();
384 m_symDirs.push_back(u);
385 if (!params.oh_tst_options().symmetry_products.empty()) {
386 std::string rest = params.oh_tst_options().symmetry_products;
387 while (!rest.empty()) {
388 const auto comma = rest.find(',');
389 std::string fname = rest.substr(0, comma);
390 rest = (comma == std::string::npos) ? "" : rest.substr(comma + 1);
391 if (fname.empty()) {
392 continue;
393 }
394 Matter other(pot, params);
395 if (!eonc::io::io_ok(other.con2matter(fname))) {
396 EONC_LOG_CRITICAL("OH-TST failed to load symmetry product {}", fname);
397 throw std::runtime_error("oh_tst: failed to load symmetry product");
398 }
399 VectorXd d = other.getPositionsFreeV() - xR;
400 AtomMatrix dm(AtomMatrix::Map(d.data(), d.size() / 3, 3));
401 dm = minImageRemoveRigidDrift(*reactant, std::move(dm), nullptr);
402 d = VectorXd::Map(dm.data(), d.size());
403 const double dn = d.norm();
404 if (dn > 1e-8) {
405 m_symDirs.push_back(d / dn);
406 }
407 }
408 EONC_LOG_INFO("[oh_tst] symmetry restriction active over {} product "
409 "directions",
410 m_symDirs.size());
411 }
412
413 // Plane state: progression coordinate s, normal n, their conjugate
414 // velocities, and the previous-iteration driving forces for the
415 // two-force velocity Verlet updates (Eqs 6-7 and 9-10).
416 double s = params.oh_tst_options().s_init * guideLen;
417 double vS = 0.0;
418 VectorXd n = u;
419 VectorXd omega = VectorXd::Zero(n.size());
420 const double mS = params.oh_tst_options().plane_mass;
421 const double dtPlane = params.oh_tst_options().plane_time_step;
422 const double dsMax = params.oh_tst_options().ds_max;
423 const double dThetaMax = params.oh_tst_options().dtheta_max;
424 const double fTol = params.oh_tst_options().force_tol;
425
426 Matter walker(*reactant);
427 // Carry the unwrapped free coordinates. The next plane must not reload
428 // them after setPositionsFreeV has wrapped the configuration.
429 VectorXd xFree = walker.getPositionsFreeV();
430
431 // Reversible-work accumulators and the previous plane's averages
432 // for the trapezoid rules of Eqs 18-19.
433 double aTrans = 0.0, aRot = 0.0, aBest = 0.0, sBest = s;
434 VectorXd nBest = n;
435 bool havePrev = false;
436 double fnPrev = 0.0;
437 VectorXd rotRawPrev, posPrev, nPrev;
438 double gSPrev = 0.0;
439 VectorXd gRotPrev;
440 int sideSign = 0; // sign of <F.n> at plane 1 (grooming, Sec IIE)
441
442 // RAII: the divergence guard and samplePlane both throw out of the plane
443 // loop below, so the handle has to close itself.
444 std::ofstream prog("oh_tst_progression.dat");
445 if (prog) {
446 prog << "# plane s/L <F.n> (eV/A) dA_trans (eV) dA_rot (eV) "
447 "A (eV) n.u\n";
448 } else {
449 EONC_LOG_ERROR("[oh_tst] cannot open oh_tst_progression.dat");
450 }
451
452 const bool scanMode = params.oh_tst_options().pmf_scan;
453 const long nScan = std::max(2L, params.oh_tst_options().scan_planes);
454 const long nPlanes = scanMode ? nScan : params.oh_tst_options().max_planes;
455 // Adaptive runs start at s_init, off the force-free reactant. A PMF
456 // scan is a uniform reactant->product grid, so plane 0 is s = 0.
457 if (scanMode) {
458 s = pmfScanS(0, nScan, guideLen);
459 sBest = s;
460 }
461 long plane = 0;
462 bool converged = false;
463 // Sec IIC guideline refinement: after the translational force first
464 // changes sign the guideline is re-anchored every step through the
465 // previous plane's average position along the current normal, so a
466 // small rotational force no longer demands a huge s move (the
467 // failure mode that made small-inertia mechanism discovery diverge).
468 bool guidelineMoving = false;
469 VectorXd gOrigin = xR;
470 VectorXd gDir = u;
471 long rotOnlySteps = 0;
472 for (; plane < nPlanes; ++plane) {
473 if (scanMode) {
474 s = pmfScanS(plane, nScan, guideLen);
475 }
476 const VectorXd gamma = gOrigin + s * gDir;
477 PlaneAverages avg = samplePlane(walker, xFree, gamma, n);
478
479 // Driving forces: translation climbs against <F.n> (Eq 5 with the
480 // reversed-force convention); the normal is driven along
481 // +<(n.F) R/(alpha |R|^2)> (Appendix A, Eq A1), projected onto
482 // the tangent space of the unit sphere.
483 const double gS = -avg.fn / mS;
484 VectorXd gRot = avg.rotNorm - n * n.dot(avg.rotNorm);
485
486 if (plane == 0) {
487 sideSign = (avg.fn < 0.0) ? -1 : 1;
488 }
489
490 // Reversible work (Eqs 18-19), trapezoid between consecutive
491 // planes: the translational path is the piecewise-linear track of
492 // the average configuration <r>, and the rotational work pairs
493 // the unnormalized <(n.F) R> with the actual change of the
494 // normal. Grooming (Sec IIE): only planes on the reactant side of
495 // the ridge (same sign of <F.n> as plane 1) contribute.
496 if (havePrev) {
497 // Scan mode integrates the whole reactant->product path; the
498 // adaptive run grooms to the reactant side of the ridge only.
499 const bool sameSide = scanMode || ((fnPrev < 0.0 ? -1 : 1) == sideSign &&
500 (avg.fn < 0.0 ? -1 : 1) == sideSign);
501 if (sameSide) {
502 const VectorXd fParMean = 0.5 * (fnPrev * nPrev + avg.fn * n);
503 aTrans += -fParMean.dot(avg.pos - posPrev);
504 const VectorXd rotMean = 0.5 * (rotRawPrev + avg.rotRaw);
505 aRot += rotMean.dot(n - nPrev);
506 }
507 }
508
509 const double aTotal = aTrans + aRot;
510 // The basin bottom is force-free. A sign change moves the guideline
511 // only after the reversible work has passed two kT.
512 if (plane != 0 && !guidelineMoving &&
513 ((avg.fn < 0.0) ? -1 : 1) != sideSign &&
515 guidelineMoving = true;
516 EONC_LOG_DEBUG("[oh_tst] plane {}: translational force changed "
517 "sign; guideline now follows <r> along the normal",
518 plane);
519 }
520 if (aTotal > aBest) {
521 aBest = aTotal;
522 sBest = s;
523 nBest = n;
524 }
525 if (prog) {
526 prog << std::format("{:6} {:10.6f} {:14.6e} {:12.6f} {:12.6f} {:12.6f} "
527 "{:10.6f}\n",
528 plane, s / guideLen, avg.fn, aTrans, aRot, aTotal,
529 n.dot(u));
530 prog.flush();
531 }
532 EONC_LOG_DEBUG("[oh_tst] plane {} s/L {:.4f} <F.n> {:.4e} A {:.4f} eV",
533 plane, s / guideLen, avg.fn, aTotal);
534
535 // Divergence guard: reversible work beyond any physical barrier
536 // means the endpoints were not minimized (static relaxation
537 // forces leak into <F.n>) or the plane is chasing a drifting
538 // ensemble; 300 planes of that is pure waste.
539 if (aTotal > params.oh_tst_options().max_delta_a) {
541 "[oh_tst] accumulated work {:.2f} eV exceeds max_delta_a "
542 "{:.2f} eV at plane {} -- endpoints likely unminimized",
543 aTotal, params.oh_tst_options().max_delta_a, plane);
544 throw std::runtime_error("oh_tst: diverging reversible work");
545 }
546 // A stationary plane only counts as the variational maximum
547 // after the progression has actually climbed: the reactant basin
548 // bottom is also force-free, and a short guideline puts the first
549 // plane inside it. Two thermal energies of accumulated reversible
550 // work is the cheapest evidence of a ridge.
551 if (!scanMode && plane > 2 && aTotal > 2.0 * m_kbt &&
552 std::fabs(avg.fn) < fTol &&
553 gRot.norm() * params.oh_tst_options().alpha_rot < fTol) {
554 converged = true;
555 // The converged plane is the optimal one even if sampling noise
556 // put an earlier plane marginally higher.
557 aBest = aTotal;
558 sBest = s;
559 nBest = n;
560 if (prog) {
561 prog << std::format("# converged at plane {}\n", plane);
562 }
563 break;
564 }
565
566 if (scanMode) {
567 // Fixed-increment PMF scan: normal stays along the guideline,
568 // s advances uniformly, and the walker is projected onto the
569 // next constraint plane for samplePlane to re-equilibrate. The
570 // A(s) profile is the PMF; aBest already tracks its maximum.
571 fnPrev = avg.fn;
572 nPrev = n;
573 rotRawPrev = avg.rotRaw;
574 posPrev = avg.pos;
575 gSPrev = gS;
576 gRotPrev = gRot;
577 havePrev = true;
578 s = pmfScanS(plane + 1, nScan, guideLen);
579 const VectorXd gammaNext = xR + s * u;
580 xFree -= u * (u.dot(xFree - gammaNext));
581 walker.setPositionsFreeV(xFree);
582 continue;
583 }
584 // Damped two-force Verlet on s (Eqs 6-7): the velocity is zeroed
585 // when it opposes the driving force, so the plane settles at the
586 // free-energy maximum instead of oscillating over it ("the
587 // velocity of the plane is zeroed if the plane has gone past the
588 // maximum free energy position").
589 // Pure-rotation step (Sec IIC): right after a guideline change a
590 // spiked rotational force is relaxed at fixed s before the plane
591 // translates again.
592 const bool rotationOnly =
593 guidelineMoving &&
594 gRot.norm() * params.oh_tst_options().alpha_rot > 5.0 * fTol &&
595 rotOnlySteps < 10;
596 if (rotationOnly) {
597 ++rotOnlySteps;
598 } else {
599 rotOnlySteps = 0;
600 }
601 if (havePrev) {
602 vS += 0.5 * dtPlane * (gS + gSPrev);
603 } else {
604 vS += dtPlane * gS;
605 }
606 if (vS * gS < 0.0)
607 vS = 0.0;
608 double ds = dtPlane * vS + 0.5 * dtPlane * dtPlane * gS;
609 ds = std::clamp(ds, -dsMax, dsMax);
610 if (rotationOnly) {
611 ds = 0.0;
612 vS = 0.0;
613 }
614 const double sNew =
615 guidelineMoving ? s + ds : std::clamp(s + ds, 0.0, guideLen);
616
617 // Damped rotation (Eqs 9-10 with the Appendix A driving): the
618 // angular velocity keeps only its projection along the current
619 // driving force while aligned with it, and is zeroed otherwise.
620 if (havePrev && gRotPrev.size() == gRot.size()) {
621 omega += 0.5 * dtPlane * (gRot + gRotPrev);
622 } else {
623 omega += dtPlane * gRot;
624 }
625 omega -= n * n.dot(omega);
626 const double gNorm = gRot.norm();
627 if (gNorm > 1e-14) {
628 const VectorXd gHat = gRot / gNorm;
629 const double along = omega.dot(gHat);
630 if (along > 0.0) {
631 omega = gHat * along;
632 } else {
633 omega.setZero();
634 }
635 } else {
636 omega.setZero();
637 }
638 VectorXd dn = dtPlane * omega + 0.5 * dtPlane * dtPlane * gRot;
639 const double dTheta = dn.norm();
640 if (dTheta > dThetaMax) {
641 dn *= dThetaMax / dTheta;
642 }
643 const VectorXd nOld = n;
644 n = (n + dn).normalized();
645 if (n.dot(gDir) < 0.0) {
646 // Keep the normal pointing towards increasing s.
647 n = -n;
648 }
649
650 // Eq 11-12 restart: place the walker in the new plane at the
651 // rotated image of the average arm, rescaled so rotation does not
652 // change the arm length.
653 VectorXd arm = avg.pos - gamma;
654 VectorXd armNew = arm - nOld * arm.dot(n - nOld);
655 const double armLen = arm.norm();
656 const double armNewLen = armNew.norm();
657 if (armLen > 1e-12 && armNewLen > 1e-12) {
658 armNew *= armLen / armNewLen;
659 }
660 VectorXd gammaNew;
661 if (guidelineMoving) {
662 // Re-anchor: the guideline passes through the previous plane's
663 // average position along the CURRENT normal, and the plane
664 // ADVANCES by this iteration's ds along the fresh line. (A
665 // dead re-assignment here used to pin the plane at <r> forever:
666 // the walker drifted downhill and the trans-work integral ran
667 // away by ~20 eV per plane on the Cu doorway.)
668 gOrigin = avg.pos;
669 gDir = n;
670 s = ds;
671 gammaNew = gOrigin + s * gDir;
672 } else {
673 gammaNew = gOrigin + sNew * gDir;
674 }
675 xFree = gammaNew + armNew;
676 xFree -= n * n.dot(xFree - gammaNew);
677 walker.setPositionsFreeV(xFree);
678
679 fnPrev = avg.fn;
680 nPrev = nOld;
681 rotRawPrev = avg.rotRaw;
682 posPrev = avg.pos;
683 gSPrev = gS;
684 gRotPrev = gRot;
685 havePrev = true;
686 if (!guidelineMoving) {
687 s = sNew;
688 }
689 }
690 bool progOk = prog.is_open();
691 if (progOk) {
692 prog.close();
693 progOk = static_cast<bool>(prog);
694 if (!progOk) {
695 EONC_LOG_ERROR("[oh_tst] failed to write oh_tst_progression.dat");
696 }
697 }
698 // A completed scan yields a valid PMF even with no interior
699 // maximum; report it as converged so downstream tooling accepts
700 // the profile (barrier = aBest, the max of A(s)).
701 if (scanMode && plane >= nPlanes)
702 converged = true;
703
704 // `break` leaves `plane` at the 0-based index of the plane just
705 // sampled. A finished loop leaves it at nPlanes. planes_used is
706 // the number of planes sampled in either case.
707 const long planesUsed = (plane < nPlanes) ? plane + 1 : plane;
708
709 // Direction-dependent effective mass (Eq 24) and the one-sided
710 // thermal flux factor sqrt(kBT / 2 pi mu) (Eq 23).
711 const double mu = (m_masses3N.array() * nBest.array().square()).sum();
712 const double vFlux = std::sqrt(m_kbt / (2.0 * helpers::pi * mu));
713
714 // Q^ZR/Q^R at the FIRST plane of the progression (Z^R), whose
715 // reversible work to the optimal plane is what aBest measures.
716 Matter rWalker(*reactant);
717 const double sFirst = scanMode ? pmfScanS(0, nScan, guideLen)
718 : params.oh_tst_options().s_init * guideLen;
719 const VectorXd gammaR = xR + sFirst * u;
720 const double qRatio = reactantQRatio(rWalker, gammaR, u);
721
722 // Rate in internal units (1/internal-time), then SI.
723 const double kInternal = vFlux * qRatio * std::exp(-aBest / m_kbt);
724 const double kSI = kInternal / (params.constants().timeUnit * 1.0e-15);
725
726 std::vector<std::string> returnFiles;
727 std::ofstream out("results.dat");
728 if (!out) {
729 EONC_LOG_ERROR("[oh_tst] cannot open results.dat");
730 throw std::runtime_error("oh_tst: cannot open results.dat");
731 }
732 out << "oh_tst job_type\n";
733 out << std::format("{} converged\n", converged ? 1 : 0);
734 out << std::format("{} planes_used\n", planesUsed);
735 out << std::format("{:.8f} free_energy_barrier_eV\n", aBest);
736 out << std::format("{:.8f} delta_a_trans_eV\n", aTrans);
737 out << std::format("{:.8f} delta_a_rot_eV\n", aRot);
738 out << std::format("{:.8f} s_star_over_L\n", sBest / guideLen);
739 out << std::format("{:.8f} guideline_length_A\n", guideLen);
740 out << std::format("{:.8f} normal_overlap_with_guideline\n", nBest.dot(u));
741 out << std::format("{:.8e} effective_mass_amu\n", mu);
742 out << std::format("{:.8e} q_ratio_per_A\n", qRatio);
743 out << std::format("{:.8e} rate_ohtst_per_s\n", kSI);
744 out << std::format("{:.4f} temperature_K\n", temperature);
745 out.close();
746 if (!out) {
747 EONC_LOG_ERROR("[oh_tst] failed to write results.dat");
748 throw std::runtime_error("oh_tst: failed to write results.dat");
749 }
750 returnFiles.push_back("results.dat");
751 if (progOk) {
752 returnFiles.push_back("oh_tst_progression.dat");
753 }
754 EONC_LOG_INFO("[oh_tst] {} after {} planes: A = {:.4f} eV at s/L = {:.4f}, "
755 "k = {:.4e} 1/s at {:.1f} K",
756 converged ? "converged" : "max planes", planesUsed, aBest,
757 sBest / guideLen, kSI, temperature);
758 return returnFiles;
759}
760
761} // namespace eonc
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic, eOnStorageOrder > MatrixXd
Definition Eigen.h:33
Eigen::Matrix< double, Eigen::Dynamic, 3, eOnStorageOrder > AtomMatrix
Definition Eigen.h:37
#define EONC_LOG_DEBUG(...)
Definition EonLogger.h:310
#define EONC_LOG_ERROR(...)
Definition EonLogger.h:328
#define EONC_LOG_INFO(...)
Definition EonLogger.h:316
#define EONC_LOG_CRITICAL(...)
Definition EonLogger.h:334
static MatrixXd loadDriftMatrix(const std::string &path)
Load a drift matrix from a gle4md-layout text file ('#' starts a comment).
std::shared_ptr< Potential > pot
Set when one Potential is shared across Matters, images, or a caller.
Definition Job.h:66
Parameters params
Definition Job.h:58
VectorXd getForcesFreeV() const
Definition Matter.cpp:512
void setPositionsFreeV(const VectorXd &pos)
Definition Matter.cpp:451
AtomMatrix pbc(const AtomMatrix &diff) const
Definition Matter.cpp:943
VectorXd getPositionsFreeV() const
Definition Matter.cpp:415
io::IoStatus con2matter(std::string filename)
Definition Matter.h:281
double reactantQRatio(Matter &matter, const VectorXd &gammaR, const VectorXd &normal)
Definition OHTSTJob.cpp:247
double m_andersenProb
per-step Andersen collision probability
Definition OHTSTJob.h:110
void drawThermalVelocities(VectorXd &vel, const VectorXd *normal)
Definition OHTSTJob.cpp:94
VectorXd m_masses3N
per-DOF masses of the free atoms (amu)
Definition OHTSTJob.h:107
PlaneAverages samplePlane(Matter &matter, VectorXd &x, const VectorXd &gamma, const VectorXd &normal)
Definition OHTSTJob.cpp:149
long m_seedState
LCG state for the thermostat draws.
Definition OHTSTJob.h:111
double uniformDraw()
uniform (0,1)
Definition OHTSTJob.cpp:51
double m_gaussSpare
Definition OHTSTJob.h:115
double gaussDraw()
standard normal (Box-Muller)
Definition OHTSTJob.cpp:58
double m_kbt
k_B T (eV)
Definition OHTSTJob.h:109
std::vector< std::string > run(void)
Virtual run; used solely for dynamic dispatch.
Definition OHTSTJob.cpp:307
std::vector< VectorXd > m_symDirs
p-hat_i, index 0 = primary
Definition OHTSTJob.h:104
double m_dt
integration step, internal units
Definition OHTSTJob.h:108
VectorXd m_symXR
reactant anchor R of the half-lines
Definition OHTSTJob.h:105
bool symmetryReflect(const VectorXd &xR, VectorXd &x, VectorXd &v, const VectorXd &xOld, const VectorXd *normal)
Definition OHTSTJob.cpp:103
constexpr double pi
constexpr bool io_ok(IoStatus s) noexcept
Definition ConFileIO.h:38
RAII resource manager for the ARTn C library with global synchronization.
AtomMatrix minImageRemoveRigidDrift(const Matter &reference, AtomMatrix diff, Eigen::RowVector3d *totalDrift)
Minimum-image a free-atom difference and remove rigid translation.
Definition OHTSTJob.cpp:71
double pmfScanS(long plane, long nScan, double guideLen)
Uniform PMF-scan coordinate.
Definition OHTSTJob.h:26
bool reversibleWorkPastRidge(double reversibleWork, double thermalEnergy)
The reactant basin is force-free.
Definition OHTSTJob.h:33
VectorXd pos
, anchors Eq 18 and the Eq 12 restart
Definition OHTSTJob.h:75
VectorXd rotNorm
<(n.F) R / (alpha |R|^2)>, drives rotation
Definition OHTSTJob.h:72
VectorXd rotRaw
<(n.F) R>, integrand of Eq 19
Definition OHTSTJob.h:73