eonc::Matter Class Reference

#include <Matter.h>

Classes
struct	Impl

Public Member Functions
	~Matter ()
	Matter (std::shared_ptr< Potential > pot, const Parameters &params)
	Matter (const Matter &matter)
const Matter &	operator= (const Matter &matter)
	Matter (Matter &&other) noexcept
	Move: transfers retained movie ConFrames (move-only).
Matter &	operator= (Matter &&other) noexcept
bool	compare (const Matter &matter, bool indistinguishable=false)
double	distanceTo (const Matter &matter)
double	perAtomNorm (const Matter &matter)
void	setPotential (std::shared_ptr< Potential > pot)
std::shared_ptr< Potential >	getPotential ()
void	resize (long int nAtoms)
long int	numberOfAtoms () const
Matrix3d	getCell () const
void	setCell (const Matrix3d &newCell)
double	getPosition (long int atom, int axis) const
void	setPosition (long int atom, int axis, double position)
void	setVelocity (long int atom, int axis, double velocity)
bool	relax (bool quiet=false, bool writeMovie=false, bool checkpoint=false, std::string prefixMovie=std::string(), std::string prefixCheckpoint=std::string(), bool retainMovieFrames=false)
const std::vector< readcon::ConFrame > &	movieFrames () const
	In-memory minimization movie (same stamps as writeMovie CON).
void	clearMovieFrames ()
std::vector< readcon::ConFrame >	takeMovieFrames ()
	Take ownership of retained frames (leaves storage empty).
AtomMatrix	pbc (const AtomMatrix &diff) const
VectorXd	pbcV (const VectorXd &diff) const
size_t	getPotentialCalls () const
const AtomMatrix &	getPositions () const
AtomMatrix	getPositionsCopy () const
VectorXd	getPositionsV () const
AtomMatrix	getPositionsFree () const
VectorXd	getPositionsFreeV () const
void	setPositions (const AtomMatrix &pos)
void	setPositionsV (const VectorXd &pos)
void	setPositionsFree (const AtomMatrix &pos)
void	setPositionsFreeV (const VectorXd &pos)
AtomMatrix	getVelocities () const
void	setVelocities (const AtomMatrix &v)
void	setBiasForces (const AtomMatrix &bf)
void	setBiasPotential (BondBoost *bondBoost)
BondBoost *	getBiasPotential () const
	The bias potential added to this Matter's forces, or nullptr.
void	assignKeepingBias (const Matter &other)
	Copy another structure in and keep this Matter's own bias potential.
void	setForces (const AtomMatrix &f)
AtomMatrix	getAccelerations ()
const AtomMatrix &	getForces () const
const AtomMatrix &	getForcesRaw () const
AtomMatrix	getBiasForces ()
VectorXd	getForcesV () const
AtomMatrix	getForcesFree () const
VectorXd	getForcesFreeV () const
PbcConvention	getPbcConvention () const
void	setPbcConvention (PbcConvention convention)
double	getMass (long int atom) const
void	setMass (long int atom, double mass)
void	setMasses (const VectorXd &massesIn)
long	getAtomicNr (long int atom) const
void	setAtomicNr (long int atom, long atomicNr)
VectorXi	getAtomicNrs () const
VectorXi	getAtomicNrsFree () const
void	setAtomicNrs (const VectorXi &atmnrs)
int	getFixed (long int atom) const
	1 if every Cartesian axis of the atom is fixed, else 0.
int	getFixed (long int atom, int axis) const
	1 if this atom's axis is fixed, else 0. axis is 0=x, 1=y, 2=z.
std::array< bool, 3 >	getFixedMask (long int atom) const
	Per-axis CON column-4 mask (bit0=x, bit1=y, bit2=z).
void	setFixed (long int atom, int isFixed)
	Broadcast a whole-atom flag onto all three axes.
void	setFixed (long int atom, int axis, int isFixed)
	Set one Cartesian axis. axis is 0=x, 1=y, 2=z.
void	setFixedMask (long int atom, std::array< bool, 3 > mask)
double	getEnergyVariance () const
double	getPotentialEnergy () const
Matrix3d	cauchyStress ()
	Cauchy stress in eV/Angstrom^3.
bool	needsForceUpdate () const
	Whether forces need recomputation (positions changed since last eval).
double *	forcesData ()
	Mutable access to force storage for batched potential evaluation.
void	setEvaluation (const AtomMatrix &forces, double energy)
	Puts a known evaluation back after a position reset: the forces and energy of a geometry this object held before, so no potential call follows.
void	setComputedPotential (double energy, double variance)
	Set energy/variance from external batched evaluation and mark forces as up-to-date (recomputePotential = false).
double	getKineticEnergy () const
double	getMechanicalEnergy () const
double	distance (long index1, long index2) const
double	pdistance (long index1, long index2, int axis) const
double	distance (const Matter &matter, long index) const
long int	numberOfFreeAtoms () const
long int	numberOfFixedAtoms () const
long	getForceCalls () const
void	resetForceCalls ()
double	maxForce (void) const
double	maxFreeAtomForce (const AtomMatrix &rows) const
	Max per-atom Euclidean norm of rows.
bool	getWriteConForces () const noexcept
	Parameters.main_options().writeConForces for this Matter, if bound.
io::IoStatus	writeTibble (std::string filename)
io::IoStatus	con2matter (std::string filename)
io::IoStatus	con2matter (const readcon::ConFrame &frame, io::ConFrameMetadata *out_metadata=nullptr)
io::IoStatus	convel2matter (std::string filename)
io::IoStatus	matter2con (std::string filename, bool append=false, const io::ConFrameMetadata *metadata=nullptr)
io::IoStatus	matter2convel (std::string filename)
io::IoStatus	matter2xyz (std::string filename, bool append=false)
AtomMatrix	getFree () const
VectorXd	getFreeV () const
Eigen::Matrix< double, Eigen::Dynamic, 1 >	getMasses () const
std::int64_t	getAtomIndex (long int atom) const
	.con column-5 index (pre-grouping); public for I/O / bindings.
void	setAtomIndex (long int atom, std::int64_t index)
long	mapFileRow (long file_row) const
	Map a CON file-order row onto the Matter row after matter_order.
void	setFileToMatter (std::vector< long > map)
const std::array< std::string, 5 > &	getHeaderCon () const
	CON header lines (indices 0..4); public for I/O / bindings.
void	setHeaderCon (const std::array< std::string, 5 > &headers)
void	setHeaderConLine (size_t i, std::string line)
bool	getPeriodic () const noexcept
void	setPeriodic (bool periodic)
void	applyPeriodicBoundaryIfEnabled ()
	Apply MIC wrap when periodic boundaries are enabled (I/O path).

