#include <XTBPot.h>

Inheritance diagram for XTBPot:

Public Member Functions
	XTBPot (const eonc::Parameters &p)
virtual	~XTBPot ()
	XTBPot (const XTBPot &)=delete
XTBPot &	operator= (const XTBPot &)=delete
void	cleanMemory (void)
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
	XTB Fortran library uses per-instance state (env/calc).
bool	needsPerImageInstance () const noexcept override
	XTB restart.f90 uses global Fortran file units that collide when multiple environments exist in one process.
bool	computesStress () const noexcept override
	True when force() leaves a Cauchy stress that cauchyStress() can read until the next force() on this instance.
Matrix3d	cauchyStress () const override
	Cauchy stress in eV/Angstrom^3.
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	supportsBatchEvaluation () const noexcept
	Whether this potential supports batched evaluation of N systems in a single call.
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 Types
enum class	GFNMethod { GFNFF , GFN0xTB , GFN1xTB , GFN2xTB }

Private Attributes
xtb_TEnvironment	env = nullptr
xtb_TCalculator	calc = nullptr
xtb_TMolecule	mol = nullptr
xtb_TResults	res = nullptr
GFNMethod	xtb_paramset
double	xtb_acc
double	xtb_electronic_temperature
size_t	xtb_max_iter
double	total_charge = 0.0
int	uhf = 0
size_t	counter
bool	initialized
Matrix3d	stress_ {Matrix3d::Zero()}
bool	haveStress_ {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 21 of file XTBPot.h.

Member Enumeration Documentation

◆ GFNMethod

enum class XTBPot::GFNMethod

strongprivate

Enumerator
GFNFF
GFN0xTB
GFN1xTB
GFN2xTB

Definition at line 116 of file XTBPot.h.

116{ GFNFF, GFN0xTB, GFN1xTB, GFN2xTB };

Constructor & Destructor Documentation

◆ XTBPot() [1/2]

XTBPot::XTBPot ( const eonc::Parameters & p )

inline

Definition at line 24 of file XTBPot.h.

      : eonc::Potential(eonc::PotType::XTB, p), xtb_acc{p.xtb_options().acc},
        xtb_electronic_temperature{p.xtb_options().elec_temperature},
        xtb_max_iter{p.xtb_options().maxiter},
        total_charge{p.xtb_options().charge}, uhf{p.xtb_options().uhf} {
    // Deprecated for packaging: prefer potential=RGPOT
    // backend=xtb (dlopen libxtb_engine.so). Native -Dwith_xtb stays available.
    std::cerr
        << "WARNING: native XTBPot (-Dwith_xtb) is deprecated for packaging; "
           "prefer potential=RGPOT with [RgpotPot] backend=xtb "
           "(dlopen libxtb_engine.so; set RGPOT_XTB_ENGINE).\n";
    counter = 0;
    initialized = false;
    env = xtb_newEnvironment();
    xtb_setVerbosity(env, XTB_VERBOSITY_MUTED);
    // Release the default output unit to prevent Fortran NEWUNIT conflicts
    // when multiple XTB environments coexist (e.g. per-image NEB potentials)
    xtb_releaseOutput(env);
    if (!env) {
      throw std::runtime_error("Failed to create xtb environment");
    }
    calc = xtb_newCalculator();
    if (!calc) {
      xtb_delEnvironment(&env);
      throw std::runtime_error("Failed to create xtb calculator");
    }
    res = xtb_newResults();
    if (!calc) {
      xtb_delResults(&res);
      throw std::runtime_error("Failed to create xtb results");
    }
    // Unmarshal parameters
    if (p.xtb_options().paramset == "GFNFF") {
      xtb_paramset = GFNMethod::GFNFF;
    } else if (p.xtb_options().paramset == "GFN0xTB") {
      xtb_paramset = GFNMethod::GFN0xTB;
    } else if (p.xtb_options().paramset == "GFN1xTB") {
      xtb_paramset = GFNMethod::GFN1xTB;
    } else if (p.xtb_options().paramset == "GFN2xTB") {
      xtb_paramset = GFNMethod::GFN2xTB;
    } else {
      throw std::runtime_error("Parameter set for XTB must be one of GFNFF, "
                               "GFN0xTB, GFN1xTB or GFN2xTB.\n");
    }
  }

◆ ~XTBPot()

virtual XTBPot::~XTBPot ( )

inlinevirtual

Definition at line 70 of file XTBPot.h.

                    {
    if (res) {
      xtb_delResults(&res);
    }
    if (calc) {
      xtb_delCalculator(&calc);
    }
    if (mol) {
      xtb_delMolecule(&mol);
    }
    if (env) {
      xtb_releaseOutput(env);
      xtb_delEnvironment(&env);
    }
    QUILL_LOG_INFO(eonc::log::get(), "[XTB] called potential {} times",
                   counter++);
  }

◆ XTBPot() [2/2]

XTBPot::XTBPot ( const XTBPot & )

delete

Member Function Documentation

◆ cauchyStress()

Matrix3d XTBPot::cauchyStress ( ) const

inlinenodiscardoverridevirtual

Cauchy stress in eV/Angstrom^3.

sigma = (1/V) dE/dε for the right strain h <- h (I+ε) at fixed fractional coordinates.

Reimplemented from eonc::Potential.

Definition at line 113 of file XTBPot.h.

113{ return stress_; }

XTBPot::stress_

Matrix3d stress_

Definition XTBPot.h:131

◆ cleanMemory()

void XTBPot::cleanMemory ( void )

◆ computesStress()

bool XTBPot::computesStress ( ) const

inlinenodiscardoverridevirtualnoexcept

True when force() leaves a Cauchy stress that cauchyStress() can read until the next force() on this instance.

Reimplemented from eonc::Potential.

Definition at line 109 of file XTBPot.h.

                                                              {
    return haveStress_;
  }

◆ force()

void XTBPot::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 28 of file XTBPot.cpp.

                                                                   {
  variance = nullptr;
  int intN = static_cast<int>(N);
  const bool periodicity[3]{std::abs(box[0]) > 1e-8, std::abs(box[4]) > 1e-8,
                            std::abs(box[8]) > 1e-8};
  double box_bohr[3 * 3];
 
  // Allocate memory for converted positions
  std::vector<double> R_bohr(3 * N);
 
  // Convert positions from Angstrom to Bohr
  for (long idx = 0; idx < 3 * N; ++idx) {
    R_bohr[idx] = R[idx] / BOHR;
  }
  for (long idx = 0; idx < 9; ++idx) {
    box_bohr[idx] = box[idx] / BOHR;
  }
 
  if (!initialized) {
    // First call: Create the molecule and load the Hamiltonian
    mol = xtb_newMolecule(env, &intN, atomicNrs, R_bohr.data(), &total_charge,
                          &uhf, box_bohr, periodicity);
 
    switch (xtb_paramset) {
    case GFNMethod::GFNFF:
      xtb_loadGFNFF(env, mol, calc, nullptr);
      break;
    case GFNMethod::GFN0xTB:
      xtb_loadGFN0xTB(env, mol, calc, nullptr);
      break;
    case GFNMethod::GFN1xTB:
      xtb_loadGFN1xTB(env, mol, calc, nullptr);
      break;
    case GFNMethod::GFN2xTB:
      xtb_loadGFN2xTB(env, mol, calc, nullptr);
      break;
    }
 
    xtb_setAccuracy(env, calc, xtb_acc);
    xtb_setElectronicTemp(env, calc, xtb_electronic_temperature);
    xtb_setMaxIter(env, calc, xtb_max_iter);
    initialized = true;
  } else {
    // Subsequent calls: Only update coordinates and lattice
    xtb_updateMolecule(env, mol, R_bohr.data(), box_bohr);
  }
 
  xtb_singlepoint(env, mol, calc, res);
 
  // Check for SCF convergence or internal xTB errors
  if (xtb_checkEnvironment(env) != 0) {
    char err_msg[512];
    xtb_getError(env, err_msg, nullptr);
    throw std::runtime_error(std::string("xTB Error: ") + err_msg);
  }
 
  xtb_getEnergy(env, res, U);
  xtb_getGradient(env, res, F);
 
  // Convert Hartree/Bohr to eV/Angstrom
  for (long i = 0; i < 3 * N; ++i) {
    F[i] *= -1.0 * (HARTREE / BOHR);
  }
  *U *= HARTREE;
 
  // xtb's virial is dE/dε in Hartree, column-major. sigma = virial / V.
  double virial[9] = {};
  xtb_getVirial(env, res, virial);
  const double volume = std::abs(Matrix3d::Map(box).determinant());
  stress_.setZero();
  haveStress_ = volume > 0.0;
  if (haveStress_) {
    const double scale = HARTREE / volume;
    for (int col = 0; col < 3; ++col) {
      for (int row = 0; row < 3; ++row) {
        const double vij =
            0.5 * (virial[row + 3 * col] + virial[col + 3 * row]);
        stress_(row, col) = vij * scale;
      }
    }
  }
  counter++;
}

◆ isThreadSafe()

bool XTBPot::isThreadSafe ( ) const

inlinenodiscardoverridevirtualnoexcept

XTB Fortran library uses per-instance state (env/calc).

Thread-safe with separate instances; not safe on same instance.

Reimplemented from eonc::Potential.

Definition at line 100 of file XTBPot.h.

100{ return false; }

◆ needsPerImageInstance()

bool XTBPot::needsPerImageInstance ( ) const

inlinenodiscardoverridevirtualnoexcept

XTB restart.f90 uses global Fortran file units that collide when multiple environments exist in one process.

Run sequentially with a single instance until upstream fixes unit management.

Reimplemented from eonc::Potential.

Definition at line 105 of file XTBPot.h.

                                                                     {
    return false;
  }

◆ operator=()

XTBPot & XTBPot::operator= ( const XTBPot & )

delete

Member Data Documentation

◆ calc

xtb_TCalculator XTBPot::calc = nullptr

private

Definition at line 118 of file XTBPot.h.

◆ counter

size_t XTBPot::counter

private

Definition at line 129 of file XTBPot.h.

◆ env

xtb_TEnvironment XTBPot::env = nullptr

private

Definition at line 117 of file XTBPot.h.

◆ haveStress_

bool XTBPot::haveStress_ {false}

private

Definition at line 132 of file XTBPot.h.

132{false};

◆ initialized

bool XTBPot::initialized

private

Definition at line 130 of file XTBPot.h.

◆ mol

xtb_TMolecule XTBPot::mol = nullptr

private

Definition at line 119 of file XTBPot.h.

◆ res

xtb_TResults XTBPot::res = nullptr

private

Definition at line 120 of file XTBPot.h.

◆ stress_

Matrix3d XTBPot::stress_ {Matrix3d::Zero()}

private

Definition at line 131 of file XTBPot.h.

131{Matrix3d::Zero()};

◆ total_charge

double XTBPot::total_charge = 0.0

private

Definition at line 126 of file XTBPot.h.

◆ uhf

int XTBPot::uhf = 0

private

Definition at line 127 of file XTBPot.h.

◆ xtb_acc

double XTBPot::xtb_acc

private

Definition at line 123 of file XTBPot.h.

◆ xtb_electronic_temperature

double XTBPot::xtb_electronic_temperature

private

Definition at line 124 of file XTBPot.h.

◆ xtb_max_iter

size_t XTBPot::xtb_max_iter

private

Definition at line 125 of file XTBPot.h.

◆ xtb_paramset

GFNMethod XTBPot::xtb_paramset

private

Definition at line 122 of file XTBPot.h.

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

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

Public Member Functions

Private Types

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ GFNMethod

Constructor & Destructor Documentation

◆ XTBPot() [1/2]

◆ ~XTBPot()

◆ XTBPot() [2/2]

Member Function Documentation

◆ cauchyStress()

◆ cleanMemory()

◆ computesStress()

◆ force()

◆ isThreadSafe()

◆ needsPerImageInstance()

◆ operator=()

Member Data Documentation

◆ calc

◆ counter

◆ env

◆ haveStress_

◆ initialized

◆ mol

◆ res

◆ stress_

◆ total_charge

◆ uhf

◆ xtb_acc

◆ xtb_electronic_temperature

◆ xtb_max_iter

◆ xtb_paramset