eonc::BondBoost Class Reference

Functionality relying on the conjugate gradients algorithm. More...

#include <BondBoost.h>

Public Member Functions
	BondBoost (Matter *matt, const Parameters &params)
	Constructor to be used when a structure is minimized.
	~BondBoost ()
	Destructor.
void	initialize ()
void	advance ()
	Advance the equilibration / boost schedule by one MD step.
double	boost ()
	Evaluate the current bias potential and write bias forces.
long	scheduleStep () const
	Equilibration counter (starts at 1). Used to test the per-step schedule.

Private Member Functions
long	rmdSteps () const
Matrix< double, Eigen::Dynamic, 1 >	Rmdsteps ()
	Measure all tagged-atom bond lengths for the equilibration phase.
long	BondSelect ()
	Select bonds within cutoff distance for boosting.
double	Booststeps ()
	Compute bias potential and forces for bond-boost hyperdynamics.

Private Attributes
long	nAtoms {0}
	Number of free coordinates.
Matter *	matter
	Pointer to atom object outside the scope of the class.
const Parameters &	parameters
	Reference to a structure outside the scope of the class containing runtime parameters.
std::vector< long >	BAList
std::vector< long >	RAList
std::vector< long >	TABAList
std::vector< long >	BBAList
std::vector< double >	Epsr_Q
Matrix< double, Eigen::Dynamic, 1 >	TABLList
Matrix< double, Eigen::Dynamic, 1 >	EBBLList
Matrix< double, Eigen::Dynamic, 1 >	CBBLList
long	nBAs {0}
long	nRAs {0}
long	nTABs {0}
long	nReg {0}
long	nBBs {0}
eonc::log::Scoped	log

Detailed Description

Functionality relying on the conjugate gradients algorithm.

The object is capable of minimizing an Matter object or modified forces being passed in.

Definition at line 25 of file BondBoost.h.

Constructor & Destructor Documentation

BondBoost()

eonc::BondBoost::BondBoost	(	Matter *	matt,
		const Parameters &	params )

Constructor to be used when a structure is minimized.

Parameters

[in]	*matter	Pointer to the Matter object to be relaxed.
[in]	parameters	Reference to the Parameter object containing the runtime parameters.

Definition at line 31 of file BondBoost.cpp.

    : matter{matt},
      parameters{params} {
  if (!matter) {
    throw std::invalid_argument("BondBoost: null Matter");
  }
  nAtoms = matter->numberOfAtoms();
}

~BondBoost()

eonc::BondBoost::~BondBoost ( )

default

Destructor.

Member Function Documentation

advance()

void eonc::BondBoost::advance

(

)

Advance the equilibration / boost schedule by one MD step.

Call once per physical step. boost() does not move the schedule.

Definition at line 112 of file BondBoost.cpp.

                        {
  const long RMDS = rmdSteps();
  // nReg starts at 1, so a zero sample count never enters the average below
  // and never divides by RMDS. TABLList would stay the zeros from
  // initialize(), and BondSelect would keep every tagged pair at length 0.
  if (RMDS <= 0) {
    if (nBBs == 0) {
      TABLList = Rmdsteps();
      nBBs = BondSelect();
    }
    nReg++;
    return;
  }
  if (nReg <= RMDS) {
    // Equilibration: sample bond lengths once per MD step.
    Matrix<double, Eigen::Dynamic, 1> TABL_tmp = Rmdsteps();
    TABLList = TABLList + (1.0 / RMDS) * TABL_tmp;
    nReg++;
    if (nReg == RMDS + 1) {
      nBBs = BondSelect();
    }
    return;
  }
  if (nReg == RMDS + 1) {
    nBBs = BondSelect();
  }
  nReg++;
}

BondSelect()

long eonc::BondBoost::BondSelect ( )

private

Select bonds within cutoff distance for boosting.

