Loading...
Searching...
No Matches
RGPotEngine Class Reference

Opaque rgpot-backed engine (nwchemc / cpmdc / metatomic / uma / xtb). More...

#include <RGPotEngine.h>

Classes

struct  Impl

Public Member Functions

 RGPotEngine (const RGPotEngineOptions &opt)
 ~RGPotEngine ()
 RGPotEngine (const RGPotEngine &)=delete
RGPotEngine & operator= (const RGPotEngine &)=delete
const std::string & backend () const noexcept
bool available () const
void force (long N, const double *R, const int *atomicNrs, double *F, double *U, const double *box) const
void selectOrbitals (std::int64_t key) const
 Names the calculation the next force() belongs to (cpmdc: the engine keeps converged orbitals per key, so each image or bead starts its SCF from its own previous orbitals).
bool keepsOrbitalsPerKey () const
 True when the engine keeps converged orbitals per key.
int calculatorGroups () const noexcept
 Number of calculator groups the MPI world is split into (1 when ranks_per_image is off) and the group this rank belongs to.
int calculatorIndex () const noexcept
int calculatorWorld () const noexcept
 Ranks in the MPI world the groups were bound on (1 without MPI).
int worldRank () const noexcept
 This process's rank in that world (0 without MPI).
void broadcastFromDriver (void *data, std::size_t bytes) const
 Collective on MPI_COMM_WORLD: every rank leaves with world rank 0's bytes.
void finalizeMpiAtExit () const
 Registers MPI_Finalize at exit (once per process) when the world has more than one rank.
void armGroupedExit () const
 After MPI_Finalize, _Exit.
void shutdownModule () noexcept
 Calls cpmdc_finalize while the engine is still mapped. MPI stays up.
bool shareResult (int owner, long N, double *F, double *U, bool ok, std::string &error) const
 Collective on MPI_COMM_WORLD: every rank leaves with the energy and the 3N forces computed by the first rank of group owner.

Static Public Member Functions

static bool mpiAbortRequested () noexcept
 True once rgpot asked for MPI_Abort at exit in this process.

Private Member Functions

void forceEngine (long N, const double *R, const int *atomicNrs, double *F, double *U, const double *box) const

Private Attributes

std::unique_ptr< Impl > impl_
std::string backend_

Detailed Description

Opaque rgpot-backed engine (nwchemc / cpmdc / metatomic / uma / xtb).

Definition at line 57 of file RGPotEngine.h.

Constructor & Destructor Documentation

◆ RGPotEngine() [1/2]

RGPotEngine::RGPotEngine ( const RGPotEngineOptions & opt)
explicit

Definition at line 268 of file RGPotEngine.cpp.

