eonc::detail Namespace Reference

Functions
template<typename Solver>
DimerRotationResult	runRotationSolver (const std::shared_ptr< Matter > &matter, const Parameters &params, const std::shared_ptr< Potential > &pot, const AtomMatrix &initialDirection)
double	maxFreeAtomForceNormScalar (const double *forces, const double *fixed, long begin, long nAtoms)
	Scalar max of per-atom Euclidean norms on [begin, nAtoms).

Function Documentation

maxFreeAtomForceNormScalar()

double eonc::detail::maxFreeAtomForceNormScalar ( const double * forces, const double * fixed, long begin, long nAtoms )

inline

Scalar max of per-atom Euclidean norms on [begin, nAtoms).

Fully fixed atoms (fixed entries all > 0.5) contribute nothing. A NaN norm on a free atom is returned as is: std::max would drop it and let a convergence test pass on bad forces.

Definition at line 25 of file ForceNorm.h.

                                                      {
  double best = 0.0;
  if (forces == nullptr || nAtoms <= 0 || begin >= nAtoms) {
    return best;
  }
  if (begin < 0) {
    begin = 0;
  }
  for (long i = begin; i < nAtoms; ++i) {
    if (fixed != nullptr) {
      const double *mask = fixed + 3 * i;
      if (mask[0] > 0.5 && mask[1] > 0.5 && mask[2] > 0.5) {
        continue;
      }
    }
    const double *row = forces + 3 * i;
    const double xx = row[0] * row[0];
    const double yy = row[1] * row[1];
    const double zz = row[2] * row[2];
    const double norm = std::sqrt((xx + yy) + zz);
    if (std::isnan(norm)) {
      return norm;
    }
    best = std::max(best, norm);
  }
  return best;
}

runRotationSolver()

template<typename Solver>

DimerRotationResult eonc::detail::runRotationSolver ( const std::shared_ptr< Matter > & matter, const Parameters & params, const std::shared_ptr< Potential > & pot, const AtomMatrix & initialDirection )

nodiscard

Definition at line 48 of file DimerRotationDispatch.h.

                                                                             {
  Solver solver(matter, params, pot);
  solver.compute(matter, initialDirection);
  DimerRotationResult out;
  out.eigenvector = solver.getEigenvector();
  out.eigenvalue = solver.getEigenvalue();
  out.forceCalls = solver.totalForceCalls;
  out.rotations = solver.statsRotations;
  if constexpr (std::is_same_v<Solver, LORRotation>) {
    out.converged = solver.convergedOnResidual;
  } else {
    out.converged = true;
  }
  return out;
}