Definition at line 295 of file BondBoost.cpp.

                           {
  const double qCutoff = parameters.hyperdynamics_options().qcut;
 
  // Count bonds within cutoff
  long nSelected = 0;
  for (long i = 0; i < nTABs; i++) {
    if (TABLList(i, 0) <= qCutoff) {
      nSelected++;
    }
  }
 
  EBBLList.setZero(nSelected, 1);
  BBAList.resize(2 * nSelected);
  long count = 0;
  for (long i = 0; i < nTABs; i++) {
    if (TABLList(i, 0) <= qCutoff) {
      EBBLList(count, 0) = TABLList(i, 0);
      BBAList[2 * count] = TABAList[2 * i];
      BBAList[2 * count + 1] = TABAList[2 * i + 1];
      count++;
    }
  }
  return nSelected;
}

boost()

double eonc::BondBoost::boost

(

)

Evaluate the current bias potential and write bias forces.

Safe to call from a force evaluation; does not increment nReg.

Definition at line 141 of file BondBoost.cpp.

                        {
  const long RMDS = rmdSteps();
  if (RMDS > 0 && nReg <= RMDS) {
    return 0.0;
  }
  // Callers that never advance() still select on the first evaluation.
  // With no equilibration samples that selection has to measure lengths
  // first; SafeHyper and ParallelReplica advance() before they get here.
  if (nBBs == 0) {
    if (RMDS <= 0) {
      TABLList = Rmdsteps();
    }
    nBBs = BondSelect();
  }
  Epsr_Q.resize(nBBs);
  CBBLList.setZero(nBBs, 1);
  const double biasPot = Booststeps();
  Epsr_Q.clear();
  return biasPot;
}

Booststeps()

double eonc::BondBoost::Booststeps ( )

private

Compute bias potential and forces for bond-boost hyperdynamics.

Returns the bias potential energy contribution.

Definition at line 164 of file BondBoost.cpp.

                             {
  const double QRR = parameters.hyperdynamics_options().qrr;
  const double PRR = parameters.hyperdynamics_options().prr;
  const double DVMAX = parameters.hyperdynamics_options().dvmax;
  if (nBBs <= 0 || !(QRR > 0.0)) {
    return 0.0;
  }
  const double nBBsD = static_cast<double>(nBBs);
 
  AtomMatrix addForces(nBBs, 3);
  AtomMatrix TADF(nAtoms, 3);
  addForces.setZero();
  TADF.setZero();
 
  // Measure current bond lengths
  for (long i = 0; i < nBBs; i++) {
    CBBLList(i, 0) = matter->distance(BBAList[2 * i], BBAList[2 * i + 1]);
  }
 
  // Compute strain parameters and find maximum
  double epsrMax = 0.0;
  for (long i = 0; i < nBBs; i++) {
    const double eq = EBBLList(i, 0);
    if (!(eq > 0.0)) {
      Epsr_Q[i] = 0.0;
      continue;
    }
    Epsr_Q[i] = (CBBLList(i, 0) - eq) / eq / QRR;
    if (std::abs(Epsr_Q[i]) >= epsrMax) {
      epsrMax = std::abs(Epsr_Q[i]);
    }
  }
 
  // Envelope function A(eps_max)
  double A_eps = (1.0 - epsrMax * epsrMax) * (1.0 - epsrMax * epsrMax) /
                 (1.0 - PRR * PRR * epsrMax * epsrMax);
 
  // Sum of individual bias potentials
  double sumV = 0.0;
  if (epsrMax < 1.0) {
    for (long i = 0; i < nBBs; i++) {
      sumV += DVMAX * (1.0 - Epsr_Q[i] * Epsr_Q[i]) / nBBsD;
    }
  } else {
    A_eps = 0.0;
  }
 
  double boostFact = A_eps * sumV;
 
  // Compute bias forces per bond, accumulate on atoms
  for (long i = 0; i < nBBs; i++) {
    double dforce = 0.0;
    double fact1 =
        2.0 * A_eps * DVMAX * Epsr_Q[i] / QRR / EBBLList(i, 0) / nBBsD;
 
    if (std::abs(Epsr_Q[i]) < epsrMax) {
      dforce = fact1;
    } else {
      // Bond at maximum strain: additional envelope derivative
      double fTmp1 = 1.0 - PRR * PRR * Epsr_Q[i] * Epsr_Q[i];
      double fTmp2 = 1.0 - Epsr_Q[i] * Epsr_Q[i];
      double fact2 = 2.0 * fTmp2 * Epsr_Q[i] *
                     (2.0 * fTmp1 - PRR * PRR * fTmp2) / QRR / EBBLList(i, 0) /
                     fTmp1 / fTmp1;
      dforce = fact1 + sumV * fact2;
    }
 
    long a1 = BBAList[2 * i];
    long a2 = BBAList[2 * i + 1];
    if (!(EBBLList(i, 0) > 0.0)) {
      continue;
    }
    // distance() minimum-images the whole bond. pdistance minimum-images one
    // Cartesian axis after zeroing the other two, which is not that vector
    // when the cell is non-orthogonal.
    AtomMatrix delta(1, 3);
    delta.row(0) =
        matter->getPositions().row(a1) - matter->getPositions().row(a2);
    delta = matter->pbc(delta);
    const double R = delta.norm();
    if (!(R > 0.0)) {
      continue;
    }
 
    for (int j = 0; j < 3; j++) {
      const double rij = delta(0, j);
      const double fij = rij / R * dforce;
      addForces(i, j) = fij;
      TADF(a1, j) += fij;
      TADF(a2, j) -= fij;
    }
  }
 
  // Apply free-atom mask and set bias forces
  AtomMatrix biasForces = TADF.array() * matter->getFree().array();
  matter->setBiasForces(biasForces);
  return boostFact;
}

