MinModeSaddleSearch Class Reference

#include <MinModeSaddleSearch.h>

Inheritance diagram for MinModeSaddleSearch:

Public Types

enum

Status : int {   STATUS_GOOD , STATUS_INIT , STATUS_BAD_NO_CONVEX , STATUS_BAD_HIGH_ENERGY ,   STATUS_BAD_MAX_CONCAVE_ITERATIONS , STATUS_BAD_MAX_ITERATIONS , STATUS_BAD_NOT_CONNECTED , STATUS_BAD_PREFACTOR ,   STATUS_BAD_HIGH_BARRIER , STATUS_BAD_MINIMA , STATUS_FAILED_PREFACTOR , STATUS_POTENTIAL_FAILED ,   STATUS_NONNEGATIVE_ABORT , STATUS_NONLOCAL_ABORT , STATUS_NEGATIVE_BARRIER , STATUS_BAD_MD_TRAJECTORY_TOO_SHORT ,   STATUS_BAD_NO_NEGATIVE_MODE_AT_SADDLE , STATUS_BAD_NO_BARRIER , STATUS_ZEROMODE_ABORT , STATUS_OPTIMIZER_ERROR ,   STATUS_DIMER_LOST_MODE , STATUS_DIMER_RESTORED_BEST , STATUS_KNOWN_SADDLE = 23 }

Public Member Functions
	MinModeSaddleSearch (std::shared_ptr< Matter > matterPassed, AtomMatrix modePassed, double reactantEnergyPassed, const Parameters &parametersPassed, std::shared_ptr< Potential > potPassed)
	MinModeSaddleSearch (const MinModeSaddleSearch &)=delete
	MinModeSaddleSearch (MinModeSaddleSearch &&) noexcept=default
	~MinModeSaddleSearch ()=default
MinModeSaddleSearch &	operator= (const MinModeSaddleSearch &)=delete
MinModeSaddleSearch &	operator= (MinModeSaddleSearch &&) noexcept=default
AtomMatrix	getEigenvector ()
double	getEigenvalue ()
std::string_view	describeStatus (int status) const override
int	getStatus () const override
int	getIterationCount () const override
int	getForceCalls () const override
int	run () override
int	run (long max_iterations_override)
int	runRetainFrames (long max_iterations_override=-1)
	Like run(), but also retain climb ConFrames in memory (same stamps as write_movies climb CON).
const std::vector< readcon::ConFrame > &	climbFrames () const
void	clearClimbFrames ()
void	setKnownSaddles (std::vector< AtomMatrix > positions, std::vector< double > energies)
	Saddles the server already holds for this state (positions, energies).
std::vector< readcon::ConFrame >	takeClimbFrames ()
Public Member Functions inherited from eonc::SaddleSearchMethod
	SaddleSearchMethod (std::shared_ptr< Potential > potPassed, const Parameters &paramsPassed)
virtual	~SaddleSearchMethod ()

Static Public Member Functions
static constexpr std::string_view	statusMessage (int status)
	Human-readable message for a status code.
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 (unfeasible systems must not look like success).

Public Attributes
int	forcecalls {0}
int	iteration {0}
int	status {0}

Private Member Functions
bool	atKnownSaddle () const

Private Attributes
std::vector< readcon::ConFrame >	climb_frames_
bool	retain_climb_frames_ {false}
AtomMatrix	mode
AtomMatrix	initialTangent_
std::shared_ptr< Matter >	matter
std::shared_ptr< EigenmodeStrategy >	minModeMethod
double	reactantEnergy
std::vector< AtomMatrix >	knownSaddlePositions_
std::vector< double >	knownSaddleEnergies_
eonc::log::Scoped	log

Additional Inherited Members
Protected Attributes inherited from eonc::SaddleSearchMethod
std::shared_ptr< Potential >	pot
const Parameters &	params

Detailed Description

Definition at line 26 of file MinModeSaddleSearch.h.

Member Enumeration Documentation

Status

enum eonc::MinModeSaddleSearch::Status : int

