Matter Class Reference

#include <Matter.h>

Classes
struct	Impl

Public Member Functions
	~Matter ()
	Matter (std::shared_ptr< Potential > pot, const Parameters &params)
	Matter (std::unique_ptr< Potential > pot, const Parameters &params)
	Exclusive handoff.
	Matter (const Matter &matter)
	Matter (Matter &&other) noexcept
	Move: transfers retained movie ConFrames (move-only).
bool	holdsExclusivePotential () const
	True while no copy has shared the Potential from an exclusive handoff.
const Matter &	operator= (const Matter &matter)
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 or surface epoch changed).
void	setSurfaceEpoch (unsigned long long epoch)
	Host surface generation.
unsigned long long	getSurfaceEpoch () const noexcept
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	distance (const Matter &matter, long index) const
double	pdistance (long index1, long index2, int axis) 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	inp2matter (const std::string &filename)
	Any structure file: .con/.convel via readcon, the rest via chemfiles.
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	setCancelToken (CancelToken token)
const CancelToken &	cancelToken () const
void	pollCancel (const char *site) const
void	applyPeriodicBoundaryIfEnabled ()
	Apply MIC wrap when periodic boundaries are enabled (I/O path).

Private Member Functions
Potential *	livePotential () const
void	shareOwnedPotential () const
void	assertIsolatedMoleculeLayoutSafe () const
	Throw if pot forbids PBC (isolated molecular QM backends, issue #188).
bool	epochDirty () const
void	stampSurfaceEpoch () const
void	computePotential () const
void	captureStress () 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::unique_ptr< Potential >	ownedPotential
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
unsigned long long	surfaceEpoch_ {0}
unsigned long long	cachedHostEpoch_ {0}
unsigned long long	cachedPotEpoch_ {0}
CancelToken	cancel_token_

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

Detailed Description

Definition at line 94 of file Matter.h.

Constructor & Destructor Documentation

~Matter()

eonc::Matter::~Matter ( )

default

Matter() [1/4]

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

Definition at line 76 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},
      surfaceEpoch_{0},
      cachedHostEpoch_{0},
      cachedPotEpoch_{0} {}

Matter() [2/4]

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

Exclusive handoff.

The Potential stays a unique_ptr until a copy shares that same instance. A copy does not clone it.

Definition at line 94 of file Matter.cpp.

    : Matter(std::shared_ptr<Potential>{}, params) {
  ownedPotential = std::move(pot);
  if (ownedPotential && ownedPotential->requiresIsolatedMoleculeLayout()) {
    usePeriodicBoundaries = false;
  }
}

Matter() [3/4]

eonc::Matter::Matter

(

const Matter &

matter

)

Definition at line 133 of file Matter.cpp.

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

