eonc::HostSurfacePotential Class Reference

#include <HostSurfacePotential.h>

Inheritance diagram for eonc::HostSurfacePotential:

Public Member Functions
	HostSurfacePotential (eon_relax_surface_fn fn, void *user, std::uint64_t epoch)
bool	supportsBatchEvaluation () const noexcept override
	Whether this potential supports batched evaluation of N systems in a single call.
unsigned long long	surfaceEpoch () const noexcept override
	Host-visible surface generation.
int	lastStatus () const noexcept
void	setEpoch (std::uint64_t epoch)
void	bindPath (const std::vector< std::shared_ptr< Matter > > &path)
void	bindBand (const std::vector< std::shared_ptr< Matter > > &path) override
	NEB calls this with the finished band before the first force evaluation, so a host surface can name each image.
bool	forwardsStoredCell () const noexcept override
	A host that owns the cell reads the stored matrix.
void	force (long nAtoms, const double *positions, const int *atomicNrs, double *forces, double *energy, double *variance, const double *box) override
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) override
Public Member Functions inherited from eonc::Potential
void	recordForceCall () noexcept
	Charge one evaluated geometry to this potential and its owning registry.
IPotRegistry &	registry () const noexcept
	The registry this potential charges its force calls to.
	Potential (PotType a_ptype)
	Production default: construction-scope registry, else PotRegistry::get().
	Potential (PotType a_ptype, IPotRegistry &registry)
	Test seam: injected registry, no process-default get() counters.
	Potential (PotType a_ptype, const Parameters &p)
	Potential (const Parameters &a_params)
virtual	~Potential ()
void	force (std::span< const double > positions, std::span< const int > atomicNrs, std::span< double > forces, double *energy, double *variance, std::span< const double > box)
	C++ call site: size-checked view over the raw FFI force().
virtual void	setFixedMask (long nAtoms, const double *isFixed)
	Optional frozen-atom mask (nAtoms*3, 1.0 = fixed).
std::tuple< double, AtomMatrix >	get_ef (const AtomMatrix &pos, const VectorXi &atmnrs, const Matrix3d &box)
PotType	getType () const
virtual double	finiteCutoff () const noexcept
	Finite interaction range in position length units.
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 unsigned	layoutFlags () const noexcept
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 std::shared_ptr< Potential >	clonePotential () const
	Independent instance that does not reload from disk.
virtual bool	computesStress () const noexcept
	True when force() leaves a Cauchy stress that cauchyStress() can read until the next force() on this instance.
virtual Matrix3d	cauchyStress () const
	Cauchy stress in eV/Angstrom^3.
virtual void	forceBatchOwned (long nSystems, long nAtoms, const double *const *positions, const int *const *atomicNrs, double *const *forces, double *energies, double *variances, const double *const *boxes, const long *owners)
	Evaluate forces for N systems in a single call.
virtual double	hessianRange () const noexcept
	Distance beyond which every Hessian block between two atoms is exactly zero, in position length units.

Private Attributes
eon_relax_surface_fn	fn_
void *	user_
std::uint64_t	epoch_ {0}
int	last_ {0}
bool	count_calls_ {true}
std::vector< std::shared_ptr< Matter > >	path_

Additional Inherited Members
Public Types inherited from eonc::Potential
enum class	PotLayout : unsigned { InProcess = 1u << 0 , NeedsWorkingDirectory = 1u << 1 , Subprocess = 1u << 2 }
	How the pot is executed. Combine with bitwise or. More...
Public Attributes inherited from eonc::Potential
std::atomic< size_t >	forceCallCounter
Protected Attributes inherited from eonc::Potential
PotType	ptype

Detailed Description

Definition at line 35 of file HostSurfacePotential.h.

Constructor & Destructor Documentation

HostSurfacePotential()

eonc::HostSurfacePotential::HostSurfacePotential ( eon_relax_surface_fn fn, void * user, std::uint64_t epoch )

inline

Definition at line 37 of file HostSurfacePotential.h.

      : Potential(PotType::UNKNOWN),
        fn_{fn},
        user_{user},
        epoch_{epoch} {}

Member Function Documentation

bindBand()

void eonc::HostSurfacePotential::bindBand ( const std::vector< std::shared_ptr< Matter > > & path )

inlineoverridevirtual

NEB calls this with the finished band before the first force evaluation, so a host surface can name each image.

Reimplemented from eonc::Potential.

Definition at line 54 of file HostSurfacePotential.h.

                                                                       {
    bindPath(path);
  }

bindPath()

void eonc::HostSurfacePotential::bindPath ( const std::vector< std::shared_ptr< Matter > > & path )

inline

Definition at line 51 of file HostSurfacePotential.h.

                                                              {
    path_ = path;
  }

force()

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

inlineoverridevirtual

Implements eonc::Potential.

Definition at line 61 of file HostSurfacePotential.h.

                                         {
    const double *posv[] = {positions};
    const int *nrv[] = {atomicNrs};
    double *frcv[] = {forces};
    const double *boxv[] = {box};
    double e{0};
    double var{0};
    count_calls_ = false;
    forceBatch(1, nAtoms, posv, nrv, frcv, &e, &var, boxv);
    count_calls_ = true;
    if (energy) {
      *energy = e;
    }
    if (variance) {
      *variance = var;
    }
  }

forceBatch()

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

inlineoverridevirtual

Reimplemented from eonc::Potential.

