Loading...
Searching...
No Matches
XTBEngineLoader Class Reference

#include <XTBEngineLoader.h>

Public Member Functions

 XTBEngineLoader (const XTBEngineOptions &opt)
 ~XTBEngineLoader ()
 XTBEngineLoader (const XTBEngineLoader &)=delete
XTBEngineLoader & operator= (const XTBEngineLoader &)=delete
bool available () const noexcept
void force (long N, const double *R, const int *atomicNrs, double *F, double *U, double *variance, const double *box) const

Private Types

using create_fn = RgpotXtbPot *(*)(const RgpotXtbConfig *, char *, size_t)
using destroy_fn = void (*)(RgpotXtbPot *)
using force_fn

Private Attributes

void * m_lib {nullptr}
RgpotXtbPot * m_pot {nullptr}
create_fn m_create {nullptr}
destroy_fn m_destroy {nullptr}
force_fn m_force {nullptr}

Detailed Description

Definition at line 20 of file XTBEngineLoader.h.

Member Typedef Documentation

◆ create_fn

using XTBEngineLoader::create_fn = RgpotXtbPot *(*)(const RgpotXtbConfig *, char *, size_t)
private

Definition at line 34 of file XTBEngineLoader.h.

◆ destroy_fn

using XTBEngineLoader::destroy_fn = void (*)(RgpotXtbPot *)
private

Definition at line 35 of file XTBEngineLoader.h.

◆ force_fn

Initial value:
int (*)(RgpotXtbPot *, long, const double *, const int *,
double *, double *, double *, const double *)
struct RgpotXtbPot RgpotXtbPot
Definition xtb_c_abi.h:28

Definition at line 36 of file XTBEngineLoader.h.

Constructor & Destructor Documentation

◆ XTBEngineLoader() [1/2]

XTBEngineLoader::XTBEngineLoader ( const XTBEngineOptions & opt)
explicit

Definition at line 38 of file XTBEngineLoader.cpp.

38 {
39 std::vector<std::string> paths;
40 if (!opt.engine_path.empty())
41 paths.push_back(opt.engine_path);
42 if (const char *e = std::getenv("RGPOT_XTB_ENGINE"))
43 if (e && *e)
44 paths.emplace_back(e);
45 if (const char *e = std::getenv("XTB_ENGINE"))
46 if (e && *e)
47 paths.emplace_back(e);
48 paths.emplace_back("librgpot_xtb_engine.so");
49 paths.emplace_back("libxtb_engine.so");
50 auto add_dirs = [&](const char *env) {
51 if (!env)
52 return;
53 std::string s(env);
54 size_t i = 0;
55 while (i < s.size()) {
56 auto j = s.find(':', i);
57 if (j == std::string::npos)
58 j = s.size();
59 if (j > i) {
60 std::string d = s.substr(i, j - i);
61 if (!d.empty() && d.back() != '/')
62 d += '/';
63 paths.push_back(d + "librgpot_xtb_engine.so");
64 paths.push_back(d + "libxtb_engine.so");
65 }
66 i = j + 1;
67 }
68 };
69 add_dirs(std::getenv("EON_POTENTIALS_PATH"));
70 add_dirs(std::getenv("RGPOT_ENGINE_PATH"));
71
72 std::string last_dlerr;
73 for (const auto &p : paths) {
74 m_lib = open_lib(p.c_str());
75 if (m_lib)
76 break;
77#ifndef _WIN32
78 if (const char *e = dlerror())
79 last_dlerr = e;
80#endif
81 }
82 if (!m_lib) {
83 std::string msg = "RGPOT(xtb): librgpot_xtb_engine.so not found "
84 "(set RGPOT_XTB_ENGINE or [RgpotPot] engine_path)";
85 if (!last_dlerr.empty())
86 msg += std::string("; last dlerror: ") + last_dlerr;
87 throw std::runtime_error(msg);
88 }
89
90 auto abi =
91 reinterpret_cast<int (*)()>(load_sym(m_lib, "rgpot_xtb_abi_version"));
92 m_create = reinterpret_cast<create_fn>(load_sym(m_lib, "rgpot_xtb_create"));
93 m_destroy =
94 reinterpret_cast<destroy_fn>(load_sym(m_lib, "rgpot_xtb_destroy"));
95 m_force = reinterpret_cast<force_fn>(load_sym(m_lib, "rgpot_xtb_force"));
96 if (!abi || !m_create || !m_destroy || !m_force ||
97 abi() != RGPOT_XTB_ABI_VERSION) {
98 close_lib(m_lib);
99 m_lib = nullptr;
100 throw std::runtime_error("RGPOT(xtb): engine C ABI missing/mismatch");
101 }
102 char err[1024]{};
103 RgpotXtbConfig cfg{};
104 cfg.method = opt.method;
105 cfg.accuracy = opt.accuracy;
108 cfg.charge = opt.charge;
109 cfg.uhf = opt.uhf;
110 m_pot = m_create(&cfg, err, sizeof err);
111 if (!m_pot) {
112 close_lib(m_lib);
113 m_lib = nullptr;
114 throw std::runtime_error(std::string("RGPOT(xtb): create failed: ") + err);
115 }
116}
void(*)(RgpotXtbPot *) destroy_fn
destroy_fn m_destroy
RgpotXtbPot *(*)(const RgpotXtbConfig *, char *, size_t) create_fn
RgpotXtbPot * m_pot
int(*)(RgpotXtbPot *, long, const double *, const int *, double *, double *, double *, const double *) force_fn
double accuracy
Definition xtb_c_abi.h:40
int method
RGPOT_XTB_METHOD_*.
Definition xtb_c_abi.h:39
double charge
Definition xtb_c_abi.h:43
double electronic_temperature
Kelvin.
Definition xtb_c_abi.h:41
std::string engine_path
double electronic_temperature
struct RgpotXtbConfig RgpotXtbConfig
#define RGPOT_XTB_ABI_VERSION
Definition xtb_c_abi.h:47

