eonc::MetatomicDynPot Class Reference

#include <MetatomicDynPot.h>

Inheritance diagram for eonc::MetatomicDynPot:

Public Member Functions
	MetatomicDynPot (const Parameters &params)
	~MetatomicDynPot () override
void	force (long nAtoms, const double *positions, const int *atomicNrs, double *forces, double *energy, double *variance, const double *box) override
bool	isThreadSafe () const noexcept override
	Whether this potential's force() can be called from multiple threads on the SAME instance.
bool	needsPerImageInstance () const noexcept override
	Whether NEB should create separate Potential instances per image for true parallel force evaluation.
Public Member Functions inherited from eonc::Potential
	Potential (PotType a_ptype)
	Potential (PotType a_ptype, const Parameters &)
	Potential (const Parameters &a_params)
virtual	~Potential ()
std::tuple< double, AtomMatrix >	get_ef (const AtomMatrix &pos, const VectorXi &atmnrs, const Matrix3d &box)
PotType	getType () const
virtual bool	isSurrogate () const noexcept
	Whether this is a surrogate (GP) potential.
virtual bool	requiresIsolatedMoleculeLayout () const noexcept
	True for molecular QM / non-PBC backends (NWChem socket, ASE ORCA/NWChem, …).
virtual bool	isSharedInstanceThreadSafe () const noexcept
	Conservative gate for sharing one Potential instance across threads.
virtual bool	supportsBatchEvaluation () const noexcept
	Whether this potential supports batched evaluation of N systems in a single call.
virtual void	forceBatch (long nSystems, long nAtoms, const double *const *positions, const int *const *atomicNrs, double *const *forces, double *energies, double *variances, const double *const *boxes)
	Evaluate forces for N systems in a single call.

Private Attributes
EonMtaPot *	m_handle {nullptr}

Additional Inherited Members
Public Attributes inherited from eonc::Potential
std::atomic< size_t >	forceCallCounter
Protected Attributes inherited from eonc::Potential
PotType	ptype

Detailed Description

Definition at line 16 of file MetatomicDynPot.h.

Constructor & Destructor Documentation

MetatomicDynPot()

eonc::MetatomicDynPot::MetatomicDynPot ( const Parameters & params )

explicit

Definition at line 39 of file MetatomicDynPot.cpp.

    : Potential(PotType::METATOMIC) {
  auto &loader = MetatomicLoader::instance();
  loader.require_loaded();
  std::array<char, 1024> err{};
  auto cfg = config_from_params(params);
  m_handle = loader.create(&cfg, err.data(), err.size());
  if (!m_handle) {
    throw std::runtime_error(std::string("MetatomicDynPot: create failed: ") +
                             err.data());
  }
}

~MetatomicDynPot()

eonc::MetatomicDynPot::~MetatomicDynPot ( )

override

Definition at line 52 of file MetatomicDynPot.cpp.

                                  {
  if (m_handle) {
    MetatomicLoader::instance().destroy(m_handle);
    m_handle = nullptr;
  }
}

Member Function Documentation

force()

void eonc::MetatomicDynPot::force ( long nAtoms, const double * positions, const int * atomicNrs, double * forces, double * energy, double * variance, const double * box )

overridevirtual

Implements eonc::Potential.

Definition at line 59 of file MetatomicDynPot.cpp.

                                               {
  auto &loader = MetatomicLoader::instance();
  const int rc = loader.force(m_handle, nAtoms, positions, atomicNrs, forces,
                              energy, variance, box);
  if (rc != 0) {
    throw std::runtime_error("MetatomicDynPot: eon_mta_pot_force failed rc=" +
                             std::to_string(rc));
  }
}

isThreadSafe()

bool eonc::MetatomicDynPot::isThreadSafe ( ) const

inlinenodiscardoverridevirtualnoexcept

Whether this potential's force() can be called from multiple threads on the SAME instance.

Python-based potentials return false. Potentials with internal mutex (MetatomicPotential) return true but serialize internally – use needsPerImageInstance() to check if separate instances would enable true parallelism.

Reimplemented from eonc::Potential.

Definition at line 25 of file MetatomicDynPot.h.

{ return false; }

needsPerImageInstance()

bool eonc::MetatomicDynPot::needsPerImageInstance ( ) const

inlinenodiscardoverridevirtualnoexcept

Whether NEB should create separate Potential instances per image for true parallel force evaluation.

When true, NEB calls makePotential() once per image instead of sharing one instance. Override in potentials that use internal mutexes (e.g. MetatomicPotential).

Reimplemented from eonc::Potential.

Definition at line 26 of file MetatomicDynPot.h.

                                                                     {
    return false;
  }

Member Data Documentation

m_handle

EonMtaPot* eonc::MetatomicDynPot::m_handle {nullptr}

private

Definition at line 31 of file MetatomicDynPot.h.

{nullptr};

---

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

• /home/runner/work/eOn/eOn/include/eon/potentials/Metatomic/MetatomicDynPot.h
• /home/runner/work/eOn/eOn/client/potentials/Metatomic/MetatomicDynPot.cpp