initialize()

void eonc::BondBoost::initialize

(

)

Definition at line 42 of file BondBoost.cpp.

                           {
  nBBs = 0;
  nReg = 1;
 
  const std::string &balString =
      parameters.hyperdynamics_options().boost_atom_list;
  std::string lowered = balString;
  std::ranges::transform(lowered, lowered.begin(), [](unsigned char c) {
    return static_cast<char>(std::tolower(c));
  });
 
  BAList.clear();
  if (lowered.empty() || lowered == "all") {
    for (long i = 0; i < nAtoms; ++i) {
      if (!matter->getFixed(i)) {
        BAList.push_back(i);
      }
    }
  } else {
    const auto atoms = eonc::helpers::split_string_int(balString, ",");
    if (atoms.empty()) {
      throw std::invalid_argument(
          "hyperdynamics.boost_atom_list must be 'all' or a comma list of "
          "CON file-order indices");
    }
    std::unordered_set<long> seen;
    for (int raw : atoms) {
      const long row = matter->mapFileRow(static_cast<long>(raw));
      if (row < 0 || row >= nAtoms) {
        throw std::out_of_range(
            "hyperdynamics.boost_atom_list index out of range");
      }
      if (matter->getFixed(row)) {
        continue;
      }
      if (seen.insert(row).second) {
        BAList.push_back(row);
      }
    }
  }
  if (BAList.empty()) {
    throw std::runtime_error("BondBoost: no boostable atoms");
  }
 
  nBAs = static_cast<long>(BAList.size());
  const std::unordered_set<long> boosted(BAList.begin(), BAList.end());
  RAList.clear();
  RAList.reserve(static_cast<size_t>(nAtoms - nBAs));
  for (long i = 0; i < nAtoms; ++i) {
    if (boosted.find(i) == boosted.end()) {
      RAList.push_back(i);
    }
  }
  nRAs = static_cast<long>(RAList.size());
 
  nTABs = nBAs * (nBAs - 1) / 2 + nBAs * nRAs;
  TABAList.assign(static_cast<size_t>(2 * std::max(nTABs, 0L)), 0);
  TABLList.setZero(nTABs, 1);
  QUILL_LOG_DEBUG(log, "BondBoost: {} boost atoms, {} rest, {} tagged bonds",
                  nBAs, nRAs, nTABs);
}

Rmdsteps()

Matrix< double, Eigen::Dynamic, 1 > eonc::BondBoost::Rmdsteps ( )

private

Measure all tagged-atom bond lengths for the equilibration phase.