Enumerator
STATUS_GOOD
STATUS_INIT
STATUS_BAD_NO_CONVEX
STATUS_BAD_HIGH_ENERGY
STATUS_BAD_MAX_CONCAVE_ITERATIONS
STATUS_BAD_MAX_ITERATIONS
STATUS_BAD_NOT_CONNECTED
STATUS_BAD_PREFACTOR
STATUS_BAD_HIGH_BARRIER
STATUS_BAD_MINIMA
STATUS_FAILED_PREFACTOR
STATUS_POTENTIAL_FAILED
STATUS_NONNEGATIVE_ABORT
STATUS_NONLOCAL_ABORT
STATUS_NEGATIVE_BARRIER
STATUS_BAD_MD_TRAJECTORY_TOO_SHORT
STATUS_BAD_NO_NEGATIVE_MODE_AT_SADDLE
STATUS_BAD_NO_BARRIER
STATUS_ZEROMODE_ABORT
STATUS_OPTIMIZER_ERROR
STATUS_DIMER_LOST_MODE
STATUS_DIMER_RESTORED_BEST
STATUS_KNOWN_SADDLE

Definition at line 29 of file MinModeSaddleSearch.h.

              : int {
    // DO NOT CHANGE THE ORDER OF THIS LIST
    STATUS_GOOD,                           // 0
    STATUS_INIT,                           // 1
    STATUS_BAD_NO_CONVEX,                  // 2
    STATUS_BAD_HIGH_ENERGY,                // 3
    STATUS_BAD_MAX_CONCAVE_ITERATIONS,     // 4
    STATUS_BAD_MAX_ITERATIONS,             // 5
    STATUS_BAD_NOT_CONNECTED,              // 6
    STATUS_BAD_PREFACTOR,                  // 7
    STATUS_BAD_HIGH_BARRIER,               // 8
    STATUS_BAD_MINIMA,                     // 9
    STATUS_FAILED_PREFACTOR,               // 10
    STATUS_POTENTIAL_FAILED,               // 11
    STATUS_NONNEGATIVE_ABORT,              // 12
    STATUS_NONLOCAL_ABORT,                 // 13
    STATUS_NEGATIVE_BARRIER,               // 14
    STATUS_BAD_MD_TRAJECTORY_TOO_SHORT,    // 15
    STATUS_BAD_NO_NEGATIVE_MODE_AT_SADDLE, // 16
    STATUS_BAD_NO_BARRIER,                 // 17
    STATUS_ZEROMODE_ABORT,                 // 18
    STATUS_OPTIMIZER_ERROR,                // 19
    STATUS_DIMER_LOST_MODE,                // 20
    STATUS_DIMER_RESTORED_BEST,            // 21
    // 22 is ARTnSaddleSearch::STATUS_BAD_ARTN_ERROR
    STATUS_KNOWN_SADDLE = 23
  };

Constructor & Destructor Documentation

MinModeSaddleSearch() [1/3]

eonc::MinModeSaddleSearch::MinModeSaddleSearch	(	std::shared_ptr< Matter >	matterPassed,
		AtomMatrix	modePassed,
		double	reactantEnergyPassed,
		const Parameters &	parametersPassed,
		std::shared_ptr< Potential >	potPassed )

Definition at line 318 of file MinModeSaddleSearch.cpp.

    : SaddleSearchMethod(potPassed, parametersPassed),
      matter{matterPassed} {
  eonc::helpers::requireKnownConvergenceMetric(
      params.optimizer_options().convergence_metric, "[MinModeSaddleSearch]");
  reactantEnergy = reactantEnergyPassed;
  mode = modePassed;
  initialTangent_ = modePassed;
  status = STATUS_GOOD;
  iteration = 0;
 
  minModeMethod = eonc::buildEigenmodeStrategy(matter, params, pot);
 
  // Set reference mode for ImprovedDimer (prevents mode switching)
  if (auto *dimer = eonc::asImprovedDimer(*minModeMethod)) {
    VectorXd refVec = VectorXd::Map(mode.data(), 3 * matter->numberOfAtoms());
    refVec = refVec.array() * matter->getFreeV().array();
    dimer->setReferenceMode(refVec);
  }
}

MinModeSaddleSearch() [2/3]

eonc::MinModeSaddleSearch::MinModeSaddleSearch ( const MinModeSaddleSearch & )

delete

MinModeSaddleSearch() [3/3]

eonc::MinModeSaddleSearch::MinModeSaddleSearch ( MinModeSaddleSearch && )

defaultnoexcept

~MinModeSaddleSearch()

eonc::MinModeSaddleSearch::~MinModeSaddleSearch ( )

default

Member Function Documentation

atKnownSaddle()