269 : impl_(std::make_unique<Impl>()) {
270 backend_ = to_lower(opt.backend);
271 if (backend_ == "nwchem" || backend_ == "nwchemc" ||
272 backend_ == "nwchempot") {
273 backend_ = "nwchemc";
274 impl_->backend = Impl::Backend::Nwchemc;
275 ::capnp::MallocMessageBuilder msg;
276 auto params = msg.initRoot<::NWChemParams>();
277 params.setBasis(opt.basis);
278 params.setTheory(opt.theory);
279 params.setScfType(opt.scf_type);
280 params.setCharge(opt.charge);
281 params.setMultiplicity(opt.multiplicity);
282 if (!opt.engine_path.empty())
283 params.setEnginePath(opt.engine_path);
284 else if (!opt.engine_library.empty())
285 params.setEnginePath(opt.engine_library);
286 if (!opt.engine_root.empty())
287 params.setNwchemRoot(opt.engine_root);
288 if (!opt.title.empty())
289 params.setTitle(opt.title);
290 if (opt.memory_mb > 0)
291 params.setMemoryMb(static_cast<uint32_t>(opt.memory_mb));
292 if (!opt.scratch_dir.empty())
293 params.setScratchDir(opt.scratch_dir);
294 // DFT XC as inputBlocks when theory=dft and scfType is an XC label
295 std::string block = opt.input_block;
296 if (block.empty()) {
297 if (const char *env = std::getenv("RGPOT_NWCHEM_INPUT_BLOCK"))
298 block = env;
299 }
300 if (block.empty()) {
301 block = nwchemDftInputBlock(opt.theory, opt.scf_type, opt.multiplicity,
302 block);
303 }
304 if (!block.empty()) {
305 auto blocks = params.initInputBlocks(1);
306 blocks.set(0, block);
307 }
308 impl_->nwchem = std::make_unique<rgpot::NWChemPot>(params.asReader());
309 if (!impl_->nwchem->available())
310 throw std::runtime_error(
311 "RGPOT(nwchemc): engine not available (set NWCHEMC_LIBRARY / "
312 "RGPOT_NWCHEMC_ENGINE or [RgpotPot] engine_path)");
313 } else if (backend_ == "cpmd" || backend_ == "cpmdc" ||
314 backend_ == "cpmdpot") {
315 backend_ = "cpmdc";
316 impl_->backend = Impl::Backend::Cpmdc;
317 std::string local_error;
318 ::capnp::MallocMessageBuilder msg;
319 try {
320 static_cast<void>(eon::fillCpmdParams(msg, opt));
321 } catch (const std::exception &ex) {
322 local_error = ex.what();
323 }
324 // Several ranks: agree before MPI_Comm_split. One rank that cannot
325 // read params_path must not leave the others inside the split.
326 if (mpi_world_hint() <= 1 && !local_error.empty())
327 throw std::runtime_error(local_error);
328 // rgpot reports MPI only once MPI_Init has run, and agree_construction
329 // is what initialises it, so the agreement keys on the launch size.
330 if (mpi_world_hint() > 1 && !agree_construction(local_error)) {
332 throw std::runtime_error(
333 local_error.empty()
334 ? std::string(
335 "RGPOT(cpmdc): a rank failed before the calculator split")
336 : local_error);
337 }
338 if (!local_error.empty())
339 throw std::runtime_error(local_error);
340 if (::rgpot::calculatorsUseMpi()) {
341 // Collective on MPI_COMM_WORLD, before the engine holds a session.
342 // cpmdc adopts a calculator communicator only while no session is
343 // live, and CPMD's mp_start reads that communicator. The CPMDPot
344 // built below finds the split made and hands its engine the group
345 // communicator before it creates its session.
346 // ranks_per_image = 0 is one calculator on the whole world.
347 const rgpot::CalculatorGroup g =
348 ::rgpot::bindCalculators(opt.ranks_per_image);
349 ::rgpot::finalizeMpiAtExit();
350 if (mpi_world_hint() > 1)
352 if (g.index < 0)
353 throw std::runtime_error(
354 "RGPOT(cpmdc): ranks_per_image=" +
355 std::to_string(opt.ranks_per_image) +
356 " does not divide the MPI world into calculator groups");
357 impl_->groups = ::rgpot::calculatorCount();
358 impl_->group = g.index;
359 impl_->world = ::rgpot::calculatorWorldSize();
360 } else if (opt.ranks_per_image > 0) {
361 throw std::runtime_error(
362 "RGPOT(cpmdc): ranks_per_image needs rgpot built with MPI "
363 "(-Drgpot:with_mpi=enabled)");
364 }
365 try {
366 impl_->cpmd = std::make_unique<rgpot::CPMDPot>(
367 msg.getRoot<::CPMDParams>().asReader());
368 pin_cpmd_library(opt.engine_path.empty() ? opt.engine_library
369 : opt.engine_path);
370 if (!impl_->cpmd->available())
371 throw std::runtime_error(
372 "RGPOT(cpmdc): engine not available (set CPMDC_LIBRARY / "
373 "RGPOT_CPMDC_ENGINE or [RgpotPot] engine_path)");
374 } catch (const std::exception &ex) {
375 local_error = ex.what();
376 }
377 // A rank whose engine did not load or refused the group communicator
378 // must not leave the others waiting in the first force.
379 if (mpi_world_hint() > 1 && !agree_construction(local_error))
380 throw std::runtime_error(
381 local_error.empty()
382 ? std::string("RGPOT(cpmdc): a rank failed to load the engine")
383 : local_error);
384 if (!local_error.empty())
385 throw std::runtime_error(local_error);
386 } else if (backend_ == "metatomic" || backend_ == "mta" ||
387 backend_ == "metatomicpot") {
388 backend_ = "metatomic";
390 MetatomicEngineOptions mopt;
391 mopt.model_path = opt.model_path;
392 mopt.device = opt.device;
393 mopt.length_unit = opt.length_unit;
397 mopt.engine_path =
398 !opt.engine_path.empty() ? opt.engine_path : opt.engine_library;
400 impl_->metatomic = std::make_unique<MetatomicEngineLoader>(mopt);
401 if (!impl_->metatomic->available())
402 throw std::runtime_error(
403 "RGPOT(metatomic): engine not available (set RGPOT_METATOMIC_ENGINE "
404 "or [RgpotPot] engine_path to librgpot_metatomic_engine.so)");
405 } else if (backend_ == "uma" || backend_ == "omol" || backend_ == "umapot") {
406 backend_ = "uma";
407 impl_->backend = Impl::Backend::Uma;
408 GenericEngineOptions gopt;
409 gopt.library = "libuma_engine.so";
410 gopt.env_var = "RGPOT_UMA_ENGINE";
411 gopt.engine_path =
412 !opt.engine_path.empty() ? opt.engine_path : opt.engine_library;
413 gopt.tag = "uma";
414 {
415 ::capnp::MallocMessageBuilder msg;
416 auto params = msg.initRoot<::UmaParams>();
417 params.setModelPath(opt.model_path);
418 params.setTaskName(opt.task_name);
419 params.setDevice(opt.device);
420 params.setCharge(opt.charge);
421 params.setSpin(opt.multiplicity);
422 const auto words = ::capnp::messageToFlatArray(msg);
423 const auto bytes = words.asBytes();
424 gopt.config.assign(bytes.begin(), bytes.end());
425 }
426 impl_->uma = std::make_unique<GenericEngineLoader>(gopt);
427 if (!impl_->uma->available())
428 throw std::runtime_error(
429 "RGPOT(uma): engine not available (set RGPOT_UMA_ENGINE or "
430 "[RgpotPot] engine_path to libuma_engine.so)");
431 } else if (backend_ == "xtb" || backend_ == "xtbpot" || backend_ == "gfn" ||
432 backend_ == "gfnxtb") {
433 backend_ = "xtb";
434 impl_->backend = Impl::Backend::Xtb;
435 XTBEngineOptions xopt;
436 xopt.method = xtb_method_from_paramset(opt.xtb_paramset);
437 xopt.accuracy = opt.xtb_accuracy;
440 xopt.charge = opt.xtb_charge;
441 xopt.uhf = opt.xtb_uhf;
442 xopt.engine_path =
443 !opt.engine_path.empty() ? opt.engine_path : opt.engine_library;
444 impl_->xtb = std::make_unique<XTBEngineLoader>(xopt);
445 if (!impl_->xtb->available())
446 throw std::runtime_error(
447 "RGPOT(xtb): engine not available (set RGPOT_XTB_ENGINE or "
448 "[RgpotPot] engine_path to librgpot_xtb_engine.so)");
449 } else {
450 throw std::runtime_error(
451 "RGPOT: unknown backend '" + opt.backend +
452 "' (expected nwchemc, cpmdc, metatomic, uma, or xtb)");
453 }
454}
std::string nwchemDftInputBlock(const std::string &theory, const std::string &scfType, int multiplicity, const std::string &existing)
NWChem input block for a DFT theory.
void armGroupedExit() const
After MPI_Finalize, _Exit.
std::unique_ptr< Impl > impl_
std::string backend_
::CPMDParams::Builder fillCpmdParams(::capnp::MallocMessageBuilder &msg, const RGPotEngineOptions &opt)
std::string tag
Backend tag for error messages ("uma", ...).
std::string env_var
Optional env var naming an explicit .so path (checked first).
std::vector< unsigned char > config
Cap'n Proto flat-array message (the engine's params struct on the shared Potentials....
std::string engine_path
Optional explicit .so path from config.
std::string library
Library basename to search for, e.g. "libuma_engine.so".
std::string scf_type
Definition RGPotEngine.h:12
std::string title
Definition RGPotEngine.h:20
std::string xtb_paramset
Definition RGPotEngine.h:38
std::string basis
Definition RGPotEngine.h:10
std::string scratch_dir
Definition RGPotEngine.h:22
std::string engine_path
Definition RGPotEngine.h:17
std::string backend
Definition RGPotEngine.h:9
std::string extensions_directory
Definition RGPotEngine.h:33
std::string engine_library
Definition RGPotEngine.h:18
double xtb_electronic_temperature
Definition RGPotEngine.h:40
std::string length_unit
Definition RGPotEngine.h:32
bool torch_determinism_strict
Definition RGPotEngine.h:36
std::string device
Definition RGPotEngine.h:31
std::string model_path
Definition RGPotEngine.h:30
std::string task_name
Definition RGPotEngine.h:47
std::string engine_root
Definition RGPotEngine.h:19
double uncertainty_threshold
Definition RGPotEngine.h:35
std::string theory
Definition RGPotEngine.h:11
std::string input_block
Definition RGPotEngine.h:24
std::string engine_path
double electronic_temperature

