BasinHoppingSaddleSearch Class Reference

#include <BasinHoppingSaddleSearch.h>

Inheritance diagram for BasinHoppingSaddleSearch:

Public Member Functions
	BasinHoppingSaddleSearch (std::shared_ptr< Matter > reactant, std::shared_ptr< Matter > displacement, std::shared_ptr< Potential > potPassed, const Parameters &parametersPassed)
	~BasinHoppingSaddleSearch ()=default
int	run (void)
double	getEigenvalue ()
AtomMatrix	getEigenvector ()
std::string_view	describeStatus (int status) const override
int	getStatus () const override
Public Member Functions inherited from eonc::SaddleSearchMethod
	SaddleSearchMethod (std::shared_ptr< Potential > potPassed, const Parameters &paramsPassed)
virtual	~SaddleSearchMethod ()
virtual int	getIterationCount () const
virtual int	getForceCalls () const

Public Attributes
double	eigenvalue {0.0}
AtomMatrix	eigenvector
std::shared_ptr< Matter >	reactant
std::shared_ptr< Matter >	saddle
std::shared_ptr< Matter >	product
int	status {0}

Private Attributes
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 22 of file BasinHoppingSaddleSearch.h.

Constructor & Destructor Documentation

BasinHoppingSaddleSearch()

eonc::BasinHoppingSaddleSearch::BasinHoppingSaddleSearch ( std::shared_ptr< Matter > reactant, std::shared_ptr< Matter > displacement, std::shared_ptr< Potential > potPassed, const Parameters & parametersPassed )

inline

Definition at line 24 of file BasinHoppingSaddleSearch.h.

      : SaddleSearchMethod(potPassed, parametersPassed),
        reactant{std::make_shared<Matter>(*reactant)},
        saddle{displacement} {
    eigenvector.resize(reactant->numberOfAtoms(), 3);
    eigenvector.setZero();
  }

~BasinHoppingSaddleSearch()

eonc::BasinHoppingSaddleSearch::~BasinHoppingSaddleSearch ( )

default

Member Function Documentation

describeStatus()

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

inlineoverridevirtual

Implements eonc::SaddleSearchMethod.

Definition at line 39 of file BasinHoppingSaddleSearch.h.

                                                           {
    return MinModeSaddleSearch::statusMessage(status);
  }

getEigenvalue()

double BasinHoppingSaddleSearch::getEigenvalue ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 82 of file BasinHoppingSaddleSearch.cpp.

{ return eigenvalue; }

getEigenvector()

AtomMatrix BasinHoppingSaddleSearch::getEigenvector ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 84 of file BasinHoppingSaddleSearch.cpp.

{ return eigenvector; }

getStatus()

int eonc::BasinHoppingSaddleSearch::getStatus ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 42 of file BasinHoppingSaddleSearch.h.

{ return status; }

run()

int BasinHoppingSaddleSearch::run ( void )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 22 of file BasinHoppingSaddleSearch.cpp.

                                  {
  // minimize "saddle"
  saddle->relax(false, true, false, "displacementmin");
  product = std::make_shared<Matter>(pot, params);
  *product = *saddle;
  // accept or reject based on boltzman
  // exp(-de/(kB*params.main_options.temperature))
  double eproduct, ereactant, de;
  eproduct = product->getPotentialEnergy();
  ereactant = reactant->getPotentialEnergy();
  de = eproduct - ereactant;
  double kB = params.constants.kB;
  double Temperature = params.main_options.temperature;
  double arg = -de / (kB * Temperature);
  double p = std::exp(arg);
  double r = eonc::helpers::random();
  if (ereactant < eproduct) {
    if (r > p) { // reject
      return 1;
    }
  }
  // NEB reactant to minimized "saddle"
  NudgedElasticBand neb(reactant, product, params, pot);
  if (!eonc::io::io_ok(
          neb.path[0]->matter2con("neb_initial_band.con", false))) {
    QUILL_LOG_WARNING(log, "Failed to write neb_initial_band.con");
  }
  for (int j = 1; j < neb.numImages; j++) {
    if (!eonc::io::io_ok(neb.path[j]->matter2con("neb_initial_band", true))) {
      QUILL_LOG_WARNING(log, "Failed to append neb_initial_band frame");
    }
  }
  neb.compute();
  // pick the maximum energy image along the band
  double Emax = -1e100;
  int HighestImage = 0;
 
  for (int i = 1; i < neb.numImages; i++) {
    double Etest = neb.path[i]->getPotentialEnergy();
    QUILL_LOG_DEBUG(log, "i: {} Etest: {:.1f}", i, Etest);
    if (Etest > Emax) {
      Emax = Etest;
      HighestImage = i;
    }
  }
  // do dimer
  // Calculate initial direction
  AtomMatrix r_1 = neb.path[HighestImage - 1]->getPositions();
  AtomMatrix r_2 = neb.path[HighestImage]->getPositions();
  AtomMatrix r_3 = neb.path[HighestImage + 1]->getPositions();
  AtomMatrix direction = (r_3 - r_1) / 2;
  MinModeSaddleSearch dim(neb.path[HighestImage], direction.normalized(),
                          ereactant, params, pot);
  dim.run();
  *saddle = *neb.path[HighestImage];
  eigenvalue = dim.getEigenvalue();
  eigenvector = dim.getEigenvector();
  return 0;
}

Member Data Documentation

eigenvalue

double eonc::BasinHoppingSaddleSearch::eigenvalue {0.0}

Definition at line 44 of file BasinHoppingSaddleSearch.h.

{0.0};

eigenvector

AtomMatrix eonc::BasinHoppingSaddleSearch::eigenvector

Definition at line 45 of file BasinHoppingSaddleSearch.h.

log

eonc::log::Scoped eonc::BasinHoppingSaddleSearch::log

private

Definition at line 54 of file BasinHoppingSaddleSearch.h.

product

std::shared_ptr<Matter> eonc::BasinHoppingSaddleSearch::product

Definition at line 49 of file BasinHoppingSaddleSearch.h.

reactant

std::shared_ptr<Matter> eonc::BasinHoppingSaddleSearch::reactant

Definition at line 47 of file BasinHoppingSaddleSearch.h.

saddle

std::shared_ptr<Matter> eonc::BasinHoppingSaddleSearch::saddle

Definition at line 48 of file BasinHoppingSaddleSearch.h.

status

int eonc::BasinHoppingSaddleSearch::status {0}

Definition at line 51 of file BasinHoppingSaddleSearch.h.

{0};

---

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

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