MinModeObjectiveFunction Class Reference

Inheritance diagram for MinModeObjectiveFunction:

Public Member Functions
	MinModeObjectiveFunction (std::shared_ptr< Matter > matterPassed, std::shared_ptr< EigenmodeStrategy > minModeMethodPassed, AtomMatrix modePassed, const Parameters &paramsPassed)
	~MinModeObjectiveFunction () override=default
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 ()

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 32 of file MinModeSaddleSearch.cpp.

Constructor & Destructor Documentation

MinModeObjectiveFunction()

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

inline

Definition at line 40 of file MinModeSaddleSearch.cpp.

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

~MinModeObjectiveFunction()

MinModeObjectiveFunction::~MinModeObjectiveFunction ( )

overridedefault

Member Function Documentation

degreesOfFreedom()

int MinModeObjectiveFunction::degreesOfFreedom ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 145 of file MinModeSaddleSearch.cpp.

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

difference()

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

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 166 of file MinModeSaddleSearch.cpp.

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

getConvergence()

double MinModeObjectiveFunction::getConvergence ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 150 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().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 MinModeObjectiveFunction::getEnergy ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 142 of file MinModeSaddleSearch.cpp.

{ return matter->getPotentialEnergy(); }

getGradient()

VectorXd MinModeObjectiveFunction::getGradient ( bool fdstep = false )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 51 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();
          int nBowlActive =
              params.saddle_search_options.confine_positive.bowl_active;
          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;
          while (sufficientForce <
                 params.saddle_search_options.confine_positive.min_active) {
            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;
          }
        }
      } else {
        force = -proj;
      }
    } else {
      force += -2.0 * proj;
    }
 
    VectorXd forceV = VectorXd::Map(force.data(), 3 * matter->numberOfAtoms());
    return -forceV;
  }

getPositions()

VectorXd MinModeObjectiveFunction::getPositions ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 144 of file MinModeSaddleSearch.cpp.

{ return matter->getPositionsV(); }

isConverged()

bool MinModeObjectiveFunction::isConverged ( )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 146 of file MinModeSaddleSearch.cpp.

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

setPositions()

void MinModeObjectiveFunction::setPositions ( const VectorXd & x )

inlinevirtual

Implements eonc::ObjectiveFunction.

Definition at line 143 of file MinModeSaddleSearch.cpp.

{ matter->setPositionsV(x); }

Member Data Documentation

eigenvector

AtomMatrix MinModeObjectiveFunction::eigenvector

private

Definition at line 35 of file MinModeSaddleSearch.cpp.

iteration

int MinModeObjectiveFunction::iteration {0}

private

Definition at line 37 of file MinModeSaddleSearch.cpp.

{0};

matter

std::shared_ptr<Matter> MinModeObjectiveFunction::matter

private

Definition at line 34 of file MinModeSaddleSearch.cpp.

minModeMethod

std::shared_ptr<EigenmodeStrategy> MinModeObjectiveFunction::minModeMethod

private

Definition at line 36 of file MinModeSaddleSearch.cpp.

---

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

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