#include <BiasedGradientSquaredDescent.h>

Inheritance diagram for BiasedGradientSquaredDescent:

Public Member Functions
	BiasedGradientSquaredDescent (std::shared_ptr< Matter > matterPassed, double reactantEnergyPassed, const Parameters &parametersPassed)
	~BiasedGradientSquaredDescent ()=default
int	run ()
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
AtomMatrix	eigenvector
std::shared_ptr< Matter >	saddle
int	status

Private Attributes
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 23 of file BiasedGradientSquaredDescent.h.

Constructor & Destructor Documentation

◆ BiasedGradientSquaredDescent()

eonc::BiasedGradientSquaredDescent::BiasedGradientSquaredDescent	(	std::shared_ptr< Matter >	matterPassed,
		double	reactantEnergyPassed,
		const Parameters &	parametersPassed )

inline

Definition at line 25 of file BiasedGradientSquaredDescent.h.

      : SaddleSearchMethod(matterPassed->getPotential(), parametersPassed),
        saddle{matterPassed} {
    reactantEnergy = reactantEnergyPassed;
    saddle = matterPassed;
    eigenvector.resize(saddle->numberOfAtoms(), 3);
    eigenvector.setZero();
  }

◆ ~BiasedGradientSquaredDescent()

eonc::BiasedGradientSquaredDescent::~BiasedGradientSquaredDescent ( )

default

Member Function Documentation

◆ describeStatus()

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

inlineoverridevirtual

Implements eonc::SaddleSearchMethod.

Definition at line 40 of file BiasedGradientSquaredDescent.h.

                                                           {
    return MinModeSaddleSearch::statusMessage(status);
  }

◆ getEigenvalue()

double BiasedGradientSquaredDescent::getEigenvalue ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 163 of file BiasedGradientSquaredDescent.cpp.

163{ return eigenvalue; }

BiasedGradientSquaredDescent::eigenvalue

double eigenvalue

Definition BiasedGradientSquaredDescent.h:45

◆ getEigenvector()

AtomMatrix BiasedGradientSquaredDescent::getEigenvector ( )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 165 of file BiasedGradientSquaredDescent.cpp.

                                                        {
  return eigenvector;
}

◆ getStatus()

int eonc::BiasedGradientSquaredDescent::getStatus ( ) const

inlineoverridevirtual

Reimplemented from eonc::SaddleSearchMethod.

Definition at line 43 of file BiasedGradientSquaredDescent.h.

43{ return status; }

◆ run()

int BiasedGradientSquaredDescent::run ( void )

virtual

Implements eonc::SaddleSearchMethod.

Definition at line 103 of file BiasedGradientSquaredDescent.cpp.

                                      {
  auto objf = std::make_shared<BGSDObjectiveFunction>(
      *saddle, reactantEnergy, params.bgsd_options.alpha, params);
  auto optim = eonc::helpers::create::mkOptim(
      objf, params.optimizer_options.method, params);
  int iteration = 0;
  QUILL_LOG_DEBUG(
      log,
      "starting optimization of H with params alpha and beta: {:.2f} {:.2f}",
      params.bgsd_options.alpha, params.bgsd_options.beta);
  while (!objf->isConvergedH() || iteration == 0) {
    optim->step(params.optimizer_options.max_move);
    QUILL_LOG_DEBUG(log,
                    "iteration {} Henergy, gradientHnorm, and Venergy: "
                    "{:.8f} {:.8f} {:.8f}",
                    iteration, objf->getEnergy(), objf->getGradientnorm(),
                    saddle->getPotentialEnergy());
    iteration++;
  }
  auto objf2 = std::make_shared<BGSDObjectiveFunction>(*saddle, reactantEnergy,
                                                       0.0, params);
  auto optim2 = eonc::helpers::create::mkOptim(
      objf2, params.optimizer_options.method, params);
  while (!objf2->isConvergedV() || iteration == 0) {
    if (objf2->isConvergedIP()) {
      break;
    };
    optim2->step(params.optimizer_options.max_move);
    QUILL_LOG_DEBUG(log,
                    "gradient squared iteration {} Henergy, gradientHnorm, "
                    "and Venergy: {:.8f} {:.8f} {:.8f}",
                    iteration, objf2->getEnergy(), objf2->getGradientnorm(),
                    saddle->getPotentialEnergy());
    iteration++;
  }
 
  auto minModeMethod = eonc::buildEigenmodeStrategy(saddle, params, pot);
 
  eigenvector.setRandom();
  for (int i = 0; i < saddle->numberOfAtoms(); i++) {
    for (int j = 0; j < 3; j++) {
      if (saddle->getFixed(i)) {
        eigenvector(i, j) = 0.0;
      };
    }
  }
  eigenvector.normalize();
  eonc::eigenmodeCompute(*minModeMethod, saddle, eigenvector);
  eigenvector = eonc::eigenmodeGetEigenvector(*minModeMethod);
  eigenvalue = eonc::eigenmodeGetEigenvalue(*minModeMethod);
  QUILL_LOG_DEBUG(log, "lowest eigenvalue {:.8f}", eigenvalue);
  if (objf2->isConvergedV()) {
    return 0;
  } else if (objf2->isConvergedIP()) {
    return 1;
  } else {
    return 1;
  };
}