eonc::MinModeObjectiveFunction Class Reference

Inheritance diagram for eonc::MinModeObjectiveFunction:

Public Member Functions
	MinModeObjectiveFunction (std::shared_ptr< Matter > matterPassed, std::shared_ptr< EigenmodeStrategy > minModeMethodPassed, AtomMatrix modePassed, const Parameters &paramsPassed)
	~MinModeObjectiveFunction () override=default
std::optional< double >	knownCurvature () const override
VectorXd	getGradient (bool fdstep=false)
double	getEnergy ()
void	setPositions (const VectorXd &x)
VectorXd	getPositions ()
int	degreesOfFreedom ()
bool	isConverged ()
double	getConvergence ()
VectorXd	difference (const VectorXd &a, const VectorXd &b)
Public Member Functions inherited from eonc::ObjectiveFunction
	ObjectiveFunction (const Parameters &paramsPassed)
virtual	~ObjectiveFunction ()
virtual bool	supportsFiniteDifferenceCurvature () const
virtual void	minimumImage (Eigen::Ref< Eigen::Vector3d >) const
virtual VectorXd	getMasses () const
virtual bool	getPeriodic () const

Private Attributes
std::shared_ptr< Matter >	matter
AtomMatrix	eigenvector
std::shared_ptr< EigenmodeStrategy >	minModeMethod
int	iteration {0}

Additional Inherited Members
Protected Attributes inherited from eonc::ObjectiveFunction
const Parameters &	params

Detailed Description

Definition at line 33 of file MinModeSaddleSearch.cpp.

Constructor & Destructor Documentation

MinModeObjectiveFunction()

eonc::MinModeObjectiveFunction::MinModeObjectiveFunction ( std::shared_ptr< Matter > matterPassed, std::shared_ptr< EigenmodeStrategy > minModeMethodPassed, AtomMatrix modePassed, const Parameters & paramsPassed )

inline

Definition at line 41 of file MinModeSaddleSearch.cpp.

      : ObjectiveFunction(paramsPassed),
        matter{std::move(matterPassed)},
        minModeMethod{minModeMethodPassed},
        eigenvector{std::move(modePassed)} {}

~MinModeObjectiveFunction()

eonc::MinModeObjectiveFunction::~MinModeObjectiveFunction ( )

overridedefault

Member Function Documentation

degreesOfFreedom()

int eonc::MinModeObjectiveFunction::degreesOfFreedom ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 173 of file MinModeSaddleSearch.cpp.

{ return 3 * matter->numberOfAtoms(); }

difference()

VectorXd eonc::MinModeObjectiveFunction::difference ( const VectorXd & a, const VectorXd & b )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 195 of file MinModeSaddleSearch.cpp.

                                                            {
    return matter->pbcV(a - b);
  }

getConvergence()

double eonc::MinModeObjectiveFunction::getConvergence ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 178 of file MinModeSaddleSearch.cpp.

                          {
    if (params.optimizer_options().convergence_metric == "norm") {
      return matter->getForcesFreeV().norm();
    } else if (params.optimizer_options().convergence_metric == "max_atom") {
      return matter->maxForce();
    } else if (params.optimizer_options().convergence_metric ==
               "max_component") {
      return matter->getForces().cwiseAbs().maxCoeff();
    } else {
      EONC_LOG_CRITICAL("[MinModeSaddleSearch] unknown convergence metric: {}",
                        params.optimizer_options().convergence_metric);
      throw std::invalid_argument(
          std::format("[MinModeSaddleSearch] unknown convergence_metric: {}",
                      params.optimizer_options().convergence_metric));
    }
  }

getEnergy()

double eonc::MinModeObjectiveFunction::getEnergy ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 170 of file MinModeSaddleSearch.cpp.

{ return matter->getPotentialEnergy(); }

getGradient()

