#include <MinModeSaddleSearch.h>

Inheritance diagram for MinModeSaddleSearch:

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 ()
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 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
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

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
  };

Constructor & Destructor Documentation

◆ MinModeSaddleSearch() [1/3]

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

Definition at line 171 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

◆ clearClimbFrames()

void eonc::MinModeSaddleSearch::clearClimbFrames ( )

inline

Definition at line 130 of file MinModeSaddleSearch.h.

130{ climb_frames_.clear(); }

MinModeSaddleSearch::climb_frames_

std::vector< readcon::ConFrame > climb_frames_

Definition MinModeSaddleSearch.h:136

◆ climbFrames()

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

inlinenodiscard

Definition at line 127 of file MinModeSaddleSearch.h.

                                                                      {
    return climb_frames_;
  }

◆ describeStatus()

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

inlineoverridevirtual

Implements eonc::SaddleSearchMethod.

Definition at line 110 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 91 of file MinModeSaddleSearch.h.

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

◆ getEigenvalue()

double MinModeSaddleSearch::getEigenvalue ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 477 of file MinModeSaddleSearch.cpp.

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

◆ getEigenvector()

AtomMatrix MinModeSaddleSearch::getEigenvector ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 481 of file MinModeSaddleSearch.cpp.

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

◆ getForceCalls()

int eonc::MinModeSaddleSearch::getForceCalls ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 115 of file MinModeSaddleSearch.h.

115{ return forcecalls; }

MinModeSaddleSearch::forcecalls

int forcecalls

Definition MinModeSaddleSearch.h:123

◆ getIterationCount()

int eonc::MinModeSaddleSearch::getIterationCount ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 114 of file MinModeSaddleSearch.h.

114{ return iteration; }

◆ getStatus()

int eonc::MinModeSaddleSearch::getStatus ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 113 of file MinModeSaddleSearch.h.

113{ 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 MinModeSaddleSearch::run ( void )

overridevirtual

Implements eonc::SaddleSearchMethod.

Definition at line 196 of file MinModeSaddleSearch.cpp.

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

◆ run() [2/2]

int MinModeSaddleSearch::run ( long max_iterations_override )

Definition at line 211 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));
      return STATUS_NONNEGATIVE_ABORT;
    }
    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, 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);
        }
      }
 
      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));
        return STATUS_NONNEGATIVE_ABORT;
      }
    }
 
    auto optim = eonc::helpers::create::mkOptim(
        objf, params.optimizer_options.method, params);
 
    while (!objf->isConverged() || iteration == 0) {
 
      if (!firstIteration) {
 
        if (params.saddle_search_options.nonlocal_count_abort != 0) {
          long nm = 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;
      }
 
      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(-params.optimizer_options.max_move);
        } else {
          optStatus = optim->step(params.optimizer_options.max_move);
        }
      } 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;
 
      // Melander, Laasonen, Jonsson, JCTC 11(3), 1055-1062, 2015
      if (params.saddle_search_options.remove_rotation) {
        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 (de > params.saddle_search_options.max_energy) {
        status = STATUS_BAD_HIGH_ENERGY;
        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;
    }
  }
 
  return status;
}

◆ runRetainFrames()

int 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 200 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;
}

◆ statusMessage()

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

inlinestaticconstexpr

Human-readable message for a status code.

Definition at line 56 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 >= 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 131 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 136 of file MinModeSaddleSearch.h.

◆ forcecalls

int eonc::MinModeSaddleSearch::forcecalls {0}

Definition at line 123 of file MinModeSaddleSearch.h.

123{0};

◆ initialTangent_

AtomMatrix eonc::MinModeSaddleSearch::initialTangent_

private

Definition at line 139 of file MinModeSaddleSearch.h.

◆ iteration

int eonc::MinModeSaddleSearch::iteration {0}

Definition at line 124 of file MinModeSaddleSearch.h.

124{0};

◆ log

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

private

Definition at line 144 of file MinModeSaddleSearch.h.

◆ matter

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

private

Definition at line 140 of file MinModeSaddleSearch.h.

◆ minModeMethod

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

private

Definition at line 142 of file MinModeSaddleSearch.h.

◆ mode

AtomMatrix eonc::MinModeSaddleSearch::mode

private

Definition at line 138 of file MinModeSaddleSearch.h.

◆ reactantEnergy

double eonc::MinModeSaddleSearch::reactantEnergy

private

Definition at line 143 of file MinModeSaddleSearch.h.

◆ retain_climb_frames_

bool eonc::MinModeSaddleSearch::retain_climb_frames_ {false}

private

Definition at line 137 of file MinModeSaddleSearch.h.

137{false};

◆ status

int eonc::MinModeSaddleSearch::status {0}

Definition at line 125 of file MinModeSaddleSearch.h.

125{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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Status

Constructor & Destructor Documentation

◆ MinModeSaddleSearch() [1/3]

◆ MinModeSaddleSearch() [2/3]

◆ MinModeSaddleSearch() [3/3]

◆ ~MinModeSaddleSearch()

Member Function Documentation

◆ clearClimbFrames()

◆ climbFrames()

◆ describeStatus()

◆ finalizeClimbStatus()

◆ getEigenvalue()

◆ getEigenvector()

◆ getForceCalls()

◆ getIterationCount()

◆ getStatus()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ run() [1/2]

◆ run() [2/2]

◆ runRetainFrames()

◆ statusMessage()

◆ takeClimbFrames()

Member Data Documentation

◆ climb_frames_

◆ forcecalls

◆ initialTangent_

◆ iteration

◆ log

◆ matter

◆ minModeMethod

◆ mode

◆ reactantEnergy

◆ retain_climb_frames_

◆ status