◆ ~RGPotEngine()

RGPotEngine::~RGPotEngine ( )
default

◆ RGPotEngine() [2/2]

RGPotEngine::RGPotEngine ( const RGPotEngine & )
delete

Member Function Documentation

◆ armGroupedExit()

void RGPotEngine::armGroupedExit ( ) const

After MPI_Finalize, _Exit.

Library destructors do not run on a finalized MPI world. When rgpot requested an abort at exit (a failed engine call), MPI_Abort replaces MPI_Finalize. No-op unless this process was started as one of several ranks.

Definition at line 486 of file RGPotEngine.cpp.

486 {
487#if defined(__linux__)
488 if (mpi_world_hint() <= 1)
489 return;
490 const EonRgpotGroupMpi *api = group_mpi();
491 if (api == nullptr || api->hard_exit == nullptr)
492 return;
493 // A library loaded during the run can register an exit handler after
494 // the first call. Registering again puts this handler last, so it runs
495 // first and _Exit skips those destructors. The handler does not return.
496 ::on_exit(api->hard_exit, nullptr);
497#else
498 static_cast<void>(this);
499#endif
500}
void(* hard_exit)(int status, void *arg)
on_exit handler: MPI_Abort when rgpot asked for it, else MPI_Finalize, then _Exit.