bool eonc::MinModeSaddleSearch::atKnownSaddle ( ) const

nodiscardprivate

Definition at line 755 of file MinModeSaddleSearch.cpp.

                                              {
  if (knownSaddleEnergies_.empty() ||
      !(eonc::eigenmodeGetEigenvalue(*minModeMethod) < 0.0)) {
    return false;
  }
  const double energy = matter->getPotentialEnergy();
  const double eps = params.structure_comparison_options().energy_difference;
  for (size_t k = 0; k < knownSaddleEnergies_.size(); ++k) {
    if (std::abs(energy - knownSaddleEnergies_[k]) > eps) {
      continue;
    }
    Matter known(*matter);
    known.setPositions(knownSaddlePositions_[k]);
    if (known.compare(*matter)) {
      return true;
    }
  }
  return false;
}

clearClimbFrames()

void eonc::MinModeSaddleSearch::clearClimbFrames ( )

inline

Definition at line 134 of file MinModeSaddleSearch.h.

{ climb_frames_.clear(); }

climbFrames()

const std::vector< readcon::ConFrame > & eonc::MinModeSaddleSearch::climbFrames ( ) const

inlinenodiscard

Definition at line 131 of file MinModeSaddleSearch.h.

                                                                      {
    return climb_frames_;
  }

describeStatus()

std::string_view eonc::MinModeSaddleSearch::describeStatus ( int status ) const

inlineoverridevirtual

Implements eonc::SaddleSearchMethod.

Definition at line 114 of file MinModeSaddleSearch.h.

                                                           {
    return statusMessage(status);
  }

finalizeClimbStatus()

constexpr int eonc::MinModeSaddleSearch::finalizeClimbStatus ( int climbStatus, bool objectiveConverged )

inlinestaticnodiscardconstexprnoexcept

Issue #20 policy: never leave climb as STATUS_GOOD when the climb objective is still unconverged (unfeasible systems must not look like success).

Used by run(); unit-tested so deleting this rule fails CI.

Definition at line 95 of file MinModeSaddleSearch.h.

                                                                         {
    if (climbStatus == STATUS_GOOD && !objectiveConverged) {
      return STATUS_BAD_MAX_ITERATIONS;
    }
    return climbStatus;
  }

getEigenvalue()

double eonc::MinModeSaddleSearch::getEigenvalue ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 775 of file MinModeSaddleSearch.cpp.

                                          {
  return eonc::eigenmodeGetEigenvalue(*minModeMethod);
}

getEigenvector()

AtomMatrix eonc::MinModeSaddleSearch::getEigenvector ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 779 of file MinModeSaddleSearch.cpp.

                                               {
  return eonc::eigenmodeGetEigenvector(*minModeMethod);
}

getForceCalls()

int eonc::MinModeSaddleSearch::getForceCalls ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 119 of file MinModeSaddleSearch.h.

{ return forcecalls; }

getIterationCount()

int eonc::MinModeSaddleSearch::getIterationCount ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 118 of file MinModeSaddleSearch.h.

{ return iteration; }

getStatus()

int eonc::MinModeSaddleSearch::getStatus ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 117 of file MinModeSaddleSearch.h.

{ return status; }

operator=() [1/2]

MinModeSaddleSearch & eonc::MinModeSaddleSearch::operator= ( const MinModeSaddleSearch & )

delete

operator=() [2/2]

MinModeSaddleSearch & eonc::MinModeSaddleSearch::operator= ( MinModeSaddleSearch && )

defaultnoexcept

run() [1/2]

int eonc::MinModeSaddleSearch::run ( void )

overridevirtual

Implements eonc::SaddleSearchMethod.

Definition at line 343 of file MinModeSaddleSearch.cpp.

                             {
  return run(params.saddle_search_options().max_iterations);
}

run() [2/2]

int eonc::MinModeSaddleSearch::run

(

long

max_iterations_override

)