Matter() [4/4]

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 196 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 758 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 349 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 661 of file Matter.cpp.

                                                    {
  if (!livePotential() || !livePotential()->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 467 of file Matter.cpp.

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

cancelToken()

const CancelToken & eonc::Matter::cancelToken ( ) const

inlinenodiscard

Definition at line 346 of file Matter.h.

{ return cancel_token_; }

captureStress()

void eonc::Matter::captureStress ( ) const

private

Definition at line 896 of file Matter.cpp.

                                 {
  impl_->haveStress = false;
  if (!livePotential()->computesStress()) {
    return;
  }
  // A potential instance holds the stress of its own last call. With
  // [Main] parallel on, a thread-safe shared instance can serve another
  // image between that call and this read, so it is not read here.
  const bool threads = parameters && parameters->main_options().parallel;
  if (threads && livePotential()->isSharedInstanceThreadSafe() &&
      !livePotential()->needsPerImageInstance()) {
    return;
  }
  try {
    impl_->stress = livePotential()->cauchyStress();
    impl_->haveStress = impl_->stress.allFinite();
  } catch (const std::logic_error &) {
    impl_->haveStress = false;
  }
}

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 917 of file Matter.cpp.

                              {
  if (!livePotential() || !livePotential()->computesStress()) {
    throw std::logic_error(
        "Matter::cauchyStress requires a potential that reports stress");
  }
  // The stress that came with the cached evaluation describes this image.
  if (!recomputePotential && impl_->haveStress) {
    return impl_->stress;
  }
  recomputePotential = true;
  computePotential();
  Matrix3d sigma = livePotential()->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 141 of file Matter.h.

{ movie_frames_.clear(); }

compare()

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

Definition at line 251 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 692 of file Matter.cpp.

                                    {
  cancel_token_.poll("force");
  if (recomputePotential || epochDirty()) {
    if (!livePotential()) {
      throw std::runtime_error(
          "Matter::computePotential called without a potential");
    }
    assertIsolatedMoleculeLayoutSafe();
    if (livePotential()->isSurrogate()) {
      // Surrogate potential case: uses free-atom subset interface
      auto surrogatePotential =
          static_cast<SurrogatePotential *>(livePotential());
      auto [freePE, freeForces, vari] = surrogatePotential->get_ef_var(
          this->getPositionsFree(), this->getAtomicNrsFree(), impl_->cell);
      this->potentialEnergy = freePE;
      this->energyVariance = vari;
      impl_->haveStress = false;
      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};
      livePotential()->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 || livePotential()->forwardsStoredCell())
              ? impl_->cell
              : Matrix3d::Zero();
      livePotential()->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));
      this->energyVariance = var;
      livePotential()->recordForceCall();
      captureStress();
    }
    if (!std::isfinite(potentialEnergy) || !impl_->forces.allFinite()) {
      throw std::runtime_error(
          "Potential returned non-finite energy or forces");
    }
    forceCalls = forceCalls + 1;
    recomputePotential = false;
    stampSurfaceEpoch();
 
    // 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) {
      const Vector3d tempForce = exactMeanForce(impl_->forces);
      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 283 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 279 of file Matter.h.

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

convel2matter()

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

inlinenodiscard

Definition at line 287 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 538 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 515 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 273 of file Matter.cpp.

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

epochDirty()

bool eonc::Matter::epochDirty ( ) const

nodiscardprivate

Definition at line 673 of file Matter.cpp.

                              {
  const unsigned long long pe =
      livePotential() ? livePotential()->surfaceEpoch() : 0ULL;
  return cachedHostEpoch_ != surfaceEpoch_ || cachedPotEpoch_ != pe;
}

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 954 of file Matter.cpp.

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

getAccelerations()

AtomMatrix eonc::Matter::getAccelerations

(

)

Definition at line 832 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 562 of file Matter.cpp.

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

getAtomicNrs()

VectorXi eonc::Matter::getAtomicNrs

(

)

const

Definition at line 783 of file Matter.cpp.

{ return this->impl_->atomicNrs; }

getAtomicNrsFree()

VectorXi eonc::Matter::getAtomicNrsFree

(

)

const

Definition at line 392 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 956 of file Matter.cpp.

                                                   {
  return impl_->atomIndex(atom);
}

getBiasForces()

AtomMatrix eonc::Matter::getBiasForces

(

)

Definition at line 452 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 465 of file Matter.cpp.

{ return biasPotential; }

getCell()

Matrix3d eonc::Matter::getCell

(

)

const

Definition at line 342 of file Matter.cpp.

{ return impl_->cell; }

getEnergyVariance()

double eonc::Matter::getEnergyVariance

(

)

const

Definition at line 889 of file Matter.cpp.

                                       {
  if (nAtoms > 0) {
    computePotential();
  }
  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 572 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 581 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 587 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 654 of file Matter.cpp.

{ return (forceCalls); }

getForces()

const AtomMatrix & eonc::Matter::getForces

(

)

const

Definition at line 479 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 499 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 509 of file Matter.cpp.

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

getForcesRaw()

const AtomMatrix & eonc::Matter::getForcesRaw

(

)

const

Definition at line 490 of file Matter.cpp.

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

getForcesV()

VectorXd eonc::Matter::getForcesV

(

)

const

Definition at line 495 of file Matter.cpp.

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

getFree()

AtomMatrix eonc::Matter::getFree

(

)

const

Definition at line 796 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 812 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 326 of file Matter.h.

                                                                   {
    return headerCon;
  }

getKineticEnergy()

double eonc::Matter::getKineticEnergy

(

)

const

Definition at line 629 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 545 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 843 of file Matter.cpp.

                                                        {
  return impl_->masses;
}

getMechanicalEnergy()

double eonc::Matter::getMechanicalEnergy

(

)

const

Definition at line 636 of file Matter.cpp.

                                         {
  return getPotentialEnergy() + getKineticEnergy();
}

getPbcConvention()

PbcConvention eonc::Matter::getPbcConvention ( ) const

inline

Definition at line 186 of file Matter.h.

{ return pbcConvention; }

getPeriodic()

bool eonc::Matter::getPeriodic ( ) const

inlinenodiscardnoexcept

Definition at line 336 of file Matter.h.

                                                  {
    return usePeriodicBoundaries;
  }

getPosition()

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

Definition at line 351 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 375 of file Matter.cpp.

{ return impl_->positions; }

getPositionsCopy()

AtomMatrix eonc::Matter::getPositionsCopy

(

)

const

Definition at line 377 of file Matter.cpp.

{ return impl_->positions; }

getPositionsFree()

AtomMatrix eonc::Matter::getPositionsFree

(

)

const

Definition at line 383 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 412 of file Matter.cpp.

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

getPositionsV()

VectorXd eonc::Matter::getPositionsV

(

)

const

Definition at line 379 of file Matter.cpp.

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

getPotential()

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

(

)

Definition at line 935 of file Matter.cpp.

                                              {
  shareOwnedPotential();
  return potential;
}

getPotentialCalls()

size_t eonc::Matter::getPotentialCalls

(

)

const

Definition at line 885 of file Matter.cpp.

                                       {
  return this->livePotential()->forceCallCounter;
}

getPotentialEnergy()

double eonc::Matter::getPotentialEnergy

(

)

const

Definition at line 621 of file Matter.cpp.

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

getSurfaceEpoch()

unsigned long long eonc::Matter::getSurfaceEpoch ( ) const

inlinenodiscardnoexcept

Definition at line 228 of file Matter.h.

                                                                    {
    return surfaceEpoch_;
  }

getVelocities()

AtomMatrix eonc::Matter::getVelocities

(

)

const

Definition at line 816 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 116 of file Matter.cpp.

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

holdsExclusivePotential()

bool eonc::Matter::holdsExclusivePotential ( ) const

nodiscard

True while no copy has shared the Potential from an exclusive handoff.

Definition at line 112 of file Matter.cpp.

                                           {
  return static_cast<bool>(ownedPotential);
}

inp2matter()

io::IoStatus eonc::Matter::inp2matter ( const std::string & filename )

inlinenodiscard

Any structure file: .con/.convel via readcon, the rest via chemfiles.

Definition at line 276 of file Matter.h.

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

livePotential()

Potential * eonc::Matter::livePotential ( ) const

private

Definition at line 102 of file Matter.cpp.

                                       {
  return ownedPotential ? ownedPotential.get() : potential.get();
}

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 316 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 291 of file Matter.h.

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

matter2convel()

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

inlinenodiscard

Definition at line 295 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 298 of file Matter.h.

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

maxForce()

double eonc::Matter::maxForce

(

void

)

const

Definition at line 777 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 769 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 138 of file Matter.h.

                                                                      {
    return movie_frames_;
  }

needsForceUpdate()

bool eonc::Matter::needsForceUpdate ( ) const

inlinenodiscard

Whether forces need recomputation (positions or surface epoch changed).

Definition at line 220 of file Matter.h.

                                              {
    return recomputePotential || epochDirty();
  }

numberOfAtoms()

long int eonc::Matter::numberOfAtoms

(

)

const

Definition at line 340 of file Matter.cpp.

{ return (nAtoms); }

numberOfFixedAtoms()

long int eonc::Matter::numberOfFixedAtoms

(

)

const

Definition at line 640 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 650 of file Matter.cpp.

                                         {
  return nAtoms - numberOfFixedAtoms();
}

operator=() [1/2]

const Matter & eonc::Matter::operator=

(

const Matter &

matter

)

Definition at line 138 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_->stress = matter.impl_->stress;
  impl_->haveStress = matter.impl_->haveStress;
  impl_->velocities = matter.impl_->velocities;
 
  removeNetForce = matter.removeNetForce;
  structComp = matter.structComp;
  parameters = matter.parameters;
 
  usePeriodicBoundaries = matter.usePeriodicBoundaries;
  pbcConvention = matter.pbcConvention;
 
  matter.shareOwnedPotential();
  ownedPotential.reset();
  potential = matter.potential;
  potentialEnergy = matter.potentialEnergy;
  energyVariance = matter.energyVariance;
  forceCalls = matter.forceCalls;
  recomputePotential = matter.recomputePotential;
  surfaceEpoch_ = matter.surfaceEpoch_;
  cachedHostEpoch_ = matter.cachedHostEpoch_;
  cachedPotEpoch_ = matter.cachedPotEpoch_;
  // 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;
  cancel_token_ = matter.cancel_token_;
  // 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 201 of file Matter.cpp.

                                               {
  if (this == &other) {
    return *this;
  }
  ownedPotential = std::move(other.ownedPotential);
  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);
  impl_->stress = other.impl_->stress;
  impl_->haveStress = other.impl_->haveStress;
  energyVariance = other.energyVariance;
  movie_frames_ = std::move(other.movie_frames_);
  potentialEnergy = other.potentialEnergy;
  cancel_token_ = std::move(other.cancel_token_);
  surfaceEpoch_ = other.surfaceEpoch_;
  cachedHostEpoch_ = other.cachedHostEpoch_;
  cachedPotEpoch_ = other.cachedPotEpoch_;
 
  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 940 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 947 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 524 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 281 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;
}

pollCancel()

void eonc::Matter::pollCancel ( const char * site ) const

inline

Definition at line 347 of file Matter.h.

{ cancel_token_.poll(site); }

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 401 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 656 of file Matter.cpp.

                             {
  forceCalls = 0;
  return;
}

resize()

void eonc::Matter::resize

(

long int

nAtoms

)

Definition at line 294 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 964 of file Matter.cpp.

                                              {
  impl_->forces = fileForces;
  impl_->haveStress = false;
  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 566 of file Matter.cpp.

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

setAtomicNrs()

void eonc::Matter::setAtomicNrs

(

const VectorXi &

atmnrs

)

Definition at line 785 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 960 of file Matter.cpp.

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

setBiasForces()

void eonc::Matter::setBiasForces

(

const AtomMatrix &

bf

)

Definition at line 473 of file Matter.cpp.

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

setBiasPotential()

void eonc::Matter::setBiasPotential

(

BondBoost *

bondBoost

)

Definition at line 461 of file Matter.cpp.

                                                  {
  biasPotential = bondBoost;
}

setCancelToken()

void eonc::Matter::setCancelToken ( CancelToken token )

inline

Definition at line 345 of file Matter.h.

{ cancel_token_ = std::move(token); }

setCell()

void eonc::Matter::setCell

(

const Matrix3d &

newCell

)

Definition at line 344 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 866 of file Matter.cpp.

                                                                {
  potentialEnergy = energy;
  energyVariance = variance;
  // A batch leaves at most the last system's stress on the potential.
  impl_->haveStress = false;
  recomputePotential = false;
  stampSurfaceEpoch();
  recomputeMaskedForces = true;
  forceCalls++;
 
  // Apply the same net force removal as computePotential()
  if (impl_->isFixed.maxCoeff() < 0.5 && removeNetForce && nAtoms > 1) {
    const Vector3d tempForce = exactMeanForce(impl_->forces);
    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 238 of file Matter.h.

                                                              {
    restoreFileForces(forces, true, energy);
  }

setFileToMatter()

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

inline

Definition at line 323 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 604 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 594 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 612 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 824 of file Matter.cpp.

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

setHeaderCon()

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

inline

Definition at line 329 of file Matter.h.

                                                           {
    headerCon = headers;
  }

setHeaderConLine()

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

inline

Definition at line 332 of file Matter.h.

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

setMass()

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

Definition at line 550 of file Matter.cpp.

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

setMasses()

void eonc::Matter::setMasses

(

const VectorXd &

massesIn

)

Definition at line 555 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 187 of file Matter.h.

                                                  {
    pbcConvention = convention;
  }

setPeriodic()

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

inline

Definition at line 339 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 357 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 417 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 434 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 448 of file Matter.cpp.

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

setPositionsV()

void eonc::Matter::setPositionsV

(

const VectorXd &

pos

)

Definition at line 430 of file Matter.cpp.

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

setPotential()

void eonc::Matter::setPotential

(

std::shared_ptr< Potential >

pot

)

Definition at line 847 of file Matter.cpp.

                                                      {
  ownedPotential.reset();
  this->potential = std::move(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 (livePotential() && livePotential()->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;
}

setSurfaceEpoch()

void eonc::Matter::setSurfaceEpoch

(

unsigned long long

epoch

)

Host surface generation.

A GP refit increments this; identical positions then miss the energy and variance caches. Combined with Potential::surfaceEpoch() as the other half of the cache key.

Definition at line 684 of file Matter.cpp.

                                                     {
  if (epoch != surfaceEpoch_) {
    surfaceEpoch_ = epoch;
    recomputePotential = true;
    recomputeMaskedForces = true;
  }
}

setVelocities()

void eonc::Matter::setVelocities

(

const AtomMatrix &

v

)

Definition at line 820 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 368 of file Matter.cpp.

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

shareOwnedPotential()

void eonc::Matter::shareOwnedPotential ( ) const

private

Definition at line 106 of file Matter.cpp.

                                       {
  if (ownedPotential) {
    potential = std::shared_ptr<Potential>(std::move(ownedPotential));
  }
}

stampSurfaceEpoch()

void eonc::Matter::stampSurfaceEpoch ( ) const

private

Definition at line 679 of file Matter.cpp.

                                     {
  cachedHostEpoch_ = surfaceEpoch_;
  cachedPotEpoch_ = livePotential() ? livePotential()->surfaceEpoch() : 0ULL;
}

takeMovieFrames()

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

inlinenodiscard

Take ownership of retained frames (leaves storage empty).

Definition at line 143 of file Matter.h.

                                                             {
    return std::move(movie_frames_);
  }

writeTibble()

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

inlinenodiscard

Definition at line 272 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 399 of file Matter.h.

{nullptr};

cachedHostEpoch_

unsigned long long eonc::Matter::cachedHostEpoch_ {0}

mutableprivate

Definition at line 411 of file Matter.h.

{0};

cachedPotEpoch_

unsigned long long eonc::Matter::cachedPotEpoch_ {0}

mutableprivate

Definition at line 412 of file Matter.h.

{0};

cancel_token_

CancelToken eonc::Matter::cancel_token_

private

Definition at line 413 of file Matter.h.

energyVariance

double eonc::Matter::energyVariance

mutableprivate

Definition at line 407 of file Matter.h.

fileToMatter

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

private

Definition at line 400 of file Matter.h.

forceCalls

long eonc::Matter::forceCalls

mutableprivate

Definition at line 376 of file Matter.h.

freeIndices

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

mutableprivate

Definition at line 404 of file Matter.h.

headerCon

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

private

Definition at line 379 of file Matter.h.

impl_

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

private

Definition at line 398 of file Matter.h.

m_log

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

private

Definition at line 362 of file Matter.h.

movie_frames_

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

private

Definition at line 408 of file Matter.h.

nAtoms

long eonc::Matter::nAtoms

private

Definition at line 394 of file Matter.h.

ownedPotential

std::unique_ptr<Potential> eonc::Matter::ownedPotential

mutableprivate

Definition at line 365 of file Matter.h.

parameters

const Parameters* eonc::Matter::parameters

private

Definition at line 393 of file Matter.h.

pbcConvention

PbcConvention eonc::Matter::pbcConvention

private

Definition at line 372 of file Matter.h.

potential

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

mutableprivate

Definition at line 367 of file Matter.h.

potentialEnergy

double eonc::Matter::potentialEnergy

mutableprivate

Definition at line 409 of file Matter.h.

recomputeFreeMask

bool eonc::Matter::recomputeFreeMask {true}

mutableprivate

Definition at line 405 of file Matter.h.

{true};

recomputeMaskedForces

bool eonc::Matter::recomputeMaskedForces {true}

mutableprivate

Definition at line 406 of file Matter.h.

{true};

recomputePotential

bool eonc::Matter::recomputePotential

mutableprivate

Definition at line 373 of file Matter.h.

removeNetForce

bool eonc::Matter::removeNetForce {true}

private

Definition at line 390 of file Matter.h.

{true};

structComp

StructureComparisonOptions eonc::Matter::structComp

private

Definition at line 391 of file Matter.h.

surfaceEpoch_

unsigned long long eonc::Matter::surfaceEpoch_ {0}

private

Definition at line 410 of file Matter.h.

{0};

usePeriodicBoundaries

bool eonc::Matter::usePeriodicBoundaries

private

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