Private Member Functions
void	assertIsolatedMoleculeLayoutSafe () const
	Throw if pot forbids PBC (isolated molecular QM backends, issue #188).
void	computePotential () const
void	applyPeriodicBoundary ()
void	applyPeriodicBoundary (double &component, int axis)
void	applyPeriodicBoundary (AtomMatrix &diff)
void	restoreFileForces (const AtomMatrix &fileForces, bool trustEnergy, double energy)
	Write .con forces without the fixed-atom mask setForces applies.

Private Attributes
eonc::log::Scoped	m_log
std::shared_ptr< Potential >	potential
bool	usePeriodicBoundaries
PbcConvention	pbcConvention
bool	recomputePotential
long	forceCalls
std::array< std::string, 5 >	headerCon
bool	removeNetForce {true}
StructureComparisonOptions	structComp
const Parameters *	parameters
long	nAtoms
std::unique_ptr< Impl >	impl_
BondBoost *	biasPotential {nullptr}
std::vector< long >	fileToMatter
std::vector< int >	freeIndices
bool	recomputeFreeMask {true}
bool	recomputeMaskedForces {true}
double	energyVariance
std::vector< readcon::ConFrame >	movie_frames_
double	potentialEnergy

Friends
io::IoStatus	io::con2matter (Matter &, const readcon::ConFrame &, io::ConFrameMetadata *)

Detailed Description

Definition at line 90 of file Matter.h.

Constructor & Destructor Documentation

~Matter()

eonc::Matter::~Matter ( )

default

Matter() [1/3]

eonc::Matter::Matter	(	std::shared_ptr< Potential >	pot,
		const Parameters &	params )

Definition at line 49 of file Matter.cpp.

    : potential{pot},
      usePeriodicBoundaries{!(pot && pot->requiresIsolatedMoleculeLayout())},
      pbcConvention{PbcConvention::Legacy},
      recomputePotential{true},
      forceCalls{0},
      removeNetForce{params.main_options().removeNetForce},
      structComp{params.structure_comparison_options()},
      parameters{&params},
      nAtoms{0},
      impl_{std::make_unique<Impl>()},
      biasPotential{nullptr},
      energyVariance{0.0},
      potentialEnergy{0.0} {}

Matter() [2/3]

eonc::Matter::Matter

(

const Matter &

matter

)

Definition at line 81 of file Matter.cpp.

    : impl_{std::make_unique<Impl>()} {
  operator=(matter);
}

Matter() [3/3]

eonc::Matter::Matter ( Matter && other )

noexcept

Move: transfers retained movie ConFrames (move-only).

User copy suppresses implicit move — without this, relax(inplace=False, retain_frames=True) loses frames when returning the working Matter.

Definition at line 136 of file Matter.cpp.

    : impl_{std::make_unique<Impl>()} {
  operator=(std::move(other));
}

Member Function Documentation

applyPeriodicBoundary() [1/3]

void eonc::Matter::applyPeriodicBoundary ( )

private

Definition at line 666 of file Matter.cpp.

                                   {
  assertIsolatedMoleculeLayoutSafe();
  // Unset / singular cell (default after Matter construct is Zero) — do not
  // wipe coordinates; callers set the cell before wrapping makes sense.
  if (std::abs(impl_->cell.determinant()) < 1e-30) {
    return;
  }
  impl_->positions = eonc::pbc::applyPositions(
      impl_->positions, impl_->cell, impl_->cellInverse, pbcConvention);
}

applyPeriodicBoundary() [2/3]

void eonc::Matter::applyPeriodicBoundary ( AtomMatrix & diff )

private

applyPeriodicBoundary() [3/3]

void eonc::Matter::applyPeriodicBoundary ( double & component, int axis )

private

applyPeriodicBoundaryIfEnabled()

void eonc::Matter::applyPeriodicBoundaryIfEnabled ( )

inline

Apply MIC wrap when periodic boundaries are enabled (I/O path).

Definition at line 322 of file Matter.h.

                                        {
    if (usePeriodicBoundaries) {
      applyPeriodicBoundary();
    }
  }

assertIsolatedMoleculeLayoutSafe()

void eonc::Matter::assertIsolatedMoleculeLayoutSafe ( ) const

private

Throw if pot forbids PBC (isolated molecular QM backends, issue #188).

Definition at line 594 of file Matter.cpp.

                                                    {
  if (!potential || !potential->requiresIsolatedMoleculeLayout()) {
    return;
  }
  if (usePeriodicBoundaries) {
    throw std::runtime_error(
        "Potential requires an isolated (non-periodic) molecular layout "
        "(NWChem/ORCA-class). Disable periodic boundaries before optimizing; "
        "PBC wraps can tear non-centered molecules (issue #188).");
  }
}

assignKeepingBias()

void eonc::Matter::assignKeepingBias

(

const Matter &

other

)

Copy another structure in and keep this Matter's own bias potential.

operator= clears the bias pointer, because it names the source's boost.

Definition at line 400 of file Matter.cpp.

                                                  {
  BondBoost *keep = biasPotential;
  *this = other;
  biasPotential = keep;
}

cauchyStress()

Matrix3d eonc::Matter::cauchyStress

(

)

Cauchy stress in eV/Angstrom^3.

Recomputes the potential so the tensor belongs to this image. The potential must report stress.

Definition at line 794 of file Matter.cpp.

                              {
  if (!potential || !potential->computesStress()) {
    throw std::logic_error(
        "Matter::cauchyStress requires a potential that reports stress");
  }
  recomputePotential = true;
  computePotential();
  Matrix3d sigma = potential->cauchyStress();
  if (!sigma.allFinite()) {
    throw std::runtime_error("Potential returned a non-finite stress tensor");
  }
  return sigma;
}

clearMovieFrames()

void eonc::Matter::clearMovieFrames ( )

inline

Definition at line 132 of file Matter.h.

{ movie_frames_.clear(); }

compare()

bool eonc::Matter::compare	(	const Matter &	matter,
		bool	indistinguishable = false )

Definition at line 184 of file Matter.cpp.

                                                                 {
  if (nAtoms != matter.numberOfAtoms())
    return false;
  if (structComp.check_rotation && indistinguishable) {
    return eonc::geometry::sortedR(*this, matter,
                                   structComp.distance_difference);
  } else if (indistinguishable) {
    if (this->numberOfFixedAtoms() == 0 and structComp.remove_translation)
      eonc::geometry::translationRemove(*this, matter);
    return eonc::geometry::identical(*this, matter,
                                     structComp.distance_difference);
  } else if (structComp.check_rotation) {
    return eonc::geometry::rotationMatch(*this, matter,
                                         structComp.distance_difference);
  } else {
    if (this->numberOfFixedAtoms() == 0 and structComp.remove_translation)
      eonc::geometry::translationRemove(*this, matter);
    return (structComp.distance_difference) > perAtomNorm(matter);
  }
}

computePotential()

void eonc::Matter::computePotential ( ) const

private

Definition at line 606 of file Matter.cpp.

                                    {
  if (recomputePotential) {
    if (!potential) {
      throw std::runtime_error(
          "Matter::computePotential called without a potential");
    }
    assertIsolatedMoleculeLayoutSafe();
    if (potential->isSurrogate()) {
      // Surrogate potential case: uses free-atom subset interface
      auto surrogatePotential =
          static_cast<SurrogatePotential *>(potential.get());
      auto [freePE, freeForces, vari] = surrogatePotential->get_ef_var(
          this->getPositionsFree(), this->getAtomicNrsFree(), impl_->cell);
      this->potentialEnergy = freePE;
      this->energyVariance = vari;
      for (long idx{0}, jdx{0}; idx < nAtoms; idx++) {
        if (!getFixed(idx)) {
          impl_->forces.row(idx) = freeForces.row(jdx);
          jdx++;
        }
      }
    } else {
      // Hot path: call force() directly into member storage.
      // No intermediate allocation, no tuple, no copy.
      double var{0};
      potential->setFixedMask(nAtoms, impl_->isFixed.data());
      const auto n = static_cast<size_t>(nAtoms);
      // Isolated molecules still store a box for I/O. Pots that infer PBC
      // from a non-zero cell (GFN2) must see a zero box here.
      const Matrix3d force_cell =
          usePeriodicBoundaries ? impl_->cell : Matrix3d::Zero();
      potential->force(std::span<const double>(impl_->positions.data(), n * 3),
                       std::span<const int>(impl_->atomicNrs.data(), n),
                       std::span<double>(impl_->forces.data(), n * 3),
                       &potentialEnergy, &var,
                       std::span<const double>(force_cell.data(), 9));
      potential->forceCallCounter++;
      PotRegistry::get().on_force_call(potential->getType());
    }
    if (!std::isfinite(potentialEnergy) || !impl_->forces.allFinite()) {
      throw std::runtime_error(
          "Potential returned non-finite energy or forces");
    }
    forceCalls = forceCalls + 1;
    recomputePotential = false;
 
    // One free atom: subtracting the mean force is identically zero,
    // and NEB would then report immediate GOOD.
    if (impl_->isFixed.maxCoeff() < 0.5 && removeNetForce && nAtoms > 1) {
      Vector3d tempForce = impl_->forces.colwise().sum() / nAtoms;
      for (long int i = 0; i < nAtoms; i++) {
        impl_->forces.row(i) -= tempForce.transpose();
      }
    }
  }
}

con2matter() [1/2]

io::IoStatus eonc::Matter::con2matter ( const readcon::ConFrame & frame, io::ConFrameMetadata * out_metadata = nullptr )

inlinenodiscard

Definition at line 260 of file Matter.h.

                                                       {
    return io::con2matter(*this, frame, out_metadata);
  }

con2matter() [2/2]

io::IoStatus eonc::Matter::con2matter ( std::string filename )

inlinenodiscard

Definition at line 256 of file Matter.h.

                                                          {
    return io::con2matter(*this, filename);
  }

convel2matter()

io::IoStatus eonc::Matter::convel2matter ( std::string filename )

inlinenodiscard

Definition at line 264 of file Matter.h.

                                                             {
    return io::convel2matter(*this, filename);
  }

distance() [1/2]

double eonc::Matter::distance	(	const Matter &	matter,
		long	index ) const

Definition at line 471 of file Matter.cpp.

                                                              {
  checkAtom(nAtoms, index, "Matter::distance");
  checkAtom(matter.nAtoms, index, "Matter::distance");
  return pbc(impl_->positions.row(index) - matter.getPositions().row(index))
      .norm();
}

distance() [2/2]

double eonc::Matter::distance	(	long	index1,
		long	index2 ) const

Definition at line 448 of file Matter.cpp.

                                                      {
  checkAtom(nAtoms, index1, "Matter::distance");
  checkAtom(nAtoms, index2, "Matter::distance");
  return pbc(impl_->positions.row(index1) - impl_->positions.row(index2))
      .norm();
}

distanceTo()

double eonc::Matter::distanceTo

(

const Matter &

matter

)

Definition at line 206 of file Matter.cpp.

                                              {
  if (matter.numberOfAtoms() != nAtoms) {
    throw std::invalid_argument("Matter::distanceTo: size mismatch");
  }
  return pbc(impl_->positions - matter.impl_->positions).norm();
}

forcesData()

double * eonc::Matter::forcesData

(

)

Mutable access to force storage for batched potential evaluation.

Caller must also call setComputedPotential() after writing forces.

Definition at line 824 of file Matter.cpp.

{ return impl_->forces.data(); }

getAccelerations()

AtomMatrix eonc::Matter::getAccelerations

(

)

Definition at line 739 of file Matter.cpp.

                                    {
  AtomMatrix totF = getForces() + getBiasForces();
  AtomMatrix ret = totF.array() * getFree().array();
  // Single reciprocal mass computation, replicated across 3 columns
  auto invMass = impl_->masses.array().inverse();
  ret.col(0).array() *= invMass;
  ret.col(1).array() *= invMass;
  ret.col(2).array() *= invMass;
  return ret;
}

getAtomicNr()

long eonc::Matter::getAtomicNr

(

long int

atom

)

const

Definition at line 495 of file Matter.cpp.

                                                 {
  return (impl_->atomicNrs[indexAtom]);
}

getAtomicNrs()

VectorXi eonc::Matter::getAtomicNrs

(

)

const

Definition at line 691 of file Matter.cpp.

{ return this->impl_->atomicNrs; }

getAtomicNrsFree()

VectorXi eonc::Matter::getAtomicNrsFree

(

)

const

Definition at line 325 of file Matter.cpp.

                                        {
  getFree();
  VectorXi ret(static_cast<Eigen::Index>(freeIndices.size()));
  for (size_t j = 0; j < freeIndices.size(); j++) {
    ret[static_cast<Eigen::Index>(j)] = impl_->atomicNrs[freeIndices[j]];
  }
  return ret;
}

getAtomIndex()

std::int64_t eonc::Matter::getAtomIndex ( long int atom ) const

nodiscard

.con column-5 index (pre-grouping); public for I/O / bindings.

Held 64-bit wide: readcon carries the column as a uint64_t, and a 32-bit slot drops the high half of any id past 2^31.

Definition at line 826 of file Matter.cpp.

                                                   {
  return impl_->atomIndex(atom);
}

getBiasForces()

AtomMatrix eonc::Matter::getBiasForces

(

)

Definition at line 385 of file Matter.cpp.

                                 {
  if (biasPotential != nullptr) {
    // Evaluate the current bias only. The MD job advances the bond-boost
    // schedule once per step via BondBoost::advance().
    biasPotential->boost();
  }
  return impl_->biasForces.array() * getFree().array();
}

getBiasPotential()

BondBoost * eonc::Matter::getBiasPotential

(

)

const

The bias potential added to this Matter's forces, or nullptr.

Definition at line 398 of file Matter.cpp.

{ return biasPotential; }

getCell()

Matrix3d eonc::Matter::getCell

(

)

const

Definition at line 275 of file Matter.cpp.

{ return impl_->cell; }

getEnergyVariance()

double eonc::Matter::getEnergyVariance

(

)

const

Definition at line 792 of file Matter.cpp.

{ return this->energyVariance; }

getFixed() [1/2]

int eonc::Matter::getFixed

(

long int

atom

)

const

1 if every Cartesian axis of the atom is fixed, else 0.

Definition at line 505 of file Matter.cpp.

                                             {
  checkAtom(nAtoms, indexAtom, "Matter::getFixed");
  return (impl_->isFixed(indexAtom, 0) > 0.5 &&
          impl_->isFixed(indexAtom, 1) > 0.5 &&
          impl_->isFixed(indexAtom, 2) > 0.5)
             ? 1
             : 0;
}

getFixed() [2/2]

int eonc::Matter::getFixed	(	long int	atom,
		int	axis ) const

1 if this atom's axis is fixed, else 0. axis is 0=x, 1=y, 2=z.

Definition at line 514 of file Matter.cpp.

                                                       {
  checkAtom(nAtoms, indexAtom, "Matter::getFixed");
  checkAxis(axis, "Matter::getFixed");
  return impl_->isFixed(indexAtom, axis) > 0.5 ? 1 : 0;
}

getFixedMask()

std::array< bool, 3 > eonc::Matter::getFixedMask ( long int atom ) const

nodiscard

Per-axis CON column-4 mask (bit0=x, bit1=y, bit2=z).

Definition at line 520 of file Matter.cpp.

                                                               {
  checkAtom(nAtoms, indexAtom, "Matter::getFixedMask");
  return {impl_->isFixed(indexAtom, 0) > 0.5,
          impl_->isFixed(indexAtom, 1) > 0.5,
          impl_->isFixed(indexAtom, 2) > 0.5};
}

getForceCalls()

long eonc::Matter::getForceCalls

(

)

const

Definition at line 587 of file Matter.cpp.

{ return (forceCalls); }

getForces()

const AtomMatrix & eonc::Matter::getForces

(

)

const

Definition at line 412 of file Matter.cpp.

                                          {
  computePotential();
  if (recomputeMaskedForces) {
    // Use the cached freeMask (Nx3, 1.0 for free / 0.0 for fixed) to zero
    // fixed-atom forces in a single vectorized Eigen operation.
    impl_->maskedForces = impl_->forces.array() * getFree().array();
    recomputeMaskedForces = false;
  }
  return impl_->maskedForces;
}

getForcesFree()

AtomMatrix eonc::Matter::getForcesFree

(

)

const

Definition at line 432 of file Matter.cpp.

                                       {
  AtomMatrix allForces = getForces();
  getFree(); // ensure freeIndices is up to date (mutable cache)
  AtomMatrix ret(static_cast<long>(freeIndices.size()), 3);
  for (size_t j = 0; j < freeIndices.size(); j++) {
    ret.row(static_cast<long>(j)) = allForces.row(freeIndices[j]);
  }
  return ret;
}

getForcesFreeV()

VectorXd eonc::Matter::getForcesFreeV

(

)

const

Definition at line 442 of file Matter.cpp.

                                      {
  AtomMatrix freeForces = getForcesFree();
  return VectorXd::Map(freeForces.data(), 3 * numberOfFreeAtoms());
}

getForcesRaw()

const AtomMatrix & eonc::Matter::getForcesRaw

(

)

const

Definition at line 423 of file Matter.cpp.

                                             {
  computePotential();
  return impl_->forces;
}

getForcesV()

VectorXd eonc::Matter::getForcesV

(

)

const

Definition at line 428 of file Matter.cpp.

                                  {
  return VectorXd::Map(getForces().data(), 3 * numberOfAtoms());
}

getFree()

AtomMatrix eonc::Matter::getFree

(

)

const

Definition at line 704 of file Matter.cpp.

                                 {
  if (recomputeFreeMask) {
    impl_->freeMask.resize(nAtoms, 3);
    impl_->freeMask = 1.0 - impl_->isFixed.array();
    freeIndices.clear();
    freeIndices.reserve(static_cast<size_t>(nAtoms));
    for (long i = 0; i < nAtoms; i++) {
      if (impl_->freeMask.row(i).sum() > 0.5) {
        freeIndices.push_back(static_cast<int>(i));
      }
    }
    recomputeFreeMask = false;
  }
  return impl_->freeMask;
}

getFreeV()

VectorXd eonc::Matter::getFreeV

(

)

const

Definition at line 720 of file Matter.cpp.

                                {
  return VectorXd::Map(getFree().data(), 3 * numberOfAtoms());
}

getHeaderCon()

const std::array< std::string, 5 > & eonc::Matter::getHeaderCon ( ) const

inlinenodiscard

CON header lines (indices 0..4); public for I/O / bindings.

Definition at line 303 of file Matter.h.

                                                                   {
    return headerCon;
  }

getKineticEnergy()

double eonc::Matter::getKineticEnergy

(

)

const

Definition at line 562 of file Matter.cpp.

                                      {
  // 0.5 * sum(mass_i * |v_i,free|^2); a constrained axis does not contribute.
  AtomMatrix vfree = impl_->velocities.array() * getFree().array();
  Eigen::VectorXd speed2 = vfree.rowwise().squaredNorm();
  return 0.5 * (impl_->masses.array() * speed2.array()).sum();
}

getMass()

double eonc::Matter::getMass

(

long int

atom

)

const

Definition at line 478 of file Matter.cpp.

                                               {
  checkAtom(nAtoms, indexAtom, "Matter::getMass");
  return (impl_->masses[indexAtom]);
}

getMasses()

Matrix< double, Eigen::Dynamic, 1 > eonc::Matter::getMasses

(

)

const

Definition at line 750 of file Matter.cpp.

                                                        {
  return impl_->masses;
}

getMechanicalEnergy()

double eonc::Matter::getMechanicalEnergy

(

)

const

Definition at line 569 of file Matter.cpp.

                                         {
  return getPotentialEnergy() + getKineticEnergy();
}

getPbcConvention()

PbcConvention eonc::Matter::getPbcConvention ( ) const

inline

Definition at line 177 of file Matter.h.

{ return pbcConvention; }

getPeriodic()

bool eonc::Matter::getPeriodic ( ) const

inlinenodiscardnoexcept

Definition at line 313 of file Matter.h.

                                                  {
    return usePeriodicBoundaries;
  }

getPosition()

double eonc::Matter::getPosition	(	long int	atom,
		int	axis ) const

Definition at line 284 of file Matter.cpp.

                                                             {
  checkAtom(nAtoms, indexAtom, "Matter::getPosition");
  checkAxis(axis, "Matter::getPosition");
  return impl_->positions(indexAtom, axis);
}

getPositions()

const AtomMatrix & eonc::Matter::getPositions

(

)

const

Definition at line 308 of file Matter.cpp.

{ return impl_->positions; }

getPositionsCopy()

AtomMatrix eonc::Matter::getPositionsCopy

(

)

const

Definition at line 310 of file Matter.cpp.

{ return impl_->positions; }

getPositionsFree()

AtomMatrix eonc::Matter::getPositionsFree

(

)

const

Definition at line 316 of file Matter.cpp.

                                          {
  getFree(); // ensure freeIndices is up to date
  AtomMatrix ret(static_cast<long>(freeIndices.size()), 3);
  for (size_t j = 0; j < freeIndices.size(); j++) {
    ret.row(static_cast<long>(j)) = impl_->positions.row(freeIndices[j]);
  }
  return ret;
}

getPositionsFreeV()

VectorXd eonc::Matter::getPositionsFreeV

(

)

const

Definition at line 345 of file Matter.cpp.

                                         {
  return VectorXd::Map(getPositionsFree().data(), 3 * numberOfFreeAtoms());
}

getPositionsV()

VectorXd eonc::Matter::getPositionsV

(

)

const

Definition at line 312 of file Matter.cpp.

                                     {
  return VectorXd::Map(impl_->positions.data(), 3 * numberOfAtoms());
}

getPotential()

std::shared_ptr< Potential > eonc::Matter::getPotential

(

)

Definition at line 808 of file Matter.cpp.

{ return this->potential; }

getPotentialCalls()

size_t eonc::Matter::getPotentialCalls

(

)

const

Definition at line 788 of file Matter.cpp.

                                       {
  return this->potential->forceCallCounter;
}

getPotentialEnergy()

double eonc::Matter::getPotentialEnergy

(

)

const

Definition at line 554 of file Matter.cpp.

                                        {
  if (nAtoms > 0) {
    computePotential();
    return potentialEnergy;
  } else
    return 0.0;
}

getVelocities()

AtomMatrix eonc::Matter::getVelocities

(

)

const

Definition at line 724 of file Matter.cpp.

                                       {
  return impl_->velocities.array() * getFree().array();
}

getWriteConForces()

bool eonc::Matter::getWriteConForces ( ) const

nodiscardnoexcept

Parameters.main_options().writeConForces for this Matter, if bound.

Definition at line 64 of file Matter.cpp.

                                              {
  return parameters != nullptr && parameters->main_options().writeConForces;
}

mapFileRow()

long eonc::Matter::mapFileRow ( long file_row ) const

inlinenodiscard

Map a CON file-order row onto the Matter row after matter_order.

Identity when the Matter was not loaded from a .con, or the ids were already ascending.

Definition at line 293 of file Matter.h.

                                                     {
    if (file_row < 0 || file_row >= nAtoms ||
        fileToMatter.size() != static_cast<size_t>(nAtoms)) {
      return file_row;
    }
    return fileToMatter[static_cast<size_t>(file_row)];
  }

matter2con()

io::IoStatus eonc::Matter::matter2con ( std::string filename, bool append = false, const io::ConFrameMetadata * metadata = nullptr )

inlinenodiscard

Definition at line 268 of file Matter.h.

                                                         {
    return io::matter2con(*this, filename, append, metadata);
  }

matter2convel()

io::IoStatus eonc::Matter::matter2convel ( std::string filename )

inlinenodiscard

Definition at line 272 of file Matter.h.

                                                             {
    return io::matter2convel(*this, filename);
  }

matter2xyz()

io::IoStatus eonc::Matter::matter2xyz ( std::string filename, bool append = false )

inlinenodiscard

Definition at line 275 of file Matter.h.

                                                           {
    return io::matter2xyz(*this, filename, append);
  }

maxForce()

double eonc::Matter::maxForce

(

void

)

const

Definition at line 685 of file Matter.cpp.

                              {
  // Ensures that the forces are up to date
  computePotential();
  return maxFreeAtomForce(getForces());
}

maxFreeAtomForce()

double eonc::Matter::maxFreeAtomForce ( const AtomMatrix & rows ) const

nodiscard

Max per-atom Euclidean norm of rows.

Atoms fixed on every axis are ignored. rows must have one row per atom.

Definition at line 677 of file Matter.cpp.

                                                            {
  if (rows.rows() != nAtoms) {
    throw std::invalid_argument(
        "Matter::maxFreeAtomForce: row count does not match atom count");
  }
  return maxFreeAtomForceNorm(rows.data(), impl_->isFixed.data(), nAtoms);
}

movieFrames()

const std::vector< readcon::ConFrame > & eonc::Matter::movieFrames ( ) const

inlinenodiscard

In-memory minimization movie (same stamps as writeMovie CON).

Cleared when retainMovieFrames=false on the next relax, or via clearMovieFrames().

Definition at line 129 of file Matter.h.

                                                                      {
    return movie_frames_;
  }

needsForceUpdate()

bool eonc::Matter::needsForceUpdate ( ) const

inlinenodiscard

Whether forces need recomputation (positions changed since last eval).

Definition at line 211 of file Matter.h.

{ return recomputePotential; }

numberOfAtoms()

long int eonc::Matter::numberOfAtoms

(

)

const

Definition at line 273 of file Matter.cpp.

{ return (nAtoms); }

numberOfFixedAtoms()

long int eonc::Matter::numberOfFixedAtoms

(

)

const

Definition at line 573 of file Matter.cpp.

                                          {
  long n = 0;
  for (long i = 0; i < nAtoms; ++i) {
    if (getFixed(i)) {
      ++n;
    }
  }
  return n;
}

numberOfFreeAtoms()

long int eonc::Matter::numberOfFreeAtoms

(

)

const

Definition at line 583 of file Matter.cpp.

                                         {
  return nAtoms - numberOfFixedAtoms();
}

operator=() [1/2]

const Matter & eonc::Matter::operator=

(

const Matter &

matter

)

Definition at line 86 of file Matter.cpp.

                                                  {
  if (this == &matter) {
    return *this;
  }
  nAtoms = matter.nAtoms;
  resize(nAtoms);
 
  impl_->positions = matter.impl_->positions;
  impl_->forces = matter.impl_->forces;
  impl_->masses = matter.impl_->masses;
  impl_->atomicNrs = matter.impl_->atomicNrs;
  impl_->isFixed = matter.impl_->isFixed;
  impl_->atomIndex = matter.impl_->atomIndex;
  fileToMatter = matter.fileToMatter;
  impl_->cell = matter.impl_->cell;
  impl_->cellInverse = matter.impl_->cellInverse;
  impl_->velocities = matter.impl_->velocities;
 
  removeNetForce = matter.removeNetForce;
  structComp = matter.structComp;
  parameters = matter.parameters;
 
  usePeriodicBoundaries = matter.usePeriodicBoundaries;
  pbcConvention = matter.pbcConvention;
 
  potential = matter.potential;
  potentialEnergy = matter.potentialEnergy;
  energyVariance = matter.energyVariance;
  forceCalls = matter.forceCalls;
  recomputePotential = matter.recomputePotential;
  // Both caches describe the forces this object held before the assignment.
  // resize() above already raises them; state it here alongside the members
  // this function owns.
  recomputeFreeMask = true;
  recomputeMaskedForces = true;
 
  // A BondBoost binds to one Matter (BondBoost.h:32 takes a Matter *), so a
  // copy cannot share the source's: boosting through it would drive the
  // original. The copy starts without one and re-establishes it through
  // setBiasPotential. biasForces is zeroed by the resize above, which is the
  // state that matches having no bias potential.
  biasPotential = nullptr;
 
  headerCon = matter.headerCon;
  // ConFrame is move-only; copy does not retain movie trajectory.
  movie_frames_.clear();
 
  return *this;
}

operator=() [2/2]

Matter & eonc::Matter::operator= ( Matter && other )

noexcept

Definition at line 141 of file Matter.cpp.

                                               {
  if (this == &other) {
    return *this;
  }
  potential = std::move(other.potential);
  usePeriodicBoundaries = other.usePeriodicBoundaries;
  pbcConvention = other.pbcConvention;
  recomputePotential = other.recomputePotential;
  forceCalls = other.forceCalls;
  headerCon = std::move(other.headerCon);
  removeNetForce = other.removeNetForce;
  structComp = other.structComp;
  parameters = other.parameters;
  nAtoms = other.nAtoms;
  impl_->positions = std::move(other.impl_->positions);
  impl_->velocities = std::move(other.impl_->velocities);
  impl_->forces = std::move(other.impl_->forces);
  impl_->biasForces = std::move(other.impl_->biasForces);
  biasPotential = other.biasPotential;
  other.biasPotential = nullptr;
  impl_->masses = std::move(other.impl_->masses);
  impl_->atomicNrs = std::move(other.impl_->atomicNrs);
  impl_->isFixed = std::move(other.impl_->isFixed);
  impl_->atomIndex = std::move(other.impl_->atomIndex);
  fileToMatter = std::move(other.fileToMatter);
  impl_->freeMask = std::move(other.impl_->freeMask);
  impl_->maskedForces = std::move(other.impl_->maskedForces);
  freeIndices = std::move(other.freeIndices);
  recomputeFreeMask = other.recomputeFreeMask;
  recomputeMaskedForces = other.recomputeMaskedForces;
  impl_->cell = std::move(other.impl_->cell);
  impl_->cellInverse = std::move(other.impl_->cellInverse);
  energyVariance = other.energyVariance;
  movie_frames_ = std::move(other.movie_frames_);
  potentialEnergy = other.potentialEnergy;
 
  other.nAtoms = 0;
  other.recomputePotential = true;
  other.recomputeFreeMask = true;
  other.recomputeMaskedForces = true;
  return *this;
}

pbc()

AtomMatrix eonc::Matter::pbc

(

const AtomMatrix &

diff

)

const

Definition at line 810 of file Matter.cpp.

                                                   {
  if (!usePeriodicBoundaries) {
    return diff;
  }
  return eonc::pbc::apply(diff, impl_->cell, impl_->cellInverse);
}

pbcV()

VectorXd eonc::Matter::pbcV

(

const VectorXd &

diff

)

const

Definition at line 817 of file Matter.cpp.

                                                {
  if (!usePeriodicBoundaries) {
    return diff;
  }
  return eonc::pbc::applyV(diff, impl_->cell, impl_->cellInverse);
}

pdistance()

double eonc::Matter::pdistance	(	long	index1,
		long	index2,
		int	axis ) const

Definition at line 457 of file Matter.cpp.

                                                                 {
  checkAtom(nAtoms, index1, "Matter::pdistance");
  checkAtom(nAtoms, index2, "Matter::pdistance");
  checkAxis(axis, "Matter::pdistance");
  Matrix<double, 1, 3> ret;
  ret.setZero();
  ret(0, axis) =
      impl_->positions(index1, axis) - impl_->positions(index2, axis);
  ret = pbc(ret);
  return ret(0, axis);
}

perAtomNorm()

double eonc::Matter::perAtomNorm

(

const Matter &

matter

)

Definition at line 214 of file Matter.cpp.

                                               {
  long i = 0;
  double max_distance = 0.0;
 
  if (matter.numberOfAtoms() == nAtoms) {
    AtomMatrix diff = pbc(impl_->positions - matter.impl_->positions);
    for (i = 0; i < nAtoms; i++) {
      max_distance = std::max(diff.row(i).norm(), max_distance);
    }
  }
  return max_distance;
}

relax()

bool eonc::Matter::relax	(	bool	quiet = false,
		bool	writeMovie = false,
		bool	checkpoint = false,
		std::string	prefixMovie = std::string(),
		std::string	prefixCheckpoint = std::string(),
		bool	retainMovieFrames = false )

Definition at line 334 of file Matter.cpp.

                                           {
  if (retainMovieFrames) {
    movie_frames_.clear();
  }
  return eonc::helpers::relaxMatter(
      *this, *parameters, quiet, writeMovie, checkpoint, prefixMovie,
      prefixCheckpoint, retainMovieFrames ? &movie_frames_ : nullptr);
}

resetForceCalls()

void eonc::Matter::resetForceCalls

(

)

Definition at line 589 of file Matter.cpp.

                             {
  forceCalls = 0;
  return;
}

resize()

void eonc::Matter::resize

(

long int

nAtoms

)

Definition at line 227 of file Matter.cpp.

                                         {
  if (length < 0) {
    throw std::invalid_argument("Matter::resize: negative atom count");
  }
  // Same-N resize still zeros coordinates. Keep .con column-5 ids and
  // the file-order map so a later matter2con does not stamp 1..N.
  const bool keepAtomIds =
      (length == nAtoms && impl_->atomIndex.size() == length &&
       fileToMatter.size() == static_cast<size_t>(length));
  // Zero is a real size: leaving nAtoms at the old value there sends
  // setMasses and every other nAtoms loop off the end of an empty array.
  nAtoms = length;
  impl_->positions.resize(length, 3);
  impl_->positions.setZero();
 
  impl_->velocities.resize(length, 3);
  impl_->velocities.setZero();
 
  impl_->biasForces.resize(length, 3);
  impl_->biasForces.setZero();
 
  impl_->forces.resize(length, 3);
  impl_->forces.setZero();
 
  impl_->masses.resize(length);
  impl_->masses.setZero();
 
  impl_->atomicNrs.resize(length);
  impl_->atomicNrs.setZero();
 
  impl_->isFixed.resize(length, 3);
  impl_->isFixed.setZero();
 
  if (!keepAtomIds) {
    impl_->atomIndex.resize(length);
    fileToMatter.resize(static_cast<size_t>(length));
    for (long i = 0; i < length; i++) {
      impl_->atomIndex(i) = static_cast<std::int64_t>(i); // default: sequential
      fileToMatter[static_cast<size_t>(i)] = i;
    }
  }
  recomputePotential = true;
  recomputeMaskedForces = true;
  recomputeFreeMask = true;
}

restoreFileForces()

void eonc::Matter::restoreFileForces ( const AtomMatrix & fileForces, bool trustEnergy, double energy )

private

Write .con forces without the fixed-atom mask setForces applies.

Definition at line 834 of file Matter.cpp.

                                              {
  impl_->forces = fileForces;
  recomputeMaskedForces = true;
  if (trustEnergy) {
    potentialEnergy = energy;
    energyVariance = 0.0;
    recomputePotential = false;
  } else {
    recomputePotential = true;
  }
}

setAtomicNr()

void eonc::Matter::setAtomicNr	(	long int	atom,
		long	atomicNr )

Definition at line 499 of file Matter.cpp.

                                                          {
  impl_->atomicNrs[indexAtom] = atomicNr;
  recomputePotential = true;
  recomputeMaskedForces = true;
}

setAtomicNrs()

void eonc::Matter::setAtomicNrs

(

const VectorXi &

atmnrs

)

Definition at line 693 of file Matter.cpp.

                                                {
  if (atmnrs.size() != this->nAtoms) {
    throw std::invalid_argument(
        "Vector of atomic numbers not equal to the number of atoms");
  } else {
    this->impl_->atomicNrs = atmnrs;
    recomputePotential = true;
    recomputeMaskedForces = true;
  }
}

setAtomIndex()

void eonc::Matter::setAtomIndex	(	long int	atom,
		std::int64_t	index )

Definition at line 830 of file Matter.cpp.

                                                         {
  impl_->atomIndex(atom) = index;
}

setBiasForces()

void eonc::Matter::setBiasForces

(

const AtomMatrix &

bf

)

Definition at line 406 of file Matter.cpp.

                                               {
  impl_->biasForces = bf.array() * getFree().array();
}

setBiasPotential()

void eonc::Matter::setBiasPotential

(

BondBoost *

bondBoost

)

Definition at line 394 of file Matter.cpp.

                                                  {
  biasPotential = bondBoost;
}

setCell()

void eonc::Matter::setCell

(

const Matrix3d &

newCell

)

Definition at line 277 of file Matter.cpp.

                                            {
  impl_->cell = newCell;
  impl_->cellInverse = impl_->cell.inverse();
  recomputePotential = true;
  recomputeMaskedForces = true;
}

setComputedPotential()

void eonc::Matter::setComputedPotential	(	double	energy,
		double	variance )

Set energy/variance from external batched evaluation and mark forces as up-to-date (recomputePotential = false).

Definition at line 772 of file Matter.cpp.

                                                                {
  potentialEnergy = energy;
  energyVariance = variance;
  recomputePotential = false;
  recomputeMaskedForces = true;
  forceCalls++;
 
  // Apply the same net force removal as computePotential()
  if (impl_->isFixed.maxCoeff() < 0.5 && removeNetForce && nAtoms > 1) {
    Vector3d tempForce = impl_->forces.colwise().sum() / nAtoms;
    for (long int i = 0; i < nAtoms; i++) {
      impl_->forces.row(i) -= tempForce.transpose();
    }
  }
}

setEvaluation()

void eonc::Matter::setEvaluation ( const AtomMatrix & forces, double energy )

inline

Puts a known evaluation back after a position reset: the forces and energy of a geometry this object held before, so no potential call follows.

Fixed-atom masking applies on read as for any evaluation.

Definition at line 219 of file Matter.h.

                                                              {
    restoreFileForces(forces, true, energy);
  }

setFileToMatter()

void eonc::Matter::setFileToMatter ( std::vector< long > map )

inline

Definition at line 300 of file Matter.h.

{ fileToMatter = std::move(map); }

setFixed() [1/2]

void eonc::Matter::setFixed	(	long int	atom,
		int	axis,
		int	isFixed )

Set one Cartesian axis. axis is 0=x, 1=y, 2=z.

Definition at line 537 of file Matter.cpp.

                                                                      {
  checkAtom(nAtoms, indexAtom, "Matter::setFixed");
  checkAxis(axis, "Matter::setFixed");
  impl_->isFixed(indexAtom, axis) = isFixed_passed ? 1.0 : 0.0;
  recomputeFreeMask = true;
  recomputeMaskedForces = true;
}

setFixed() [2/2]

void eonc::Matter::setFixed	(	long int	atom,
		int	isFixed )

Broadcast a whole-atom flag onto all three axes.

Definition at line 527 of file Matter.cpp.

                                                            {
  checkAtom(nAtoms, indexAtom, "Matter::setFixed");
  const double v = isFixed_passed ? 1.0 : 0.0;
  impl_->isFixed(indexAtom, 0) = v;
  impl_->isFixed(indexAtom, 1) = v;
  impl_->isFixed(indexAtom, 2) = v;
  recomputeFreeMask = true;
  recomputeMaskedForces = true;
}

setFixedMask()

void eonc::Matter::setFixedMask	(	long int	atom,
		std::array< bool, 3 >	mask )

Definition at line 545 of file Matter.cpp.

                                                                    {
  checkAtom(nAtoms, indexAtom, "Matter::setFixedMask");
  impl_->isFixed(indexAtom, 0) = mask[0] ? 1.0 : 0.0;
  impl_->isFixed(indexAtom, 1) = mask[1] ? 1.0 : 0.0;
  impl_->isFixed(indexAtom, 2) = mask[2] ? 1.0 : 0.0;
  recomputeFreeMask = true;
  recomputeMaskedForces = true;
}

setForces()

void eonc::Matter::setForces

(

const AtomMatrix &

f

)

Definition at line 732 of file Matter.cpp.

                                          {
  impl_->forces = f.array() * getFree().array();
  impl_->maskedForces = impl_->forces;
  recomputeMaskedForces = false;
  recomputePotential = false;
}

setHeaderCon()

void eonc::Matter::setHeaderCon ( const std::array< std::string, 5 > & headers )

inline

Definition at line 306 of file Matter.h.

                                                           {
    headerCon = headers;
  }

setHeaderConLine()

void eonc::Matter::setHeaderConLine ( size_t i, std::string line )

inline

Definition at line 309 of file Matter.h.

                                                  {
    headerCon.at(i) = std::move(line);
  }

setMass()

void eonc::Matter::setMass	(	long int	atom,
		double	mass )

Definition at line 483 of file Matter.cpp.

                                                    {
  checkAtom(nAtoms, indexAtom, "Matter::setMass");
  impl_->masses[indexAtom] = mass;
}

setMasses()

void eonc::Matter::setMasses

(

const VectorXd &

massesIn

)

Definition at line 488 of file Matter.cpp.

                                               {
  if (massesIn.size() != nAtoms) {
    throw std::invalid_argument("Matter::setMasses: size mismatch");
  }
  impl_->masses = massesIn;
}

setPbcConvention()

void eonc::Matter::setPbcConvention ( PbcConvention convention )

inline

Definition at line 178 of file Matter.h.

                                                  {
    pbcConvention = convention;
  }

setPeriodic()

void eonc::Matter::setPeriodic ( bool periodic )

inline

Definition at line 316 of file Matter.h.

                                  {
    usePeriodicBoundaries = periodic;
    recomputePotential = true;
    recomputeMaskedForces = true;
  }

setPosition()

void eonc::Matter::setPosition	(	long int	atom,
		int	axis,
		double	position )

Definition at line 290 of file Matter.cpp.

                                                                      {
  checkAtom(nAtoms, indexAtom, "Matter::setPosition");
  checkAxis(axis, "Matter::setPosition");
  impl_->positions(indexAtom, axis) = position;
  if (usePeriodicBoundaries) {
    applyPeriodicBoundary();
  }
  recomputePotential = true;
  recomputeMaskedForces = true;
}

setPositions()

void eonc::Matter::setPositions

(

const AtomMatrix &

pos

)

Definition at line 350 of file Matter.cpp.

                                               {
  if (pos.rows() != nAtoms) {
    throw std::invalid_argument("Matter::setPositions: row count mismatch");
  }
  impl_->positions = pos;
  if (usePeriodicBoundaries) {
    applyPeriodicBoundary();
  }
  recomputePotential = true;
  recomputeMaskedForces = true;
}

setPositionsFree()

void eonc::Matter::setPositionsFree

(

const AtomMatrix &

pos

)

Definition at line 367 of file Matter.cpp.

                                                   {
  getFree(); // ensure freeIndices is up to date
  for (size_t j = 0; j < freeIndices.size(); j++) {
    impl_->positions.row(freeIndices[j]) = pos.row(static_cast<long>(j));
  }
  // Optimizers write free-atom coords only (TIP4P/SPCE and any PBC pot).
  // Match setPositions: wrap the full configuration when PBC is on (#171).
  if (usePeriodicBoundaries) {
    applyPeriodicBoundary();
  }
  recomputePotential = true;
  recomputeMaskedForces = true;
}

setPositionsFreeV()

void eonc::Matter::setPositionsFreeV

(

const VectorXd &

pos

)

Definition at line 381 of file Matter.cpp.

                                                  {
  setPositionsFree(AtomMatrix::Map(pos.data(), numberOfFreeAtoms(), 3));
}

setPositionsV()

void eonc::Matter::setPositionsV

(

const VectorXd &

pos

)

Definition at line 363 of file Matter.cpp.

                                              {
  setPositions(AtomMatrix::Map(pos.data(), numberOfAtoms(), 3));
}

setPotential()

void eonc::Matter::setPotential

(

std::shared_ptr< Potential >

pot

)

Definition at line 754 of file Matter.cpp.

                                                      {
  this->potential = pot;
  // Molecular QM backends (NWChem/ORCA) must not use PBC wraps (#188). Auto-off
  // with a hard fail if code later forces PBC while this pot is attached.
  if (potential && potential->requiresIsolatedMoleculeLayout() &&
      usePeriodicBoundaries) {
    usePeriodicBoundaries = false;
    // Use EONC_LOG_* (not bare QUILL_LOG_* with eonc::log::get() as arg): the
    // quill macros expand logger->… and choke on a call expression as the first
    // macro argument on some GCC versions (CI: expected primary-expression).
    EONC_LOG_WARNING(
        "Disabled PBC for isolated-molecule potential (NWChem/ORCA-class); "
        "re-enabling PBC will throw (issue #188)");
  }
  recomputePotential = true;
  recomputeMaskedForces = true;
}

setVelocities()

void eonc::Matter::setVelocities

(

const AtomMatrix &

v

)

Definition at line 728 of file Matter.cpp.

                                              {
  impl_->velocities = v.array() * getFree().array();
}

setVelocity()

void eonc::Matter::setVelocity	(	long int	atom,
		int	axis,
		double	velocity )

Definition at line 301 of file Matter.cpp.

                                                                 {
  checkAtom(nAtoms, indexAtom, "Matter::setVelocity");
  checkAxis(axis, "Matter::setVelocity");
  impl_->velocities(indexAtom, axis) = vel;
}

takeMovieFrames()

std::vector< readcon::ConFrame > eonc::Matter::takeMovieFrames ( )

inlinenodiscard

Take ownership of retained frames (leaves storage empty).

Definition at line 134 of file Matter.h.

                                                             {
    return std::move(movie_frames_);
  }

writeTibble()

io::IoStatus eonc::Matter::writeTibble ( std::string filename )

inlinenodiscard

Definition at line 253 of file Matter.h.

                                                           {
    return io::writeTibble(*this, filename);
  }

Friends And Related Symbol Documentation

io::con2matter

io::IoStatus io::con2matter ( Matter & , const readcon::ConFrame & , io::ConFrameMetadata *  )

friend

Member Data Documentation

biasPotential

BondBoost* eonc::Matter::biasPotential {nullptr}

private

Definition at line 366 of file Matter.h.

{nullptr};

energyVariance

double eonc::Matter::energyVariance

mutableprivate

Definition at line 374 of file Matter.h.

fileToMatter

std::vector<long> eonc::Matter::fileToMatter

private

Definition at line 367 of file Matter.h.

forceCalls

long eonc::Matter::forceCalls

mutableprivate

Definition at line 346 of file Matter.h.

freeIndices

std::vector<int> eonc::Matter::freeIndices

mutableprivate

Definition at line 371 of file Matter.h.

headerCon

std::array<std::string, 5> eonc::Matter::headerCon

private

Definition at line 349 of file Matter.h.

impl_

std::unique_ptr<Impl> eonc::Matter::impl_

private

Definition at line 365 of file Matter.h.

m_log

eonc::log::Scoped eonc::Matter::m_log

private

Definition at line 335 of file Matter.h.

movie_frames_

std::vector<readcon::ConFrame> eonc::Matter::movie_frames_

private

Definition at line 375 of file Matter.h.

nAtoms

long eonc::Matter::nAtoms

private

Definition at line 361 of file Matter.h.

parameters

const Parameters* eonc::Matter::parameters

private

Definition at line 360 of file Matter.h.

pbcConvention

PbcConvention eonc::Matter::pbcConvention

private

Definition at line 342 of file Matter.h.

potential

std::shared_ptr<Potential> eonc::Matter::potential

private

Definition at line 337 of file Matter.h.

potentialEnergy

double eonc::Matter::potentialEnergy

mutableprivate

Definition at line 376 of file Matter.h.

recomputeFreeMask

bool eonc::Matter::recomputeFreeMask {true}

mutableprivate

Definition at line 372 of file Matter.h.

{true};

recomputeMaskedForces

bool eonc::Matter::recomputeMaskedForces {true}

mutableprivate

Definition at line 373 of file Matter.h.

{true};

recomputePotential

bool eonc::Matter::recomputePotential

mutableprivate

Definition at line 343 of file Matter.h.

removeNetForce

bool eonc::Matter::removeNetForce {true}

private

Definition at line 357 of file Matter.h.

{true};

structComp

StructureComparisonOptions eonc::Matter::structComp

private

Definition at line 358 of file Matter.h.

usePeriodicBoundaries

bool eonc::Matter::usePeriodicBoundaries

private

Definition at line 338 of file Matter.h.

---

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

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