47constexpr double kPi = std::numbers::pi;
49std::string lower(std::string s) {
51 c =
static_cast<char>(std::tolower(
static_cast<unsigned char>(c)));
56double ecoResponse(
double x) {
57 const double z = 0.5 * x;
59 const double z2 = z * z;
61 1.0 / 3.0 - z2 / 45.0 + 2.0 * z2 * z2 / 945.0 - z2 * z2 * z2 / 4725.0;
64 return (x * x) / (z / std::tanh(z) - 1.0);
67VectorXd ecoFit(
long nBeads,
double xmax) {
68 const long nfree = nBeads / 2;
70 mult.setConstant(2.0);
71 if (nBeads % 2 == 0) {
72 mult[nfree - 1] = 1.0;
74 const long m = std::max(std::lround(10.0 * xmax), 100L);
77 for (
long i = 0; i < m; ++i) {
78 x[i] = (
static_cast<double>(i) + 0.5) * (xmax /
static_cast<double>(m));
79 f[i] = ecoResponse(x[i]);
82 auto objective = [&](
const VectorXd &y,
double &s, VectorXd &g,
MatrixXd &h) {
88 for (
long i = 0; i < m; ++i) {
90 for (
long k = 0; k < nfree; ++k) {
91 d(i, k) = 1.0 / (y[k] * y[k] + x[i] * x[i]);
92 e(i, k) = f[i] * mult[k] * d(i, k);
94 dg(i, k) = -2.0 * d(i, k) * e(i, k) * y[k];
95 d2(i, k) = 2.0 * d(i, k) * d(i, k) * e(i, k) *
96 (3.0 * y[k] * y[k] - x[i] * x[i]);
100 s = 0.5 * r.squaredNorm() /
static_cast<double>(m);
101 g = VectorXd::Zero(nfree);
102 for (
long i = 0; i < m; ++i) {
103 for (
long k = 0; k < nfree; ++k) {
104 g[k] += r[i] * dg(i, k);
107 g /=
static_cast<double>(m);
108 h = dg.transpose() * dg;
109 h += (d2.transpose() * r).asDiagonal();
110 h /=
static_cast<double>(m);
114 for (
long k = 0; k < nfree; ++k) {
115 y[k] = 2.0 * kPi *
static_cast<double>(k + 1);
120 objective(y, s, g, h);
121 auto gmaxOf = [](
const VectorXd &gg) {
123 for (
long k = 0; k < gg.size(); ++k) {
124 gmax = std::max(gmax, std::fabs(gg[k]));
128 auto ordered = [&](
const VectorXd &z) {
129 if (!(z[0] >= 0.0)) {
132 for (
long k = 1; k < nfree; ++k) {
133 if (!(z[k] >= z[k - 1])) {
141 auto lineSearch = [&](
const VectorXd &dy) {
143 for (
int cut = 0; cut < 60; ++cut) {
144 const VectorXd z = y + scale * dy;
149 objective(z, sn, gn, hn);
165 bool exhausted =
true;
169 for (
int iter = 0; iter < 10000; ++iter) {
170 Eigen::SelfAdjointEigenSolver<MatrixXd> es(h);
171 if (es.info() != Eigen::Success) {
172 throw std::runtime_error(
"economised spring fit: Hessian eigensolve");
174 const VectorXd eva = es.eigenvalues();
175 const MatrixXd vec = es.eigenvectors();
176 const double delta = std::max(1e-16 * eva[nfree - 1], -2.0 * eva[0]);
177 const VectorXd rhs = vec.transpose() * g;
178 VectorXd scaled(nfree);
179 for (
long k = 0; k < nfree; ++k) {
180 scaled[k] = -rhs[k] / (eva[k] + delta);
182 const VectorXd dy = vec * scaled;
183 const double previous = s;
184 const bool accepted = lineSearch(dy);
185 const double gmax = gmaxOf(g);
186 const bool stationary =
187 accepted && previous - s <= 1e-12 * previous && gmax < 1e-12;
193 !accepted || (previous - s <= 1e-12 * previous && !(gmax < 1e-12));
195 VectorXd dyDiag(nfree);
196 for (
long k = 0; k < nfree; ++k) {
197 const double denom = std::max(std::fabs(h(k, k)), 1e-18);
198 dyDiag[k] = -g[k] / denom;
200 bool moved = lineSearch(dyDiag);
203 double worstAbs = -1.0;
204 for (
long k = 0; k < nfree; ++k) {
205 const double a = std::fabs(g[k]);
211 VectorXd dyOne = VectorXd::Zero(nfree);
212 const double denom = std::max(std::fabs(h(worst, worst)), 1e-18);
213 dyOne[worst] = -g[worst] / denom;
214 moved = lineSearch(dyOne);
220 if (gmaxOf(g) < 1e-12) {
227 if (exhausted && s > 1e-8 && gmaxOf(g) > 1e-6) {
228 throw std::runtime_error(
"economised spring fit did not converge");
234 if (cov.rows() == 0 || cov.rows() != cov.cols() || !cov.allFinite()) {
235 throw std::runtime_error(
"GLE covariance must be finite and square");
237 const double symmetryTolerance = 64.0 *
238 std::numeric_limits<double>::epsilon() *
239 cov.rows() * cov.cwiseAbs().maxCoeff();
240 if ((cov - cov.transpose()).cwiseAbs().maxCoeff() > symmetryTolerance) {
241 throw std::runtime_error(
"GLE covariance must be symmetric");
243 const MatrixXd sym = 0.5 * (cov + cov.transpose());
244 Eigen::SelfAdjointEigenSolver<MatrixXd> es(sym);
245 if (es.info() != Eigen::Success) {
246 throw std::runtime_error(
"GLE covariance factorisation failed");
248 const double tolerance = 64.0 * std::numeric_limits<double>::epsilon() *
249 cov.rows() * es.eigenvalues().cwiseAbs().maxCoeff();
250 if (!es.eigenvalues().allFinite() ||
251 es.eigenvalues().minCoeff() < -tolerance) {
252 throw std::runtime_error(
"GLE covariance is not positive semidefinite");
254 return es.eigenvectors() *
255 es.eigenvalues().cwiseMax(0.0).cwiseSqrt().asDiagonal();
261 std::vector<MatrixXd> drift;
262 std::vector<MatrixXd> covariance;
265GleFile readGle(
const std::string &path) {
266 std::ifstream in(path);
268 throw std::runtime_error(
"cannot read GLE matrices from " + path);
270 std::vector<double> nums;
272 while (std::getline(in, line)) {
273 const auto hash = line.find(
'#');
274 if (hash != std::string::npos) {
277 std::istringstream ss(line);
283 if (nums.size() < 2) {
284 throw std::runtime_error(
"GLE matrix file " + path +
" is empty");
287 out.nModes = std::lround(nums[0]);
288 out.dim = std::lround(nums[1]);
289 if (out.nModes < 1 || out.dim < 1) {
290 throw std::runtime_error(
"GLE matrix file " + path +
291 " has no modes or no matrix");
293 const long block = out.dim * out.dim;
294 const long need = 2 + out.nModes * 2 * block;
295 if (
static_cast<long>(nums.size()) != need) {
296 throw std::runtime_error(
"GLE matrix file " + path +
297 " does not match its header");
300 out.drift.resize(
static_cast<size_t>(out.nModes));
301 out.covariance.resize(
static_cast<size_t>(out.nModes));
302 for (
long mode = 0; mode < out.nModes; ++mode) {
305 for (
long i = 0; i < out.dim; ++i) {
306 for (
long j = 0; j < out.dim; ++j) {
307 a(i, j) = nums[
static_cast<size_t>(cursor++)];
310 for (
long i = 0; i < out.dim; ++i) {
311 for (
long j = 0; j < out.dim; ++j) {
312 c(i, j) = nums[
static_cast<size_t>(cursor++)];
315 out.drift[
static_cast<size_t>(mode)] = std::move(a);
316 out.covariance[
static_cast<size_t>(mode)] = std::move(c);
324 const std::string s = lower(springs);
325 if (s ==
"eco" || s ==
"economised") {
326 throw std::invalid_argument(
328 " requires Trotter springs; economised springs are refused");
334 throw std::invalid_argument(
"bead count must be positive");
336 VectorXd eva(nBeads);
337 for (
long k = 0; k < nBeads; ++k) {
338 eva[k] = 2.0 * std::sin(kPi *
static_cast<double>(k) /
339 static_cast<double>(nBeads));
346 throw std::invalid_argument(
"bead count must be positive");
348 VectorXd eva = VectorXd::Zero(nBeads);
353 throw std::invalid_argument(
354 "economised springs need a positive maximum frequency");
356 const VectorXd y = ecoFit(nBeads, xmax);
357 for (
long k = 1; k < nBeads; ++k) {
358 const long pair = std::min(k, nBeads - k) - 1;
359 eva[k] = y[pair] /
static_cast<double>(nBeads);
366 throw std::invalid_argument(
"bead count must be positive");
368 MatrixXd b = MatrixXd::Zero(nBeads, nBeads);
369 const double n =
static_cast<double>(nBeads);
370 for (
long j = 0; j < nBeads; ++j) {
372 for (
long i = 1; i <= nBeads / 2; ++i) {
373 b(i, j) = std::sqrt(2.0) * std::cos(2.0 * kPi *
static_cast<double>(j) *
374 static_cast<double>(i) / n);
376 for (
long i = nBeads / 2 + 1; i < nBeads; ++i) {
377 b(i, j) = std::sqrt(2.0) * std::sin(2.0 * kPi *
static_cast<double>(j) *
378 static_cast<double>(i) / n);
381 if (nBeads % 2 == 0) {
382 const long mid = nBeads / 2;
383 for (
long j = 0; j < nBeads; ++j) {
384 b(mid, j) = (j % 2 == 0) ? 1.0 : -1.0;
392 std::vector<int> atomicNumbers, std::vector<char> free,
394 :
opt_(std::move(opt)),
399 free_(std::move(free)),
402 throw std::invalid_argument(
"path integral needs atoms and beads");
404 if (
static_cast<long>(masses.size()) !=
nAtoms_ ||
407 throw std::invalid_argument(
"path integral mass, number or mask size");
409 if (!(
opt_.temperature > 0.0) || !(
opt_.kB > 0.0) || !(
opt_.hbar > 0.0) ||
410 !(
opt_.dt > 0.0) || !(
opt_.pileTau > 0.0) || !(
opt_.pileScale > 0.0)) {
411 throw std::invalid_argument(
412 "path integral temperature, timestep and damping must be positive");
415 throw std::invalid_argument(
416 "economised springs cannot be combined with a normal-mode GLE");
418 mass_.assign(
static_cast<size_t>(
nDof_), 0.0);
420 for (
long i = 0; i <
nAtoms_; ++i) {
421 if (!(masses[
static_cast<size_t>(i)] > 0.0)) {
422 throw std::invalid_argument(
"path integral atom has no mass");
424 for (
int axis = 0; axis < 3; ++axis) {
425 const long a = 3 * i + axis;
426 mass_[
static_cast<size_t>(a)] = masses[
static_cast<size_t>(i)];
427 if (
free_[
static_cast<size_t>(a)]) {
434 throw std::invalid_argument(
"path integral has no free coordinate");
437 const double omegan =
451 for (
long k = 0; k <
nBeads_; ++k) {
455 cosFull_[
static_cast<size_t>(k)] = std::cos(w *
opt_.dt);
456 sinFull_[
static_cast<size_t>(k)] = std::sin(w *
opt_.dt);
474 if (
opt_.gleFile.empty()) {
475 throw std::invalid_argument(
"normal-mode GLE needs a matrix file");
477 const GleFile file = readGle(
opt_.gleFile);
478 const long first = file.nModes ==
nBeads_ ? 0 : 1;
480 throw std::invalid_argument(
481 "GLE matrix count must be the bead count or one less");
483 const double h = 0.5 *
opt_.dt;
485 for (
long k = first; k <
nBeads_; ++k) {
486 const long src = k - first;
488 mode.
drift = file.drift[
static_cast<size_t>(src)];
489 mode.
covariance = file.covariance[
static_cast<size_t>(src)];
494 mode.
noise = factorCovariance(cov);
497 mode.
acc = MatrixXd::Zero(file.dim,
nFree_);
498 gle_[
static_cast<size_t>(k)] = std::move(mode);
504 throw std::invalid_argument(
"path integral positions are missing");
506 for (
long bead = 0; bead <
nBeads_; ++bead) {
507 for (
long a = 0; a <
nDof_; ++a) {
508 q_[
static_cast<size_t>(bead)][a] = q[a];
519 throw std::invalid_argument(
"path integral bead count mismatch");
521 for (
long bead = 0; bead <
nBeads_; ++bead) {
522 if (
beads[
static_cast<size_t>(bead)].size() !=
nDof_) {
523 throw std::invalid_argument(
"path integral bead has the wrong length");
525 q_[
static_cast<size_t>(bead)] =
beads[
static_cast<size_t>(bead)];
535 throw std::invalid_argument(
"path integral bead count mismatch");
537 for (
long bead = 0; bead <
nBeads_; ++bead) {
538 if (
momenta[
static_cast<size_t>(bead)].size() !=
nDof_) {
539 throw std::invalid_argument(
540 "path integral momentum has the wrong length");
542 for (
long a = 0; a <
nDof_; ++a) {
543 p_[
static_cast<size_t>(bead)][a] =
544 free_[
static_cast<size_t>(a)] ?
momenta[
static_cast<size_t>(bead)][a]
551 const VectorXd &origin) {
552 if (normal.size() !=
nDof_ || origin.size() !=
nDof_) {
553 throw std::invalid_argument(
"hyperplane vectors have the wrong length");
560 norm += normal[a] * normal[a];
563 throw std::invalid_argument(
"hyperplane normal has no free component");
573 rng_ =
rng_ * 6364136223846793005ULL + 1ULL;
575 std::max((
rng_ >> 11) * (1.0 / 9007199254740992.0), 1.0e-16);
576 rng_ =
rng_ * 6364136223846793005ULL + 1ULL;
577 const double u2 = (
rng_ >> 11) * (1.0 / 9007199254740992.0);
578 return std::sqrt(-2.0 * std::log(u1)) * std::cos(2.0 * kPi * u2);
582 for (
long bead = 0; bead <
nBeads_; ++bead) {
583 p_[
static_cast<size_t>(bead)].setZero();
586 const double tSim =
static_cast<double>(
nBeads_) *
opt_.kB *
opt_.temperature;
587 for (
long k = 0; k <
nBeads_; ++k) {
589 gle_[
static_cast<size_t>(k)].extended.rows() > 0;
594 pnm_[
static_cast<size_t>(k)][a] =
595 gauss() * std::sqrt(
mass_[
static_cast<size_t>(a)] * tSim);
599 for (
long k = 0; k <
nBeads_; ++k) {
606 for (
long r = 0; r < noise.rows(); ++r) {
607 for (
long c = 0; c < noise.cols(); ++c) {
608 noise(r, c) =
gauss();
612 for (
long col = 0; col <
nFree_; ++col) {
613 const long a =
freeIndex_[
static_cast<size_t>(col)];
614 pnm_[
static_cast<size_t>(k)][a] =
615 mode.
extended(0, col) * std::sqrt(
mass_[
static_cast<size_t>(a)]);
625 std::vector<VectorXd> &dst)
const {
629 const double *mode =
modes_.data();
632 for (
long k = 0; k < n; ++k) {
634 const double *row = mode + k * n;
635 for (
long j = 0; j < n; ++j) {
636 sum += src[
static_cast<size_t>(j)][a] * row[j];
638 dst[
static_cast<size_t>(k)][a] = sum;
644 std::vector<VectorXd> &dst)
const {
645 const double *mode =
modes_.data();
648 for (
long j = 0; j < n; ++j) {
650 for (
long k = 0; k < n; ++k) {
651 sum += src[
static_cast<size_t>(k)][a] * mode[k * n + j];
653 dst[
static_cast<size_t>(j)][a] = sum;
659 double zeroBox[9] = {};
660 const double *cell = box !=
nullptr ? box : zeroBox;
661 const auto n =
static_cast<size_t>(
nBeads_);
668 for (
long bead = 0; bead <
nBeads_; ++bead) {
669 posPtr_[
static_cast<size_t>(bead)] =
q_[
static_cast<size_t>(bead)].data();
671 frcPtr_[
static_cast<size_t>(bead)] =
f_[
static_cast<size_t>(bead)].data();
685 for (
long bead = 0; bead <
nBeads_; ++bead) {
686 for (
long a = 0; a <
nDof_; ++a) {
687 if (!
free_[
static_cast<size_t>(a)]) {
688 f_[
static_cast<size_t>(bead)][a] = 0.0;
696 VectorXd c = VectorXd::Zero(
nDof_);
697 for (
long bead = 0; bead <
nBeads_; ++bead) {
698 c +=
q_[
static_cast<size_t>(bead)];
700 c /=
static_cast<double>(
nBeads_);
705 std::vector<VectorXd> pnm(
static_cast<size_t>(
nBeads_),
706 VectorXd::Zero(
nDof_));
708 VectorXd v = VectorXd::Zero(
nDof_);
709 const double scale = std::sqrt(
static_cast<double>(
nBeads_));
710 for (
long a = 0; a <
nDof_; ++a) {
711 const double m =
mass_[
static_cast<size_t>(a)];
713 v[a] = pnm[0][a] / (scale * m);
720 double k = 0.5 *
static_cast<double>(
nFree_) *
opt_.kB *
opt_.temperature;
728 for (
long bead = 0; bead <
nBeads_; ++bead) {
733 for (
long bead = 0; bead <
nBeads_; ++bead) {
735 virial += (
q_[
static_cast<size_t>(bead)][a] -
centroid_[a]) *
736 f_[
static_cast<size_t>(bead)][a];
739 k += -0.5 /
static_cast<double>(
nBeads_) * virial;
758 const double tSim =
static_cast<double>(
nBeads_) *
opt_.kB *
opt_.temperature;
759 auto langevin = [&](
long k,
double tau) {
760 const double damp = std::exp(-h / tau);
761 const double noise = std::sqrt(tSim * (1.0 - damp * damp));
763 const double sm = std::sqrt(
mass_[
static_cast<size_t>(a)]);
764 double pms =
pnm_[
static_cast<size_t>(k)][a] / sm;
765 pms = damp * pms + noise *
gauss();
766 pnm_[
static_cast<size_t>(k)][a] = pms * sm;
769 for (
long k = 0; k <
nBeads_; ++k) {
771 gle_[
static_cast<size_t>(k)].extended.rows() > 0) {
773 for (
long col = 0; col <
nFree_; ++col) {
774 const long a =
freeIndex_[
static_cast<size_t>(col)];
775 mode.
extended(0, col) =
pnm_[
static_cast<size_t>(k)][a] /
776 std::sqrt(
mass_[
static_cast<size_t>(a)]);
779 for (
long r = 0; r < draw.rows(); ++r) {
780 for (
long c = 0; c < draw.cols(); ++c) {
781 draw(r, c) =
gauss();
785 mode.
acc.noalias() += mode.
noise * draw;
787 for (
long col = 0; col <
nFree_; ++col) {
788 const long a =
freeIndex_[
static_cast<size_t>(col)];
789 pnm_[
static_cast<size_t>(k)][a] =
790 mode.
extended(0, col) * std::sqrt(
mass_[
static_cast<size_t>(a)]);
803 for (
long bead = 0; bead <
nBeads_; ++bead) {
805 p_[
static_cast<size_t>(bead)][a] +=
806 f_[
static_cast<size_t>(bead)][a] * h;
811 VectorXd removal = VectorXd::Zero(
nDof_);
813 VectorXd fc = VectorXd::Zero(
nDof_);
814 for (
long bead = 0; bead <
nBeads_; ++bead) {
815 fc +=
f_[
static_cast<size_t>(bead)];
817 fc /=
static_cast<double>(
nBeads_);
824 for (
long bead = 0; bead <
nBeads_; ++bead) {
826 p_[
static_cast<size_t>(bead)][a] +=
827 (
f_[
static_cast<size_t>(bead)][a] - removal[a]) * h;
835 const double *cosH =
nullptr;
836 const double *sinH =
nullptr;
840 }
else if (h ==
opt_.dt) {
845 const double m =
mass_[
static_cast<size_t>(a)];
847 for (
long k = 1; k <
nBeads_; ++k) {
848 const double omega =
omegaK_[k];
849 const double c = cosH !=
nullptr ? cosH[k] : std::cos(omega * h);
850 const double s = sinH !=
nullptr ? sinH[k] : std::sin(omega * h);
851 const double pk =
pnm_[
static_cast<size_t>(k)][a];
852 const double qk =
qnm_[
static_cast<size_t>(k)][a];
853 pnm_[
static_cast<size_t>(k)][a] = c * pk - m * omega * s * qk;
854 qnm_[
static_cast<size_t>(k)][a] = c * qk + s * pk / (omega * m);
872 for (
long bead = 0; bead <
nBeads_; ++bead) {
883 VectorXd sum = VectorXd::Zero(
nDof_);
884 for (
long bead = 0; bead <
nBeads_; ++bead) {
885 sum +=
p_[
static_cast<size_t>(bead)];
888 const double scale = std::sqrt(
static_cast<double>(
nBeads_));
892 const double m =
mass_[
static_cast<size_t>(a)];
897 const double shift = num / den / scale;
898 for (
long bead = 0; bead <
nBeads_; ++bead) {
904 auto &state =
gle_[0].extended;
907 for (
long row = 0; row < state.rows(); ++row) {
909 for (
long col = 0; col <
nFree_; ++col) {
910 const long a =
freeIndex_[
static_cast<size_t>(col)];
912 std::sqrt(
mass_[
static_cast<size_t>(a)]);
914 for (
long col = 0; col <
nFree_; ++col) {
915 const long a =
freeIndex_[
static_cast<size_t>(col)];
917 std::sqrt(
mass_[
static_cast<size_t>(a)]);
925 const double half = 0.5 *
opt_.dt;
942 VectorXd fc = VectorXd::Zero(
nDof_);
943 for (
long bead = 0; bead <
nBeads_; ++bead) {
944 fc +=
f_[
static_cast<size_t>(bead)];
946 fc /=
static_cast<double>(
nBeads_);
963 throw std::logic_error(
"path integral NVE step with a hyperplane set");
965 const double half = 0.5 *
opt_.dt;
976 long equilibration,
long production) {
977 if (equilibration < 0 || production < 1) {
978 throw std::invalid_argument(
"path integral sample length");
981 this->
step(pot, box,
false);
984 const long batchesBefore =
batches_;
986 this->
step(pot, box,
true);