◆ available()

bool RGPotEngine::available ( ) const
nodiscard

Definition at line 555 of file RGPotEngine.cpp.

555 {
556 if (!impl_)
557 return false;
558 if (impl_->backend == Impl::Backend::Nwchemc && impl_->nwchem)
559 return impl_->nwchem->available();
560 if (impl_->backend == Impl::Backend::Cpmdc && impl_->cpmd)
561 return impl_->cpmd->available();
562 if (impl_->backend == Impl::Backend::Metatomic && impl_->metatomic)
563 return impl_->metatomic->available();
564 if (impl_->backend == Impl::Backend::Uma && impl_->uma)
565 return impl_->uma->available();
566 if (impl_->backend == Impl::Backend::Xtb && impl_->xtb)
567 return impl_->xtb->available();
568 return false;
569}

◆ backend()

const std::string & RGPotEngine::backend ( ) const
inlinenodiscardnoexcept

Definition at line 64 of file RGPotEngine.h.

64{ return backend_; }

◆ broadcastFromDriver()

void RGPotEngine::broadcastFromDriver ( void * data,
std::size_t bytes ) const

Collective on MPI_COMM_WORLD: every rank leaves with world rank 0's bytes.

A no-op on one rank.

Definition at line 514 of file RGPotEngine.cpp.

514 {
515 if (!impl_ || impl_->world <= 1 || bytes == 0)
516 return;
517 // World rank 0 is the first rank of calculator 0.
518 if (::rgpot::shareFromCalculator(0, data, bytes) == 0)
519 throw std::runtime_error("RGPOT: could not broadcast from the driver rank");
520}

◆ calculatorGroups()

int RGPotEngine::calculatorGroups ( ) const
nodiscardnoexcept

Number of calculator groups the MPI world is split into (1 when ranks_per_image is off) and the group this rank belongs to.

Definition at line 458 of file RGPotEngine.cpp.

458 {
459 return impl_ ? impl_->groups : 1;
460}

◆ calculatorIndex()

int RGPotEngine::calculatorIndex ( ) const
nodiscardnoexcept

Definition at line 462 of file RGPotEngine.cpp.

462 {
463 return impl_ ? impl_->group : 0;
464}

◆ calculatorWorld()

