eonc::LammpsLoader Class Reference

#include <LammpsLoader.h>

Inheritance diagram for eonc::LammpsLoader:

Public Member Functions
bool	is_loaded () const noexcept override
bool	available () const override
	Filesystem probe: a candidate liblammps file is visible without dlopen, so LAMMPS static initializers (the banner) do not run.
const std::string &	last_error () const noexcept override
	Why the last ensure_loaded() failed. Empty if unused or loaded.
void	require_loaded () override
	Load on first use, then throw if liblammps is not available.
	LammpsLoader (const LammpsLoader &)=delete
LammpsLoader &	operator= (const LammpsLoader &)=delete
Public Member Functions inherited from eonc::ILammpsLoader
virtual	~ILammpsLoader ()=default
	ILammpsLoader (const ILammpsLoader &)=delete
ILammpsLoader &	operator= (const ILammpsLoader &)=delete

Static Public Member Functions
static LammpsLoader &	instance ()
	Thread-safe singleton accessor (Meyer's pattern). Does not dlopen.

Private Member Functions
	LammpsLoader ()=default
	~LammpsLoader () override
void	ensure_loaded ()
template<typename Fn>
Fn	load_sym (const char *name)
	Try to load a symbol; returns nullptr on failure.

Private Attributes
bool	m_loaded {false}
bool	m_tried {false}
dynlib::Handle	m_handle {}
std::string	m_last_error {}

Additional Inherited Members
Public Types inherited from eonc::ILammpsLoader
using	open_no_mpi_fn = void *(*)(int, char **, void **)
using	close_fn = void (*)(void *)
using	command_fn = char *(*)(void *, const char *)
using	file_fn = void (*)(void *, const char *)
using	scatter_atoms_fn = void (*)(void *, const char *, int, int, void *)
using	extract_var_fn = void *(*)(void *, const char *, const char *)
Public Attributes inherited from eonc::ILammpsLoader
open_no_mpi_fn	open_no_mpi {nullptr}
close_fn	close {nullptr}
command_fn	command {nullptr}
file_fn	file {nullptr}
scatter_atoms_fn	scatter_atoms {nullptr}
extract_var_fn	extract_variable {nullptr}
Protected Member Functions inherited from eonc::ILammpsLoader
	ILammpsLoader ()=default

Detailed Description

Definition at line 74 of file LammpsLoader.h.

Constructor & Destructor Documentation

LammpsLoader() [1/2]

eonc::LammpsLoader::LammpsLoader ( const LammpsLoader & )

delete

LammpsLoader() [2/2]

eonc::LammpsLoader::LammpsLoader ( )

privatedefault

~LammpsLoader()

eonc::LammpsLoader::~LammpsLoader ( )

overrideprivate

Definition at line 135 of file LammpsLoader.cpp.

{ dynlib::close(m_handle); }

Member Function Documentation

available()

bool eonc::LammpsLoader::available ( ) const

nodiscardoverridevirtual

Filesystem probe: a candidate liblammps file is visible without dlopen, so LAMMPS static initializers (the banner) do not run.

Implements eonc::ILammpsLoader.

Definition at line 137 of file LammpsLoader.cpp.

                                   {
  return lib_file_visible(lammps_lib_names());
}

ensure_loaded()

void eonc::LammpsLoader::ensure_loaded ( )

private

Definition at line 84 of file LammpsLoader.cpp.

                                 {
  if (m_tried)
    return;
  m_tried = true;
  m_last_error.clear();
 
  // Always dlopen the soname. lib_file_visible only walks cwd and
  // LD_LIBRARY_PATH; the dynamic linker also searches ld.so.cache and
  // the default lib dirs. Gating on visibility skipped a distro so.
  m_handle = dynlib::openFirst(lammps_lib_names());
  if (!m_handle) {
    const std::string dle = dynlib::error();
    if (!lib_file_visible(lammps_lib_names())) {
      m_last_error = "liblammps.so not visible on LD_LIBRARY_PATH / cwd "
                     "and dlopen of the soname failed "
                     "(liblammps_pot.so is the eOn plugin, not LAMMPS)";
    } else {
      m_last_error = "liblammps.so is visible but dlopen failed";
    }
    if (!dle.empty()) {
      m_last_error += ": " + dle;
    }
    return;
  }
 
  open_no_mpi = dynlib::loadSym<open_no_mpi_fn>(m_handle, "lammps_open_no_mpi");
  close = dynlib::loadSym<close_fn>(m_handle, "lammps_close");
  command = dynlib::loadSym<command_fn>(m_handle, "lammps_command");
  file = dynlib::loadSym<file_fn>(m_handle, "lammps_file");
  scatter_atoms =
      dynlib::loadSym<scatter_atoms_fn>(m_handle, "lammps_scatter_atoms");
  extract_variable =
      dynlib::loadSym<extract_var_fn>(m_handle, "lammps_extract_variable");
 
#ifdef EONMPI
  open_mpi = dynlib::loadSym<open_mpi_fn>(m_handle, "lammps_open");
#endif
 
  if (!open_no_mpi || !close || !command || !file || !scatter_atoms ||
      !extract_variable) {
    std::cerr << "[LAMMPS] Library loaded but missing required symbols\n";
    m_last_error = "opened a liblammps* but lammps_open_no_mpi is missing "
                   "(plugin or ABI mismatch, not the LAMMPS C library)";
    dynlib::close(m_handle);
    m_handle = {};
    return;
  }
 
  m_loaded = true;
}

instance()

LammpsLoader & eonc::LammpsLoader::instance ( )

static

Thread-safe singleton accessor (Meyer's pattern). Does not dlopen.

Definition at line 79 of file LammpsLoader.cpp.

                                     {
  static LammpsLoader loader;
  return loader;
}

is_loaded()

bool eonc::LammpsLoader::is_loaded ( ) const

inlinenodiscardoverridevirtualnoexcept

Implements eonc::ILammpsLoader.

Definition at line 79 of file LammpsLoader.h.

{ return m_loaded; }

last_error()

const std::string & eonc::LammpsLoader::last_error ( ) const

inlinenodiscardoverridevirtualnoexcept

Why the last ensure_loaded() failed. Empty if unused or loaded.

Implements eonc::ILammpsLoader.

Definition at line 86 of file LammpsLoader.h.

                                                                      {
    return m_last_error;
  }

load_sym()

template<typename Fn>

Fn eonc::LammpsLoader::load_sym ( const char * name )

inlineprivate

Try to load a symbol; returns nullptr on failure.

Definition at line 108 of file LammpsLoader.h.

                                                       {
    return reinterpret_cast<Fn>(dynlib::sym(m_handle, name));
  }

operator=()

LammpsLoader & eonc::LammpsLoader::operator= ( const LammpsLoader & )

delete

require_loaded()

void eonc::LammpsLoader::require_loaded ( )

overridevirtual

Load on first use, then throw if liblammps is not available.

Implements eonc::ILammpsLoader.

Definition at line 141 of file LammpsLoader.cpp.

                                  {
  ensure_loaded();
  if (!m_loaded) {
    std::string msg =
        "LAMMPS potential requested but liblammps is not usable.\n";
    if (!m_last_error.empty()) {
      msg += m_last_error;
      msg += "\n";
    }
    msg += "Need a real liblammps.so with lammps_open_no_mpi, built for "
           "this glibc. conda-forge latest may need a newer libc than "
           "the host. liblammps_pot.so is the eOn plugin, not LAMMPS.";
    throw std::runtime_error(msg);
  }
}

Member Data Documentation

m_handle

dynlib::Handle eonc::LammpsLoader::m_handle {}

private

Definition at line 104 of file LammpsLoader.h.

{};

m_last_error

std::string eonc::LammpsLoader::m_last_error {}

private

Definition at line 105 of file LammpsLoader.h.

{};

m_loaded

bool eonc::LammpsLoader::m_loaded {false}

private

Definition at line 102 of file LammpsLoader.h.

{false};

m_tried

bool eonc::LammpsLoader::m_tried {false}

private

Definition at line 103 of file LammpsLoader.h.

{false};

---

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

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