ASE Class Reference

#include <ASE.h>

Inheritance diagram for ASE:

Public Member Functions
	ASE (const eonc::Parameters &a_params)
virtual	~ASE ()
void	force (long nAtoms, const double *R, const int *atomicNrs, double *F, double *U, 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
	ASE calculators are independent objects.
bool	supportsBatchEvaluation () const noexcept override
	Whether this potential supports batched evaluation of N systems in a single call.
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
	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 unsigned	layoutFlags () const noexcept
virtual bool	isSharedInstanceThreadSafe () const noexcept
	Conservative gate for sharing one Potential instance across threads.
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.

Private Attributes
size_t	counter {0}
py::module_	py_module
py::object	calculator
py::object	_calculate
py::object	batch_calculate_
bool	has_batch_ {false}

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 19 of file ASE.h.

Constructor & Destructor Documentation

ASE()

ASE::ASE

(

const eonc::Parameters &

a_params

)

Definition at line 30 of file ASE.cpp.

    : eonc::Potential(eonc::PotType::ASE_POT, a_params) {
  eonc::ensure_interpreter();
  counter = 1;
  std::string py_file = a_params.potential_options().extPotPath;
 
  // import
  try {
    // must briefly disable FPE because Python packages like Numpy causes it
    // during import
    eonc::FPEHandler fpeh;
    fpeh.eat_fpe();
 
    // Create a Python script to use importlib.util to load the module
    py::exec(R"(
            import sys
            import importlib.util
 
            def load_module_from_path(module_name, file_path):
                spec = importlib.util.spec_from_file_location(module_name, file_path)
                module = importlib.util.module_from_spec(spec)
                sys.modules[module_name] = module
                spec.loader.exec_module(module)
                return module
        )");
 
    // Prepare the module name and file path
    std::string module_name = "ase_eon";
    py::object load_module = py::globals()["load_module_from_path"];
    py_module = load_module(module_name, py_file);
 
    fpeh.restore_fpe();
 
    calculator = py_module.attr("ase_calc")();
    _calculate = py_module.attr("_calculate");
    has_batch_ = py::hasattr(py_module, "batch_calculate");
    if (has_batch_) {
      batch_calculate_ = py_module.attr("batch_calculate");

~ASE()

virtual ASE::~ASE ( )

inlinevirtual

Definition at line 32 of file ASE.h.

                 {
    QUILL_LOG_INFO(eonc::log::get(), "[ASE] called potential {} times",
                   counter);
  }

Member Function Documentation

force()

void ASE::force ( long nAtoms, const double * R, const int * atomicNrs, double * F, double * U, double * variance, const double * box )

overridevirtual

Implements eonc::Potential.

Definition at line 69 of file ASE.cpp.

                                  {
    EONC_LOG_ERROR("ASE calculator import failed for {}: {}", py_file,
                   e.what());
    throw std::runtime_error(std::string("ASE calculator import failed: ") +
                             e.what());
  }
  return;
}
 
void ASE::force(long nAtoms, const double *R, const int *atomicNrs, double *F,
                double *U, double *variance, const double *box) {
  if (variance != nullptr) {
    *variance = 0.0;
  }
  py::gil_scoped_acquire gil;
  try {
    const Eigen::Map<const AtomMatrix> positions(R, nAtoms, 3);
    const Eigen::Map<const RotationMatrix> boxx(box);
    const Eigen::Map<const Eigen::VectorXi> atmnmrs(atomicNrs, nAtoms);
 
    std::tuple<double, py::array_t<double>> py_result =
        _calculate(positions, atmnmrs, boxx, calculator)
            .cast<std::tuple<double, py::array_t<double>>>();
 
    *U = std::get<0>(py_result);
    py::array_t<double> forces = std::get<1>(py_result);
    auto buffer = forces.request();
    if (buffer.size < nAtoms * 3) {
      throw std::runtime_error(
          "ASE _calculate returned forces of the wrong size");
    }
    Eigen::Map<AtomMatrix>(F, nAtoms, 3) = Eigen::Map<const AtomMatrix>(
        static_cast<const double *>(buffer.ptr), nAtoms, 3);
 
  } catch (py::error_already_set &e) {
    EONC_LOG_ERROR("ASE calculator Python error: {}", e.what());
    throw std::runtime_error(std::string("ASE calculator Python error: ") +

forceBatch()

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

overridevirtual

Reimplemented from eonc::Potential.

Definition at line 108 of file ASE.cpp.

                                  {
    EONC_LOG_ERROR("ASE calculator C++ exception: {}", e.what());
    throw std::runtime_error(std::string("ASE calculator C++ exception: ") +
                             e.what());
  }
 
  counter++;
  return;
}
 
void ASE::forceBatch(long nSystems, long nAtoms, const double *const *positions,
                     const int *const *atomicNrs, double *const *forces,
                     double *energies, double *variances,
                     const double *const *boxes) {
  if (!has_batch_) {
    eonc::Potential::forceBatch(nSystems, nAtoms, positions, atomicNrs, forces,
                                energies, variances, boxes);
    return;
  }
  py::gil_scoped_acquire gil;
  try {
    const auto ns = static_cast<size_t>(nSystems);
    const auto na = static_cast<size_t>(nAtoms);
    std::vector<double> R_data(ns * na * 3);
    std::vector<int> Z_data(ns * na);
    std::vector<double> box_data(ns * 9);
    for (long s = 0; s < nSystems; ++s) {
      std::copy(positions[s], positions[s] + static_cast<long>(na) * 3,
                R_data.data() + static_cast<size_t>(s) * na * 3);
      std::copy(atomicNrs[s], atomicNrs[s] + nAtoms,
                Z_data.data() + static_cast<size_t>(s) * na);
      std::copy(boxes[s], boxes[s] + 9,
                box_data.data() + static_cast<size_t>(s) * 9);
    }
    py::array_t<double> R_np({ns, na, size_t{3}}, R_data.data());
    py::array_t<int> Z_np({ns, na}, Z_data.data());
    py::array_t<double> box_np({ns, size_t{3}, size_t{3}}, box_data.data());
    auto py_result =
        batch_calculate_(R_np, Z_np, box_np, calculator)
            .cast<std::tuple<py::array_t<double>, py::array_t<double>>>();
    py::array_t<double> E = std::get<0>(py_result);
    py::array_t<double> F = std::get<1>(py_result);
    auto bufE = E.request();
    auto bufF = F.request();
    if (bufE.size < nSystems || bufF.size < nSystems * nAtoms * 3) {
      throw std::runtime_error(
          "ASE batch_calculate returned energies/forces of the wrong size");
    }
    auto *ePtr = static_cast<double *>(bufE.ptr);
    auto *fPtr = static_cast<double *>(bufF.ptr);
    std::copy(ePtr, ePtr + nSystems, energies);
    for (long s = 0; s < nSystems; ++s) {
      std::copy(fPtr + s * nAtoms * 3, fPtr + (s + 1) * nAtoms * 3, forces[s]);
      if (variances) {
        variances[s] = 0.0;
      }
    }
  } catch (py::error_already_set &e) {

isThreadSafe()

bool ASE::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 39 of file ASE.h.

{ return false; }

needsPerImageInstance()

bool ASE::needsPerImageInstance ( ) const

inlinenodiscardoverridevirtualnoexcept

ASE calculators are independent objects.

Most production calculators (VASP, Gaussian, ORCA, etc.) spawn subprocesses that release the GIL.

Reimplemented from eonc::Potential.

Definition at line 42 of file ASE.h.

                                                                     {
    return true;
  }

supportsBatchEvaluation()

bool ASE::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 45 of file ASE.h.

                                                                       {
    return has_batch_;
  }

Member Data Documentation

_calculate

py::object ASE::_calculate

private

Definition at line 25 of file ASE.h.

batch_calculate_

py::object ASE::batch_calculate_

private

Definition at line 27 of file ASE.h.

calculator

py::object ASE::calculator

private

Definition at line 24 of file ASE.h.

counter

size_t ASE::counter {0}

private

Definition at line 22 of file ASE.h.

{0};

has_batch_

bool ASE::has_batch_ {false}

private

Definition at line 28 of file ASE.h.

{false};

py_module

py::module_ ASE::py_module

private

Definition at line 23 of file ASE.h.

---

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

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