Definition at line 358 of file MinModeSaddleSearch.cpp.

                                                         {
  long effectiveMaxIter = max_iterations_override;
  QUILL_LOG_DEBUG(
      log, "Saddle point search started from reactant with energy {} eV.",
      reactantEnergy);
 
  int optStatus;
  bool firstIteration = true;
  const char *forceLabel =
      params.optimizer_options().convergence_metric_label.c_str();
 
  if (params.saddle_search_options().minmode_method ==
      LowestEigenmode::MINMODE_GPRDIMER) {
    QUILL_LOG_DEBUG(
        log, "================= Using the GP Dimer Library =================");
    eonc::eigenmodeCompute(*minModeMethod, matter, mode);
    if (eonc::eigenmodeGetEigenvalue(*minModeMethod) > 0) {
      QUILL_LOG_DEBUG(log, "GPR eigenvalue: {}",
                      eonc::eigenmodeGetEigenvalue(*minModeMethod));
      status = STATUS_NONNEGATIVE_ABORT;
      return status;
    }
    if (getEigenvalue() > 0.0 && status == STATUS_GOOD) {
      QUILL_LOG_DEBUG(log, "[MinModeSaddleSearch] eigenvalue not negative");
      status = STATUS_BAD_NO_NEGATIVE_MODE_AT_SADDLE;
    }
    if (std::abs(eonc::eigenmodeGetEigenvalue(*minModeMethod)) <
        params.saddle_search_options().zero_mode_abort_curvature) {
      QUILL_LOG_DEBUG(log, "Zero mode eigenvalue: {}",
                      eonc::eigenmodeGetEigenvalue(*minModeMethod));
      status = STATUS_ZEROMODE_ABORT;
    }
    iteration = eonc::eigenmodeTotalIterations(*minModeMethod);
    forcecalls = eonc::eigenmodeTotalForceCalls(*minModeMethod);
  } else {
 
    if (params.saddle_search_options().minmode_method ==
        LowestEigenmode::MINMODE_DIMER) {
      QUILL_LOG_INFO(log,
                     "[Dimer]  {:9s}   {:9s}   {:10s}   {:18s}   {:9s}   "
                     "{:7s}   {:6s}   {:4s}   {:5s}\n",
                     "Step", "Step Size", "Delta E", forceLabel, "Curvature",
                     "Torque", "Angle", "Rots", "Align");
    } else if (params.saddle_search_options().minmode_method ==
               LowestEigenmode::MINMODE_LANCZOS) {
      QUILL_LOG_INFO(
          log,
          "[Lanczos]  {:9s} {:9s} {:10s} {:18s} {:9s} {:10s} {:7s} {:5s}\n",
          "Step", "Step Size", "Delta E", forceLabel, "Curvature", "Rel Change",
          "Angle", "Iters");
    } else if (params.saddle_search_options().minmode_method ==
               LowestEigenmode::MINMODE_GPRDIMER) {
      QUILL_LOG_INFO(log,
                     "[GPRDimer]  {:9s}   {:9s}   {:10s}   {:18s}   {:9s}  "
                     " {:7s}   {:6s}   {:4s}\n",
                     "Step", "Step Size", "Delta E", forceLabel, "Curvature",
                     "Torque", "Angle", "Rots");
    }
 
    std::string climbLabel = "climb";
    std::string climbDatFilename = "climb.dat";
 
    AtomMatrix initialPosition = matter->getPositions();
 
    auto objf = std::make_shared<MinModeObjectiveFunction>(
        matter, minModeMethod, mode, reactantEnergy, params);
    auto write_climb_frame = [&](uint64_t frameIndex, bool append,
                                 double stepSize, double de, double conv,
                                 double eigenval, double torque, double angle,
                                 long rotations) {
      eonc::io::ConFrameMetadata metadata;
      metadata.frame_index = frameIndex;
      metadata.energy = matter->getPotentialEnergy();
      metadata.scalars.push_back({"step_size", stepSize});
      metadata.scalars.push_back({"delta_e", de});
      metadata.scalars.push_back({"convergence", conv});
      metadata.scalars.push_back({"eigenvalue", eigenval});
      metadata.scalars.push_back({"torque", torque});
      metadata.scalars.push_back({"angle", angle});
      metadata.scalars.push_back({"rotations", static_cast<double>(rotations)});
      if (retain_climb_frames_) {
        climb_frames_.push_back(eonc::io::matterToConFrame(*matter, &metadata));
      }
      if (params.debug_options().write_movies) {
        if (!eonc::io::io_ok(
                matter->matter2con(climbLabel, append, &metadata))) {
          QUILL_LOG_WARNING(log, "Failed to write climb movie frame {}",
                            climbLabel);
        }
        eonc::helpers::saveMode(std::format("mode_{:03}.dat", frameIndex),
                                matter,
                                eonc::eigenmodeGetEigenvector(*minModeMethod));
      }
 
      if (params.debug_options().write_deprecated_outs) {
        std::ofstream climbDat(climbDatFilename,
                               append ? (std::ios::binary | std::ios::app)
                                      : std::ios::binary);
        if (climbDat) {
          if (!append) {
            climbDat << "iteration\tstep_size\tdelta_e\tconvergence"
                        "\teigenvalue\ttorque\tangle\trotations\n";
          }
          climbDat << std::format("{}\t{:.7e}\t{:.6f}\t{:.5e}\t{:.6f}"
                                  "\t{:.6f}\t{:.4f}\t{}\n",
                                  frameIndex, stepSize, de, conv, eigenval,
                                  torque, angle, rotations);
        }
      }
    };
    if (params.debug_options().write_movies || retain_climb_frames_) {
      write_climb_frame(0, false, 0.0, 0.0, objf->getConvergence(),
                        eonc::eigenmodeGetEigenvalue(*minModeMethod), 0.0, 0.0,
                        0);
    }
    if (params.saddle_search_options().nonnegative_displacement_abort) {
      objf->getGradient();
      if (eonc::eigenmodeGetEigenvalue(*minModeMethod) > 0) {
        QUILL_LOG_DEBUG(log, "Nonnegative eigenvalue: {}",
                        eonc::eigenmodeGetEigenvalue(*minModeMethod));
        status = STATUS_NONNEGATIVE_ABORT;
        return status;
      }
    }
 
    auto optim = eonc::helpers::create::mkOptim(
        objf, params.optimizer_options().method, params);
 
    // Stock max_move stays the cap until a translation crosses max_energy.
    // A search that never crosses it takes the same steps as before.
    const double stockMove = params.optimizer_options().max_move;
    double translationCap = stockMove;
    int wallStalls = 0;
    int wallEvents = 0;
    int reseeds = 0;
    int probeForceCalls = 0;
    auto probedEnergy = [&]() {
      const long beforeCalls = matter->getForceCalls();
      const double energy = objf->getEnergy();
      probeForceCalls +=
          static_cast<int>(matter->getForceCalls() - beforeCalls);
      return energy;
    };
    auto pullUnderEnergy = [&](const VectorXd &before) -> bool {
      const double limit = params.saddle_search_options().max_energy;
      const VectorXd after = objf->getPositions();
      const VectorXd delta = objf->difference(after, before);
      double alpha = 0.5;
      bool found = false;
      for (int probe = 0; probe < kMaxEnergyHalvings; ++probe) {
        if (eonc::geometry::maxAtomMotionV(alpha * delta) <
            kMaxEnergyMotionFloor) {
          break;
        }
        objf->setPositions(before + alpha * delta);
        if (probedEnergy() - reactantEnergy <= limit) {
          found = true;
          break;
        }
        alpha *= 0.5;
      }
      auto freshMode = [&]() {
        AtomMatrix seed = initialTangent_;
        if (reseeds % 2 == 1) {
          seed = -seed;
        }
        objf->reseedMode(seed);
        ++reseeds;
      };
      if (found) {
        wallStalls = 0;
        ++wallEvents;
        const double accepted = eonc::geometry::maxAtomMotionV(alpha * delta);
        translationCap =
            std::min(stockMove, std::max(accepted, kMaxEnergyStepFloor));
        if (alpha < kMaxEnergyReseedAlpha) {
          freshMode();
          QUILL_LOG_DEBUG(
              log,
              "[MinMode] energy above max_energy {:.4f}, shortened "
              "the translation to {:.3e} and re-initialised the mode",
              limit, accepted);
        } else {
          QUILL_LOG_DEBUG(log,
                          "[MinMode] energy above max_energy {:.4f}, shortened "
                          "the translation to {:.3e}",
                          limit, accepted);
        }
        if (wallEvents >= kMaxEnergyWallEvents) {
          QUILL_LOG_DEBUG(log,
                          "[MinMode] {} crossings of max_energy {:.4f}, "
                          "ending the search",
                          wallEvents, limit);
          return false;
        }
        return true;
      }
      objf->setPositions(before);
      if (probedEnergy() - reactantEnergy > limit) {
        return false;
      }
      ++wallEvents;
      ++wallStalls;
      translationCap = std::min(
          stockMove, std::max(translationCap * 0.5, kMaxEnergyStepFloor));
      freshMode();
      QUILL_LOG_DEBUG(log,
                      "[MinMode] translation stays above max_energy {:.4f}, "
                      "restored the centre and re-initialised the mode",
                      limit);
      if (wallEvents >= kMaxEnergyWallEvents) {
        QUILL_LOG_DEBUG(log,
                        "[MinMode] {} crossings of max_energy {:.4f}, "
                        "ending the search",
                        wallEvents, limit);
        return false;
      }
      return wallStalls < kMaxEnergyStalls;
    };
 
    while (!objf->isConverged() || iteration == 0) {
      matter->pollCancel("saddle");
 
      if (!firstIteration) {
 
        if (params.saddle_search_options().nonlocal_count_abort != 0) {
          long nm = eonc::geometry::numAtomsMoved(
              initialPosition - matter->getPositions(),
              params.saddle_search_options().nonlocal_distance_abort);
          if (nm >= params.saddle_search_options().nonlocal_count_abort) {
            status = STATUS_NONLOCAL_ABORT;
            break;
          }
        }
 
        if (std::abs(eonc::eigenmodeGetEigenvalue(*minModeMethod)) <
            params.saddle_search_options().zero_mode_abort_curvature) {
          QUILL_LOG_DEBUG(log, "Zero mode eigenvalue: {}",
                          eonc::eigenmodeGetEigenvalue(*minModeMethod));
          status = STATUS_ZEROMODE_ABORT;
          break;
        }
      }
      firstIteration = false;
 
      if (iteration >= effectiveMaxIter) {
        status = STATUS_BAD_MAX_ITERATIONS;
        break;
      }
 
      const VectorXd posBefore = objf->getPositions();
      AtomMatrix pos = matter->getPositions();
 
      try {
        if (params.saddle_search_options().confine_positive.bowl_breakout &&
            eonc::eigenmodeGetEigenvalue(*minModeMethod) > 0 &&
            params.optimizer_options().method == OptType::CG) {
          optStatus = optim->step(-translationCap);
        } else {
          optStatus = optim->step(translationCap);
        }
      } catch (const eonc::DimerModeRestoredException &) {
        QUILL_LOG_DEBUG(
            log, "Dimer restored to best state. Checking convergence...");
        status = objf->isConverged() ? STATUS_GOOD : STATUS_DIMER_RESTORED_BEST;
        break;
      } catch (const eonc::DimerModeLostException &) {
        QUILL_LOG_WARNING(log, "Dimer lost mode completely. Aborting.");
        status = STATUS_DIMER_LOST_MODE;
        break;
      }
 
      if (optStatus < 0) {
        status = STATUS_OPTIMIZER_ERROR;
        break;
      }
 
      double de = objf->getEnergy() - reactantEnergy;
      const double energyLimit = params.saddle_search_options().max_energy;
      if (de > energyLimit) {
        const bool kept = pullUnderEnergy(posBefore);
        if (kept) {
          optim->onTranslationPulledBack();
        }
        if (!kept || objf->getEnergy() - reactantEnergy > energyLimit) {
          status = STATUS_BAD_HIGH_ENERGY;
          // Count the attempt so a first-step abort does not fall through
          // to the iteration == 0 mode estimate below.
          ++iteration;
          break;
        }
        de = objf->getEnergy() - reactantEnergy;
      } else if (translationCap < stockMove) {
        translationCap =
            std::min(stockMove, translationCap * kMaxEnergyCapRegrowth);
        wallStalls = 0;
      }
 
      // Melander, Laasonen, Jonsson, JCTC 11(3), 1055-1062, 2015
      if (params.saddle_search_options().remove_rotation) {
        eonc::geometry::rotationRemove(pos, matter);
      }
      double stepSize = (matter->pbc(matter->getPositions() - pos)).norm();
 
      iteration++;
 
      // Logging
      double eigenval = eonc::eigenmodeGetEigenvalue(*minModeMethod);
      double torque = eonc::eigenmodeStatsTorque(*minModeMethod);
      double angle = eonc::eigenmodeStatsAngle(*minModeMethod);
      long rotations = eonc::eigenmodeStatsRotations(*minModeMethod);
      double conv = objf->getConvergence();
 
      if (params.saddle_search_options().minmode_method ==
          LowestEigenmode::MINMODE_LANCZOS) {
        QUILL_LOG_DEBUG(
            log,
            "[Lanczos]  {:9} {:9.6f} {:10.4f} {:18.5e} {:9.4f} {:10.6f} "
            "{:7.3f} {:5}\n",
            iteration, stepSize, de, conv, eigenval, torque, angle, rotations);
      } else {
        QUILL_LOG_DEBUG(
            log,
            "[Dimer]  {:9}   {:9.7f}   {:10.4f}   {:18.5e}   {:9.4f}   {:7.3f} "
            "  {:6.3f}   {:4}\n",
            iteration, stepSize, de, conv, eigenval, torque, angle, rotations);
      }
 
      if (params.debug_options().write_movies || retain_climb_frames_) {
        write_climb_frame(static_cast<uint64_t>(iteration), true, stepSize, de,
                          conv, eigenval, torque, angle, rotations);
      }
 
      if (params.main_options().checkpoint) {
        if (!eonc::io::io_ok(
                matter->matter2con("displacement_cp.con", false))) {
          QUILL_LOG_WARNING(log, "Failed to write displacement_cp.con");
        }
        eonc::helpers::saveMode("mode_cp.dat", matter,
                                eonc::eigenmodeGetEigenvector(*minModeMethod));
      }
 
      if (atKnownSaddle()) {
        QUILL_LOG_DEBUG(log, "[MinModeSaddleSearch] reached a known saddle");
        status = STATUS_KNOWN_SADDLE;
        break;
      }
 
      // Check ImprovedDimer mode convergence
      if (auto *dimer = eonc::asImprovedDimer(*minModeMethod)) {
        if (!dimer->rotationDidConverge) {
          status = (dimer->getEigenvalue() < 0.0) ? STATUS_DIMER_RESTORED_BEST
                                                  : STATUS_DIMER_LOST_MODE;
          if (status == STATUS_DIMER_RESTORED_BEST) {
            QUILL_LOG_DEBUG(log, "Dimer restored to valid state. C_tau={:.4f}",
                            dimer->getEigenvalue());
          }
          break;
        }
      }
    }
 
    if (iteration == 0) {
      eonc::eigenmodeCompute(*minModeMethod, matter, mode);
    }
 
    // Never report STATUS_GOOD when the climb objective is unconverged
    // (issue #20: unfeasible systems must not look like success).
    const bool climbConverged = objf->isConverged();
    const int statusBeforeGuard = status;
    status = finalizeClimbStatus(status, climbConverged);
    if (statusBeforeGuard == STATUS_GOOD && status != STATUS_GOOD) {
      QUILL_LOG_WARNING(log, "[MinModeSaddleSearch] objective not converged; "
                             "refusing STATUS_GOOD");
    }
 
    if (getEigenvalue() > 0.0 && status == STATUS_GOOD) {
      QUILL_LOG_DEBUG(log, "[MinModeSaddleSearch] eigenvalue not negative");
      status = STATUS_BAD_NO_NEGATIVE_MODE_AT_SADDLE;
    }
    forcecalls = static_cast<int>(
        eonc::eigenmodeTotalForceCalls(*minModeMethod) + probeForceCalls);
  }
 
  return status;
}

