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 ()

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 79 of file IDPPObjectiveFunction.hpp.

Constructor & Destructor Documentation

CollectiveIDPPObjectiveFunction()

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

inline

Definition at line 81 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 119 of file IDPPObjectiveFunction.hpp.

                                  {
    return 3 * path[0].numberOfAtoms() * (path.size() - 2);
  }

difference()

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

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 130 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 128 of file IDPPObjectiveFunction.hpp.

{ return lastMaxForce; }

getDistanceMatrix()

MatrixXd CollectiveIDPPObjectiveFunction::getDistanceMatrix ( const Matter & m )

private

Definition at line 84 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 93 of file IDPPObjectiveFunction.hpp.

{ return 0.0; }

getGradient()

VectorXd CollectiveIDPPObjectiveFunction::getGradient ( bool fdstep = false )

overridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 124 of file IDPPObjectiveFunction.cpp.

                                                                 {
  int nImgs = path.size() - 2; // Exclude fixed endpoints
  int natoms = path[0].numberOfAtoms();
  VectorXd totalGradient(3 * natoms * 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);
    tangents[i].normalize(); // Unit tangent
  }
 
  // 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;
 
    // Total NEB Force
    AtomMatrix f_neb = f_perp + f_spring;
 
    // Store as Gradient (-Force)
    totalGradient.segment(3 * natoms * (i - 1), 3 * natoms) =
        VectorXd::Map(f_neb.data(), 3 * natoms) * -1.0;
 
    // Tracking convergence
    maxForce = std::max(maxForce, f_neb.template lpNorm<Eigen::Infinity>());
  }
 
  lastMaxForce = maxForce;
  return totalGradient;
}

getIDPPForces()

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

private

Definition at line 97 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 107 of file IDPPObjectiveFunction.hpp.

                                   {
    int atoms = path[0].numberOfAtoms();
    int n_free_images = path.size() - 2;
    VectorXd pos(3 * atoms * n_free_images);
 
    for (size_t i = 1; i < path.size() - 1; ++i) {
      pos.segment(3 * atoms * (i - 1), 3 * atoms) =
          VectorXd::Map(path[i].getPositions().data(), 3 * atoms);
    }
    return pos;
  }

isConverged()

bool eonc::CollectiveIDPPObjectiveFunction::isConverged ( )

inlineoverridevirtual

Implements eonc::ObjectiveFunction.

Definition at line 124 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 98 of file IDPPObjectiveFunction.hpp.

                                                {
    int atoms = path[0].numberOfAtoms();
    // Skip endpoints (0 and N+1)
    for (size_t i = 1; i < path.size() - 1; ++i) {
      path[i].setPositions(AtomMatrix::Map(
          x.segment(3 * atoms * (i - 1), 3 * atoms).data(), atoms, 3));
    }
  }

Member Data Documentation

dFinal

MatrixXd eonc::CollectiveIDPPObjectiveFunction::dFinal

private

Definition at line 138 of file IDPPObjectiveFunction.hpp.

dInit

MatrixXd eonc::CollectiveIDPPObjectiveFunction::dInit

private

Definition at line 138 of file IDPPObjectiveFunction.hpp.

lastMaxForce

double eonc::CollectiveIDPPObjectiveFunction::lastMaxForce = 100.0

private

Definition at line 139 of file IDPPObjectiveFunction.hpp.

path

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

private

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