VectorXd eonc::MinModeObjectiveFunction::getGradient ( bool fdstep = false )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 66 of file MinModeSaddleSearch.cpp.

                                          {
    AtomMatrix force = matter->getForces();
 
    if (!fdstep || iteration == 0) {
      eonc::eigenmodeCompute(*minModeMethod, matter, eigenvector);
      // Check if ImprovedDimer lost the mode
      auto *dimer = eonc::asImprovedDimer(*minModeMethod);
      if (dimer && !dimer->rotationDidConverge) {
        if (dimer->getEigenvalue() < 0.0) {
          eigenvector = eonc::eigenmodeGetEigenvector(*minModeMethod);
          EONC_LOG_DEBUG(
              "[MinMode] Dimer restored to best state with C_tau={:.4f}",
              dimer->getEigenvalue());
          throw eonc::DimerModeRestoredException();
        } else {
          throw eonc::DimerModeLostException();
        }
      }
      iteration++;
    }
 
    eigenvector = eonc::eigenmodeGetEigenvector(*minModeMethod);
    double eigenvalue = eonc::eigenmodeGetEigenvalue(*minModeMethod);
 
    AtomMatrix proj = matDot(force, eigenvector) *
                      eonc::safemath::safe_normalized(eigenvector);
 
    if (eigenvalue > 0.0) {
      if (params.saddle_search_options().perp_force_ratio > 0.0) {
        double d = params.saddle_search_options().perp_force_ratio;
        force = d * force - (1.0 + d) * proj;
      } else if (params.saddle_search_options().confine_positive.enabled) {
        if (params.saddle_search_options().confine_positive.bowl_breakout) {
          AtomMatrix forceTemp = matter->getForces();
          const long nAtoms = matter->numberOfAtoms();
          int nBowlActive = static_cast<int>(std::min<long>(
              params.saddle_search_options().confine_positive.bowl_active,
              nAtoms));
          if (nBowlActive <= 0) {
            force.setZero();
          } else {
            std::vector<int> indices_max(nBowlActive);
 
            // Find the nBowlActive atoms with largest forces
            for (int j = 0; j < nBowlActive; j++) {
              double f_max = forceTemp.row(0).norm();
              int i_max = 0;
              for (long i = 0; i < matter->numberOfAtoms(); i++) {
                if (f_max < forceTemp.row(i).norm()) {
                  f_max = forceTemp.row(i).norm();
                  i_max = static_cast<int>(i);
                }
              }
              forceTemp.row(i_max).setZero();
              indices_max[j] = i_max;
            }
            forceTemp.setZero();
            for (int j = 0; j < nBowlActive; j++) {
              forceTemp.row(indices_max[j]) = -proj.row(indices_max[j]);
            }
            force = forceTemp;
          }
        } else {
          int sufficientForce = 0;
          double minForce =
              params.saddle_search_options().confine_positive.min_force;
          const long maxBoostTries = std::max(
              3 * matter->numberOfAtoms(),
              params.saddle_search_options().confine_positive.min_active);
          long boostTries = 0;
          while (
              sufficientForce <
                  params.saddle_search_options().confine_positive.min_active &&
              boostTries < maxBoostTries) {
            sufficientForce = 0;
            force = matter->getForces();
            for (long i = 0; i < matter->numberOfAtoms(); i++) {
              for (int k = 0; k < 3; k++) {
                if (std::abs(force(i, k)) < minForce) {
                  force(i, k) = 0;
                } else {
                  sufficientForce++;
                  force(i, k) =
                      -params.saddle_search_options().confine_positive.boost *
                      proj(i, k);
                }
              }
            }
            minForce *=
                params.saddle_search_options().confine_positive.scale_ratio;
            boostTries++;
          }
        }
      } else {
        force = -proj;
      }
    } else {
      force += -2.0 * proj;
    }
 
    VectorXd forceV = VectorXd::Map(force.data(), 3 * matter->numberOfAtoms());
    return -forceV;
  }

getPositions()

VectorXd eonc::MinModeObjectiveFunction::getPositions ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 172 of file MinModeSaddleSearch.cpp.

{ return matter->getPositionsV(); }

isConverged()

bool eonc::MinModeObjectiveFunction::isConverged ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 174 of file MinModeSaddleSearch.cpp.

                     {
    return getConvergence() < params.saddle_search_options().converged_force;
  }

knownCurvature()

std::optional< double > eonc::MinModeObjectiveFunction::knownCurvature ( ) const

inlineoverridevirtual

Reimplemented from eonc::ObjectiveFunction.

Definition at line 55 of file MinModeSaddleSearch.cpp.

                                                      {
    if (iteration == 0 || !minModeMethod) {
      return std::nullopt;
    }
    const double c = eonc::eigenmodeGetEigenvalue(*minModeMethod);
    if (!std::isfinite(c) || c >= 0.0) {
      return std::nullopt;
    }
    return -c;
  }

setPositions()

void eonc::MinModeObjectiveFunction::setPositions ( const VectorXd & x )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 171 of file MinModeSaddleSearch.cpp.

{ matter->setPositionsV(x); }

Member Data Documentation

eigenvector

AtomMatrix eonc::MinModeObjectiveFunction::eigenvector

private

Definition at line 36 of file MinModeSaddleSearch.cpp.

iteration

int eonc::MinModeObjectiveFunction::iteration {0}

private

Definition at line 38 of file MinModeSaddleSearch.cpp.

{0};

matter

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

private

Definition at line 35 of file MinModeSaddleSearch.cpp.

minModeMethod

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

private

Definition at line 37 of file MinModeSaddleSearch.cpp.

---

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

• /home/runner/work/eOn/eOn/client/MinModeSaddleSearch.cpp