runRetainFrames()

int eonc::MinModeSaddleSearch::runRetainFrames

(

long

max_iterations_override = -1

)

Like run(), but also retain climb ConFrames in memory (same stamps as write_movies climb CON).

Does not require write_movies on disk.

Definition at line 347 of file MinModeSaddleSearch.cpp.

                                                                     {
  retain_climb_frames_ = true;
  climb_frames_.clear();
  const long maxIter = max_iterations_override < 0
                           ? params.saddle_search_options().max_iterations
                           : max_iterations_override;
  const int st = run(maxIter);
  retain_climb_frames_ = false;
  return st;
}

setKnownSaddles()

void eonc::MinModeSaddleSearch::setKnownSaddles	(	std::vector< AtomMatrix >	positions,
		std::vector< double >	energies )

Saddles the server already holds for this state (positions, energies).

A climb point with negative curvature that matches one under the structure comparison ends the search with STATUS_KNOWN_SADDLE.

Definition at line 745 of file MinModeSaddleSearch.cpp.

                                                                      {
  if (positions.size() != energies.size()) {
    throw std::invalid_argument(
        "MinModeSaddleSearch::setKnownSaddles: size mismatch");
  }
  knownSaddlePositions_ = std::move(positions);
  knownSaddleEnergies_ = std::move(energies);
}

