Potential backed by rgpot NWChemPot / CPMDPot (in-process dlopen of libnwchemc / libcpmdc). More...

#include <RgpotPot.h>

Inheritance diagram for RgpotPot:

Public Member Functions
	RgpotPot (const Parameters &p)
	~RgpotPot () override
	RgpotPot (const RgpotPot &)=delete
RgpotPot &	operator= (const RgpotPot &)=delete
void	force (long N, 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
	NWChem molecular SCF does not support PBC; CPMD may be periodic.
const std::string &	backend () const noexcept
bool	engineAvailable () const
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	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.

Private Attributes
std::unique_ptr< RGPotEngine >	impl_
std::string	backend_

Additional Inherited Members
Public Attributes inherited from eonc::Potential
std::atomic< size_t >	forceCallCounter
Protected Attributes inherited from eonc::Potential
PotType	ptype

Detailed Description

Potential backed by rgpot NWChemPot / CPMDPot (in-process dlopen of libnwchemc / libcpmdc).

Not potserv RPC. Configure via [RgpotPot] INI; energy eV, forces eV/Angstrom.

Definition at line 25 of file RgpotPot.h.

Constructor & Destructor Documentation

◆ RgpotPot() [1/2]

RgpotPot::RgpotPot ( const Parameters & p )

explicit

Definition at line 13 of file RgpotPot.cpp.

    : Potential(PotType::RGPOT, p) {
  RGPotEngineOptions opt;
  const auto &o = p.rgpot_options;
  opt.backend = o.backend;
  opt.basis = o.basis;
  opt.theory = o.theory;
  opt.scf_type = o.scf_type;
  opt.functional = o.functional;
  opt.cutoff_ry = o.cutoff_ry;
  opt.charge = o.charge;
  opt.multiplicity = o.multiplicity;
  opt.engine_path = o.engine_path;
  opt.engine_library = o.engine_library;
  opt.engine_root = o.engine_root;
  opt.title = o.title;
  opt.memory_mb = o.memory_mb;
  opt.scratch_dir = o.scratch_dir;
  opt.input_block = o.input_block;
  opt.model_path = o.model_path;
  opt.device = o.device;
  opt.length_unit = o.length_unit;
  opt.extensions_directory = o.extensions_directory;
  opt.check_consistency = o.check_consistency;
  opt.uncertainty_threshold = o.uncertainty_threshold;
  opt.torch_determinism_strict = o.torch_determinism_strict;
  opt.xtb_paramset = o.xtb_paramset;
  opt.xtb_accuracy = o.xtb_accuracy;
  opt.xtb_electronic_temperature = o.xtb_electronic_temperature;
  opt.xtb_max_iterations = o.xtb_max_iterations;
  opt.xtb_charge = o.xtb_charge;
  opt.xtb_uhf = o.xtb_uhf;
 
  // Env overrides (CI / benchmarks)
  if (const char *e = std::getenv("RGPOT_BACKEND"))
    opt.backend = e;
  if (const char *e = std::getenv("RGPOT_NWCHEM_BASIS"))
    opt.basis = e;
  if (const char *e = std::getenv("RGPOT_NWCHEM_THEORY"))
    opt.theory = e;
  if (const char *e = std::getenv("RGPOT_NWCHEM_SCF_TYPE"))
    opt.scf_type = e;
  // Engine-path env overrides are backend-scoped: NWCHEMC_LIBRARY must not
  // leak into a cpmdc configure (CPMDPot resolves CPMDC_LIBRARY itself).
  std::string backend_lc = opt.backend;
  std::transform(backend_lc.begin(), backend_lc.end(), backend_lc.begin(),
                 [](unsigned char c) { return std::tolower(c); });
  if (backend_lc.rfind("nwchem", 0) == 0) {
    if (const char *e = std::getenv("NWCHEMC_LIBRARY"))
      opt.engine_path = e;
    else if (const char *e = std::getenv("RGPOT_NWCHEMC_ENGINE"))
      opt.engine_path = e;
  } else if (backend_lc.rfind("cpmd", 0) == 0) {
    if (const char *e = std::getenv("CPMDC_LIBRARY"))
      opt.engine_path = e;
    else if (const char *e = std::getenv("RGPOT_CPMDC_ENGINE"))
      opt.engine_path = e;
  } else if (backend_lc.rfind("meta", 0) == 0 || backend_lc == "mta") {
    if (const char *e = std::getenv("RGPOT_METATOMIC_ENGINE"))
      opt.engine_path = e;
    else if (const char *e = std::getenv("METATOMIC_ENGINE"))
      opt.engine_path = e;
    if (const char *e = std::getenv("RGPOT_METATOMIC_MODEL"))
      opt.model_path = e;
  } else if (backend_lc == "xtb" || backend_lc == "xtbpot" ||
             backend_lc == "gfn" || backend_lc == "gfnxtb") {
    if (const char *e = std::getenv("RGPOT_XTB_ENGINE"))
      opt.engine_path = e;
    else if (const char *e = std::getenv("XTB_ENGINE"))
      opt.engine_path = e;
    if (opt.xtb_paramset.empty() || opt.xtb_paramset == "GFN2xTB") {
      if (!p.xtb_options.paramset.empty())
        opt.xtb_paramset = p.xtb_options.paramset;
    }
  }
 
  // Dual-read [Metatomic] when RGPOT backend is metatomic
  if ((backend_lc.rfind("meta", 0) == 0 || backend_lc == "mta") &&
      opt.model_path.empty())
    opt.model_path = p.metatomic_options.model_path;
  if ((backend_lc.rfind("meta", 0) == 0 || backend_lc == "mta") &&
      opt.device == "cpu" && !p.metatomic_options.device.empty())
    opt.device = p.metatomic_options.device;
 
  impl_ = std::make_unique<RGPotEngine>(opt);
  backend_ = impl_->backend();
  std::cout
      << "RgpotPot: in-process rgpot backend=" << backend_
      << " (dlopen: libnwchemc/libcpmdc/libmetatomic_engine/libxtb_engine)"
      << std::endl;
}

◆ ~RgpotPot()

RgpotPot::~RgpotPot ( )

overridedefault

◆ RgpotPot() [2/2]

RgpotPot::RgpotPot ( const RgpotPot & )

delete

Member Function Documentation

◆ backend()

const std::string & RgpotPot::backend ( ) const

inlinenodiscardnoexcept

Definition at line 41 of file RgpotPot.h.

41{ return backend_; }

◆ engineAvailable()

bool RgpotPot::engineAvailable ( ) const

nodiscard

Definition at line 107 of file RgpotPot.cpp.

107{ return impl_ && impl_->available(); }

◆ force()

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

overridevirtual

Implements eonc::Potential.

Definition at line 109 of file RgpotPot.cpp.

                                                                     {
  (void)variance;
  impl_->force(N, R, atomicNrs, F, U, box);
}

◆ isThreadSafe()

bool RgpotPot::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 36 of file RgpotPot.h.

36{ return false; }

◆ operator=()

RgpotPot & RgpotPot::operator= ( const RgpotPot & )

delete

◆ requiresIsolatedMoleculeLayout()

bool RgpotPot::requiresIsolatedMoleculeLayout ( ) const

inlinenodiscardoverridevirtualnoexcept

NWChem molecular SCF does not support PBC; CPMD may be periodic.

Reimplemented from eonc::Potential.

Definition at line 38 of file RgpotPot.h.

                                                                              {
    return backend_ == "nwchemc";
  }

Member Data Documentation

◆ backend_

std::string RgpotPot::backend_

private

Definition at line 46 of file RgpotPot.h.

◆ impl_

std::unique_ptr<RGPotEngine> RgpotPot::impl_