eonc::CollectiveIDPPObjectiveFunction Class Reference

#include <IDPPObjectiveFunction.hpp>

Inheritance diagram for eonc::CollectiveIDPPObjectiveFunction:

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

Private Member Functions
MatrixXd	getDistanceMatrix (const Matter &m)
MatrixXd	getIDPPForces (const Matter &m, const MatrixXd &dTarget)

Private Attributes
std::vector< Matter > &	path
MatrixXd	dInit
MatrixXd	dFinal
double	lastMaxForce = 100.0

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

Detailed Description

Definition at line 73 of file IDPPObjectiveFunction.hpp.

Constructor & Destructor Documentation

CollectiveIDPPObjectiveFunction()

eonc::CollectiveIDPPObjectiveFunction::CollectiveIDPPObjectiveFunction ( std::vector< Matter > & pathRef, const Parameters & paramsPassed )

inline

Definition at line 75 of file IDPPObjectiveFunction.hpp.

      : ObjectiveFunction(paramsPassed), path(pathRef) {
 
    // Initialize distances for endpoints
    dInit = getDistanceMatrix(path.front());
    dFinal = getDistanceMatrix(path.back());
  }

Member Function Documentation

degreesOfFreedom()

int eonc::CollectiveIDPPObjectiveFunction::degreesOfFreedom ( )

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 110 of file IDPPObjectiveFunction.hpp.

                                  {
    return 3 * static_cast<int>(path[0].numberOfFreeAtoms()) *
           (static_cast<int>(path.size()) - 2);
  }

difference()

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

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 123 of file IDPPObjectiveFunction.hpp.

                                                                     {
    // Simple difference for this purpose, assuming pre-aligned or handling PBC
    // inside
    return a - b;
  }

getConvergence()

double eonc::CollectiveIDPPObjectiveFunction::getConvergence ( )

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 121 of file IDPPObjectiveFunction.hpp.

{ return lastMaxForce; }

getDistanceMatrix()

MatrixXd eonc::CollectiveIDPPObjectiveFunction::getDistanceMatrix ( const Matter & m )

private

Definition at line 98 of file IDPPObjectiveFunction.cpp.

                                                                           {
  int natoms = m.numberOfAtoms();
  MatrixXd d(natoms, natoms);
  auto pos = m.getPositions();
  for (int i = 0; i < natoms; ++i) {
    for (int j = 0; j < natoms; ++j) {
      d(i, j) = m.pbc(pos.row(i) - pos.row(j)).norm();
    }
  }
  return d;
}

getEnergy()

double eonc::CollectiveIDPPObjectiveFunction::getEnergy ( )

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 86 of file IDPPObjectiveFunction.hpp.

{ return 0.0; }

getGradient()

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

overridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 138 of file IDPPObjectiveFunction.cpp.

                                                            {
  int nImgs = path.size() - 2; // Exclude fixed endpoints
  int nfree = static_cast<int>(path[0].numberOfFreeAtoms());
  VectorXd totalGradient(3 * nfree * nImgs);
  double maxForce = 0.0;
 
  // 1. Compute Raw IDPP Forces and Tangents
  std::vector<AtomMatrix> rawForces(path.size());
  std::vector<AtomMatrix> tangents(path.size());
 
  // We compute for 1..N (moving images)
  for (size_t i = 1; i <= nImgs; ++i) {
    // Interpolate Target
    double xi = static_cast<double>(i) / (nImgs + 1);
    MatrixXd dTarget = (1.0 - xi) * dInit + xi * dFinal;
 
    rawForces[i] = getIDPPForces(path[i], dTarget);
 
    // Simple Tangent: Next - Prev
    AtomMatrix nextPos = path[i + 1].getPositions();
    AtomMatrix prevPos = path[i - 1].getPositions();
    tangents[i] = path[i].pbc(nextPos - prevPos);
    const double tnorm = tangents[i].norm();
    if (tnorm > 1e-10) {
      tangents[i] /= tnorm;
    }
  }
 
  // 2. Project Forces and Add Springs (The "NEB" part of IDPP-NEB)
  double k = params.neb_options().spring.constant;
 
  for (size_t i = 1; i <= nImgs; ++i) {
    AtomMatrix f = rawForces[i];
    AtomMatrix t = tangents[i];
 
    // Perpendicular Force (IDPP optimization)
    double f_dot_t = matDot(f, t);
    AtomMatrix f_perp = f - f_dot_t * t;
 
    // Spring Force (Spacing optimization)
    double distNext = path[i].distanceTo(path[i + 1]);
    double distPrev = path[i].distanceTo(path[i - 1]);
    AtomMatrix f_spring = k * (distNext - distPrev) * t;
 
    AtomMatrix f_neb = f_perp + f_spring;
 
    VectorXd freeForce = packFree(path[i], f_neb);
    totalGradient.segment(3 * nfree * static_cast<int>(i - 1), 3 * nfree) =
        freeForce * -1.0;
 
    // Free-atom residuals only. Frozen pair rows stay in f_neb for
    // Newton's third law and must not pin lastMaxForce.
    maxForce = std::max(maxForce, freeForce.lpNorm<Eigen::Infinity>());
  }
 
  lastMaxForce = maxForce;
  return totalGradient;
}