statusMessage()

constexpr std::string_view eonc::MinModeSaddleSearch::statusMessage ( int status )

inlinestaticconstexpr

Human-readable message for a status code.

Definition at line 58 of file MinModeSaddleSearch.h.

                                                            {
    constexpr std::string_view msgs[] = {
        "Success",                                                // 0
        "Initialized",                                            // 1
        "Initial displacement unable to reach convex region",     // 2
        "Barrier too high",                                       // 3
        "Too many iterations in concave region",                  // 4
        "Too many iterations",                                    // 5
        "Saddle is not connected to initial state",               // 6
        "Prefactors not within window",                           // 7
        "Energy barrier not within window",                       // 8
        "Minimizations from saddle did not converge",             // 9
        "Hessian calculation failed",                             // 10
        "Potential evaluation failed",                            // 11
        "Nonnegative initial mode, aborting",                     // 12
        "Nonlocal abort",                                         // 13
        "Negative barrier detected",                              // 14
        "No reaction found during MD trajectory",                 // 15
        "Converged to stationary point with zero negative modes", // 16
        "No forward barrier found along minimized band",          // 17
        "Zero mode abort",                                        // 18
        "Optimizer error",                                        // 19
        "Dimer lost mode",                                        // 20
        "Dimer restored best",                                    // 21
    };
    if (status == STATUS_KNOWN_SADDLE)
      return "Climb reached a known saddle";
    if (status >= 0 &&
        status < static_cast<int>(sizeof(msgs) / sizeof(msgs[0])))
      return msgs[status];
    return "Unknown status";
  }