Definition at line 264 of file BondBoost.cpp.

                                                    {
  Matrix<double, Eigen::Dynamic, 1> bondLengths(nTABs, 1);
  long count = 0;
 
  // Boost-atom pairs
  for (long i = 0; i < nBAs; i++) {
    for (long j = i + 1; j < nBAs; j++) {
      bondLengths(count, 0) = matter->distance(BAList[i], BAList[j]);
      TABAList[2 * count] = BAList[i];
      TABAList[2 * count + 1] = BAList[j];
      count++;
    }
  }
 
  // Boost-atom to rest-atom pairs
  for (long i = 0; i < nBAs; i++) {
    for (long j = 0; j < nRAs; j++) {
      bondLengths(count, 0) = matter->distance(BAList[i], RAList[j]);
      TABAList[2 * count] = BAList[i];
      TABAList[2 * count + 1] = RAList[j];
      count++;
    }
  }
 
  if (count != nTABs) {
    QUILL_LOG_DEBUG(log, "Total involved bond count does not match expected\n");
  }
  return bondLengths;
}

rmdSteps()

long eonc::BondBoost::rmdSteps ( ) const

private

Definition at line 104 of file BondBoost.cpp.

                               {
  const double dt = parameters.dynamics_options().time_step;
  if (!(dt > 0.0)) {
    return 0;
  }
  return static_cast<long>(parameters.hyperdynamics_options().rmd_time / dt);
}

scheduleStep()

long eonc::BondBoost::scheduleStep ( ) const

inlinenodiscard

Equilibration counter (starts at 1). Used to test the per-step schedule.

Definition at line 43 of file BondBoost.h.

{ return nReg; }

Member Data Documentation

BAList

std::vector<long> eonc::BondBoost::BAList

private

Definition at line 55 of file BondBoost.h.

BBAList

std::vector<long> eonc::BondBoost::BBAList

private

Definition at line 58 of file BondBoost.h.

CBBLList

Matrix<double, Eigen::Dynamic, 1> eonc::BondBoost::CBBLList

private

Definition at line 63 of file BondBoost.h.

EBBLList

Matrix<double, Eigen::Dynamic, 1> eonc::BondBoost::EBBLList

private

Definition at line 62 of file BondBoost.h.

Epsr_Q

std::vector<double> eonc::BondBoost::Epsr_Q

private

Definition at line 59 of file BondBoost.h.

log

eonc::log::Scoped eonc::BondBoost::log

private

Definition at line 69 of file BondBoost.h.

matter

Matter* eonc::BondBoost::matter

private

Initial value:

{
      nullptr}

Pointer to atom object outside the scope of the class.

Definition at line 51 of file BondBoost.h.

                {
      nullptr}; 

nAtoms

long eonc::BondBoost::nAtoms {0}

private

Number of free coordinates.

Definition at line 50 of file BondBoost.h.

{0}; 

nBAs

long eonc::BondBoost::nBAs {0}

private

Definition at line 64 of file BondBoost.h.

{0};

nBBs

long eonc::BondBoost::nBBs {0}

private

Definition at line 68 of file BondBoost.h.

{0};

nRAs

long eonc::BondBoost::nRAs {0}

private

Definition at line 65 of file BondBoost.h.

{0};

nReg

long eonc::BondBoost::nReg {0}

private

Definition at line 67 of file BondBoost.h.

{0};

nTABs

long eonc::BondBoost::nTABs {0}

private

Definition at line 66 of file BondBoost.h.

{0};

parameters

const Parameters& eonc::BondBoost::parameters

private

Reference to a structure outside the scope of the class containing runtime parameters.

Definition at line 53 of file BondBoost.h.

RAList

std::vector<long> eonc::BondBoost::RAList

private

Definition at line 56 of file BondBoost.h.

TABAList

std::vector<long> eonc::BondBoost::TABAList

private

Definition at line 57 of file BondBoost.h.

TABLList

Matrix<double, Eigen::Dynamic, 1> eonc::BondBoost::TABLList

private

Definition at line 61 of file BondBoost.h.

---

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

• /home/runner/work/eOn/eOn/include/eon/BondBoost.h
• /home/runner/work/eOn/eOn/client/BondBoost.cpp