Definition at line 81 of file HostSurfacePotential.h.

                                                       {
    if (!fn_) {
      throw std::runtime_error("HostSurfacePotential: NULL surface");
    }
    const long npos = 3 * nAtoms * nSystems;
    const long nbox = 9 * nSystems;
    std::vector<double> pos(static_cast<size_t>(npos), 0.0);
    std::vector<double> frc(static_cast<size_t>(npos), 0.0);
    std::vector<double> box(static_cast<size_t>(nbox), 0.0);
    std::vector<int32_t> z(static_cast<size_t>(nAtoms), 0);
    std::vector<int64_t> ids(static_cast<size_t>(nSystems), 0);
    if (atomicNrs && atomicNrs[0]) {
      for (long a = 0; a < nAtoms; ++a) {
        z[static_cast<size_t>(a)] = atomicNrs[0][a];
      }
    }
    for (long s = 0; s < nSystems; ++s) {
      int64_t id = EON_RELAX_IMAGE_NONE;
      if (positions && positions[s]) {
        for (size_t i = 0; i < path_.size(); ++i) {
          if (path_[i] && path_[i]->getPositions().data() == positions[s]) {
            id = static_cast<int64_t>(i);
            break;
          }
        }
      }
      ids[static_cast<size_t>(s)] = id;
      if (positions && positions[s]) {
        for (long k = 0; k < 3 * nAtoms; ++k) {
          pos[static_cast<size_t>(s * 3 * nAtoms + k)] = positions[s][k];
        }
      }
      if (boxes && boxes[s]) {
        for (long k = 0; k < 9; ++k) {
          box[static_cast<size_t>(s * 9 + k)] = boxes[s][k];
        }
      }
    }
    std::vector<double> ebuf(static_cast<size_t>(nSystems), 0.0);
    std::vector<double> vbuf(static_cast<size_t>(nSystems), 0.0);
    std::uint64_t new_epoch = epoch_;
    eon_relax_surface_request_t req{};
    req.version.major = EON_RELAX_ABI_MAJOR;
    req.version.minor = EON_RELAX_ABI_MINOR;
    req.n_images = static_cast<int64_t>(nSystems);
    req.n_atoms = static_cast<int64_t>(nAtoms);
    req.positions = pos.data();
    req.atomic_nrs = z.data();
    req.boxes = box.data();
    req.image_ids = ids.data();
    req.energies = ebuf.data();
    req.forces = frc.data();
    req.variances = vbuf.data();
    req.epoch_out = &new_epoch;
    last_ = fn_(user_, &req);
    if (last_ < 0) {
      throw std::runtime_error("HostSurfacePotential: surface failed");
    }
    if (last_ > 0) {
      throw SurfaceRecoverable(last_);
    }
    if (new_epoch != epoch_) {
      epoch_ = new_epoch;
    }
    if (count_calls_) {
      for (long s = 0; s < nSystems; ++s) {
        recordForceCall();
      }
    }
    for (long s = 0; s < nSystems; ++s) {
      if (energies) {
        energies[s] = ebuf[static_cast<size_t>(s)];
      }
      if (variances) {
        variances[s] = vbuf[static_cast<size_t>(s)];
      }
      if (forces && forces[s]) {
        for (long k = 0; k < 3 * nAtoms; ++k) {
          forces[s][k] = frc[static_cast<size_t>(s * 3 * nAtoms + k)];
        }
      }
    }
  }

forwardsStoredCell()

bool eonc::HostSurfacePotential::forwardsStoredCell ( ) const

inlinenodiscardoverridevirtualnoexcept

A host that owns the cell reads the stored matrix.

Pots that infer periodic boundaries from a non-zero box keep seeing a zero box when the image is not periodic.

Reimplemented from eonc::Potential.

Definition at line 57 of file HostSurfacePotential.h.

                                                                  {
    return true;
  }

lastStatus()

int eonc::HostSurfacePotential::lastStatus ( ) const

inlinenodiscardnoexcept

Definition at line 49 of file HostSurfacePotential.h.

{ return last_; }

setEpoch()

void eonc::HostSurfacePotential::setEpoch ( std::uint64_t epoch )

inline

Definition at line 50 of file HostSurfacePotential.h.

{ epoch_ = epoch; }

supportsBatchEvaluation()

bool eonc::HostSurfacePotential::supportsBatchEvaluation ( ) const

inlinenodiscardoverridevirtualnoexcept

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.

Reimplemented from eonc::Potential.

Definition at line 43 of file HostSurfacePotential.h.

                                                                       {
    return true;
  }

surfaceEpoch()

unsigned long long eonc::HostSurfacePotential::surfaceEpoch ( ) const

inlinenodiscardoverridevirtualnoexcept

Host-visible surface generation.

A learning host increments this on every refit; Matter keys its energy and variance caches on the value so identical positions after a refit cannot return a stale energy or variance. Static pots stay 0.

Reimplemented from eonc::Potential.

Definition at line 46 of file HostSurfacePotential.h.

                                                                          {
    return epoch_;
  }

Member Data Documentation

count_calls_

bool eonc::HostSurfacePotential::count_calls_ {true}

private

Definition at line 173 of file HostSurfacePotential.h.

{true};

epoch_

std::uint64_t eonc::HostSurfacePotential::epoch_ {0}

private

Definition at line 171 of file HostSurfacePotential.h.

{0};

fn_

eon_relax_surface_fn eonc::HostSurfacePotential::fn_

private

Definition at line 169 of file HostSurfacePotential.h.

last_

int eonc::HostSurfacePotential::last_ {0}

private

Definition at line 172 of file HostSurfacePotential.h.

{0};

path_

std::vector<std::shared_ptr<Matter> > eonc::HostSurfacePotential::path_

private

Definition at line 174 of file HostSurfacePotential.h.

user_

void* eonc::HostSurfacePotential::user_

private

Definition at line 170 of file HostSurfacePotential.h.

---

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

• /home/runner/work/eOn/eOn/client/relax/HostSurfacePotential.h