21namespace fs = std::filesystem;
28 const double n = v.norm();
37storedOrEndpointTangent(
const std::vector<std::shared_ptr<Matter>> &path,
38 const std::vector<std::shared_ptr<AtomMatrix>> &tangent,
39 long numImages,
long imageIndex) {
41 if (imageIndex == 0) {
42 tang = path[0]->pbc(path[1]->getPositions() - path[0]->getPositions());
43 normalizeOrZero(tang);
46 if (imageIndex == numImages + 1) {
47 tang = path[numImages]->pbc(path[numImages + 1]->getPositions() -
48 path[numImages]->getPositions());
49 normalizeOrZero(tang);
52 return *tangent[
static_cast<size_t>(imageIndex)];
56double referenceOrFirst(
const std::vector<std::shared_ptr<Matter>> &path,
57 double referenceEnergy) {
58 return std::isnan(referenceEnergy) ? path[0]->getPotentialEnergy()
62eonc::io::ConFrameMetadata neb_frame_metadata(
63 const std::vector<std::shared_ptr<Matter>> &path,
64 const std::vector<std::shared_ptr<AtomMatrix>> &tangent,
65 const std::vector<std::shared_ptr<EigenmodeStrategy>> &eigenmode_solvers,
66 long numImages,
bool estimateEigenvalues,
long imageIndex,
67 double reactionCoordinate, std::optional<size_t> bandIndex,
68 double referenceEnergy) {
70 if (imageIndex == 0) {
71 tang = path[0]->pbc(path[1]->getPositions() - path[0]->getPositions());
72 }
else if (imageIndex == numImages + 1) {
73 tang = path[numImages]->pbc(path[numImages + 1]->getPositions() -
74 path[numImages]->getPositions());
76 tang = *tangent[imageIndex];
78 normalizeOrZero(tang);
80 const double reference_energy = referenceOrFirst(path, referenceEnergy);
81 const double absolute_energy = path[imageIndex]->getPotentialEnergy();
82 const double relative_energy = absolute_energy - reference_energy;
83 const double parallel_force =
matDot(path[imageIndex]->getForces(), tang);
85 eonc::io::ConFrameMetadata metadata;
86 metadata.
frame_index =
static_cast<uint64_t
>(imageIndex);
87 metadata.
energy = absolute_energy;
88 metadata.
neb_bead =
static_cast<uint64_t
>(imageIndex);
90 metadata.
neb_band =
static_cast<uint64_t
>(*bandIndex);
92 metadata.
scalars.push_back({
"reaction_coordinate", reactionCoordinate});
93 metadata.
scalars.push_back({
"relative_energy", relative_energy});
94 metadata.
scalars.push_back({
"parallel_force", parallel_force});
96 if (estimateEigenvalues && imageIndex >= 0 &&
97 imageIndex <
static_cast<long>(eigenmode_solvers.size()) &&
98 eigenmode_solvers[imageIndex]) {
102 {
"lowest_eigenvalue",
113 const std::vector<std::shared_ptr<AtomMatrix>> &tangent,
120 std::vector<double> a(numImages + 1), b(numImages + 1), c(numImages + 1),
122 double F1, F2, U1, U2, dist;
124 for (
long i = 0; i <= numImages; i++) {
125 dist = path[i]->distanceTo(*path[i + 1]);
128 path[i]->pbc(path[1]->getPositions() - path[0]->getPositions());
129 normalizeOrZero(tangentEndpoint);
130 F1 =
matDot(path[i]->getForces(), tangentEndpoint) * dist;
132 F1 =
matDot(path[i]->getForces(), *tangent[i]) * dist;
134 if (i == numImages) {
135 tangentEndpoint = path[i + 1]->pbc(path[numImages + 1]->getPositions() -
136 path[numImages]->getPositions());
137 normalizeOrZero(tangentEndpoint);
138 F2 =
matDot(path[i + 1]->getForces(), tangentEndpoint) * dist;
140 F2 =
matDot(path[i + 1]->getForces(), *tangent[i + 1]) * dist;
142 U1 = path[i]->getPotentialEnergy();
143 U2 = path[i + 1]->getPotentialEnergy();
146 c[i] = 3. * (U2 - U1) + 2. * F1 + F2;
147 d[i] = -2. * (U2 - U1) - (F1 + F2);
151 result.
positions.resize(2 * (numImages + 1));
152 result.
energies.resize(2 * (numImages + 1));
153 result.
curvatures.resize(2 * (numImages + 1));
155 double discriminant, f;
157 for (
long i = 0; i <= numImages; i++) {
158 discriminant = c[i] * c[i] - 3.0 * b[i] * d[i];
159 if (discriminant >= 0) {
163 if ((d[i] == 0) && (c[i] != 0)) {
164 f = (-b[i] / (2. * c[i]));
167 else if (d[i] != 0) {
168 f = -(c[i] + std::sqrt(discriminant)) / (3. * d[i]);
170 if ((f >= 0) && (f <= 1)) {
173 ((d[i] * f + c[i]) * f + b[i]) * f + a[i];
180 if (d[i] != 0 && discriminant != 0.0) {
181 f = -(c[i] - std::sqrt(discriminant)) / (3. * d[i]);
185 if ((f >= 0) && (f <= 1)) {
188 ((d[i] * f + c[i]) * f + b[i]) * f + a[i];
196 QUILL_LOG_DEBUG(
log,
"Energy reference: {}", path[0]->getPotentialEnergy());
197 for (
long i = 0; i < result.
numExtrema; i++) {
199 log,
"extrema #{} at image position {} with energy {} and curvature {}",
201 result.
energies[i] - path[0]->getPotentialEnergy(),
210 const std::vector<std::shared_ptr<AtomMatrix>> &tangent,
211 long numImages,
double posFraction) {
212 const int nat = path.empty() ? 0 : path[0]->numberOfAtoms();
213 const auto leftIdx =
static_cast<long>(std::floor(posFraction));
214 if (path.size() < 2 || leftIdx < 0 || leftIdx >= numImages + 1 ||
215 leftIdx + 1 >=
static_cast<long>(path.size())) {
216 return AtomMatrix::Zero(nat, 3);
218 const double f = posFraction -
static_cast<double>(leftIdx);
220 (1.0 - f) * storedOrEndpointTangent(path, tangent, numImages, leftIdx) +
221 f * storedOrEndpointTangent(path, tangent, numImages, leftIdx + 1);
222 normalizeOrZero(mode);
227 const std::vector<std::shared_ptr<Matter>> &path,
228 const std::vector<std::shared_ptr<AtomMatrix>> &tangent,
229 const std::vector<std::shared_ptr<EigenmodeStrategy>> &eigenmode_solvers,
230 long numImages,
bool estimateEigenvalues,
bool writeToFile,
size_t idx,
233 double dist, distTotal = 0;
235 path[0]->pbc(path[1]->getPositions() - path[0]->getPositions());
237 path[numImages + 1]->getPositions() - path[numImages]->getPositions());
240 if (estimateEigenvalues) {
241 header = std::format(
"{:>3s} {:>12s} {:>12s} {:>12s} {:>12s}",
"img",
242 "rxn_coord",
"energy",
"f_para",
"eigval");
244 header = std::format(
"{:>3s} {:>12s} {:>12s} {:>12s}",
"img",
"rxn_coord",
248 normalizeOrZero(tangentStart);
249 normalizeOrZero(tangentEnd);
251 std::ofstream fileLogger;
253 std::string neb_dat_fs;
254 if (idx == std::numeric_limits<size_t>::max()) {
255 neb_dat_fs =
"neb.dat";
257 neb_dat_fs = std::format(
"neb_{:03}.dat", idx);
259 if (fs::exists(neb_dat_fs)) {
260 fs::remove(neb_dat_fs);
262 fileLogger.open(neb_dat_fs);
263 if (fileLogger.is_open()) {
264 fileLogger << header <<
"\n";
267 const double energy_reactant = referenceOrFirst(path, referenceEnergy);
269 for (
long i = 0; i <= numImages + 1; i++) {
272 }
else if (i == numImages + 1) {
279 dist = path[i]->distanceTo(*path[i - 1]);
283 double relative_energy = path[i]->getPotentialEnergy() - energy_reactant;
284 double parallel_force =
matDot(path[i]->getForces(), tang);
286 if (estimateEigenvalues) {
288 double lowest_eigenvalue =
290 if (fileLogger.is_open()) {
291 fileLogger << std::format(
292 "{:>3} {:>12.6f} {:>12.6f} {:>12.6f} {:>12.6f}\n", i, distTotal,
293 relative_energy, parallel_force, lowest_eigenvalue);
295 QUILL_LOG_DEBUG(
log,
"{:>3} {:>12.6f} {:>12.6f} {:>12.6f} {:>12.6f}", i,
296 distTotal, relative_energy, parallel_force,
300 if (fileLogger.is_open()) {
301 fileLogger << std::format(
"{:>3} {:>12.6f} {:>12.6f} {:>12.6f}\n", i,
302 distTotal, relative_energy, parallel_force);
304 QUILL_LOG_DEBUG(
log,
"{:>3} {:>12.6f} {:>12.6f} {:>12.6f}", i,
305 distTotal, relative_energy, parallel_force);
312 const std::vector<std::shared_ptr<Matter>> &path,
313 const std::vector<std::shared_ptr<AtomMatrix>> &tangent,
314 const std::vector<std::shared_ptr<EigenmodeStrategy>> &eigenmode_solvers,
315 long numImages,
bool estimateEigenvalues, std::optional<size_t> bandIndex,
316 double referenceEnergy,
const std::vector<double> *quantumFreeEnergy,
318 const size_t nframes =
static_cast<size_t>(numImages) + 2;
319 if (path.size() < nframes) {
323 double distTotal = 0.0;
324 std::vector<eonc::io::ConFrameMetadata> metas;
325 metas.reserve(nframes);
332 for (
long i = 0; i <= numImages + 1; i++) {
334 distTotal += path[i]->distanceTo(*path[i - 1]);
339 }
catch (
const std::invalid_argument &) {
344 metas.push_back(neb_frame_metadata(path, tangent, eigenmode_solvers,
345 numImages, estimateEigenvalues, i,
346 distTotal, bandIndex, referenceEnergy));
348 metas.back().scalars.push_back({
"reaction_coordinate_mw", distMw});
354 if (haveMw && !metas.empty()) {
356 std::vector<std::shared_ptr<Matter>> ends(
357 path.begin(), path.begin() +
static_cast<std::ptrdiff_t
>(nframes));
359 ends, referenceOrFirst(path, referenceEnergy));
360 auto &head = metas.front().scalars;
361 head.push_back({
"hbar_omega_reactant", split.hwReactant});
362 head.push_back({
"hbar_omega_product", split.hwProduct});
363 head.push_back({
"tunnel_action", split.action});
364 head.push_back({
"tunnel_splitting", split.delta0});
365 head.push_back({
"tunnel_asymmetry_zpe", split.asymmetry()});
366 head.push_back({
"tls_energy", split.tlsEnergy()});
367 head.push_back({
"tunnel_deep_wells", split.deepWells ? 1.0 : 0.0});
371 ends, referenceOrFirst(path, referenceEnergy));
373 head.push_back({
"tls_energy_dvr", levels.gap});
374 head.push_back({
"tunnel_asymmetry_dvr", levels.asymmetry});
375 head.push_back({
"tunnel_splitting_dvr", levels.delta0});
376 head.push_back({
"tunnel_wall_sampled", walls !=
nullptr ? 1.0 : 0.0});
377 head.push_back({
"tunnel_double_well",
379 }
catch (
const std::invalid_argument &) {
382 if (quantumFreeEnergy !=
nullptr && quantumFreeEnergy->size() == nframes) {
383 const double reactant = quantumFreeEnergy->front();
384 const double barrier = *std::max_element(quantumFreeEnergy->begin(),
385 quantumFreeEnergy->end()) -
387 for (
size_t i = 0; i < nframes; ++i) {
388 metas[i].scalars.push_back(
389 {
"quantum_free_energy", (*quantumFreeEnergy)[i]});
390 metas[i].scalars.push_back({
"zpe_corrected_barrier", barrier});
394 std::vector<std::shared_ptr<Matter>> band(
395 path.begin(), path.begin() +
static_cast<std::ptrdiff_t
>(nframes));
400 const std::vector<std::shared_ptr<Matter>> &path,
401 const std::vector<std::shared_ptr<AtomMatrix>> &tangent,
402 const std::vector<std::shared_ptr<EigenmodeStrategy>> &eigenmode_solvers,
403 long numImages,
bool estimateEigenvalues, std::string filename,
404 std::optional<size_t> bandIndex,
double referenceEnergy,
405 const std::vector<double> *quantumFreeEnergy,
407 auto frames =
pathToConFrames(path, tangent, eigenmode_solvers, numImages,
408 estimateEigenvalues, bandIndex, referenceEnergy,
409 quantumFreeEnergy, walls);
410 if (frames.empty()) {
double matDot(const AtomMatrix &a, const AtomMatrix &b)
SIMD-optimized dot product for contiguous Eigen matrices.
Eigen::Matrix< double, Eigen::Dynamic, 3, eOnStorageOrder > AtomMatrix
IoStatus writeConFrames(std::string filename, const std::vector< readcon::ConFrame > &frames)
Write already-built ConFrames to a multi-frame .con (temp or durable).
std::vector< readcon::ConFrame > buildNebPathFrames(const std::vector< std::shared_ptr< Matter > > &path, const std::vector< ConFrameMetadata > &metadata_per_image)
Build NEB band ConFrames without writing (clone builder path of writeNebPath).
IoStatus
Structured I/O result for the client surface (nanobind-friendly).
quill::Logger * get() noexcept
Get or create the default "combi" logger.
std::vector< readcon::ConFrame > pathToConFrames(const std::vector< std::shared_ptr< Matter > > &path, const std::vector< std::shared_ptr< AtomMatrix > > &tangent, const std::vector< std::shared_ptr< EigenmodeStrategy > > &eigenmode_solvers, long numImages, bool estimateEigenvalues, std::optional< size_t > bandIndex, double referenceEnergy, const std::vector< double > *quantumFreeEnergy, const eonc::tunneling::BandWalls *walls)
Build stamped ConFrames for a NEB band (same metadata as writePathCon).
AtomMatrix interpolatedPeakMode(const std::vector< std::shared_ptr< Matter > > &path, const std::vector< std::shared_ptr< AtomMatrix > > &tangent, long numImages, double posFraction)
Unit tangent at a fractional image index.
eonc::io::IoStatus writePathCon(const std::vector< std::shared_ptr< Matter > > &path, const std::vector< std::shared_ptr< AtomMatrix > > &tangent, const std::vector< std::shared_ptr< EigenmodeStrategy > > &eigenmode_solvers, long numImages, bool estimateEigenvalues, std::string filename, std::optional< size_t > bandIndex, double referenceEnergy, const std::vector< double > *quantumFreeEnergy, const eonc::tunneling::BandWalls *walls)
Write a NEB band as a multi-frame .con via readcon ConFrameBuilder::clone().
void printImageData(const std::vector< std::shared_ptr< Matter > > &path, const std::vector< std::shared_ptr< AtomMatrix > > &tangent, const std::vector< std::shared_ptr< EigenmodeStrategy > > &eigenmode_solvers, long numImages, bool estimateEigenvalues, bool writeToFile, size_t idx, eonc::log::Scoped log, double referenceEnergy)
Print NEB image data to log and optionally to file.
ExtremaResult findSplineExtrema(const std::vector< std::shared_ptr< Matter > > &path, const std::vector< std::shared_ptr< AtomMatrix > > &tangent, long numImages)
Find extrema along the MEP using cubic spline interpolation.
Splitting bandSplitting(const std::vector< std::shared_ptr< Matter > > &band, double referenceEnergy)
The splitting of a converged band, with the well frequencies from the band's curvature at each end.
bool singleBarrier(const Profile &p)
Whether a profile is one double well: its images rise to exactly one maximum between the two ends.
double massWeightedDistance(const Matter &a, const Matter &b)
sqrt(sum_i m_i |b_i - a_i|^2) under the minimum image of a's cell.
Levels bandLevels(const Profile &p, const BandWalls *walls)
dvrLevels on a band: the profile between the images, and past each end the well's fit a s^2 + b s^3 c...
Profile bandProfile(const std::vector< std::shared_ptr< Matter > > &band, double referenceEnergy)
The energy of a band against its mass-weighted arc length, measured from referenceEnergy.
void eigenmodeCompute(LowestEigenmode &s, std::shared_ptr< Matter > matter, AtomMatrix direction)
double eigenmodeGetEigenvalue(LowestEigenmode &s)
RAII helper for class-scoped logging.
std::vector< double > energies
std::vector< double > curvatures
std::vector< double > positions