takeClimbFrames()

std::vector< readcon::ConFrame > eonc::MinModeSaddleSearch::takeClimbFrames ( )

inlinenodiscard

Definition at line 141 of file MinModeSaddleSearch.h.

                                                             {
    return std::move(climb_frames_);
  }

Member Data Documentation

climb_frames_

std::vector<readcon::ConFrame> eonc::MinModeSaddleSearch::climb_frames_

private

Definition at line 146 of file MinModeSaddleSearch.h.

forcecalls

int eonc::MinModeSaddleSearch::forcecalls {0}

Definition at line 127 of file MinModeSaddleSearch.h.

{0};

initialTangent_

AtomMatrix eonc::MinModeSaddleSearch::initialTangent_

private

Definition at line 149 of file MinModeSaddleSearch.h.

iteration

int eonc::MinModeSaddleSearch::iteration {0}

Definition at line 128 of file MinModeSaddleSearch.h.

{0};

knownSaddleEnergies_

std::vector<double> eonc::MinModeSaddleSearch::knownSaddleEnergies_

private

Definition at line 155 of file MinModeSaddleSearch.h.

knownSaddlePositions_

std::vector<AtomMatrix> eonc::MinModeSaddleSearch::knownSaddlePositions_

private

Definition at line 154 of file MinModeSaddleSearch.h.