◆ ~XTBEngineLoader()

XTBEngineLoader::~XTBEngineLoader ( )

Definition at line 118 of file XTBEngineLoader.cpp.

118 {
119 if (m_pot && m_destroy)
121 m_pot = nullptr;
122 // Safe to close: xtb has no torch-style static teardown hazard.
123 if (m_lib)
124 close_lib(m_lib);
125 m_lib = nullptr;
126}

◆ XTBEngineLoader() [2/2]

XTBEngineLoader::XTBEngineLoader ( const XTBEngineLoader & )
delete

Member Function Documentation

◆ available()

bool XTBEngineLoader::available ( ) const
inlinenodiscardnoexcept

Definition at line 27 of file XTBEngineLoader.h.

27{ return m_pot != nullptr; }

◆ force()

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

Definition at line 128 of file XTBEngineLoader.cpp.

130 {
131 if (!m_pot || !m_force)
132 throw std::runtime_error("RGPOT(xtb): engine not available");
133 double var = 0.0;
134 const int rc =
135 m_force(m_pot, N, R, atomicNrs, F, U, variance ? variance : &var, box);
136 if (rc != 0)
137 throw std::runtime_error("RGPOT(xtb): force failed");
138}

◆ operator=()

XTBEngineLoader & XTBEngineLoader::operator= ( const XTBEngineLoader & )
delete

Member Data Documentation

◆ m_create

create_fn XTBEngineLoader::m_create {nullptr}
private

Definition at line 38 of file XTBEngineLoader.h.

38{nullptr};

◆ m_destroy

destroy_fn XTBEngineLoader::m_destroy {nullptr}
private

Definition at line 39 of file XTBEngineLoader.h.

39{nullptr};

◆ m_force

force_fn XTBEngineLoader::m_force {nullptr}
private

Definition at line 40 of file XTBEngineLoader.h.

40{nullptr};

◆ m_lib

void* XTBEngineLoader::m_lib {nullptr}
private

Definition at line 32 of file XTBEngineLoader.h.

32{nullptr};

◆ m_pot

RgpotXtbPot* XTBEngineLoader::m_pot {nullptr}
private

Definition at line 33 of file XTBEngineLoader.h.

33{nullptr};

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