getIDPPForces()

MatrixXd eonc::CollectiveIDPPObjectiveFunction::getIDPPForces ( const Matter & m, const MatrixXd & dTarget )

private

Definition at line 111 of file IDPPObjectiveFunction.cpp.

                                                                        {
  int natoms = m.numberOfAtoms();
  AtomMatrix forces = AtomMatrix::Zero(natoms, 3);
  auto pos = m.getPositions();
 
  for (int i = 0; i < natoms; ++i) {
    for (int j = i + 1; j < natoms; ++j) {
      Eigen::RowVector3d dr_vec = m.pbc(pos.row(i) - pos.row(j));
      double r = dr_vec.norm();
      if (r < 1e-4)
        r = 1e-4;
 
      double diff = r - dTarget(i, j);
      // SOTA Weighting: w = 1/r^4. Gradient logic matches Smidstrup/ASE
      double r2 = r * r;
      double r5 = r2 * r2 * r;
      double dEdr = (diff / r5) * (2.0 * dTarget(i, j) - r);
 
      Eigen::RowVector3d f = -dEdr * (dr_vec / r); // -dE/dr * r_hat
      forces.row(i) += f;
      forces.row(j) -= f;
    }
  }
  return forces;
}

getPositions()

VectorXd eonc::CollectiveIDPPObjectiveFunction::getPositions ( )

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 98 of file IDPPObjectiveFunction.hpp.

                                   {
    const int nfree = static_cast<int>(path[0].numberOfFreeAtoms());
    const int seg = 3 * nfree;
    const int n_free_images = static_cast<int>(path.size()) - 2;
    VectorXd pos(seg * n_free_images);
    for (size_t i = 1; i < path.size() - 1; ++i) {
      pos.segment(seg * static_cast<int>(i - 1), seg) =
          path[i].getPositionsFreeV();
    }
    return pos;
  }

isConverged()

bool eonc::CollectiveIDPPObjectiveFunction::isConverged ( )

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 116 of file IDPPObjectiveFunction.hpp.

                              {
    return getConvergence() <
           params.neb_options().initialization.force_tolerance;
  }

setPositions()

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

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 90 of file IDPPObjectiveFunction.hpp.

                                                {
    const int nfree = static_cast<int>(path[0].numberOfFreeAtoms());
    const int seg = 3 * nfree;
    for (size_t i = 1; i < path.size() - 1; ++i) {
      path[i].setPositionsFreeV(x.segment(seg * static_cast<int>(i - 1), seg));
    }
  }

Member Data Documentation

dFinal

MatrixXd eonc::CollectiveIDPPObjectiveFunction::dFinal

private

Definition at line 131 of file IDPPObjectiveFunction.hpp.

dInit

MatrixXd eonc::CollectiveIDPPObjectiveFunction::dInit

private

Definition at line 131 of file IDPPObjectiveFunction.hpp.

lastMaxForce

double eonc::CollectiveIDPPObjectiveFunction::lastMaxForce = 100.0

private

Definition at line 132 of file IDPPObjectiveFunction.hpp.

path

std::vector<Matter>& eonc::CollectiveIDPPObjectiveFunction::path

private

Definition at line 130 of file IDPPObjectiveFunction.hpp.

---

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

• /home/runner/work/eOn/eOn/include/eon/IDPPObjectiveFunction.hpp
• /home/runner/work/eOn/eOn/client/IDPPObjectiveFunction.cpp