int RGPotEngine::calculatorWorld ( ) const
nodiscardnoexcept

Ranks in the MPI world the groups were bound on (1 without MPI).

Definition at line 466 of file RGPotEngine.cpp.

466 {
467 return impl_ ? impl_->world : 1;
468}

◆ finalizeMpiAtExit()

void RGPotEngine::finalizeMpiAtExit ( ) const

Registers MPI_Finalize at exit (once per process) when the world has more than one rank.

Definition at line 477 of file RGPotEngine.cpp.

477 {
478 if (impl_ && impl_->world > 1)
479 ::rgpot::finalizeMpiAtExit();
480}

◆ force()

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

Definition at line 597 of file RGPotEngine.cpp.

598 {
599 forceEngine(N, R, atomicNrs, F, U, box);
600 // Set on one rank by the multi-rank failure test. The text is the
601 // engine error that rank has to deliver to rank 0. It is raised after
602 // the engine call, where an engine error surfaces, so the rank has
603 // already taken part in every collective the engine runs.
604 if (const char *fail = std::getenv("RGPOT_FORCE_FAIL")) {
605 if (fail[0] != '\0')
606 throw std::runtime_error(fail);
607 }
608}
void forceEngine(long N, const double *R, const int *atomicNrs, double *F, double *U, const double *box) const

◆ forceEngine()

void RGPotEngine::forceEngine ( long N,
const double * R,
const int * atomicNrs,
double * F,
double * U,
const double * box ) const
private

Definition at line 610 of file RGPotEngine.cpp.

611 {
612 if (N <= 0)
613 throw std::runtime_error("RGPotEngine::force called with N <= 0");
614
615 AtomMatrix positions(static_cast<int>(N), 3);
616 for (long i = 0; i < N; ++i) {
617 const int ii = static_cast<int>(i);
618 positions(ii, 0) = R[3 * i + 0];
619 positions(ii, 1) = R[3 * i + 1];
620 positions(ii, 2) = R[3 * i + 2];
621 }
622 std::vector<int> atmtypes(atomicNrs, atomicNrs + N);
623 const auto cell = box_from_row_major(box);
624
625 if (impl_->backend == Impl::Backend::Metatomic) {
626 impl_->metatomic->force(N, R, atomicNrs, F, U, nullptr, box);
627 return;
628 }
629 if (impl_->backend == Impl::Backend::Uma) {
630 // A molecular .con may omit the cell. A 25 A diagonal stands in, so
631 // a singular box does not reach the neighbor list.
632 const bool got_cell = box && box[0] > 0.0 && box[4] > 0.0 && box[8] > 0.0;
633 std::array<double, 9> cell_sub{};
634 const double *effective_box = box;
635 if (!got_cell) {
636 cell_sub[0] = cell_sub[4] = cell_sub[8] = 25.0;
637 effective_box = cell_sub.data();
638 }
639 impl_->uma->force(N, R, atomicNrs, F, U, nullptr, effective_box);
640 return;
641 }
642 if (impl_->backend == Impl::Backend::Xtb) {
643 impl_->xtb->force(N, R, atomicNrs, F, U, nullptr, box);
644 return;
645 }
646
647 // rgpot >= 2.5.0: operator() returns (energy, forces, variance).
648 std::tuple<double, AtomMatrix, double> result;
649 if (impl_->backend == Impl::Backend::Nwchemc)
650 result = (*impl_->nwchem)(positions, atmtypes, cell);
651 else
652 result = (*impl_->cpmd)(positions, atmtypes, cell);
653
654 *U = std::get<0>(result);
655 const auto &forces = std::get<1>(result);
656 for (long i = 0; i < N; ++i) {
657 const int ii = static_cast<int>(i);
658 F[3 * i + 0] = forces(ii, 0);
659 F[3 * i + 1] = forces(ii, 1);
660 F[3 * i + 2] = forces(ii, 2);
661 }
662}
Eigen::Matrix< double, Eigen::Dynamic, 3, eOnStorageOrder > AtomMatrix
Definition Eigen.h:37

◆ keepsOrbitalsPerKey()

bool RGPotEngine::keepsOrbitalsPerKey ( ) const
nodiscard

True when the engine keeps converged orbitals per key.

Definition at line 592 of file RGPotEngine.cpp.

