Potential Class Reference

#include <Potential.h>

Inheritance diagram for Potential:

Public Member Functions
	Potential (PotType a_ptype)
	Potential (PotType a_ptype, const Parameters &)
	Potential (const Parameters &a_params)
virtual	~Potential ()
virtual void	force (long nAtoms, const double *positions, const int *atomicNrs, double *forces, double *energy, double *variance, const double *box)=0
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	isThreadSafe () const noexcept
	Whether this potential's force() can be called from multiple threads on the SAME instance.
virtual bool	isSharedInstanceThreadSafe () const noexcept
	Conservative gate for sharing one Potential instance across threads.
virtual bool	needsPerImageInstance () const noexcept
	Whether NEB should create separate Potential instances per image for true parallel force evaluation.
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.

Public Attributes
std::atomic< size_t >	forceCallCounter

Protected Attributes
PotType	ptype

Private Attributes
uint64_t	m_registry_id
PotRegistry::TimePoint	m_created_at

Detailed Description

Definition at line 23 of file Potential.h.

Constructor & Destructor Documentation

Potential() [1/3]

eonc::Potential::Potential ( PotType a_ptype )

inlineexplicit

Definition at line 35 of file Potential.h.

      : ptype{a_ptype},
        m_registry_id{PotRegistry::get().on_created(a_ptype)},
        m_created_at{PotRegistry::Clock::now()},
        forceCallCounter{0} {}

Potential() [2/3]

eonc::Potential::Potential ( PotType a_ptype, const Parameters &  )

inline

Definition at line 42 of file Potential.h.

      : Potential(a_ptype) {}

Potential() [3/3]

eonc::Potential::Potential ( const Parameters & a_params )

inline

Definition at line 45 of file Potential.h.

      : Potential(a_params.potential_options.potential) {}

~Potential()

virtual eonc::Potential::~Potential ( )

inlinevirtual

Definition at line 48 of file Potential.h.

                       {
    PotRegistry::get().on_destroyed(m_registry_id, ptype, forceCallCounter,
                                    m_created_at);
  }

Member Function Documentation

force()

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

pure virtual

forceBatch()

virtual void eonc::Potential::forceBatch ( long nSystems, long nAtoms, const double *const * positions, const int *const * atomicNrs, double *const * forces, double * energies, double * variances, const double *const * boxes )

inlinevirtual

Evaluate forces for N systems in a single call.

Default: loops over force(). Override in potentials that support native batching (e.g. MetatomicPotential uses a single model.forward() for all N systems).

Definition at line 108 of file Potential.h.

                                                      {
    for (long i = 0; i < nSystems; i++) {
      double var = 0;
      force(nAtoms, positions[i], atomicNrs[i], forces[i], &energies[i], &var,
            boxes[i]);
      if (variances)
        variances[i] = var;
      forceCallCounter++;
      PotRegistry::get().on_force_call(ptype);
    }
  }

get_ef()

std::tuple< double, AtomMatrix > Potential::get_ef	(	const AtomMatrix &	pos,
		const VectorXi &	atmnrs,
		const Matrix3d &	box )

Definition at line 102 of file Potential.cpp.

                                                                      {
  double energy{std::numeric_limits<double>::infinity()};
  long nAtoms = static_cast<long>(pos.rows());
  AtomMatrix forces{MatrixXd::Zero(nAtoms, 3)};
  double var{0}; // no variance for true potentials
  this->force(nAtoms, pos.data(), atmnrs.data(), forces.data(), &energy, &var,
              box.data());
  forceCallCounter++;
  PotRegistry::get().on_force_call(ptype);
 
  return std::make_tuple(energy, forces);
}

getType()

PotType eonc::Potential::getType ( ) const

inlinenodiscard

Definition at line 62 of file Potential.h.

{ return this->ptype; }

isSharedInstanceThreadSafe()

virtual bool eonc::Potential::isSharedInstanceThreadSafe ( ) const

inlinenodiscardvirtualnoexcept

Conservative gate for sharing one Potential instance across threads.

Defaults to isThreadSafe(); backends whose state lives outside the wrapper instance (global/common-block Fortran entry points) override this to false on their own classes.

Definition at line 85 of file Potential.h.

                                                                         {
    return isThreadSafe();
  }

isSurrogate()

virtual bool eonc::Potential::isSurrogate ( ) const

inlinenodiscardvirtualnoexcept

Whether this is a surrogate (GP) potential.

Override in SurrogatePotential.

Definition at line 66 of file Potential.h.

{ return false; }

isThreadSafe()

virtual bool eonc::Potential::isThreadSafe ( ) const

inlinenodiscardvirtualnoexcept

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.

Definition at line 79 of file Potential.h.

{ return true; }

needsPerImageInstance()

virtual bool eonc::Potential::needsPerImageInstance ( ) const

inlinenodiscardvirtualnoexcept

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).

Definition at line 94 of file Potential.h.

                                                                    {
    return false;
  }

requiresIsolatedMoleculeLayout()

virtual bool eonc::Potential::requiresIsolatedMoleculeLayout ( ) const

inlinenodiscardvirtualnoexcept

True for molecular QM / non-PBC backends (NWChem socket, ASE ORCA/NWChem, …).

Callers must not apply periodic wraps that can tear molecules (#188).

Definition at line 70 of file Potential.h.

                                                                             {
    return false;
  }

supportsBatchEvaluation()

virtual bool eonc::Potential::supportsBatchEvaluation ( ) const

inlinenodiscardvirtualnoexcept

Whether this potential supports batched evaluation of N systems in a single call.

When true, callers (NEB, Dimer) should use forceBatch() instead of N individual force() calls for better GPU utilization.

Definition at line 101 of file Potential.h.

                                                                      {
    return false;
  }

Member Data Documentation

forceCallCounter

std::atomic<size_t> eonc::Potential::forceCallCounter

Definition at line 32 of file Potential.h.

m_created_at

PotRegistry::TimePoint eonc::Potential::m_created_at

private

Definition at line 29 of file Potential.h.

m_registry_id

uint64_t eonc::Potential::m_registry_id

private

Definition at line 28 of file Potential.h.

ptype

PotType eonc::Potential::ptype

protected

Definition at line 25 of file Potential.h.

---

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

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