41constexpr int kMaxEnergyHalvings = 20;
46constexpr int kMaxEnergyStalls = 6;
52constexpr double kMaxEnergyReseedAlpha = 1.0 / 64.0;
58constexpr double kMaxEnergyStepFloor = 1.0e-4;
63constexpr double kMaxEnergyMotionFloor = 1.0e-8;
69constexpr double kMaxEnergyCapRegrowth = 2.0;
83constexpr int kMaxEnergyWallEvents = 16;
97 std::shared_ptr<Matter> matterPassed,
98 std::shared_ptr<EigenmodeStrategy> minModeMethodPassed,
99 AtomMatrix modePassed,
double reactantEnergyPassed,
102 matter{std::move(matterPassed)},
127 if (
params.saddle_search_options().minmode_method !=
129 params.dimer_options().improved) {
133 if (!std::isfinite(c) || c >= 0.0) {
149 if (
matter->needsForceUpdate()) {
160 params.saddle_search_options().max_energy;
173 if (dimer && !dimer->rotationDidConverge) {
174 if (dimer->getEigenvalue() < 0.0) {
177 "[MinMode] Dimer restored to best state with C_tau={:.4f}",
178 dimer->getEigenvalue());
191 if (eigenvalue > 0.0 &&
192 params.neb_options().climbing_image.ocineb.use_mmf) {
199 if (eigenvalue > 0.0) {
200 if (
params.saddle_search_options().perp_force_ratio > 0.0) {
201 double d =
params.saddle_search_options().perp_force_ratio;
202 force = d * force - (1.0 + d) * proj;
203 }
else if (
params.saddle_search_options().confine_positive.enabled) {
204 if (
params.saddle_search_options().confine_positive.bowl_breakout) {
206 const long nAtoms =
matter->numberOfAtoms();
207 int nBowlActive =
static_cast<int>(std::min<long>(
208 params.saddle_search_options().confine_positive.bowl_active,
210 if (nBowlActive <= 0) {
213 std::vector<int> indices_max(nBowlActive);
216 for (
int j = 0; j < nBowlActive; j++) {
217 double f_max = forceTemp.row(0).norm();
219 for (
long i = 0; i <
matter->numberOfAtoms(); i++) {
220 if (f_max < forceTemp.row(i).norm()) {
221 f_max = forceTemp.row(i).norm();
222 i_max =
static_cast<int>(i);
225 forceTemp.row(i_max).setZero();
226 indices_max[j] = i_max;
229 for (
int j = 0; j < nBowlActive; j++) {
230 forceTemp.row(indices_max[j]) = -proj.row(indices_max[j]);
235 int sufficientForce = 0;
237 params.saddle_search_options().confine_positive.min_force;
238 const long maxBoostTries = std::max(
239 3 *
matter->numberOfAtoms(),
240 params.saddle_search_options().confine_positive.min_active);
244 params.saddle_search_options().confine_positive.min_active &&
245 boostTries < maxBoostTries) {
247 force =
matter->getForces();
248 for (
long i = 0; i <
matter->numberOfAtoms(); i++) {
249 for (
int k = 0; k < 3; k++) {
250 if (std::abs(force(i, k)) < minForce) {
255 -
params.saddle_search_options().confine_positive.boost *
261 params.saddle_search_options().confine_positive.scale_ratio;
269 force += -2.0 * proj;
272 VectorXd forceV = VectorXd::Map(force.data(), 3 *
matter->numberOfAtoms());
288 if (
params.optimizer_options().convergence_metric ==
"norm") {
289 return matter->getForcesFreeV().norm();
290 }
else if (
params.optimizer_options().convergence_metric ==
"max_atom") {
291 return matter->maxForce();
292 }
else if (
params.optimizer_options().convergence_metric ==
294 return matter->getForces().cwiseAbs().maxCoeff();
297 params.optimizer_options().convergence_metric);
298 throw std::invalid_argument(
299 std::format(
"[MinModeSaddleSearch] unknown convergence_metric: {}",
300 params.optimizer_options().convergence_metric));
305 return matter->pbcV(a - b);
314 dimer->init_cg =
true;
315 dimer->init_lbfgs =
true;
319 dimer->gradients.clear();
320 dimer->positions.clear();
327 double reactantEnergyPassed,
329 std::shared_ptr<Potential> potPassed)
333 params.optimizer_options().convergence_metric,
"[MinModeSaddleSearch]");
345 VectorXd refVec = VectorXd::Map(
mode.data(), 3 *
matter->numberOfAtoms());
346 refVec = refVec.array() *
matter->getFreeV().array();
347 dimer->setReferenceMode(refVec);
352 return run(
params.saddle_search_options().max_iterations);
358 const long maxIter = max_iterations_override < 0
359 ?
params.saddle_search_options().max_iterations
360 : max_iterations_override;
361 const int st =
run(maxIter);
367 long effectiveMaxIter = max_iterations_override;
369 log,
"Saddle point search started from reactant with energy {} eV.",
373 bool firstIteration =
true;
374 const char *forceLabel =
375 params.optimizer_options().convergence_metric_label.c_str();
377 if (
params.saddle_search_options().minmode_method ==
380 log,
"================= Using the GP Dimer Library =================");
383 QUILL_LOG_DEBUG(
log,
"GPR eigenvalue: {}",
389 QUILL_LOG_DEBUG(
log,
"[MinModeSaddleSearch] eigenvalue not negative");
393 params.saddle_search_options().zero_mode_abort_curvature) {
394 QUILL_LOG_DEBUG(
log,
"Zero mode eigenvalue: {}",
402 if (
params.saddle_search_options().minmode_method ==
405 "[Dimer] {:9s} {:9s} {:10s} {:18s} {:9s} "
406 "{:7s} {:6s} {:4s} {:5s}\n",
407 "Step",
"Step Size",
"Delta E", forceLabel,
"Curvature",
408 "Torque",
"Angle",
"Rots",
"Align");
409 }
else if (
params.saddle_search_options().minmode_method ==
413 "[Lanczos] {:9s} {:9s} {:10s} {:18s} {:9s} {:10s} {:7s} {:5s}\n",
414 "Step",
"Step Size",
"Delta E", forceLabel,
"Curvature",
"Rel Change",
416 }
else if (
params.saddle_search_options().minmode_method ==
419 "[GPRDimer] {:9s} {:9s} {:10s} {:18s} {:9s} "
420 " {:7s} {:6s} {:4s}\n",
421 "Step",
"Step Size",
"Delta E", forceLabel,
"Curvature",
422 "Torque",
"Angle",
"Rots");
425 std::string climbLabel =
"climb";
426 std::string climbDatFilename =
"climb.dat";
430 auto objf = std::make_shared<MinModeObjectiveFunction>(
432 auto write_climb_frame = [&](uint64_t frameIndex,
bool append,
433 double stepSize,
double de,
double conv,
434 double eigenval,
double torque,
double angle,
439 metadata.
scalars.push_back({
"step_size", stepSize});
440 metadata.
scalars.push_back({
"delta_e", de});
441 metadata.
scalars.push_back({
"convergence", conv});
442 metadata.
scalars.push_back({
"eigenvalue", eigenval});
443 metadata.
scalars.push_back({
"torque", torque});
444 metadata.
scalars.push_back({
"angle", angle});
445 metadata.
scalars.push_back({
"rotations",
static_cast<double>(rotations)});
449 if (
params.debug_options().write_movies) {
451 matter->matter2con(climbLabel, append, &metadata))) {
452 QUILL_LOG_WARNING(
log,
"Failed to write climb movie frame {}",
460 if (
params.debug_options().write_deprecated_outs) {
461 std::ofstream climbDat(climbDatFilename,
462 append ? (std::ios::binary | std::ios::app)
466 climbDat <<
"iteration\tstep_size\tdelta_e\tconvergence"
467 "\teigenvalue\ttorque\tangle\trotations\n";
469 climbDat << std::format(
"{}\t{:.7e}\t{:.6f}\t{:.5e}\t{:.6f}"
470 "\t{:.6f}\t{:.4f}\t{}\n",
471 frameIndex, stepSize, de, conv, eigenval,
472 torque, angle, rotations);
477 write_climb_frame(0,
false, 0.0, 0.0, objf->getConvergence(),
481 if (
params.saddle_search_options().nonnegative_displacement_abort) {
484 QUILL_LOG_DEBUG(
log,
"Nonnegative eigenvalue: {}",
496 const double stockMove =
params.optimizer_options().max_move;
497 double translationCap = stockMove;
501 int probeForceCalls = 0;
502 auto probedEnergy = [&]() {
503 const long beforeCalls =
matter->getForceCalls();
504 const double energy = objf->getEnergy();
506 static_cast<int>(
matter->getForceCalls() - beforeCalls);
509 auto pullUnderEnergy = [&](
const VectorXd &before) ->
bool {
510 const double limit =
params.saddle_search_options().max_energy;
511 const VectorXd after = objf->getPositions();
512 const VectorXd delta = objf->difference(after, before);
515 for (
int probe = 0; probe < kMaxEnergyHalvings; ++probe) {
517 kMaxEnergyMotionFloor) {
520 objf->setPositions(before + alpha * delta);
527 auto freshMode = [&]() {
529 if (reseeds % 2 == 1) {
532 objf->reseedMode(seed);
540 std::min(stockMove, std::max(accepted, kMaxEnergyStepFloor));
541 if (alpha < kMaxEnergyReseedAlpha) {
545 "[MinMode] energy above max_energy {:.4f}, shortened "
546 "the translation to {:.3e} and re-initialised the mode",
550 "[MinMode] energy above max_energy {:.4f}, shortened "
551 "the translation to {:.3e}",
554 if (wallEvents >= kMaxEnergyWallEvents) {
556 "[MinMode] {} crossings of max_energy {:.4f}, "
563 objf->setPositions(before);
569 translationCap = std::min(
570 stockMove, std::max(translationCap * 0.5, kMaxEnergyStepFloor));
573 "[MinMode] translation stays above max_energy {:.4f}, "
574 "restored the centre and re-initialised the mode",
576 if (wallEvents >= kMaxEnergyWallEvents) {
578 "[MinMode] {} crossings of max_energy {:.4f}, "
583 return wallStalls < kMaxEnergyStalls;
586 while (!objf->isConverged() ||
iteration == 0) {
587 matter->pollCancel(
"saddle");
589 if (!firstIteration) {
591 if (
params.saddle_search_options().nonlocal_count_abort != 0) {
593 initialPosition -
matter->getPositions(),
594 params.saddle_search_options().nonlocal_distance_abort);
595 if (nm >=
params.saddle_search_options().nonlocal_count_abort) {
602 params.saddle_search_options().zero_mode_abort_curvature) {
603 QUILL_LOG_DEBUG(
log,
"Zero mode eigenvalue: {}",
609 firstIteration =
false;
616 const VectorXd posBefore = objf->getPositions();
620 if (
params.saddle_search_options().confine_positive.bowl_breakout &&
623 optStatus = optim->step(-translationCap);
625 optStatus = optim->step(translationCap);
629 log,
"Dimer restored to best state. Checking convergence...");
633 QUILL_LOG_WARNING(
log,
"Dimer lost mode completely. Aborting.");
644 const double energyLimit =
params.saddle_search_options().max_energy;
645 if (de > energyLimit) {
646 const bool kept = pullUnderEnergy(posBefore);
648 optim->onTranslationPulledBack();
658 }
else if (translationCap < stockMove) {
660 std::min(stockMove, translationCap * kMaxEnergyCapRegrowth);
665 if (
params.saddle_search_options().remove_rotation) {
668 double stepSize = (
matter->pbc(
matter->getPositions() - pos)).norm();
677 double conv = objf->getConvergence();
679 if (
params.saddle_search_options().minmode_method ==
683 "[Lanczos] {:9} {:9.6f} {:10.4f} {:18.5e} {:9.4f} {:10.6f} "
685 iteration, stepSize, de, conv, eigenval, torque, angle, rotations);
689 "[Dimer] {:9} {:9.7f} {:10.4f} {:18.5e} {:9.4f} {:7.3f} "
691 iteration, stepSize, de, conv, eigenval, torque, angle, rotations);
695 write_climb_frame(
static_cast<uint64_t
>(
iteration),
true, stepSize, de,
696 conv, eigenval, torque, angle, rotations);
699 if (
params.main_options().checkpoint) {
701 matter->matter2con(
"displacement_cp.con",
false))) {
702 QUILL_LOG_WARNING(
log,
"Failed to write displacement_cp.con");
709 QUILL_LOG_DEBUG(
log,
"[MinModeSaddleSearch] reached a known saddle");
716 if (!dimer->rotationDidConverge) {
720 QUILL_LOG_DEBUG(
log,
"Dimer restored to valid state. C_tau={:.4f}",
721 dimer->getEigenvalue());
737 const bool climbConverged = objf->isConverged();
738 const int statusBeforeGuard =
status;
741 QUILL_LOG_WARNING(
log,
"[MinModeSaddleSearch] objective not converged; "
742 "refusing STATUS_GOOD");
745 long refineForceCalls = 0;
746 if (
params.saddle_search_options().prfo_refine.enabled &&
750 refineForceCalls = refined.forceCalls;
751 if (!refined.restored) {
758 QUILL_LOG_DEBUG(
log,
"[MinModeSaddleSearch] eigenvalue not negative");
763 probeForceCalls + refineForceCalls);
770 std::vector<double> energies) {
771 if (positions.size() != energies.size()) {
772 throw std::invalid_argument(
773 "MinModeSaddleSearch::setKnownSaddles: size mismatch");
784 const double energy =
matter->getPotentialEnergy();
785 const double eps =
params.structure_comparison_options().energy_difference;
Direct optimization for energy minimization.
double matDot(const AtomMatrix &a, const AtomMatrix &b)
SIMD-optimized dot product for contiguous Eigen matrices.
Eigen::Matrix< double, Eigen::Dynamic, 3, eOnStorageOrder > AtomMatrix
#define EONC_LOG_DEBUG(...)
#define EONC_LOG_CRITICAL(...)
Finds transition states by finding saddle points on the potential energy surface.
static const char MINMODE_GPRDIMER[]
static const char MINMODE_DIMER[]
static const char MINMODE_LANCZOS[]
void setPositions(const AtomMatrix &pos)
bool compare(const Matter &matter, bool indistinguishable=false)
~MinModeObjectiveFunction() override=default
MinModeObjectiveFunction(std::shared_ptr< Matter > matterPassed, std::shared_ptr< EigenmodeStrategy > minModeMethodPassed, AtomMatrix modePassed, double reactantEnergyPassed, const Parameters ¶msPassed)
VectorXd getGradient(bool fdstep=false)
void reseedMode(const AtomMatrix &seed)
VectorXd difference(const VectorXd &a, const VectorXd &b)
std::shared_ptr< EigenmodeStrategy > minModeMethod
std::optional< double > knownCurvature() const override
bool gradientMatchesEnergy() const override
bool pastClimbCeiling() override
void setPositions(const VectorXd &x)
std::shared_ptr< Matter > matter
MinModeSaddleSearch(std::shared_ptr< Matter > matterPassed, AtomMatrix modePassed, double reactantEnergyPassed, const Parameters ¶metersPassed, std::shared_ptr< Potential > potPassed)
int runRetainFrames(long max_iterations_override=-1)
Like run(), but also retain climb ConFrames in memory (same stamps as write_movies climb CON).
AtomMatrix getEigenvector()
bool atKnownSaddle() const
std::vector< double > knownSaddleEnergies_
@ STATUS_BAD_MAX_ITERATIONS
@ STATUS_NONNEGATIVE_ABORT
@ STATUS_BAD_NO_NEGATIVE_MODE_AT_SADDLE
@ STATUS_DIMER_RESTORED_BEST
std::vector< readcon::ConFrame > climb_frames_
bool retain_climb_frames_
AtomMatrix initialTangent_
std::shared_ptr< Matter > matter
static constexpr int finalizeClimbStatus(int climbStatus, bool objectiveConverged) noexcept
Issue #20 policy: never leave climb as STATUS_GOOD when the climb objective is still unconverged (unf...
std::shared_ptr< EigenmodeStrategy > minModeMethod
void setKnownSaddles(std::vector< AtomMatrix > positions, std::vector< double > energies)
Saddles the server already holds for this state (positions, energies).
std::vector< AtomMatrix > knownSaddlePositions_
ObjectiveFunction(const Parameters ¶msPassed)
const Parameters & params
std::shared_ptr< Potential > pot
const Parameters & params
SaddleSearchMethod(std::shared_ptr< Potential > potPassed, const Parameters ¶msPassed)
long numAtomsMoved(const AtomMatrix v1, double cutoff)
double maxAtomMotionV(const VectorXd v1)
void rotationRemove(const AtomMatrix r1, std::shared_ptr< Matter > m2)
std::unique_ptr< Optimizer > mkOptim(std::shared_ptr< ObjectiveFunction > a_objf, OptType a_otype, const Parameters &a_params)
void saveMode(FILE *modeFile, std::shared_ptr< Matter > matter, AtomMatrix mode)
Write a mode; constrained axes are emitted as 0.
void requireKnownConvergenceMetric(std::string_view metric, std::string_view context)
Throws std::invalid_argument naming context when metric is unrecognized.
readcon::ConFrame matterToConFrame(Matter &m, const ConFrameMetadata *metadata)
Build a single stamped ConFrame from Matter (same builder as matter2con).
constexpr bool io_ok(IoStatus s) noexcept
RAII resource manager for the ARTn C library with global synchronization.
void eigenmodeCompute(LowestEigenmode &s, std::shared_ptr< Matter > matter, AtomMatrix direction)
PrfoRefineResult prfoRefineSaddle(Matter &, const AtomMatrix &, double, const Parameters &)
Partitioned rational function optimization (P-RFO) of a first-order saddle in the rgsaddle Sella orde...
long eigenmodeTotalForceCalls(LowestEigenmode &s)
std::shared_ptr< LowestEigenmode > buildEigenmodeStrategy(std::shared_ptr< Matter > matter, const Parameters ¶ms, std::shared_ptr< Potential > pot)
long eigenmodeStatsRotations(LowestEigenmode &s)
ImprovedDimer * asImprovedDimer(LowestEigenmode &s)
long eigenmodeTotalIterations(LowestEigenmode &s)
double eigenmodeGetEigenvalue(LowestEigenmode &s)
double eigenmodeStatsTorque(LowestEigenmode &s)
AtomMatrix eigenmodeGetEigenvector(LowestEigenmode &s)
double eigenmodeStatsAngle(LowestEigenmode &s)
void requirePrfoRefine(const Parameters ¶ms)
Does nothing unless [Saddle Search] prfo_refine is on.