ASENwchemPot Class Reference

#include <ASE_NWCHEM.h>

Inheritance diagram for ASENwchemPot:

Public Member Functions
	ASENwchemPot (const eonc::Parameters &a_params)
virtual	~ASENwchemPot ()
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
	NWChem runs as external subprocess; separate instances are independent.
bool	requiresIsolatedMoleculeLayout () const noexcept override
	ASE-NWChem molecular SCF does not support PBC (#188).
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 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	supportsBatchEvaluation () const noexcept
	Whether this potential supports batched evaluation of N systems in a single call.
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 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)

Private Attributes
py::object	calc
py::object	ase
std::filesystem::path	workDir
size_t	counter {0}

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 25 of file ASE_NWCHEM.h.

Constructor & Destructor Documentation

ASENwchemPot()

ASENwchemPot::ASENwchemPot

(

const eonc::Parameters &

a_params

)

Definition at line 47 of file ASE_NWCHEM.cpp.

    : eonc::Potential(eonc::PotType::ASE_NWCHEM, a_params) {
  using namespace pybind11::literals;
  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_nwchem = py::module_::import("ase.calculators.nwchem");
  py::module_ psutil = py::module_::import("psutil");
  std::string nwchempth = eonc::helpers::get_value_from_env_or_param(
      "NWCHEM_COMMAND", a_params.ase_nwchem_options().path, "", "", true);
  std::string nwc_mult = eonc::helpers::get_value_from_env_or_param(
      "NWCHEM_MULTIPLICITY", a_params.ase_nwchem_options().multiplicity, "1",
      "Using 1 as a default multiplicity, i.e. an RHF calculation suitable for "
      "closed shell molecules, set multiplicity or the "
      "environment variable NWCHEM_MULTIPLICITY.\n");
 
  py::object NWCHEM = ase_nwchem.attr("NWChem");
  size_t nproc{0};
  auto mult = std::stoi(nwc_mult); // 1 for singlet, 2 for doublet
 
  if (a_params.ase_nwchem_options().nproc == "auto") {
    nproc = py::cast<int>(psutil.attr("cpu_count")(false));
  } else {
    nproc = std::stoi(a_params.ase_nwchem_options().nproc);
  }
 
  // dont_verify so we always get an energy and gradient
  // mpi_launcher: mpirun (default) or srun on Slurm nodes (issue #193)
  const std::string &launcher = a_params.ase_nwchem_options().mpi_launcher;
  std::string mpi_cmd;
  if (launcher == "srun") {
    // srun uses -n for tasks; avoid OpenMPI-specific flags.
    mpi_cmd =
        std::format("srun -n {} {} PREFIX.nwi > PREFIX.nwo", nproc, nwchempth);
  } else {
    // Default and any other launcher treated as OpenMPI-style mpirun -n.
    mpi_cmd = std::format("{} -n {} {} PREFIX.nwi > PREFIX.nwo", launcher,
                          nproc, nwchempth);
  }
 
  if (mult != 1 && mult != 2) {
    throw std::runtime_error("Unknown spin multiplicity, we support 1 for "
                             "singlet and 2 for doublet ONLY.");
  }
 
  // One directory per calculator instance so two LocalInProcess jobs in
  // the same cwd do not write PREFIX.nwi / PREFIX.nwo over each other.
  workDir = makeAseWorkDir("eon_ase_nwchem");
 
  // Common NWCHEM parameters
  py::dict nwchem_params = py::dict(
      "label"_a = "_eonpot_engrad",
      "set"_a = py::dict("geom:dont_verify"_a = true),
      "command"_a = py::str(mpi_cmd),
      "memory"_a = py::str(a_params.ase_nwchem_options().memory),
      "scf"_a =
          py::dict("nopen"_a = mult - 1,
                   "thresh"_a = a_params.ase_nwchem_options().scf_thresh,
                   "maxiter"_a = a_params.ase_nwchem_options().scf_maxiter),
      "basis"_a = py::str(a_params.ase_nwchem_options().basis),
      "task"_a = py::str("gradient"), "directory"_a = workDir.string());
 
  // Set flag for doublet (mult == 2)
  if (mult == 2) {
    nwchem_params["scf"]["uhf"] = py::none();
  }
 
  try {
    this->calc = NWCHEM(**nwchem_params);
  } catch (...) {
    std::error_code ec;
    std::filesystem::remove_all(workDir, ec);
    workDir.clear();
    throw;
  }
};

~ASENwchemPot()

ASENwchemPot::~ASENwchemPot ( )

virtual

Definition at line 130 of file ASE_NWCHEM.cpp.

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

Member Function Documentation

force()

void ASENwchemPot::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 139 of file ASE_NWCHEM.cpp.

                                            {
  using namespace pybind11::literals;
  if (variance != nullptr) {
    *variance = 0.0;
  }
  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);
    if (!boxx.isIdentity(1e-6)) {
      QUILL_LOG_WARNING(eonc::log::get(), "ASE-NWChem ignores the simulation "
                                          "cell; NWChem SCF is molecular only");
    }
    py::object atoms = this->ase.attr("Atoms")("symbols"_a = atmnmrs,
                                               "positions"_a = positions);
    atoms.attr("calc") = this->calc;
    // atoms.attr("center")();
    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-NWChem Python error: ") +
                             e.what());
  } catch (const std::exception &e) {
    throw std::runtime_error(std::string("ASE-NWChem C++ exception: ") +
                             e.what());
  }
 
  counter++;
  return;
}

isThreadSafe()

bool ASENwchemPot::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 40 of file ASE_NWCHEM.h.

{ return false; }

needsPerImageInstance()

bool ASENwchemPot::needsPerImageInstance ( ) const

inlinenodiscardoverridevirtualnoexcept

NWChem runs as external subprocess; separate instances are independent.

Reimplemented from eonc::Potential.

Definition at line 42 of file ASE_NWCHEM.h.

                                                                     {
    return true;
  }

requiresIsolatedMoleculeLayout()

bool ASENwchemPot::requiresIsolatedMoleculeLayout ( ) const

inlinenodiscardoverridevirtualnoexcept

ASE-NWChem molecular SCF does not support PBC (#188).

Reimplemented from eonc::Potential.

Definition at line 46 of file ASE_NWCHEM.h.

                                                                              {
    return true;
  }

Member Data Documentation

ase

py::object ASENwchemPot::ase

private

Definition at line 29 of file ASE_NWCHEM.h.

calc

py::object ASENwchemPot::calc

private

Definition at line 28 of file ASE_NWCHEM.h.

counter

size_t ASENwchemPot::counter {0}

private

Definition at line 31 of file ASE_NWCHEM.h.

{0};

workDir

std::filesystem::path ASENwchemPot::workDir

private

Definition at line 30 of file ASE_NWCHEM.h.

---

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

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