592 {
593 return impl_ && impl_->backend == Impl::Backend::Cpmdc && impl_->cpmd &&
594 keeps_orbitals_per_key(*impl_->cpmd);
595}

◆ mpiAbortRequested()

bool RGPotEngine::mpiAbortRequested ( )
staticnodiscardnoexcept

True once rgpot asked for MPI_Abort at exit in this process.

Definition at line 482 of file RGPotEngine.cpp.

482 {
483 return ::rgpot::mpiAbortRequested();
484}

◆ operator=()

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

◆ selectOrbitals()

void RGPotEngine::selectOrbitals ( std::int64_t key) const

Names the calculation the next force() belongs to (cpmdc: the engine keeps converged orbitals per key, so each image or bead starts its SCF from its own previous orbitals).

Other backends ignore it.

Definition at line 587 of file RGPotEngine.cpp.

587 {
588 if (impl_ && impl_->backend == Impl::Backend::Cpmdc && impl_->cpmd)
589 select_orbitals(*impl_->cpmd, key);
590}

◆ shareResult()

bool RGPotEngine::shareResult ( int owner,
long N,
double * F,
double * U,
bool ok,
std::string & error ) const

Collective on MPI_COMM_WORLD: every rank leaves with the energy and the 3N forces computed by the first rank of group owner.

Only CPMD's parent rank holds the true forces, so this also keeps the ranks of one group on the same step. ok is the owner's status; the return value is the owner's status on every rank. error is the owner's engine message on every rank.

Definition at line 522 of file RGPotEngine.cpp.

523 {
524 if (!impl_ || impl_->world <= 1) {
525 static_cast<void>(error);
526 return ok;
527 }
528 // Slot 0 carries the owner's status, so a failed evaluation reaches
529 // every rank through the same broadcast as a good one.
530 std::vector<double> buf(static_cast<size_t>(3 * N + 2));
531 if (owner == impl_->group) {
532 buf[0] = ok ? 1.0 : 0.0;
533 buf[1] = *U;
534 std::copy(F, F + 3 * N, buf.begin() + 2);
535 }
536 if (::rgpot::shareFromCalculator(owner, buf.data(),
537 buf.size() * sizeof(double)) == 0)
538 throw std::runtime_error("RGPOT: could not share a calculator result");
539 *U = buf[1];
540 std::copy(buf.begin() + 2, buf.end(), F);
541 // The owner's engine text travels with the status. Other ranks hold an
542 // empty string until this broadcast.
543 std::array<char, 512> msg{};
544 if (owner == impl_->group && !error.empty()) {
545 const auto n = std::min(error.size(), msg.size() - 1);
546 std::memcpy(msg.data(), error.data(), n);
547 }
548 if (::rgpot::shareFromCalculator(owner, msg.data(), msg.size()) == 0)
549 throw std::runtime_error("RGPOT: could not share a calculator error");
550 if (msg[0] != '\0')
551 error.assign(msg.data());
552 return buf[0] == 1.0;
553}
std::string error()
Definition DynLib.h:82

◆ shutdownModule()

void RGPotEngine::shutdownModule ( )
noexcept

Calls cpmdc_finalize while the engine is still mapped. MPI stays up.

Definition at line 502 of file RGPotEngine.cpp.

502 {
503 if (!impl_ || impl_->module_down)
504 return;
505 impl_->module_down = true;
506#if !defined(_WIN32)
507 if (auto *fin =
508 reinterpret_cast<void (*)()>(dlsym(RTLD_DEFAULT, "cpmdc_finalize")))
509 fin();
510 pin_cpmd_library({});
511#endif
512}

◆ worldRank()

int RGPotEngine::worldRank ( ) const
nodiscardnoexcept

This process's rank in that world (0 without MPI).

Definition at line 470 of file RGPotEngine.cpp.

470 {
471 if (!impl_ || impl_->world <= 1)
472 return 0;
473 const rgpot::CalculatorGroup &g = ::rgpot::thisCalculator();
474 return g.index * g.ranks + g.rank_in_group;
475}

Member Data Documentation

◆ backend_

std::string RGPotEngine::backend_
private

Definition at line 113 of file RGPotEngine.h.

◆ impl_

std::unique_ptr<Impl> RGPotEngine::impl_
private

Definition at line 112 of file RGPotEngine.h.


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