eonc Namespace Reference

RAII resource manager for the ARTn C library with global synchronization. More...

Namespaces
namespace	config
namespace	detail
namespace	dynlib
	Cross-platform dynamic library loading abstraction.
namespace	EpiCenters
namespace	geometry
namespace	helpers
namespace	io
namespace	log
namespace	neb
namespace	params_ssot
namespace	pbc
namespace	pot
namespace	Prefactor
namespace	rng
namespace	safemath

Classes
class	ARTnResource
class	ARTnSaddleSearch
	Saddle search method using the Activation-Relaxation Technique nouveau. More...
class	AtomicGPDimer
class	BasinHoppingJob
class	BasinHoppingSaddleSearch
class	BiasedGradientSquaredDescent
class	BondBoost
	Functionality relying on the conjugate gradients algorithm. More...
class	CollectiveIDPPObjectiveFunction
class	ConjugateGradients
	Decleration of the Conjugate Gradients optimizer. More...
class	Davidson
	Davidson method for the lowest Hessian curvature mode (min-mode). More...
class	Dimer
	Classic dimer method to find the lowest curvature mode. More...
class	DimerModeLostException
class	DimerModeRestoredException
struct	DimerRotationResult
	Result of a non-classical dimer rotation backend (mode estimate only). More...
class	Dynamics
struct	DynamicsConfig
	Configuration extracted from Parameters for Dynamics. More...
class	DynamicsJob
class	DynamicsSaddleSearch
class	FiniteDifferenceJob
class	FIRE
class	ForceCallTimer
	RAII wrapper for tracking force calls over a scope. More...
class	FPEHandler
class	GleThermostat
	Colored-noise (generalized Langevin) thermostat. More...
class	GlobalOptimization
class	GlobalOptimizationJob
class	GPSurrogateJob
class	Hessian
class	HessianJob
class	Hyperdynamics
class	IDPPObjectiveFunction
class	ImprovedDimer
class	IRACompare
	C++ wrapper for the IRA (Iterative Rotations and Assignments) library. More...
class	IRAResource
class	Job
	Declaration of job class. More...
class	LammpsLoader
class	Lanczos
class	LBFGS
class	LORRotation
class	LowestEigenmode
	Base for eigenmode solvers. More...
class	Matter
class	MetatomicDynPot
class	MetatomicLoader
class	MinimizationJob
class	MinModeSaddleSearch
class	MonteCarlo
class	MonteCarloJob
class	NEBObjectiveFunction
class	NudgedElasticBand
class	NudgedElasticBandJob
class	ObjectiveFunction
class	OHTSTJob
class	Optimizer
struct	OptimizerConfig
	Declaration of the optimizer class. More...
class	ParallelReplicaJob
class	Parameters
class	PluginLoader
class	PointJob
class	Potential
class	PotRegistry
class	PrefactorJob
class	ProcessSearchJob
	Declaration of the Process Search job. More...
class	Quickmin
class	ReplicaDynamicsJob
	Base class for replica dynamics jobs (TAD, SafeHyper). More...
class	ReplicaExchangeJob
class	SaddleSearchJob
	Declaration of the Saddle Search job. More...
class	SaddleSearchMethod
class	SafeHyperJob
struct	ServeEndpoint
	Configuration for a single serve endpoint. More...
class	SteepestDescent
class	StructureComparisonJob
class	SurrogatePotential
class	TADJob
class	TestJob
class	VesinNeighbors
	RAII wrapper around vesin_neighbors for Matter-style boxes (double[9] row-major 3×3 cell, same layout as Matter::cell). More...
class	ZBLRepulsiveIDPPObjective

Typedefs
using	EigenmodeStrategy = std::variant<Dimer, ImprovedDimer, Lanczos, Davidson>
using	ForceCallback
	Callback type for potential energy/force evaluation.

Enumerations
enum class	PotType {   UNKNOWN = 0 , EMT , EXT_POT , LJ ,   LJCLUSTER , MORSE_PT , CUH2 , TIP4P ,   TIP4P_PT , TIP4P_H , SPCE , EAM_AL ,   EDIP , FEHE , LENOSKY_SI , SW_SI ,   TERSOFF_SI , VASP , LAMMPS , MPI ,   AMS , AMS_IO , GPR , CatLearn ,   XTB , ASE_ORCA , ASE_POT , ASE_NWCHEM ,   METATOMIC , ZBL , SocketNWChem , RGPOT }
enum class	JobType {   Unknown = 0 , Process_Search , Saddle_Search , Minimization ,   Point , Parallel_Replica , Safe_Hyperdynamics , TAD ,   Replica_Exchange , Basin_Hopping , Hessian , Finite_Difference ,   Nudged_Elastic_Band , Dynamics , Prefactor , Global_Optimization ,   Structure_Comparison , Monte_Carlo , Test , GP_Surrogate ,   OH_TST }
enum class	OptType {   Unknown = -1 , None = 0 , QM , CG ,   LBFGS , FIRE , SD }
enum class	NEBInit {   LINEAR , IDPP , IDPP_COLLECTIVE , SIDPP ,   SIDPP_ZBL , FILE }
enum class	RunStatus { GOOD = 0 , FAIL_MAX_ITERATIONS , FAIL_POTENTIAL_FAILED }
enum class	DimerRotationBackend { Classical = 0 , Lanczos , Davidson , LOR }
enum class	PbcConvention { Legacy = 0 , MinimumImage = 1 }

Functions
int	getBundleSize ()
int	strchrcount (const char *haystack, char needle)
std::vector< std::string >	unbundle (int number)
void	deleteUnbundledFiles (const std::vector< std::string > &unbundledFilenames)
void	bundle (int number, const std::vector< std::string > &filenames, std::vector< std::string > *bundledFilenames)
void	commandLine (int argc, char **argv)
static void	fpe_signal_handler (int sig, siginfo_t *sip, void *scp)
void	enableFPE ()
void	disableFPE ()
bool	atomListMeansAll (const std::string &atomList)
	Whether atomList means "every free atom" (empty, "all", case-insensitive).
VectorXi	freeAtomIndices (const Matter *matter)
	Free (unfixed) atom indices in ascending order.
VectorXi	resolveMobileAtoms (const Matter *matter, const std::string &atomList)
	PHVA-class mobile set for FD Hessian and matrix-free Krylov (Lanczos / Davidson).
VectorXi	resolveMobileAtoms (const Matter *matter, const VectorXi &candidates)
	Explicit candidate indices, intersected with free flags (order preserved, duplicates dropped).
VectorXd	packMobileRows (const AtomMatrix &full, const VectorXi &mobile)
	Pack full (n_atoms,3) rows of mobile atoms into a 3*n_mobile vector.
void	unpackMobileRows (const VectorXd &packed, const VectorXi &mobile, AtomMatrix &full)
	Write a 3*n_mobile vector into full AtomMatrix rows (other rows unchanged).
VectorXd	mobileForces (Matter *matter, const VectorXi &mobile)
	Force components on mobile atoms after Matter has a valid force cache (calls getForces under the hood if needed via the non-const Matter API).
static EonMtaConfig	config_from_params (const Parameters &params)
void	serveMode (const Parameters &params, const std::string &host, uint16_t port)
	Start a single rgpot-compatible Cap'n Proto RPC server.
void	serveMultiple (const std::vector< ServeEndpoint > &endpoints, const Parameters &params)
	Serve multiple potentials concurrently on different ports.
void	serveReplicated (const Parameters &params, const std::string &host, uint16_t base_port, size_t replicas)
	Serve N replicas of the same potential across sequential ports.
void	serveGateway (const Parameters &params, const std::string &host, uint16_t port, size_t pool_size)
	Start a gateway server backed by a pool of potential instances.
void	serveFromConfig (const Parameters &params)
	Start serve mode from config-file parameters.
std::vector< ServeEndpoint >	parseServeSpec (const std::string &spec)
	Parse a serve configuration string into endpoints.
constexpr bool	usesAlternativeRotation (DimerRotationBackend backend) noexcept
std::optional< DimerRotationResult >	runAlternativeRotation (DimerRotationBackend backend, const std::shared_ptr< Matter > &matter, const Parameters &params, const std::shared_ptr< Potential > &pot, const AtomMatrix &initialDirection, quill::Logger *log=nullptr)
	Run Lanczos, Davidson, or LOR.
