eonc::BasinHoppingSaddleSearch Class Reference

#include <BasinHoppingSaddleSearch.h>

Inheritance diagram for eonc::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 code) 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

Static Public Member Functions
static AtomMatrix	initialDimerDirection (const Matter &image, const AtomMatrix &prev, const AtomMatrix &next)
static double	metropolisProbability (double de, double kB, double temperature)
	Quenched Metropolis weight for energy change de.
static int	highestEnergyInteriorImage (const std::vector< std::shared_ptr< Matter > > &path, long numImages)
	Highest-energy interior bead.

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 code ) const

inlineoverridevirtual

Implements eonc::SaddleSearchMethod.

Definition at line 56 of file BasinHoppingSaddleSearch.h.

                                                         {
    // Code 1 is the Metropolis rejection, not MinMode STATUS_INIT.
    if (code == 1) {
      return "Basin hop rejected";
    }
    return MinModeSaddleSearch::statusMessage(code);
  }

getEigenvalue()

double eonc::BasinHoppingSaddleSearch::getEigenvalue ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 110 of file BasinHoppingSaddleSearch.cpp.

{ return eigenvalue; }

getEigenvector()

AtomMatrix eonc::BasinHoppingSaddleSearch::getEigenvector ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 112 of file BasinHoppingSaddleSearch.cpp.

{ return eigenvector; }

getStatus()

int eonc::BasinHoppingSaddleSearch::getStatus ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 63 of file BasinHoppingSaddleSearch.h.

{ return status; }

highestEnergyInteriorImage()

int eonc::BasinHoppingSaddleSearch::highestEnergyInteriorImage ( const std::vector< std::shared_ptr< Matter > > & path, long numImages )

staticnodiscard

Highest-energy interior bead.

Interiors are indices 1..numImages. Returns 0 when numImages < 1 so the caller does not read path[-1].

Definition at line 20 of file BasinHoppingSaddleSearch.cpp.

                                                                  {
  double emax = -1e100;
  int highest = 0;
  for (long i = 1; i <= numImages; i++) {
    double etest = path[static_cast<size_t>(i)]->getPotentialEnergy();
    QUILL_LOG_DEBUG(eonc::log::get(), "i: {} Etest: {:.1f}", i, etest);
    if (etest > emax) {
      emax = etest;
      highest = static_cast<int>(i);
    }
  }
  return highest;
}

initialDimerDirection()

AtomMatrix eonc::BasinHoppingSaddleSearch::initialDimerDirection ( const Matter & image, const AtomMatrix & prev, const AtomMatrix & next )

inlinestaticnodiscard

Definition at line 38 of file BasinHoppingSaddleSearch.h.

                                                {
    return image.pbc(next - prev) / 2.0;
  }

metropolisProbability()

double eonc::BasinHoppingSaddleSearch::metropolisProbability ( double de, double kB, double temperature )

static

Quenched Metropolis weight for energy change de.

Divides by kB * temperature only for an uphill hop when both are positive. Non-positive temperature or kB refuses that hop.

Definition at line 99 of file BasinHoppingSaddleSearch.cpp.

                                                                           {
  if (!(de > 0.0)) {
    return 1.0;
  }
  if (!(temperature > 0.0) || !(kB > 0.0)) {
    return 0.0;
  }
  return std::exp(-de / (kB * temperature));
}

run()

int eonc::BasinHoppingSaddleSearch::run ( void )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 35 of file BasinHoppingSaddleSearch.cpp.

                                  {
  // minimize "saddle"
  saddle->relax(false, true, false, "displacementmin");
  product = std::make_shared<Matter>(pot, params);
  *product = *saddle;
  // Metropolis on the quenched energies: exp(-de/(kB*T)).
  // Divide only for an uphill hop at positive temperature. T <= 0 rejects
  // that hop (zero-temperature limit) and must not trap or flip the sign.
  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 p = metropolisProbability(de, kB, Temperature);
  double r = eonc::rng::random();
  if (de > 0.0 && r > p) { // reject
    status = 1;
    return status;
  }
  // 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");
  }
  // Reactant is frame 0. Interiors are 1..numImages, including the last.
  for (int j = 1; j <= neb.numImages; j++) {
    if (!eonc::io::io_ok(
            neb.path[j]->matter2con("neb_initial_band.con", true))) {
      QUILL_LOG_WARNING(log, "Failed to append neb_initial_band frame");
    }
  }
  neb.compute();
  // Interior images only. Endpoints are fixed, and a band with no interior
  // image has no highest image; one image already has both neighbours.
  if (neb.numImages < 1) {
    QUILL_LOG_WARNING(log, "No interior NEB image for basin hopping");
    status = MinModeSaddleSearch::STATUS_BAD_NO_BARRIER;
    return status;
  }
  int HighestImage = highestEnergyInteriorImage(neb.path, neb.numImages);
  if (HighestImage < 1) {
    QUILL_LOG_WARNING(log, "No interior NEB image for basin hopping");
    status = MinModeSaddleSearch::STATUS_BAD_NO_BARRIER;
    return status;
  }
  // do dimer
  // Calculate initial direction
  AtomMatrix r_1 = neb.path[HighestImage - 1]->getPositions();
  AtomMatrix r_3 = neb.path[HighestImage + 1]->getPositions();
  AtomMatrix direction =
      initialDimerDirection(*neb.path[HighestImage], r_1, r_3);
  MinModeSaddleSearch dim(neb.path[HighestImage], direction.normalized(),
                          ereactant, params, pot);
  // ProcessSearchJob treats STATUS_GOOD as a saddle. The climb's own
  // status is that decision; discarding it records a failed climb as found.
  status = dim.run();
  *saddle = *neb.path[HighestImage];
  eigenvalue = dim.getEigenvalue();
  eigenvector = dim.getEigenvector();
  return status;
}

Member Data Documentation

eigenvalue

double eonc::BasinHoppingSaddleSearch::eigenvalue {0.0}

Definition at line 65 of file BasinHoppingSaddleSearch.h.

{0.0};

eigenvector

AtomMatrix eonc::BasinHoppingSaddleSearch::eigenvector

Definition at line 66 of file BasinHoppingSaddleSearch.h.

log

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

private

Definition at line 75 of file BasinHoppingSaddleSearch.h.

product

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

Definition at line 70 of file BasinHoppingSaddleSearch.h.

reactant

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

Definition at line 68 of file BasinHoppingSaddleSearch.h.

saddle

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

Definition at line 69 of file BasinHoppingSaddleSearch.h.

status

int eonc::BasinHoppingSaddleSearch::status {0}

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