ASEOrcaPot Class Reference

#include <ASE_ORCA.h>

Inheritance diagram for ASEOrcaPot:

Public Member Functions
	ASEOrcaPot (const Parameters &a_params)
virtual	~ASEOrcaPot ()
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	requiresIsolatedMoleculeLayout () const noexcept override
	ORCA does not support PBC; non-centered PBC wraps tear molecules (#188).
bool	needsPerImageInstance () const noexcept override
	ORCA runs as external subprocess; separate instances are independent.
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	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
py::object	calc
py::object	ase
std::filesystem::path	workDir
size_t	counter {0}

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 26 of file ASE_ORCA.h.

Constructor & Destructor Documentation

ASEOrcaPot()

ASEOrcaPot::ASEOrcaPot

(

const Parameters &

a_params

)

Definition at line 61 of file ASE_ORCA.cpp.

    : Potential(PotType::ASE_ORCA, a_params) {
  eonc::ensure_interpreter();
  counter = 0;
  py::module_ sys = py::module_::import("sys");
  // Fix for gh-184, see
  // https://github.com/numpy/numpy/issues/20504#issuecomment-985542508
  eonc::FPEHandler fpeh;
  fpeh.eat_fpe();
  ase = py::module_::import("ase");
  fpeh.restore_fpe();
  py::module_ ase_orca = py::module_::import("ase.calculators.orca");
  py::module_ psutil = py::module_::import("psutil");
  std::string orcpth = eonc::helpers::get_value_from_env_or_param(
      "ORCA_COMMAND", a_params.ase_orca_options.path, "", "", true);
  std::string orca_simpleinput = eonc::helpers::get_value_from_env_or_param(
      "ORCA_SIMPLEINPUT", a_params.ase_orca_options.simpleinput, "ENGRAD HF-3c",
      "Using ENGRAD HF-3c as a default input, set simpleinput or the "
      "environment variable ORCA_SIMPLEINPUT.\n");
 
  // Set up ORCA profile and calculator
  py::object OrcaProfile = ase_orca.attr("OrcaProfile");
  py::object ORCA = ase_orca.attr("ORCA");
  size_t nproc{0};
 
  if (a_params.ase_orca_options.nproc == "auto") {
    nproc = py::cast<int>(psutil.attr("cpu_count")(false));
  } else {
    nproc = std::stoi(a_params.ase_orca_options.nproc);
  }
 
  // One directory per calculator instance so two LocalInProcess jobs in
  // the same cwd do not share ORCA scratch and output files.
  workDir = makeAseWorkDir("eon_ase_orca");
 
  try {
    this->calc =
        ORCA("profile"_a = OrcaProfile(py::str(orcpth)),
             "orcasimpleinput"_a = orca_simpleinput,
             "orcablocks"_a = py::str(std::format("%pal nprocs {} end", nproc)),
             "directory"_a = workDir.string());
  } catch (...) {
    std::error_code ec;
    std::filesystem::remove_all(workDir, ec);
    workDir.clear();
    throw;
  }
};

~ASEOrcaPot()

ASEOrcaPot::~ASEOrcaPot ( )

virtual

Definition at line 110 of file ASE_ORCA.cpp.

                        {
  QUILL_LOG_INFO(eonc::log::get(), "[ASEOrca] called potential {} times",
                 counter);
  if (!workDir.empty()) {
    std::error_code ec;
    std::filesystem::remove_all(workDir, ec);
  }
}

Member Function Documentation

force()

void ASEOrcaPot::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 119 of file ASE_ORCA.cpp.

                                          {
  variance = nullptr;
  try {
    AtomMatrix positions = AtomMatrix::Map(const_cast<double *>(R), nAtoms, 3);
    RotationMatrix boxx = RotationMatrix::Map(const_cast<double *>(box), 3, 3);
    Eigen::VectorXi atmnmrs =
        Eigen::Map<Eigen::VectorXi>(const_cast<int *>(atomicNrs), nAtoms);
    py::object atoms = this->ase.attr("Atoms")(
        "symbols"_a = atmnmrs, "positions"_a = positions, "cell"_a = boxx);
    atoms.attr("set_calculator")(this->calc);
    atoms.attr("set_pbc")(std::tuple<bool, bool, bool>(true, true, true));
    double py_e = py::cast<double>(atoms.attr("get_potential_energy")());
    Eigen::MatrixXd py_force =
        py::cast<Eigen::MatrixXd>(atoms.attr("get_forces")());
 
    // Populate the output parameters
    *U = py_e;
    for (long i = 0; i < nAtoms; ++i) {
      F[3 * i] = py_force(i, 0);
      F[3 * i + 1] = py_force(i, 1);
      F[3 * i + 2] = py_force(i, 2);
    }
  } catch (py::error_already_set &e) {
    throw std::runtime_error(std::string("ASE-ORCA Python error: ") + e.what());
  } catch (const std::exception &e) {
    throw std::runtime_error(std::string("ASE-ORCA C++ exception: ") +
                             e.what());
  }
 
  counter++;
  return;
}

isThreadSafe()

bool ASEOrcaPot::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 41 of file ASE_ORCA.h.

{ return false; }

needsPerImageInstance()

bool ASEOrcaPot::needsPerImageInstance ( ) const

inlinenodiscardoverridevirtualnoexcept

ORCA runs as external subprocess; separate instances are independent.

Reimplemented from eonc::Potential.

Definition at line 47 of file ASE_ORCA.h.

                                                                     {
    return true;
  }

requiresIsolatedMoleculeLayout()

bool ASEOrcaPot::requiresIsolatedMoleculeLayout ( ) const

inlinenodiscardoverridevirtualnoexcept

ORCA does not support PBC; non-centered PBC wraps tear molecules (#188).

Reimplemented from eonc::Potential.

Definition at line 43 of file ASE_ORCA.h.

                                                                              {
    return true;
  }

Member Data Documentation

ase

py::object ASEOrcaPot::ase

private

Definition at line 30 of file ASE_ORCA.h.

calc

py::object ASEOrcaPot::calc

private

Definition at line 29 of file ASE_ORCA.h.

counter

size_t ASEOrcaPot::counter {0}

private

Definition at line 32 of file ASE_ORCA.h.

{0};

workDir

std::filesystem::path ASEOrcaPot::workDir

private

Definition at line 31 of file ASE_ORCA.h.

---

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

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