AtomMatrix	from_fortran_layout_vector (const std::vector< double > &flat_colmajor, int nat)
	Reconstruct AtomMatrix from a flat column-major vector (e.g.
std::shared_ptr< EigenmodeStrategy >	buildEigenmodeStrategy (std::shared_ptr< Matter > matter, const Parameters &params, std::shared_ptr< Potential > pot)
	Build the eigenmode solver from parameters.
void	eigenmodeCompute (EigenmodeStrategy &s, std::shared_ptr< Matter > matter, AtomMatrix direction)
	Dispatch compute() to the active variant.
double	eigenmodeGetEigenvalue (EigenmodeStrategy &s)
	Dispatch getEigenvalue() to the active variant.
AtomMatrix	eigenmodeGetEigenvector (EigenmodeStrategy &s)
	Dispatch getEigenvector() to the active variant.
ImprovedDimer *	asImprovedDimer (EigenmodeStrategy &s)
	Access ImprovedDimer-specific features.
long	eigenmodeTotalForceCalls (EigenmodeStrategy &s)
	Read stats from any variant (all inherit LowestEigenmode stats fields).
double	eigenmodeStatsTorque (EigenmodeStrategy &s)
double	eigenmodeStatsAngle (EigenmodeStrategy &s)
long	eigenmodeStatsRotations (EigenmodeStrategy &s)
long	eigenmodeTotalIterations (EigenmodeStrategy &s)
ARTnResource &	get_artn_resource ()
	Global access to thread-safe ARTn resource.
IRAResource &	get_ira_resource ()
	Global access to thread-safe IRA resource.
void	ensure_interpreter ()
void	startRpcServer (ForceCallback callback, const std::string &host, uint16_t port)
	Start a blocking Cap'n Proto RPC server using a force callback.
void	startPooledRpcServer (std::vector< ForceCallback > pool, const std::string &host, uint16_t port)
	Start a blocking Cap'n Proto RPC server backed by a pool of force callbacks dispatched round-robin.

Variables
static constexpr unsigned	MXCSR_MASK_IM = 1u << 7
static constexpr unsigned	MXCSR_MASK_ZM = 1u << 9
static constexpr unsigned	MXCSR_MASK_OM = 1u << 10
constexpr double	IM = 2147483647.0
constexpr double	AM = 1.0 / IM
constexpr int	NTAB = 32
constexpr int	NDIV = 1 + (IM / NTAB)
constexpr double	EPS = 1.2e-7
constexpr double	RNMX = 1.0 - EPS
constexpr long	IM1 = 2147483563
constexpr long	IM2 = 2147483399
constexpr long	IMM1 = IM1 - 1
constexpr long	IA1 = 40014
constexpr long	IA2 = 40692
constexpr long	IQ1 = 53668
constexpr long	IQ2 = 52774
constexpr long	IR1 = 12211
constexpr long	IR2 = 3791

Detailed Description

RAII resource manager for the ARTn C library with global synchronization.

Runtime loader for engine plugin shared libraries.

Runtime loader for the LAMMPS C library.

Contains all runtime parameters and results.

RAII resource manager for the IRA C library with global synchronization.

Uses dlopen (POSIX) or LoadLibrary (Windows) to load libartn at runtime. Implements global mutex to ensure thread-safety when multiple threads access the Fortran backend which has shared global state.

WARNING: Due to the non-thread-safe Fortran backend, all ARTn operations are serialized through a global mutex. Multiple threads calling ARTn simultaneously will execute sequentially, potentially creating a significant performance bottleneck in multi-threaded contexts. Consider process-level parallelism if true concurrent ARTn operations are required.

Uses dlopen (POSIX) or LoadLibrary (Windows) to load libira at runtime. Implements global mutex to ensure thread-safety when multiple threads access the Fortran backend which has shared global state.

WARNING: Due to the non-thread-safe Fortran backend, all IRA operations are serialized through a global mutex. Multiple threads calling IRA simultaneously will execute sequentially, potentially creating a significant performance bottleneck in multi-threaded contexts. Consider process-level parallelism if true concurrent IRA operations are required.

No functionality just bookkeeping.

Uses dlopen (POSIX) or LoadLibrary (Windows) to load liblammps at runtime rather than requiring it at compile time. This allows a single eOn binary to optionally use LAMMPS potentials if the library is installed.

Engines that ship as their own shared objects (the rgpot metatomic and xtb backends) are found by base name across a search path rather than by an absolute path, so a build, a wheel, and a conda prefix can each place them differently.

Uses dlopen (POSIX) or LoadLibrary (Windows) to load Fortran potential libraries at runtime. The search order is:

1. Paths from the [Potential] potentials_path config key
2. EON_POTENTIALS_PATH environment variable (';' on Windows, ':' elsewhere)
3. Default system library search path (LD_LIBRARY_PATH, etc.)

Call add_config_paths() once at startup (before any potential constructor) to inject config-file paths into the singleton.

Typedef Documentation

EigenmodeStrategy

using eonc::EigenmodeStrategy = std::variant<Dimer, ImprovedDimer, Lanczos, Davidson>

Definition at line 32 of file EigenmodeStrategy.h.

ForceCallback

using eonc::ForceCallback

Initial value:

std::function<void(long nAtoms, const double *positions,
                                        const int *atomicNrs, double *forces,
                                        double *energy, const double *box)>

Callback type for potential energy/force evaluation.

Flat-array interface that avoids any AtomMatrix type dependency, preventing collisions between eOn's Eigen-based AtomMatrix and rgpot's custom AtomMatrix.

Parameters

nAtoms	Number of atoms.
positions	Flat array [x1,y1,z1, x2,y2,z2, ...] (nAtoms*3).
atomicNrs	Atomic numbers [Z1, Z2, ...] (nAtoms).
forces	Output forces [Fx1,Fy1,Fz1, ...] (nAtoms*3).
energy	Output energy (single double).
box	Simulation cell flat 3x3 row-major (9 doubles).

Definition at line 36 of file ServeRpcServer.h.

Enumeration Type Documentation

DimerRotationBackend

enum class eonc::DimerRotationBackend

strong

Enumerator
Classical
Lanczos
Davidson
LOR

Definition at line 116 of file BaseStructures.h.

                                {
  Classical = 0,
  Lanczos,
  Davidson,
  LOR,
};

JobType

enum class eonc::JobType

strong

Enumerator
Unknown
Process_Search
Saddle_Search
Minimization
Point
Parallel_Replica
Safe_Hyperdynamics
TAD
Replica_Exchange
Basin_Hopping
Hessian
Finite_Difference
Nudged_Elastic_Band
Dynamics
Prefactor
Global_Optimization
Structure_Comparison
Monte_Carlo
Test
GP_Surrogate
OH_TST

Definition at line 73 of file BaseStructures.h.

                   {
  // Only add to the end of this!!!
  Unknown = 0,
  Process_Search,
  Saddle_Search,
  Minimization,
  Point,
  Parallel_Replica,
  Safe_Hyperdynamics,
  TAD,
  Replica_Exchange,
  Basin_Hopping,
  Hessian,
  Finite_Difference,
  Nudged_Elastic_Band,
  Dynamics,
  Prefactor,
  Global_Optimization,
  Structure_Comparison,
  Monte_Carlo,
  Test,
  GP_Surrogate,
  OH_TST
};

NEBInit

enum class eonc::NEBInit

strong

Enumerator
LINEAR
IDPP
IDPP_COLLECTIVE
SIDPP
SIDPP_ZBL
FILE

Definition at line 109 of file BaseStructures.h.

{ LINEAR, IDPP, IDPP_COLLECTIVE, SIDPP, SIDPP_ZBL, FILE };

OptType

enum class eonc::OptType

strong

Enumerator
Unknown
None
QM
CG
LBFGS
FIRE
SD

Definition at line 98 of file BaseStructures.h.

                   {
  // Only add to the end of this!!!
  Unknown = -1, // an error case
  None = 0,
  QM,
  CG,
  LBFGS,
  FIRE,
  SD
};

PbcConvention

enum class eonc::PbcConvention

strong

Enumerator
Legacy
MinimumImage

Definition at line 34 of file Matter.h.

                         {
  Legacy = 0,
  MinimumImage = 1,
};

PotType

enum class eonc::PotType

strong

Enumerator
UNKNOWN
EMT
EXT_POT
LJ
LJCLUSTER
MORSE_PT
CUH2
TIP4P
TIP4P_PT
TIP4P_H
SPCE
EAM_AL
EDIP
FEHE
LENOSKY_SI
SW_SI
TERSOFF_SI
VASP
LAMMPS
MPI
AMS
AMS_IO
GPR
CatLearn
XTB
ASE_ORCA
ASE_POT
ASE_NWCHEM
METATOMIC
ZBL
SocketNWChem
RGPOT

Definition at line 36 of file BaseStructures.h.

                   {
  // Only add to the end of this!!!
  UNKNOWN = 0,
  EMT,
  EXT_POT,
  LJ,
  LJCLUSTER,
  MORSE_PT,
  CUH2,
  TIP4P,
  TIP4P_PT,
  TIP4P_H,
  SPCE,
  EAM_AL,
  EDIP,
  FEHE,
  LENOSKY_SI,
  SW_SI,
  TERSOFF_SI,
  VASP,
  LAMMPS,
  MPI,
  // Add newer entries here
  AMS,
  AMS_IO,
  GPR,
  CatLearn,
  XTB,
  ASE_ORCA,
  ASE_POT,
  ASE_NWCHEM,
  METATOMIC,
  ZBL,
  SocketNWChem,
  RGPOT
};

RunStatus

enum class eonc::RunStatus

strong

Enumerator
GOOD
FAIL_MAX_ITERATIONS
FAIL_POTENTIAL_FAILED

Definition at line 111 of file BaseStructures.h.

{ GOOD = 0, FAIL_MAX_ITERATIONS, FAIL_POTENTIAL_FAILED };

Function Documentation

asImprovedDimer()

ImprovedDimer * eonc::asImprovedDimer ( EigenmodeStrategy & s )

inline

Access ImprovedDimer-specific features.

Returns nullptr if not ImprovedDimer.

Definition at line 93 of file EigenmodeStrategy.h.

                                                            {
  return std::get_if<ImprovedDimer>(&s);
}

atomListMeansAll()

bool eonc::atomListMeansAll

(

const std::string &

atomList

)

Whether atomList means "every free atom" (empty, "all", case-insensitive).

Definition at line 21 of file MobileAtoms.cpp.

                                                 {
  if (atomList.empty()) {
    return true;
  }
  // Trim and case-fold "all"
  size_t b = 0;
  while (b < atomList.size() &&
         std::isspace(static_cast<unsigned char>(atomList[b]))) {
    ++b;
  }
  size_t e = atomList.size();
  while (e > b && std::isspace(static_cast<unsigned char>(atomList[e - 1]))) {
    --e;
  }
  if (e <= b) {
    return true;
  }
  if (e - b != 3) {
    return false;
  }
  auto lower = [](char c) {
    return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
  };
  return lower(atomList[b]) == 'a' && lower(atomList[b + 1]) == 'l' &&
         lower(atomList[b + 2]) == 'l';
}

buildEigenmodeStrategy()

std::shared_ptr< EigenmodeStrategy > eonc::buildEigenmodeStrategy ( std::shared_ptr< Matter > matter, const Parameters & params, std::shared_ptr< Potential > pot )

inline

Build the eigenmode solver from parameters.

min_mode_method: dimer (rotation CG) | lanczos | davidson | gprdimer

Definition at line 38 of file EigenmodeStrategy.h.

                                                     {
  if (params.saddle_search_options.minmode_method ==
      LowestEigenmode::MINMODE_DIMER) {
    if (params.dimer_options.improved) {
      return std::make_shared<EigenmodeStrategy>(
          ImprovedDimer(matter, params, pot));
    }
    return std::make_shared<EigenmodeStrategy>(Dimer(matter, params, pot));
  } else if (params.saddle_search_options.minmode_method ==
             LowestEigenmode::MINMODE_LANCZOS) {
    return std::make_shared<EigenmodeStrategy>(Lanczos(matter, params, pot));
  } else if (params.saddle_search_options.minmode_method ==
             LowestEigenmode::MINMODE_DAVIDSON) {
    return std::make_shared<EigenmodeStrategy>(Davidson(matter, params, pot));
  }
#ifdef WITH_GPRD
  else if (params.saddle_search_options.minmode_method ==
           LowestEigenmode::MINMODE_GPRDIMER) {
    // AtomicGPDimer embeds atmd::AtomicDimer (unique_ptr + user dtor → not
    // movable). Construct the alternative in place; do not pass a temporary.
    return std::make_shared<EigenmodeStrategy>(
        std::in_place_type<AtomicGPDimer>, matter, params, pot);
  }
#else
  else if (params.saddle_search_options.minmode_method ==
           LowestEigenmode::MINMODE_GPRDIMER) {
    throw std::runtime_error(
        "min_mode_method=gprdimer requires -Dwith_gprd=true (WITH_GPRD)");
  }
#endif
  // Default to improved dimer
  return std::make_shared<EigenmodeStrategy>(
      ImprovedDimer(matter, params, pot));
}

bundle()

void eonc::bundle	(	int	number,
		const std::vector< std::string > &	filenames,
		std::vector< std::string > *	bundledFilenames )

Definition at line 175 of file Bundling.cpp.

                                                    {
  for (const auto &filename : filenames) {
    const auto [baseName, ext] = splitBundleExtension(filename);
    const std::string newFilename =
        baseName + "_" + std::to_string(number) + ext;
 
    try {
      fs::rename(filename, newFilename);
      bundledFilenames->push_back(newFilename);
    } catch (const fs::filesystem_error &e) {
      EONC_LOG_ERROR("bundle: cannot rename {} to {}: {}", filename,
                     newFilename, e.what());
    }
  }
}

commandLine()

void eonc::commandLine	(	int	argc,
		char **	argv )

Definition at line 93 of file CommandLine.cpp.

                                        {
  bool sflag = false, mflag = false, pflag = false, cflag = false;
  double optConvergedForce = 0.001;
  std::string potential;
  std::string confile;
  std::string confileout;
  std::string optimizer("cg");
  std::optional<std::string> config_path;
 
#ifdef WITH_SERVE_MODE
  std::optional<std::string> serve_spec;
  std::optional<std::string> serve_host("localhost");
  std::optional<uint16_t> serve_port(12345);
  std::optional<size_t> replicas(1);
  std::optional<bool> gateway(false);
#endif
 
  auto params = Parameters{};
 
  const char *progname = (argc ? argv[0] : "eonclient");
 
  Parser parser;
 
  parser.add(Option("--help", "-h")
                 .help("show this help message and exit")
                 .handler([&]() {
                   // Format help with color
                   auto helpText = parser.formatHelp(progname);
                   std::cout << colorizer.heading("eOn Client - Help")
                             << "\n\n";
                   std::cout << helpText;
                   std::exit(EXIT_SUCCESS);
                 }));
 
  parser.add(Option("--version", "-v")
                 .help("Print version information")
                 .handler([&]() {
                   std::cout << VERSION_STRING << std::endl;
                   std::exit(EXIT_SUCCESS);
                 }));
 
  parser.add(
      Option("--features").help("Print compile-time features").handler([&]() {
        printFeatures();
        std::exit(EXIT_SUCCESS);
      }));
 
  parser.add(Option("--minimize", "-m")
                 .help("Minimization of inputConfile saves to outputConfile")
                 .handler([&]() { mflag = true; }));
 
  parser.add(Option("--single", "-s")
                 .help("Single point energy of inputConfile")
                 .handler([&]() { sflag = true; }));
 
  parser.add(Option("--compare", "-c")
                 .help("Compare structures of inputConfile to outputConfile")
                 .handler([&]() { cflag = true; }));
 
  parser.add(
      Option("--optimizer", "-o")
          .argName("METHOD")
          .help("Optimization method")
          .handler([&](const std::string_view &value) { optimizer = value; }));
 
  parser.add(Option("--force", "-f")
                 .argName("VALUE")
                 .help("Convergence force")
                 .handler([&](const std::string_view &value) {
                   optConvergedForce = parseFloatingPoint<double>(value);
                 }));
 
  parser.add(Option("--tolerance", "-t")
                 .argName("VALUE")
                 .help("Distance tolerance")
                 .handler([&](const std::string_view &value) {
                   params.structure_comparison_options.distance_difference =
                       parseFloatingPoint<double>(value);
                 }));
 
  parser.add(Option("--potential", "-p")
                 .argName("POTENTIAL")
                 .help("The potential (e.g. qsc, lj, eam_al)")
                 .handler([&](const std::string_view &value) {
                   pflag = true;
                   potential = value;
                 }));
 
#ifdef WITH_SERVE_MODE
  parser.add(
      Option("--serve")
          .argName("SPEC")
          .help("Serve potential(s) over rgpot Cap'n Proto RPC. "
                "Spec: 'potential:port' or 'pot1:port1,pot2:port2'")
          .handler([&](const std::string_view &value) { serve_spec = value; }));
 
  parser.add(
      Option("--serve-host")
          .argName("HOST")
          .help("Host to bind RPC server(s) to")
          .handler([&](const std::string_view &value) { serve_host = value; }));
 
  parser.add(Option("--serve-port")
                 .argName("PORT")
                 .help("Port for single-potential serve mode (used with -p)")
                 .handler([&](const std::string_view &value) {
                   serve_port = parseIntegral<uint16_t>(value);
                 }));
 
  parser.add(Option("--replicas")
                 .argName("N")
                 .help("Number of replicated server instances (used with -p)")
                 .handler([&](const std::string_view &value) {
                   replicas = parseIntegral<size_t>(value);
                 }));
 
  parser.add(Option("--gateway")
                 .help("Run a single gateway port backed by N pool instances "
                       "(use with -p and --replicas)")
                 .handler([&]() { gateway = true; }));
 
  parser.add(Option("--config")
                 .argName("FILE")
                 .help("Config file for potential parameters (INI format, "
                       "e.g. [Metatomic] model_path=model.pt)")
                 .handler([&](const std::string_view &value) {
                   config_path = value;
                 }));
#endif
 
  // One value each: the partitioner hands a greedy zeroOrMoreTimes positional
  // every remaining argument, which leaves confileout empty and overwrites
  // confile with the last one.
  parser.add(
      Positional("confile")
          .help("Input structure file")
          .occurs(zeroOrOneTime)
          .handler([&](const std::string_view &value) { confile = value; }));
 
  parser.add(
      Positional("confileout")
          .help("Output structure file (optional)")
          .occurs(zeroOrOneTime)
          .handler([&](const std::string_view &value) { confileout = value; }));
 
  try {
    parser.parse(argc, argv);
  } catch (const ParsingException &ex) {
    std::cerr << colorizer.error(ex.message()) << '\n';
    std::cerr << colorizer.warning(parser.formatUsage(progname)) << '\n';
    std::exit(EXIT_FAILURE);
  }
 
  if (sflag && mflag) {
    std::cerr << colorizer.error(
        "Cannot specify both minimization and single point\n");
    std::exit(EXIT_FAILURE);
  }
 
  if (!pflag && (sflag || mflag)) {
    std::cerr << colorizer.error("Must specify a potential\n");
    std::exit(EXIT_FAILURE);
  }
 
  if (cflag && confileout.empty()) {
    std::cerr << colorizer.error(
        "Comparison needs two structure files: the input con file and the "
        "one to compare it against\n");
    std::cerr << colorizer.warning(parser.formatUsage(progname)) << '\n';
    std::exit(EXIT_FAILURE);
  }
 
#ifdef WITH_SERVE_MODE
  // Load config file if provided (for potential-specific parameters
  // like model_path, device, length_unit, etc.)
  if (config_path.has_value()) {
    std::ifstream config_file(config_path.value());
    if (!config_file.is_open()) {
      std::cerr << colorizer.error("Cannot open config file: ")
                << config_path.value() << '\n';
      std::exit(EXIT_FAILURE);
    }
    params.load(config_path.value());
  }
 
  // Handle --serve mode (does not require a con file)
  if (serve_spec.has_value()) {
    auto endpoints = parseServeSpec(serve_spec.value());
    if (endpoints.empty()) {
      std::cerr << colorizer.error("No valid serve endpoints in spec: ")
                << serve_spec.value() << '\n';
      std::exit(EXIT_FAILURE);
    }
    serveMultiple(endpoints, params);
    std::exit(EXIT_SUCCESS);
  }
 
  // Handle -p with serve flags (single potential serve mode)
  if (pflag && !sflag && !mflag && !cflag &&
      (serve_port.has_value() || replicas.has_value() || gateway.has_value())) {
    for (auto &ch : potential) {
      ch = std::tolower(static_cast<unsigned char>(ch));
    }
    params.potential_options.potential =
        magic_enum::enum_cast<PotType>(potential, magic_enum::case_insensitive)
            .value_or(PotType::UNKNOWN);
    auto host = serve_host.value_or("localhost");
    auto port = serve_port.value_or(12345);
    auto reps = replicas.value_or(1);
    bool gw = gateway.value_or(false);
 
    if (gw) {
      serveGateway(params, host, port, reps);
    } else if (reps > 1) {
      serveReplicated(params, host, port, reps);
    } else {
      serveMode(params, host, port);
    }
    std::exit(EXIT_SUCCESS);
  }
 
  // Config-driven serve (no -p or --serve, just --config with [Serve])
  if (!pflag && !sflag && !mflag && !cflag && config_path.has_value() &&
      !serve_spec.has_value() &&
      (!params.serve_options.endpoints.empty() ||
       params.serve_options.gateway_port > 0 ||
       params.serve_options.replicas > 1)) {
    serveFromConfig(params);
    std::exit(EXIT_SUCCESS);
  }
#endif
 
  // Serve modes take no structure file and have already exited above.
  if (confile.empty()) {
    std::cerr << colorizer.error(
        "At least one non-option argument is required: the con file\n");
    std::cerr << colorizer.warning(parser.formatUsage(progname)) << '\n';
    std::exit(EXIT_FAILURE);
  }
 
  if (!cflag) {
    for (auto &ch : potential) {
      ch = std::tolower(static_cast<unsigned char>(ch));
    }
  }
 
  if (!cflag) {
    params.potential_options.potential =
        magic_enum::enum_cast<PotType>(potential, magic_enum::case_insensitive)
            .value_or(PotType::UNKNOWN);
  }
 
  if (!sflag) {
    params.optimizer_options.method =
        magic_enum::enum_cast<OptType>(optimizer, magic_enum::case_insensitive)
            .value_or(OptType::CG);
    params.optimizer_options.converged_force = optConvergedForce;
  }
 
  if (cflag) {
    // Matter copies structure_comparison_options into its own structComp in
    // the constructor, so the flag has to be set before the two below.
    params.structure_comparison_options.check_rotation = true;
  }
 
  auto pot = eonc::helpers::makePotential(params);
  auto matter = std::make_unique<Matter>(pot, params);
  auto matter2 = std::make_unique<Matter>(pot, params);
  if (!eonc::io::io_ok(matter->con2matter(confile))) {
    std::cerr << "Failed to load " << confile << std::endl;
    std::exit(EXIT_FAILURE);
  }
 
  if (sflag) {
    singlePoint(std::move(matter));
  } else if (mflag) {
    minimize(std::move(matter), confileout);
  } else if (cflag) {
    if (!eonc::io::io_ok(matter2->con2matter(confileout))) {
      std::cerr << "Failed to load " << confileout << std::endl;
      std::exit(EXIT_FAILURE);
    }
    if (matter->compare(*matter2, true)) {
      std::cout << "Structures match\n";
    } else {
      std::cout << colorizer.error("Structures do not match\n");
    }
  }
}

config_from_params()

EonMtaConfig eonc::config_from_params ( const Parameters & params )

static

Definition at line 15 of file MetatomicDynPot.cpp.

                                                                 {
  const auto &o = params.metatomic_options;
  EonMtaConfig c{};
  c.model_path = o.model_path.c_str();
  c.device = o.device.c_str();
  c.length_unit = o.length_unit.c_str();
  c.extensions_directory = o.extensions_directory.c_str();
  c.check_consistency = o.check_consistency ? 1 : 0;
  c.uncertainty_threshold = o.uncertainty_threshold;
  c.energy_output = o.energy_output.c_str();
  c.energy_uncertainty_output = o.energy_uncertainty_output.c_str();
  c.force_output = o.force_output.c_str();
  c.non_conservative = o.non_conservative ? 1 : 0;
  c.random_rotation = o.random_rotation ? 1 : 0;
  c.n_symmetry_rotations = o.n_symmetry_rotations;
  c.deterministic = o.deterministic ? 1 : 0;
  c.deterministic_strict = o.deterministic_strict ? 1 : 0;
  c.variant_base = o.variant.base.c_str();
  c.variant_energy = o.variant.energy.c_str();
  c.variant_energy_uncertainty = o.variant.energy_uncertainty.c_str();
  c.variant_force = o.variant.force.c_str();
  return c;
}

deleteUnbundledFiles()

void eonc::deleteUnbundledFiles

(

const std::vector< std::string > &

unbundledFilenames

)

Definition at line 140 of file Bundling.cpp.

                                                                          {
  for (const auto &filename : unbundledFilenames) {
    std::error_code ec;
    fs::remove(filename, ec);
    if (ec) {
      EONC_LOG_ERROR("deleteUnbundledFiles: cannot remove {}: {}", filename,
                     ec.message());
    }
  }
}

disableFPE()

void eonc::disableFPE

(

)

Definition at line 229 of file fpe_handler.cpp.

                  {
#ifdef _WIN32
  // Mask all floating-point exceptions (restore default behavior)
  unsigned int control;
  _controlfp_s(&control, _MCW_EM, _MCW_EM);
#elif defined(__unix__)
  fedisableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
#elif defined(__APPLE__)
  fenv_t env;
  fegetenv(&env);
#if defined(__aarch64__)
  env.__fpsr |= (FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
#endif
  fesetenv(&env);
#endif
}

eigenmodeCompute()

void eonc::eigenmodeCompute ( EigenmodeStrategy & s, std::shared_ptr< Matter > matter, AtomMatrix direction )

inline

Dispatch compute() to the active variant.

Definition at line 75 of file EigenmodeStrategy.h.

                                                   {
  std::visit([&](auto &impl) { impl.compute(matter, direction); }, s);
}

eigenmodeGetEigenvalue()

double eonc::eigenmodeGetEigenvalue ( EigenmodeStrategy & s )

inline

Dispatch getEigenvalue() to the active variant.

Definition at line 82 of file EigenmodeStrategy.h.

                                                           {
  return std::visit([](auto &impl) { return impl.getEigenvalue(); }, s);
}

eigenmodeGetEigenvector()

AtomMatrix eonc::eigenmodeGetEigenvector ( EigenmodeStrategy & s )

inline

Dispatch getEigenvector() to the active variant.

Definition at line 87 of file EigenmodeStrategy.h.

                                                                {
  return std::visit([](auto &impl) { return impl.getEigenvector(); }, s);
}

eigenmodeStatsAngle()

double eonc::eigenmodeStatsAngle ( EigenmodeStrategy & s )

inline

Definition at line 106 of file EigenmodeStrategy.h.

                                                        {
  return std::visit([](auto &impl) { return impl.statsAngle; }, s);
}

eigenmodeStatsRotations()

long eonc::eigenmodeStatsRotations ( EigenmodeStrategy & s )

inline

Definition at line 110 of file EigenmodeStrategy.h.

                                                          {
  return std::visit([](auto &impl) { return impl.statsRotations; }, s);
}

eigenmodeStatsTorque()

double eonc::eigenmodeStatsTorque ( EigenmodeStrategy & s )

inline

Definition at line 102 of file EigenmodeStrategy.h.

                                                         {
  return std::visit([](auto &impl) { return impl.statsTorque; }, s);
}

eigenmodeTotalForceCalls()

long eonc::eigenmodeTotalForceCalls ( EigenmodeStrategy & s )

inline

Read stats from any variant (all inherit LowestEigenmode stats fields).

Definition at line 98 of file EigenmodeStrategy.h.

                                                           {
  return std::visit([](auto &impl) { return impl.totalForceCalls; }, s);
}

eigenmodeTotalIterations()

long eonc::eigenmodeTotalIterations ( EigenmodeStrategy & s )

inline

Definition at line 114 of file EigenmodeStrategy.h.

                                                           {
  return std::visit([](auto &impl) { return impl.totalIterations; }, s);
}

enableFPE()

void eonc::enableFPE

(

)

Definition at line 193 of file fpe_handler.cpp.

                 {
#ifdef _WIN32
  // Register Windows SEH handler for FPE reporting
  SetUnhandledExceptionFilter(windowsFPEHandler);
  // Enable floating-point exceptions on Windows
  _controlfp_s(nullptr, 0, _MCW_EM);
  _controlfp_s(nullptr, ~(_EM_ZERODIVIDE | _EM_INVALID | _EM_OVERFLOW),
               _MCW_EM);
#elif defined(__unix__)
  // Enable floating-point exceptions on Unix
  feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
#elif defined(__APPLE__) && defined(__aarch64__)
  // Enable floating-point exceptions on ARM macOS
  fenv_t env;
  fegetenv(&env);
  env.__fpsr &= ~(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
  fesetenv(&env);
#elif defined(__APPLE__) && defined(__x86_64__)
  // Enable floating-point exceptions on Intel macOS
  _MM_SET_EXCEPTION_MASK(
      _MM_MASK_MASK &
      ~(_MM_MASK_INVALID | _MM_MASK_DIV_ZERO | _MM_MASK_OVERFLOW));
#else
  fprintf(stderr, "FPE trapping not supported on this platform.\n");
#endif
 
#ifndef _WIN32
  // Register POSIX signal handler
  struct sigaction act;
  act.sa_sigaction = fpe_signal_handler;
  sigemptyset(&act.sa_mask);
  act.sa_flags = SA_SIGINFO;
  sigaction(SIGFPE, &act, nullptr);
#endif
}

ensure_interpreter()

void eonc::ensure_interpreter ( )

inline

Definition at line 21 of file NbGuard.h.

                                 {
  if (!Py_IsInitialized()) {
    // 0 = skip signal handlers (same idea as pybind11 embed defaults)
    Py_InitializeEx(0);
  }
}

fpe_signal_handler()

void eonc::fpe_signal_handler ( int sig, siginfo_t * sip, void * scp )

static

Definition at line 94 of file fpe_handler.cpp.

                                                                   {
  // Async-signal-safe only: write(2) and sig_atomic_t. No iostream, malloc,
  // backtrace, or fenv helpers (fedisableexcept / feclearexcept are not
  // async-signal-safe). All continue-state is written into the saved ucontext
  // so it is restored on sigreturn.
  //
  // x86 cannot "continue" past a trapped FP op by clearing sticky flags:
  // flags are bits 0-5 of MXCSR/swd, but the exception MASK bits live at
  // MXCSR 7-12. Clearing 0x3F leaves trapping armed, so the faulting
  // instruction re-executes on the same operands and re-raises forever
  // (report, sigreturn, refault) -- multi-GB identical stderr lines and a
  // client stuck at ~100% CPU. Mask the class in the restored MXCSR so
  // re-execution produces the IEEE default (Inf/NaN) and proceeds.
  static volatile sig_atomic_t reported_div = 0;
  static volatile sig_atomic_t reported_inv = 0;
  static volatile sig_atomic_t reported_ovf = 0;
  static volatile sig_atomic_t reported_unk = 0;
 
  static constexpr char prefix[] = "FPE (continuing, masking further): ";
  static constexpr char msg_div[] = "division by zero\n";
  static constexpr char msg_inv[] = "invalid operation\n";
  static constexpr char msg_ovf[] = "overflow\n";
  static constexpr char msg_unk[] = "unknown\n";
 
  // Default: mask all three classes we enable at startup, so an unknown
  // si_code cannot leave trapping armed and re-storm.
  unsigned mxcsr_mask_bits = MXCSR_MASK_IM | MXCSR_MASK_ZM | MXCSR_MASK_OM;
  volatile sig_atomic_t *reported = &reported_unk;
  const char *msg = msg_unk;
  size_t msg_len = sizeof(msg_unk) - 1;
 
  switch (sip->si_code) {
  case FPE_FLTDIV:
    reported = &reported_div;
    msg = msg_div;
    msg_len = sizeof(msg_div) - 1;
    mxcsr_mask_bits = MXCSR_MASK_ZM;
    break;
  case FPE_FLTINV:
    reported = &reported_inv;
    msg = msg_inv;
    msg_len = sizeof(msg_inv) - 1;
    mxcsr_mask_bits = MXCSR_MASK_IM;
    break;
  case FPE_FLTOVF:
    reported = &reported_ovf;
    msg = msg_ovf;
    msg_len = sizeof(msg_ovf) - 1;
    mxcsr_mask_bits = MXCSR_MASK_OM;
    break;
  default:
    break;
  }
 
  if (*reported == 0) {
    *reported = 1;
    write(STDERR_FILENO, prefix, sizeof(prefix) - 1);
    write(STDERR_FILENO, msg, msg_len);
#if defined(__linux__) && defined(__x86_64__)
    // First-fault RIP for post-mortem addr2line / offline diagnosis.
    ucontext_t *ctx_log = static_cast<ucontext_t *>(scp);
    unsigned long rip =
        static_cast<unsigned long>(ctx_log->uc_mcontext.gregs[REG_RIP]);
    char hex[] = "FPE rip=0x0000000000000000\n";
    for (int i = 0; i < 16; ++i) {
      unsigned nibble = static_cast<unsigned>((rip >> (4 * (15 - i))) & 0xFu);
      hex[10 + i] =
          static_cast<char>(nibble < 10 ? '0' + nibble : 'a' + (nibble - 10));
    }
    write(STDERR_FILENO, hex, sizeof(hex) - 1);
#endif
  }
 
#if defined(__linux__) && (defined(__x86_64__) || defined(__i386__))
  ucontext_t *ctx = static_cast<ucontext_t *>(scp);
  if (ctx->uc_mcontext.fpregs) {
    // Clear sticky exception FLAGS (bits 0-5) and arm the MASK bit(s) for
    // the fault class (bits 7-12). Mask sticks after sigreturn because the
    // restored MXCSR becomes the live CPU state.
    ctx->uc_mcontext.fpregs->swd &= ~0x3Fu;
    ctx->uc_mcontext.fpregs->mxcsr &= ~0x3Fu;
    ctx->uc_mcontext.fpregs->mxcsr |= mxcsr_mask_bits;
    // x87 control word: mask bits are 0-5 of cwd (IM, DM, ZM, OM, UM, PM).
    // Set the matching masks so a legacy x87 fault cannot re-storm either.
    if (mxcsr_mask_bits & MXCSR_MASK_ZM) {
      ctx->uc_mcontext.fpregs->cwd |= (1u << 2); // x87 ZM
    }
    if (mxcsr_mask_bits & MXCSR_MASK_IM) {
      ctx->uc_mcontext.fpregs->cwd |= (1u << 0); // x87 IM
    }
    if (mxcsr_mask_bits & MXCSR_MASK_OM) {
      ctx->uc_mcontext.fpregs->cwd |= (1u << 3); // x87 OM
    }
  }
#endif
  (void)sig;
}

freeAtomIndices()

VectorXi eonc::freeAtomIndices

(

const Matter *

matter

)

Free (unfixed) atom indices in ascending order.

Definition at line 48 of file MobileAtoms.cpp.

                                               {
  const long n = matter->numberOfAtoms();
  std::vector<int> free;
  free.reserve(static_cast<size_t>(matter->numberOfFreeAtoms()));
  for (long i = 0; i < n; ++i) {
    if (!matter->getFixed(i)) {
      free.push_back(static_cast<int>(i));
    }
  }
  VectorXi out(static_cast<Eigen::Index>(free.size()));
  for (Eigen::Index k = 0; k < out.size(); ++k) {
    out(k) = free[static_cast<size_t>(k)];
  }
  return out;
}

from_fortran_layout_vector()

AtomMatrix eonc::from_fortran_layout_vector ( const std::vector< double > & flat_colmajor, int nat )

inline

Reconstruct AtomMatrix from a flat column-major vector (e.g.

from Fortran). RowMajor(N,3) and ColMajor(3,N) share the same contiguous memory layout, so this is effectively a reinterpretation of the flat data.

Definition at line 61 of file Eigen.h.

                                                                            {
  assert(flat_colmajor.size() >= static_cast<size_t>(3 * nat));
  return Eigen::Map<const AtomMatrix>(flat_colmajor.data(), nat, 3);
}

get_artn_resource()

ARTnResource & eonc::get_artn_resource ( )

inline

Global access to thread-safe ARTn resource.

Definition at line 120 of file ARTnResource.h.

{ return ARTnResource::instance(); }

get_ira_resource()

IRAResource & eonc::get_ira_resource ( )

inline

Global access to thread-safe IRA resource.

Definition at line 100 of file IRAResource.h.

{ return IRAResource::instance(); }

getBundleSize()

int eonc::getBundleSize

(

)

Definition at line 28 of file Bundling.cpp.

                    {
  int num_bundle = -1;
 
  for (const auto &entry : fs::directory_iterator(".")) {
    std::string name = entry.path().filename().string();
 
    if (name[0] == '.') {
      continue;
    }
 
    // If "config" is not in the filename
    // then skip.
    if (name.find("config") == std::string::npos &&
        name.find("ini") == std::string::npos) {
      continue;
    }
 
    // Find the last underscore
    auto upos = name.rfind('_');
    if (upos == std::string::npos) {
      continue;
    }
 
    // Find the last period
    auto dpos = name.rfind('.');
    if (dpos == std::string::npos || dpos <= upos) {
      continue;
    }
 
    std::string numstr = name.substr(upos + 1, dpos - upos - 1);
    if (!numstr.empty() &&
        std::isdigit(static_cast<unsigned char>(numstr[0]))) {
      int i = std::atoi(numstr.c_str()) + 1;
      if (i > num_bundle) {
        num_bundle = i;
      }
    }
  }
 
  return num_bundle;
}

mobileForces()

VectorXd eonc::mobileForces	(	Matter *	matter,
		const VectorXi &	mobile )

Force components on mobile atoms after Matter has a valid force cache (calls getForces under the hood if needed via the non-const Matter API).

Definition at line 132 of file MobileAtoms.cpp.

                                                              {
  const AtomMatrix forces = matter->getForces();
  return packMobileRows(forces, mobile);
}

packMobileRows()

VectorXd eonc::packMobileRows	(	const AtomMatrix &	full,
		const VectorXi &	mobile )

Pack full (n_atoms,3) rows of mobile atoms into a 3*n_mobile vector.

Definition at line 117 of file MobileAtoms.cpp.

                                                                        {
  VectorXd packed(3 * mobile.size());
  for (Eigen::Index a = 0; a < mobile.size(); ++a) {
    packed.segment<3>(3 * a) = full.row(mobile(a));
  }
  return packed;
}

parseServeSpec()

std::vector< ServeEndpoint > eonc::parseServeSpec

(

const std::string &

spec

)

Parse a serve configuration string into endpoints.

Accepts comma-separated entries of the form "potential:port" or "potential:host:port". Examples: "lj:12345" "metatomic:12345,lj:12346" "metatomic:0.0.0.0:12345"

Parameters

spec	The comma-separated endpoint specification.

Returns

A vector of ServeEndpoint structs.

Definition at line 229 of file ServeMode.cpp.

                                                               {
  std::vector<ServeEndpoint> endpoints;
  std::istringstream stream(spec);
  std::string token;
 
  while (std::getline(stream, token, ',')) {
    // Trim whitespace
    token.erase(0, token.find_first_not_of(" \t"));
    token.erase(token.find_last_not_of(" \t") + 1);
    if (token.empty())
      continue;
 
    // Parse "potential:port" or "potential:host:port"
    size_t first_colon = token.find(':');
    if (first_colon == std::string::npos) {
      EONC_LOG_ERROR("Invalid serve spec '{}': expected 'potential:port'",
                     token);
      continue;
    }
 
    std::string pot_str = token.substr(0, first_colon);
    std::string rest = token.substr(first_colon + 1);
 
    // Trim parts after colon split
    pot_str.erase(0, pot_str.find_first_not_of(" \t"));
    pot_str.erase(pot_str.find_last_not_of(" \t") + 1);
    rest.erase(0, rest.find_first_not_of(" \t"));
    rest.erase(rest.find_last_not_of(" \t") + 1);
 
    // Lowercase the potential name
    std::transform(pot_str.begin(), pot_str.end(), pot_str.begin(), ::tolower);
 
    ServeEndpoint ep;
    ep.potential =
        magic_enum::enum_cast<PotType>(pot_str, magic_enum::case_insensitive)
            .value_or(PotType::UNKNOWN);
 
    if (ep.potential == PotType::UNKNOWN) {
      EONC_LOG_ERROR("Unknown potential type '{}'", pot_str);
      continue;
    }
 
    size_t second_colon = rest.find(':');
    if (second_colon != std::string::npos) {
      // "host:port" format
      ep.host = rest.substr(0, second_colon);
      ep.host.erase(0, ep.host.find_first_not_of(" \t"));
      ep.host.erase(ep.host.find_last_not_of(" \t") + 1);
      std::string port_str = rest.substr(second_colon + 1);
      port_str.erase(0, port_str.find_first_not_of(" \t"));
      port_str.erase(port_str.find_last_not_of(" \t") + 1);
      ep.port = static_cast<uint16_t>(std::stoi(port_str));
    } else {
      // "port" only
      ep.host = "localhost";
      ep.port = static_cast<uint16_t>(std::stoi(rest));
    }
 
    QUILL_LOG_INFO(eonc::log::get(), "Parsed endpoint: {} on {}:{}",
                   std::string(magic_enum::enum_name(ep.potential)), ep.host,
                   ep.port);
    endpoints.push_back(ep);
  }
 
  return endpoints;
}

resolveMobileAtoms() [1/2]

VectorXi eonc::resolveMobileAtoms	(	const Matter *	matter,
		const std::string &	atomList )

PHVA-class mobile set for FD Hessian and matrix-free Krylov (Lanczos / Davidson).

free/fixed on Matter is the optimizer mask. The mobile set is a (possibly proper) subset of free atoms: those that are displaced in finite-difference Hessian-vector products (Li & Jensen, Theor. Chem. Acc. 107, 211 (2002)).

atomList empty or "all" -> all free atoms (backward-compatible default). Otherwise comma/space-separated 0-based indices, intersected with free flags; order follows the list (duplicates dropped). Out-of-range and fixed indices are skipped.

Definition at line 64 of file MobileAtoms.cpp.

                                                                             {
  if (atomListMeansAll(atomList)) {
    return freeAtomIndices(matter);
  }
  const long n = matter->numberOfAtoms();
  std::vector<int> mobile;
  std::unordered_set<int> seen;
  std::string token;
  for (size_t p = 0; p <= atomList.size(); ++p) {
    const char c = (p < atomList.size()) ? atomList[p] : ',';
    if (c == ',' || c == ' ' || c == '\t' || p == atomList.size()) {
      if (!token.empty()) {
        try {
          const long idx = std::stol(token);
          if (idx >= 0 && idx < n && !matter->getFixed(idx) &&
              seen.insert(static_cast<int>(idx)).second) {
            mobile.push_back(static_cast<int>(idx));
          }
        } catch (const std::exception &) {
          // skip non-integer tokens
        }
        token.clear();
      }
    } else {
      token.push_back(c);
    }
  }
  VectorXi out(static_cast<Eigen::Index>(mobile.size()));
  for (Eigen::Index k = 0; k < out.size(); ++k) {
    out(k) = mobile[static_cast<size_t>(k)];
  }
  return out;
}

resolveMobileAtoms() [2/2]

VectorXi eonc::resolveMobileAtoms	(	const Matter *	matter,
		const VectorXi &	candidates )

Explicit candidate indices, intersected with free flags (order preserved, duplicates dropped).

Used by pyeonclient compute(..., atoms=...).

Definition at line 98 of file MobileAtoms.cpp.

                                                                              {
  const long n = matter->numberOfAtoms();
  std::vector<int> mobile;
  std::unordered_set<int> seen;
  mobile.reserve(static_cast<size_t>(candidates.size()));
  for (Eigen::Index k = 0; k < candidates.size(); ++k) {
    const long idx = candidates(k);
    if (idx >= 0 && idx < n && !matter->getFixed(idx) &&
        seen.insert(static_cast<int>(idx)).second) {
      mobile.push_back(static_cast<int>(idx));
    }
  }
  VectorXi out(static_cast<Eigen::Index>(mobile.size()));
  for (Eigen::Index k = 0; k < out.size(); ++k) {
    out(k) = mobile[static_cast<size_t>(k)];
  }
  return out;
}

runAlternativeRotation()

std::optional< DimerRotationResult > eonc::runAlternativeRotation ( DimerRotationBackend backend, const std::shared_ptr< Matter > & matter, const Parameters & params, const std::shared_ptr< Potential > & pot, const AtomMatrix & initialDirection, quill::Logger * log = nullptr )

inlinenodiscard

Run Lanczos, Davidson, or LOR.

Classical returns nullopt (stock rotation loop).

Definition at line 70 of file DimerRotationDispatch.h.

                                                                  {
  if (!usesAlternativeRotation(backend)) {
    return std::nullopt;
  }
 
  const std::string_view backendName = magic_enum::enum_name(backend);
 
  if (log) {
    QUILL_LOG_INFO(log,
                   "[DimerRot] rotation_backend={} (skipping classical "
                   "constrained rotation loop)",
                   backendName);
  }
 
  DimerRotationResult result;
  switch (backend) {
  case DimerRotationBackend::LOR:
    result = detail::runRotationSolver<LORRotation>(matter, params, pot,
                                                    initialDirection);
    break;
  case DimerRotationBackend::Lanczos:
    result = detail::runRotationSolver<Lanczos>(matter, params, pot,
                                                initialDirection);
    break;
  case DimerRotationBackend::Davidson:
    result = detail::runRotationSolver<Davidson>(matter, params, pot,
                                                 initialDirection);
    break;
  case DimerRotationBackend::Classical:
    return std::nullopt;
  }
 
  if (log) {
    QUILL_LOG_INFO(log,
                   "[DimerRot] alternative rotation done backend={} "
                   "eigenvalue={:.6f} force_calls={}",
                   backendName, result.eigenvalue, result.forceCalls);
  }
  return result;
}

serveFromConfig()

void eonc::serveFromConfig

(

const Parameters &

params

)

Start serve mode from config-file parameters.

Reads serve_options from params and dispatches to the appropriate mode:

• If endpoints is set, uses multi-model serve (serveMultiple).
• If gateway_port > 0, uses gateway mode (serveGateway).
• Otherwise, uses replicated mode (serveReplicated).

Parameters

params

The eOn parameters with serve_options populated.

Definition at line 200 of file ServeMode.cpp.

                                               {
  const auto &opts = params.serve_options;
 
  // Multi-model endpoints take priority
  if (!opts.endpoints.empty()) {
    auto endpoints = parseServeSpec(opts.endpoints);
    if (endpoints.empty()) {
      EONC_LOG_ERROR("No valid endpoints in spec: {}", opts.endpoints);
      return;
    }
    serveMultiple(endpoints, params);
    return;
  }
 
  // Gateway mode
  if (opts.gateway_port > 0) {
    size_t pool = (opts.replicas > 0) ? opts.replicas : 1;
    serveGateway(params, opts.host, opts.gateway_port, pool);
    return;
  }
 
  // Replicated mode (default)
  serveReplicated(params, opts.host, opts.port, opts.replicas);
}

serveGateway()

void eonc::serveGateway	(	const Parameters &	params,
		const std::string &	host,
		uint16_t	port,
		size_t	pool_size )

Start a gateway server backed by a pool of potential instances.

Creates pool_size instances of the configured potential and serves them behind a single gateway port. Incoming requests are dispatched round-robin across the pool. This gives clients a single endpoint while spreading load.

Parameters

params	The eOn parameters (potential_options.potential must be set).
host	The hostname to listen on.
port	The gateway port.
pool_size	Number of potential instances in the pool.

Definition at line 167 of file ServeMode.cpp.

                                                   {
  if (pool_size == 0) {
    EONC_LOG_ERROR("Pool size must be >= 1");
    return;
  }
 
  auto pot_type = params.potential_options.potential;
  EONC_LOG_INFO("Creating pool of {} {} instances for gateway on {}:{}",
                pool_size, std::string(magic_enum::enum_name(pot_type)), host,
                port);
 
  std::vector<ForceCallback> pool;
  pool.reserve(pool_size);
 
  for (size_t i = 0; i < pool_size; ++i) {
    auto eon_pot = eonc::helpers::makePotential(params);
    if (!eon_pot) {
      EONC_LOG_ERROR("Failed to create potential instance {}/{}", i + 1,
                     pool_size);
      return;
    }
    pool.push_back(makeForceCallback(std::move(eon_pot)));
  }
 
  EONC_LOG_INFO("Pool ready, starting gateway server");
  startPooledRpcServer(std::move(pool), host, port);
}

serveMode()

void eonc::serveMode	(	const Parameters &	params,
		const std::string &	host,
		uint16_t	port )

Start a single rgpot-compatible Cap'n Proto RPC server.

Wraps eOn's Potential::force() as an rgpot PotentialBase and serves it over Cap'n Proto RPC. Blocks until the server is killed.

Parameters

params	The eOn parameters (potential_options.potential must be set).
host	The hostname to listen on (e.g., "localhost" or "*").
port	The TCP port to listen on.

Definition at line 56 of file ServeMode.cpp.

                              {
  auto pot_type = params.potential_options.potential;
  EONC_LOG_INFO("Creating potential: {}",
                std::string(magic_enum::enum_name(pot_type)));
 
  auto eon_pot = eonc::helpers::makePotential(params);
  if (!eon_pot) {
    EONC_LOG_ERROR("Failed to create potential of type {}",
                   std::string(magic_enum::enum_name(pot_type)));
    return;
  }
 
  auto callback = makeForceCallback(std::move(eon_pot));
 
  // Blocks until killed (runs Cap'n Proto event loop)
  startRpcServer(std::move(callback), host, port);
}

serveMultiple()

void eonc::serveMultiple	(	const std::vector< ServeEndpoint > &	endpoints,
		const Parameters &	params )

Serve multiple potentials concurrently on different ports.

Each endpoint gets its own thread, its own potential instance, and its own Cap'n Proto event loop. All threads block until SIGINT/SIGTERM.

Parameters

endpoints	List of {potential, host, port} configurations.
params	Base eOn parameters (potential type is overridden per endpoint).

Definition at line 79 of file ServeMode.cpp.

                                                  {
  if (endpoints.empty()) {
    EONC_LOG_ERROR("No serve endpoints specified");
    return;
  }
 
  // Single endpoint: run in the main thread (no extra overhead)
  if (endpoints.size() == 1) {
    auto params = base_params;
    params.potential_options.potential = endpoints[0].potential;
    serveMode(params, endpoints[0].host, endpoints[0].port);
    return;
  }
 
  // Multiple endpoints: one thread per server
  EONC_LOG_INFO("Starting {} concurrent RPC servers", endpoints.size());
 
  std::vector<std::thread> threads;
  threads.reserve(endpoints.size());
 
  for (const auto &ep : endpoints) {
    threads.emplace_back([&base_params, ep]() {
      auto params = base_params;
      params.potential_options.potential = ep.potential;
      auto pot_name = std::string(magic_enum::enum_name(ep.potential));
 
      EONC_LOG_INFO("[{}:{}] Creating potential: {}", ep.host, ep.port,
                    pot_name);
 
      auto eon_pot = eonc::helpers::makePotential(params);
      if (!eon_pot) {
        EONC_LOG_ERROR("[{}:{}] Failed to create potential {}", ep.host,
                       ep.port, pot_name);
        return;
      }
 
      auto callback = makeForceCallback(std::move(eon_pot));
      startRpcServer(std::move(callback), ep.host, ep.port);
    });
  }
 
  // Wait for all threads (they block until killed)
  for (auto &t : threads) {
    if (t.joinable()) {
      t.join();
    }
  }
}

serveReplicated()

void eonc::serveReplicated	(	const Parameters &	params,
		const std::string &	host,
		uint16_t	base_port,
		size_t	replicas )

Serve N replicas of the same potential across sequential ports.

Starts replicas threads, each serving the same potential type on ports base_port, base_port+1, ..., base_port+replicas-1.

Parameters

params	The eOn parameters (potential_options.potential must be set).
host	The hostname to listen on.
base_port	The first port; replicas use base_port+0 .. base_port+N-1.
replicas	Number of concurrent server instances.

Definition at line 133 of file ServeMode.cpp.

                                                          {
  if (replicas == 0) {
    EONC_LOG_ERROR("Replicas must be >= 1");
    return;
  }
  if (replicas == 1) {
    serveMode(params, host, base_port);
    return;
  }
 
  EONC_LOG_INFO("Starting {} replicated servers on ports {}-{}", replicas,
                base_port, base_port + replicas - 1);
 
  std::vector<std::thread> threads;
  threads.reserve(replicas);
 
  for (size_t i = 0; i < replicas; ++i) {
    uint16_t port = static_cast<uint16_t>(base_port + i);
    threads.emplace_back(
        [&params, &host, port]() { serveMode(params, host, port); });
  }
 
  for (auto &t : threads) {
    if (t.joinable()) {
      t.join();
    }
  }
}

startPooledRpcServer()

void eonc::startPooledRpcServer	(	std::vector< ForceCallback >	pool,
		const std::string &	host,
		uint16_t	port )

Start a blocking Cap'n Proto RPC server backed by a pool of force callbacks dispatched round-robin.

Parameters

pool	Vector of force callbacks (one per pool instance).
host	The hostname to listen on.
port	The TCP port to listen on.

Definition at line 185 of file ServeRpcServer.cpp.

                                                                      {
  EONC_LOG_INFO("Starting pooled RPC gateway on {}:{} with {} instances", host,
                port, pool.size());
 
  capnp::EzRpcServer server(kj::heap<PooledCallbackPotImpl>(std::move(pool)),
                            host, port);
 
  auto &waitScope = server.getWaitScope();
  EONC_LOG_INFO("Gateway ready on port {}. Ctrl+C to stop.", port);
  kj::NEVER_DONE.wait(waitScope);
}

startRpcServer()

void eonc::startRpcServer	(	ForceCallback	callback,
		const std::string &	host,
		uint16_t	port )

Start a blocking Cap'n Proto RPC server using a force callback.

Defined in a separate translation unit to avoid naming collision between eOn's class Potential and the capnp-generated Potential interface.

Parameters

callback	Force evaluation function.
host	The hostname to listen on.
port	The TCP port to listen on.

Definition at line 103 of file ServeRpcServer.cpp.

                                         {
  EONC_LOG_INFO("Starting Cap'n Proto RPC server on {}:{}", host, port);
 
  capnp::EzRpcServer server(kj::heap<CallbackPotImpl>(std::move(callback)),
                            host, port);
 
  auto &waitScope = server.getWaitScope();
  EONC_LOG_INFO("Server ready on port {}. Ctrl+C to stop.", port);
  kj::NEVER_DONE.wait(waitScope);
}

strchrcount()

int eonc::strchrcount	(	const char *	haystack,
		char	needle )

Definition at line 70 of file Bundling.cpp.

                                                   {
  int count = 0;
  for (const char *ch = haystack; *ch != '\0'; ch++) {
    if (*ch == needle) {
      count++;
    }
  }
  return count;
}

unbundle()

std::vector< std::string > eonc::unbundle

(

int

number

)

Definition at line 80 of file Bundling.cpp.

                                          {
  std::vector<std::string> filenames;
 
  for (const auto &entry : fs::directory_iterator(".")) {
    std::string originalFilename = entry.path().filename().string();
 
    if (originalFilename[0] == '.') {
      continue;
    }
 
    int numUnderscores = strchrcount(originalFilename.c_str(), '_');
    if (numUnderscores < 1) {
      continue;
    }
 
    // Find the last underscore
    auto upos = originalFilename.rfind('_');
    if (upos == std::string::npos) {
      continue;
    }
 
    // Find the last period
    auto dpos = originalFilename.rfind('.');
    if (dpos == std::string::npos || dpos <= upos) {
      continue;
    }
 
    std::string numstr = originalFilename.substr(upos + 1, dpos - upos - 1);
    if (!numstr.empty() &&
        std::isdigit(static_cast<unsigned char>(numstr[0]))) {
      int bundleNumber = std::atoi(numstr.c_str());
      if (bundleNumber != number) {
        continue;
      }
    }
 
    std::string baseName = originalFilename.substr(0, upos);
    // Drop the "_<n>" token and keep everything after it, so a compound
    // extension (".con.gz", ".con.zst") survives whichever side of the
    // underscore it sits on.
    size_t extStart =
        originalFilename.find_first_not_of("0123456789", upos + 1);
    if (extStart == std::string::npos) {
      extStart = originalFilename.size();
    }
    std::string newFilename = baseName + originalFilename.substr(extStart);
 
    try {
      fs::copy_file(originalFilename, newFilename,
                    fs::copy_options::overwrite_existing);
      filenames.push_back(newFilename);
    } catch (const fs::filesystem_error &e) {
      EONC_LOG_ERROR("unbundle: problem copying {} to {}: {}", originalFilename,
                     newFilename, e.what());
    }
  }
 
  return filenames;
}

unpackMobileRows()

void eonc::unpackMobileRows	(	const VectorXd &	packed,
		const VectorXi &	mobile,
		AtomMatrix &	full )

Write a 3*n_mobile vector into full AtomMatrix rows (other rows unchanged).

Definition at line 125 of file MobileAtoms.cpp.

                                        {
  for (Eigen::Index a = 0; a < mobile.size(); ++a) {
    full.row(mobile(a)) = packed.segment<3>(3 * a);
  }
}

usesAlternativeRotation()

bool eonc::usesAlternativeRotation ( DimerRotationBackend backend )

inlinenodiscardconstexprnoexcept

Definition at line 41 of file DimerRotationDispatch.h.

                                                               {
  return backend != DimerRotationBackend::Classical;
}

Variable Documentation

AM

double eonc::AM = 1.0 / IM

constexpr

Definition at line 18 of file RandomNumbers.h.

EPS

double eonc::EPS = 1.2e-7

constexpr

Definition at line 21 of file RandomNumbers.h.

IA1

long eonc::IA1 = 40014

constexpr

Definition at line 26 of file RandomNumbers.h.

IA2

long eonc::IA2 = 40692

constexpr

Definition at line 27 of file RandomNumbers.h.

IM

double eonc::IM = 2147483647.0

constexpr

Definition at line 17 of file RandomNumbers.h.

IM1

long eonc::IM1 = 2147483563

constexpr

Definition at line 23 of file RandomNumbers.h.

IM2

long eonc::IM2 = 2147483399

constexpr

Definition at line 24 of file RandomNumbers.h.

IMM1

long eonc::IMM1 = IM1 - 1

constexpr

Definition at line 25 of file RandomNumbers.h.

IQ1

long eonc::IQ1 = 53668

constexpr

Definition at line 28 of file RandomNumbers.h.

IQ2

long eonc::IQ2 = 52774

constexpr

Definition at line 29 of file RandomNumbers.h.

IR1

long eonc::IR1 = 12211

constexpr

Definition at line 30 of file RandomNumbers.h.

IR2

long eonc::IR2 = 3791

constexpr

Definition at line 31 of file RandomNumbers.h.

MXCSR_MASK_IM

unsigned eonc::MXCSR_MASK_IM = 1u << 7

staticconstexpr

Definition at line 90 of file fpe_handler.cpp.

MXCSR_MASK_OM

unsigned eonc::MXCSR_MASK_OM = 1u << 10

staticconstexpr

Definition at line 92 of file fpe_handler.cpp.

MXCSR_MASK_ZM

unsigned eonc::MXCSR_MASK_ZM = 1u << 9

staticconstexpr

Definition at line 91 of file fpe_handler.cpp.

NDIV

int eonc::NDIV = 1 + (IM / NTAB)

constexpr

Definition at line 20 of file RandomNumbers.h.

NTAB

int eonc::NTAB = 32

constexpr

Definition at line 19 of file RandomNumbers.h.

RNMX

double eonc::RNMX = 1.0 - EPS

constexpr

Definition at line 22 of file RandomNumbers.h.