log

eonc::log::Scoped eonc::MinModeSaddleSearch::log

private

Definition at line 157 of file MinModeSaddleSearch.h.

matter

std::shared_ptr<Matter> eonc::MinModeSaddleSearch::matter

private

Definition at line 150 of file MinModeSaddleSearch.h.

minModeMethod

std::shared_ptr<EigenmodeStrategy> eonc::MinModeSaddleSearch::minModeMethod

private

Definition at line 152 of file MinModeSaddleSearch.h.

mode

AtomMatrix eonc::MinModeSaddleSearch::mode

private

Definition at line 148 of file MinModeSaddleSearch.h.

reactantEnergy

double eonc::MinModeSaddleSearch::reactantEnergy

private

Definition at line 153 of file MinModeSaddleSearch.h.

retain_climb_frames_

bool eonc::MinModeSaddleSearch::retain_climb_frames_ {false}

private

Definition at line 147 of file MinModeSaddleSearch.h.

{false};

status

int eonc::MinModeSaddleSearch::status {0}

Definition at line 129 of file MinModeSaddleSearch.h.

{0};

---

The documentation for this class was generated from the following files:

• /home/runner/work/eOn/eOn/include/eon/MinModeSaddleSearch.h
• /home/runner/work/eOn/eOn/client/MinModeSaddleSearch.cpp