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	pairhess
namespace	params_ssot
namespace	pathintegral
namespace	pbc
namespace	piqtst
namespace	pot
namespace	Prefactor
namespace	rng
namespace	safemath
namespace	tunneling
namespace	xtsci_eindir

Classes
struct	ams_options_t
struct	artn_options_t
class	ARTnResource
class	ARTnSaddleSearch
	Saddle search method using the Activation-Relaxation Technique nouveau. More...
struct	ase_nwchem_options_t
struct	ase_orca_options_t
class	AtomicGPDimer
struct	basin_hopping_options_t
class	BasinHoppingJob
class	BasinHoppingSaddleSearch
struct	bgsd_options_t
class	BGSDObjectiveFunction
class	BiasedGradientSquaredDescent
class	BondBoost
	Functionality relying on the conjugate gradients algorithm. More...
struct	catlearn_options_t
class	CollectiveIDPPObjectiveFunction
class	ConjugateGradients
	Decleration of the Conjugate Gradients optimizer. More...
struct	constants_t
class	Davidson
	Davidson method for the lowest Hessian curvature mode (min-mode). More...
struct	davidson_options_t
struct	debug_options_t
struct	DecodedDiv
struct	dftd_options_t
class	Dimer
	Classic dimer method to find the lowest curvature mode. More...
struct	dimer_options_t
class	DimerModeLostException
class	DimerModeRestoredException
struct	DimerRotationResult
	Result of a non-classical dimer rotation backend (mode estimate only). More...
class	Dynamics
struct	dynamics_options_t
struct	DynamicsConfig
	Configuration extracted from Parameters for Dynamics. More...
class	DynamicsJob
class	DynamicsSaddleSearch
struct	expr_options_t
class	FiniteDifferenceJob
class	FIRE
class	ForceCallTimer
	RAII wrapper for tracking force calls over a scope. More...
class	FPEGuard
class	FPEHandler
class	GleThermostat
	Colored-noise (generalized Langevin) thermostat. More...
struct	global_optimization_options_t
class	GlobalOptimization
class	GlobalOptimizationJob
struct	gp_surrogate_options_t
struct	gpr_dimer_options_t
class	GPSurrogateJob
class	Hessian
struct	hessian_options_t
class	HessianJob
class	Hyperdynamics
struct	hyperdynamics_options_t
class	IARTnResource
class	IDPPObjectiveFunction
class	IIRAResource
class	ILammpsLoader
class	IMetatomicLoader
class	ImprovedDimer
struct	instanton_options_t
class	InstantonJob
	Ring-polymer instanton ([Instanton]): the tunnelling splitting between two minima beyond one-dimensional WKB (mode splitting), or the thermal rate through a saddle (mode rate): the ring below the crossover temperature, and the parabolic barrier factor times harmonic transition-state theory above it, written to instanton.con and results.dat. More...
class	IPluginLoader
class	IPotRegistry
struct	ira_options_t
class	IRACompare
	C++ wrapper for the IRA (Iterative Rotations and Assignments) library. More...
class	IRAResource
class	Job
	Declaration of job class. More...
struct	JobResultEnvelope
	In-memory JobResult scalars. More...
class	LammpsLoader
class	Lanczos
struct	lanczos_options_t
class	LBFGS
class	LORRotation
class	LowestEigenmode
	Base for eigenmode solvers. More...
struct	main_options_t
class	Matter
struct	metatomic_options_t
class	MetatomicDynPot
class	MetatomicLoader
class	MinimizationJob
class	MinModeObjectiveFunction
class	MinModeSaddleSearch
struct	monte_carlo_options_t
class	MonteCarlo
class	MonteCarloJob
struct	mopac_options_t
struct	neb_options_t
class	NEBObjectiveFunction
class	NudgedElasticBand
class	NudgedElasticBandJob
class	ObjectiveFunction
struct	oh_tst_options_t
class	OHTSTJob
class	Optimizer
struct	optimizer_options_t
struct	OptimizerConfig
	Declaration of the optimizer class. More...
struct	parallel_replica_options_t
class	ParallelReplicaJob
class	Parameters
struct	ParametersLoadAccess
	Write hole for INI/JSON loaders and nanobind property setters. More...
class	PluginLoader
class	PointJob
class	Potential
struct	potential_options_t
class	PotentialConstructionScope
	RAII: Potential default construction records on this registry instead of PotRegistry::get(). More...
class	PotRegistry
struct	prefactor_options_t
class	PrefactorJob
struct	process_search_options_t
class	ProcessSearchJob
	Declaration of the Process Search job. More...
class	Quickmin
struct	replica_exchange_options_t
class	ReplicaDynamicsJob
	Base class for replica dynamics jobs (TAD, SafeHyper). More...
class	ReplicaExchangeJob
struct	rgpot_options_t
class	Runtime
	Move-only composition root for process resources (dlopen loaders and the potential registry). More...
struct	saddle_search_options_t
class	SaddleSearchJob
	Declaration of the Saddle Search job. More...
class	SaddleSearchMethod
class	SafeHyperJob
struct	serve_options_t
struct	ServeEndpoint
	Configuration for a single serve endpoint. More...
struct	socket_nwchem_options_t
class	SteepestDescent
class	StructureComparisonJob
struct	StructureComparisonOptions
	Options for Matter::compare / distance. More...
class	SurrogatePotential
struct	tad_options_t
class	TADJob
class	TestJob
struct	thermostat_options_t
class	VesinNeighbors
	RAII wrapper around vesin_neighbors for Matter-style boxes (double[9] row-major 3×3 cell, same layout as Matter::cell). More...
struct	X86DivRegs
struct	xtb_options_t
class	XtsciOptimizer
	xtsci-optimize backend. More...
struct	zbl_options_t
class	ZBLRepulsiveIDPPObjective

Concepts
concept	ThreadSafeQueryable
	Duck-typed thread-safety query.

Typedefs
using	EigenmodeStrategy = LowestEigenmode
	Type-erased eigenmode solver. Layout is the same with or without gprd.
using	JobFactory
using	structure_comparison_options_t = StructureComparisonOptions
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 ,   DFTD3 , DFTD4 , EXPR , MOPAC }
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 , Instanton }
enum class	OptType {   Unknown = -1 , None = 0 , QM , CG ,   LBFGS , FIRE , SD , XTSCI }
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	FdScheme { OneSided , Central , Fourth }
	Real finite-difference scheme for the assembled Hessian and for Lanczos/Davidson Hessian-vector products. More...
enum class	PbcConvention { Legacy = 0 , MinimumImage = 1 }

Functions
int	getBundleSize ()
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)
std::shared_ptr< LowestEigenmode >	buildEigenmodeStrategy (std::shared_ptr< Matter > matter, const Parameters &params, std::shared_ptr< Potential > pot)
double	maxFreeAtomForceNorm (const double *forces, const double *fixed, long nAtoms)
	Max Euclidean norm over N x 3 row-major force rows.
template<typename Work>
void	forEachImage (long n, Work &&work)
static DecodedDiv	decode_div_insn (const unsigned char *code, bool long_mode)
static X86DivRegs	x86_div_regs (void *scp)
static bool	advance_integer_div (void *scp)
static void	write_fault_rip (void *scp)
static void	fpe_signal_handler (int sig, siginfo_t *sip, void *scp)
void	enableFPE ()
void	disableFPE ()
std::vector< int >	greedyColorCutoffGraph (const std::vector< std::vector< int > > &adj)
	Greedy coloring of an undirected graph.
std::vector< int >	colorMobileCutoffGraph (const Matter &matter, const VectorXi &atoms, double cutoff)
	Conflict graph on atoms: two mobile atoms share an edge when their closed cutoff neighborhoods intersect, then greedy-colored.
std::vector< double >	cartesianMode (const Matter &matter, const VectorXi &atoms, const Eigen::Ref< const VectorXd > &mode)
	Cartesian displacement of every atom along one mass-weighted mode over the mobile degrees of freedom atoms: x = q / sqrt(m), unit norm, zero on atoms outside atoms.
bool	writeNormalModes (Matter &matter, const VectorXi &atoms, const VectorXd &eigenvalues, const MatrixXd &modes, const std::string &path)
	Writes one frame of matter per mode to path, the mode as the displacements section and mode_eigenvalue (eV / (Angstrom^2 amu)), hbar_omega (eV, negative for an imaginary mode) and wavenumber (cm^-1, same sign) as frame metadata.
bool	trivialModeCountIsPhysical (long removed, long fixedAtoms)
	Whether removed zero-frequency modes are what the structure's symmetries give: 6 for a free cluster (3 translations and 3 rotations), 5 for a linear one, 3 for a periodic cell, where rotations are no symmetry of the lattice, and none once any atom is fixed.
void	forceJobRegistration ()
std::map< JobType, JobFactory > &	jobTable ()
void	registerJob (JobType type, JobFactory factory)
void	evaluateTogether (Potential &pot, std::span< Matter *const > systems)
	Evaluates every system that needs a force update.
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).
AtomMatrix	minImageRemoveRigidDrift (const Matter &reference, AtomMatrix diff, Eigen::RowVector3d *totalDrift)
	Minimum-image a free-atom difference and remove rigid translation.
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.
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.
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.
void	lattice_rows_to_fortran_box (const Matrix3d &cell, double *box)
	Pack an eOn cell for pARTn artn_step.
void	eigenmodeCompute (LowestEigenmode &s, std::shared_ptr< Matter > matter, AtomMatrix direction)
double	eigenmodeGetEigenvalue (LowestEigenmode &s)
AtomMatrix	eigenmodeGetEigenvector (LowestEigenmode &s)
ImprovedDimer *	asImprovedDimer (LowestEigenmode &s)
long	eigenmodeTotalForceCalls (LowestEigenmode &s)
double	eigenmodeStatsTorque (LowestEigenmode &s)
double	eigenmodeStatsAngle (LowestEigenmode &s)
long	eigenmodeStatsRotations (LowestEigenmode &s)
long	eigenmodeTotalIterations (LowestEigenmode &s)
FdScheme	parseFdScheme (std::string_view scheme)
template<class M>
M	fdForceDerivative (FdScheme scheme, double dr, const M &f0, const M &fPlus, const M &fMinus, const M &fPlus2, const M &fMinus2)
	Derivative of a sampled force map along one real step of length dr.
template<class Eval>
VectorXd	fdHessianVector (FdScheme scheme, double dr, const VectorXd &force0, Eval &&eval)
	Energy Hessian-vector product -dF.
constexpr std::uint32_t	maskWindowsMxcsrForContinue (std::uint32_t mxcsr)
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 ()
double	pmfScanS (long plane, long nScan, double guideLen)
	Uniform PMF-scan coordinate.
template<class P> requires ThreadSafeQueryable<P>
bool	potIsThreadSafe (const P &p) noexcept
template<class P> requires requires(const P &p) { { p.isSharedInstanceThreadSafe() } -> std::convertible_to<bool>; }
bool	potAllowsSharedInstance (const P &p) noexcept
bool	lammpsWorkerReaped (long got, long child, int err)
	True when waitpid has collected the child. EINTR is not a collection.
std::int64_t	lammpsScreenCursor (std::int64_t pos, std::int64_t fileSize, bool restarted)
	Byte offset at which to keep copying a LAMMPS screen file.
std::vector< std::string >	lammpsOpenArgs (bool logging, bool with_omp, const std::string &screen)
	LAMMPS argv.

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 std::uint32_t	kWindowsMxcsrExceptionMasks = 0x1F80u
constexpr double	kEvToWavenumber = 8065.543937349212
	1 eV in cm^-1, e / (h c) from the exact SI values.
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 = LowestEigenmode

Type-erased eigenmode solver. Layout is the same with or without gprd.

Definition at line 25 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.

JobFactory

using eonc::JobFactory

Initial value:

 
std::function<std::unique_ptr<Job>(std::unique_ptr<Parameters>, Runtime &)>

Definition at line 16 of file JobRegistry.h.

structure_comparison_options_t

using eonc::structure_comparison_options_t = StructureComparisonOptions

Definition at line 185 of file ParametersOptions.h.

Enumeration Type Documentation

DimerRotationBackend

enum class eonc::DimerRotationBackend

strong

Enumerator
Classical
Lanczos
Davidson
LOR

Definition at line 122 of file BaseStructures.h.

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

FdScheme

enum class eonc::FdScheme

strong

Real finite-difference scheme for the assembled Hessian and for Lanczos/Davidson Hessian-vector products.

Complex-step is not a scheme: cutoffs and external potentials are not holomorphic.

Enumerator
OneSided
Central
Fourth

Definition at line 25 of file FiniteDifference.h.

{ OneSided, Central, Fourth };

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
Instanton

Definition at line 77 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,
  Instanton
};

NEBInit

enum class eonc::NEBInit

strong

Enumerator
LINEAR
IDPP
IDPP_COLLECTIVE
SIDPP
SIDPP_ZBL
FILE

Definition at line 115 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
XTSCI

Definition at line 103 of file BaseStructures.h.

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

PbcConvention

enum class eonc::PbcConvention

strong

Enumerator
Legacy
MinimumImage

Definition at line 36 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
DFTD3
DFTD4
EXPR
MOPAC

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,
  DFTD3,
  DFTD4,
  EXPR,
  MOPAC
};

RunStatus

enum class eonc::RunStatus

strong

Enumerator
GOOD
FAIL_MAX_ITERATIONS
FAIL_POTENTIAL_FAILED

Definition at line 117 of file BaseStructures.h.

{ GOOD = 0, FAIL_MAX_ITERATIONS, FAIL_POTENTIAL_FAILED };

Function Documentation

advance_integer_div()

bool eonc::advance_integer_div ( void * scp )

static

Definition at line 249 of file fpe_handler.cpp.

                                           {
  X86DivRegs regs = x86_div_regs(scp);
  if (regs.ip == nullptr || regs.ax == nullptr || regs.dx == nullptr) {
    return false;
  }
  const auto *code = reinterpret_cast<const unsigned char *>(*regs.ip);
  DecodedDiv div = decode_div_insn(code, sizeof(void *) == 8);
  if (div.length == 0) {
    return false;
  }
  if (div.width <= 2) {
    *regs.ax &= ~uintptr_t{0xFFFFu};
    if (div.width == 2) {
      *regs.dx &= ~uintptr_t{0xFFFFu};
    }
  } else {
    *regs.ax = 0;
    *regs.dx = 0;
  }
  *regs.ip += static_cast<uintptr_t>(div.length);
  return true;
}

asImprovedDimer()

ImprovedDimer * eonc::asImprovedDimer ( LowestEigenmode & s )

inline

Definition at line 44 of file EigenmodeStrategy.h.

                                                          {
  return dynamic_cast<ImprovedDimer *>(&s);
}

atomListMeansAll()

bool eonc::atomListMeansAll

(

const std::string &

atomList

)

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

Definition at line 22 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< LowestEigenmode > eonc::buildEigenmodeStrategy	(	std::shared_ptr< Matter >	matter,
		const Parameters &	params,
		std::shared_ptr< Potential >	pot )

Definition at line 28 of file EigenmodeStrategy.cpp.

                                                     {
  if (params.saddle_search_options().minmode_method ==
      LowestEigenmode::MINMODE_DIMER) {
    if (params.dimer_options().improved) {
      return std::make_shared<ImprovedDimer>(matter, params, pot);
    }
    return std::make_shared<Dimer>(matter, params, pot);
  }
  if (params.saddle_search_options().minmode_method ==
      LowestEigenmode::MINMODE_LANCZOS) {
    return std::make_shared<Lanczos>(matter, params, pot);
  }
  if (params.saddle_search_options().minmode_method ==
      LowestEigenmode::MINMODE_DAVIDSON) {
    return std::make_shared<Davidson>(matter, params, pot);
  }
  if (params.saddle_search_options().minmode_method ==
      LowestEigenmode::MINMODE_GPRDIMER) {
#ifdef WITH_GPRD
    return std::make_shared<AtomicGPDimer>(matter, params, pot);
#else
    throw std::runtime_error(
        "min_mode_method=gprdimer needs a -Dwith_gprd build with the private "
        "gpr_optim repository checked out in subprojects/gpr_optim "
        "(rsync -a ../gpr_optim/ subprojects/gpr_optim/, then reconfigure)");
#endif
  }
  return std::make_shared<ImprovedDimer>(matter, params, pot);
}

bundle()

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

Definition at line 180 of file Bundling.cpp.

                                                    {
  for (const auto &filename : filenames) {
    const auto [baseName, ext] = splitBundleExtension(filename);
    const std::string newFilename =
        std::format("{}_{}{}", baseName, 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());
    }
  }
}

cartesianMode()

std::vector< double > eonc::cartesianMode	(	const Matter &	matter,
		const VectorXi &	atoms,
		const Eigen::Ref< const VectorXd > &	mode )

Cartesian displacement of every atom along one mass-weighted mode over the mobile degrees of freedom atoms: x = q / sqrt(m), unit norm, zero on atoms outside atoms.

Row-major N x 3.

Definition at line 748 of file Hessian.cpp.

                                                                        {
  const long n = matter.numberOfAtoms();
  std::vector<double> out(static_cast<size_t>(3 * n), 0.0);
  if (mode.size() != 3 * atoms.size()) {
    throw std::invalid_argument("cartesianMode: mode length is not 3 x atoms");
  }
  double norm2 = 0.0;
  for (long j = 0; j < mode.size(); ++j) {
    const long atom = atoms(j / 3);
    const double mass = matter.getMass(atom);
    if (!(mass > 0.0)) {
      throw std::invalid_argument("cartesianMode: atom without a mass");
    }
    const double x = mode(j) / std::sqrt(mass);
    out[static_cast<size_t>(3 * atom + j % 3)] = x;
    norm2 += x * x;
  }
  if (norm2 > 0.0) {
    const double scale = 1.0 / std::sqrt(norm2);
    for (double &x : out) {
      x *= scale;
    }
  }
  return out;
}

colorMobileCutoffGraph()

std::vector< int > eonc::colorMobileCutoffGraph	(	const Matter &	matter,
		const VectorXi &	atoms,
		double	cutoff )

Conflict graph on atoms: two mobile atoms share an edge when their closed cutoff neighborhoods intersect, then greedy-colored.

Empty when the neighbor list cannot be built.

Definition at line 266 of file Hessian.cpp.

                                                                              {
  return buildMobileColoring(matter, atoms, cutoff).color;
}

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");
 
#ifdef WITH_SERVE_MODE
  std::optional<std::string> config_path;
  std::optional<std::string> serve_spec;
  // Empty until the matching flag is passed. A value here makes has_value()
  // true, so -p alone takes the serve path and never reads a structure file.
  std::optional<std::string> serve_host;
  std::optional<uint16_t> serve_port;
  std::optional<size_t> replicas;
  std::optional<bool> gateway;
#endif
 
  auto params = Parameters{};
 
  const char *progname = (argc ? argv[0] : "eonclient");
 
  Argum::Parser parser;
 
  parser.add(Argum::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(Argum::Option("--version", "-v")
                 .help("Print version information")
                 .handler([&]() {
                   std::cout << VERSION_STRING << std::endl;
                   std::exit(EXIT_SUCCESS);
                 }));
 
  parser.add(Argum::Option("--features")
                 .help("Print compile-time features")
                 .handler([&]() {
                   printFeatures();
                   std::exit(EXIT_SUCCESS);
                 }));
 
  parser.add(Argum::Option("--minimize", "-m")
                 .help("Minimization of inputConfile saves to outputConfile")
                 .handler([&]() { mflag = true; }));
 
  parser.add(Argum::Option("--single", "-s")
                 .help("Single point energy of inputConfile")
                 .handler([&]() { sflag = true; }));
 
  parser.add(Argum::Option("--compare", "-c")
                 .help("Compare structures of inputConfile to outputConfile")
                 .handler([&]() { cflag = true; }));
 
  parser.add(
      Argum::Option("--optimizer", "-o")
          .argName("METHOD")
          .help("Optimization method")
          .handler([&](const std::string_view &value) { optimizer = value; }));
 
  parser.add(Argum::Option("--force", "-f")
                 .argName("VALUE")
                 .help("Convergence force")
                 .handler([&](const std::string_view &value) {
                   optConvergedForce = Argum::parseFloatingPoint<double>(value);
                 }));
 
  parser.add(
      Argum::Option("--tolerance", "-t")
          .argName("VALUE")
          .help("Distance tolerance")
          .handler([&](const std::string_view &value) {
            eonc::ParametersLoadAccess::structure_comparison_options(params)
                .distance_difference = Argum::parseFloatingPoint<double>(value);
          }));
 
  parser.add(Argum::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(
      Argum::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(
      Argum::Option("--serve-host")
          .argName("HOST")
          .help("Host to bind RPC server(s) to")
          .handler([&](const std::string_view &value) { serve_host = value; }));
 
  parser.add(Argum::Option("--serve-port")
                 .argName("PORT")
                 .help("Port for single-potential serve mode (used with -p)")
                 .handler([&](const std::string_view &value) {
                   serve_port = Argum::parseIntegral<uint16_t>(value);
                 }));
 
  parser.add(Argum::Option("--replicas")
                 .argName("N")
                 .help("Number of replicated server instances (used with -p)")
                 .handler([&](const std::string_view &value) {
                   replicas = Argum::parseIntegral<size_t>(value);
                 }));
 
  parser.add(Argum::Option("--gateway")
                 .help("Run a single gateway port backed by N pool instances "
                       "(use with -p and --replicas)")
                 .handler([&]() { gateway = true; }));
 
  parser.add(Argum::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(
      Argum::Positional("confile")
          .help("Input structure file")
          .occurs(Argum::zeroOrOneTime)
          .handler([&](const std::string_view &value) { confile = value; }));
 
  parser.add(
      Argum::Positional("confileout")
          .help("Output structure file (optional)")
          .occurs(Argum::zeroOrOneTime)
          .handler([&](const std::string_view &value) { confileout = value; }));
 
  try {
    parser.parse(argc, argv);
  } catch (const Argum::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).
  // Defaults are applied below with value_or; has_value() is the flag.
  if (pflag && !sflag && !mflag && !cflag &&
      (serve_host.has_value() || serve_port.has_value() ||
       replicas.has_value() || gateway.has_value())) {
    for (auto &ch : potential) {
      ch = std::tolower(static_cast<unsigned char>(ch));
    }
    eonc::ParametersLoadAccess::potential_options(params).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() &&
      (!eonc::ParametersLoadAccess::serve_options(params).endpoints.empty() ||
       eonc::ParametersLoadAccess::serve_options(params).gateway_port > 0 ||
       eonc::ParametersLoadAccess::serve_options(params).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) {
    eonc::ParametersLoadAccess::potential_options(params).potential =
        magic_enum::enum_cast<PotType>(potential, magic_enum::case_insensitive)
            .value_or(PotType::UNKNOWN);
  }
 
  if (!sflag) {
    eonc::ParametersLoadAccess::optimizer_options(params).method =
        magic_enum::enum_cast<OptType>(optimizer, magic_enum::case_insensitive)
            .value_or(OptType::CG);
    eonc::ParametersLoadAccess::optimizer_options(params).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.
    eonc::ParametersLoadAccess::structure_comparison_options(params)
        .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);
    }
    Matter probe(*matter);
    if (probe.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 16 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;
}

decode_div_insn()

DecodedDiv eonc::decode_div_insn ( const unsigned char * code, bool long_mode )

static

Definition at line 120 of file fpe_handler.cpp.

                                                                             {
  DecodedDiv out{0, 0};
  const unsigned char *p = code;
  const unsigned char *limit = code + 15;
  bool operand16 = false;
  bool rex_w = false;
  bool addr16 = false;
  while (p < limit) {
    unsigned char c = *p;
    if (c == 0x66) {
      operand16 = true;
      ++p;
      continue;
    }
    if (c == 0x67) {
      if (!long_mode) {
        addr16 = true;
      }
      ++p;
      continue;
    }
    if (c == 0xF0 || c == 0xF2 || c == 0xF3 || c == 0x26 || c == 0x2E ||
        c == 0x36 || c == 0x3E || c == 0x64 || c == 0x65) {
      ++p;
      continue;
    }
    if (long_mode && c >= 0x40 && c <= 0x4F) {
      rex_w = (c & 0x08) != 0;
      ++p;
      continue;
    }
    break;
  }
  if (addr16 || p >= limit) {
    return out;
  }
  unsigned char opcode = *p++;
  if (opcode != 0xF6 && opcode != 0xF7) {
    return out;
  }
  if (p >= limit) {
    return out;
  }
  unsigned char modrm = *p++;
  unsigned mod = modrm >> 6;
  unsigned reg = (modrm >> 3) & 7u;
  unsigned rm = modrm & 7u;
  if (reg != 6u && reg != 7u) {
    return out;
  }
  if (mod != 3u) {
    bool have_sib = rm == 4u;
    unsigned sib_base = 0;
    if (have_sib) {
      if (p >= limit) {
        return out;
      }
      sib_base = static_cast<unsigned>(*p++ & 7u);
    }
    if ((mod == 0u && rm == 5u) || (have_sib && mod == 0u && sib_base == 5u) ||
        mod == 2u) {
      if (p + 4 > limit) {
        return out;
      }
      p += 4;
    } else if (mod == 1u) {
      if (p + 1 > limit) {
        return out;
      }
      ++p;
    }
  }
  int length = static_cast<int>(p - code);
  if (length < 2 || length > 15) {
    return out;
  }
  out.length = length;
  if (opcode == 0xF6) {
    out.width = 1;
  } else if (rex_w) {
    out.width = 8;
  } else if (operand16) {
    out.width = 2;
  } else {
    out.width = 4;
  }
  return out;
}

deleteUnbundledFiles()

void eonc::deleteUnbundledFiles

(

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

unbundledFilenames

)

Definition at line 145 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 527 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.__fpcr &= ~((1u << 8) | (1u << 9) | (1u << 10));
#elif defined(__x86_64__)
  // enableFPE clears MXCSR IM/ZM/OM. Restoring that environment unchanged
  // leaves the traps armed.
  env.__mxcsr |= (MXCSR_MASK_IM | MXCSR_MASK_ZM | MXCSR_MASK_OM);
  env.__mxcsr &= ~0x3Fu;
  env.__control = static_cast<unsigned short>(env.__control | (1u << 0) |
                                              (1u << 2) | (1u << 3));
  env.__status = static_cast<unsigned short>(env.__status & ~0x3Fu);
#endif
  fesetenv(&env);
#if defined(__x86_64__)
  _MM_SET_EXCEPTION_MASK(_MM_GET_EXCEPTION_MASK() | _MM_MASK_INVALID |
                         _MM_MASK_DIV_ZERO | _MM_MASK_OVERFLOW);
#endif
#endif
}

eigenmodeCompute()

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

inline

Definition at line 31 of file EigenmodeStrategy.h.

                                                   {
  s.compute(matter, direction);
}

eigenmodeGetEigenvalue()

double eonc::eigenmodeGetEigenvalue ( LowestEigenmode & s )

inline

Definition at line 36 of file EigenmodeStrategy.h.

                                                         {
  return s.getEigenvalue();
}

eigenmodeGetEigenvector()

AtomMatrix eonc::eigenmodeGetEigenvector ( LowestEigenmode & s )

inline

Definition at line 40 of file EigenmodeStrategy.h.

                                                              {
  return s.getEigenvector();
}

eigenmodeStatsAngle()

double eonc::eigenmodeStatsAngle ( LowestEigenmode & s )

inline

Definition at line 54 of file EigenmodeStrategy.h.

{ return s.statsAngle; }

eigenmodeStatsRotations()

long eonc::eigenmodeStatsRotations ( LowestEigenmode & s )

inline

Definition at line 56 of file EigenmodeStrategy.h.

                                                        {
  return s.statsRotations;
}

eigenmodeStatsTorque()

double eonc::eigenmodeStatsTorque ( LowestEigenmode & s )

inline

Definition at line 52 of file EigenmodeStrategy.h.

{ return s.statsTorque; }

eigenmodeTotalForceCalls()

long eonc::eigenmodeTotalForceCalls ( LowestEigenmode & s )

inline

Definition at line 48 of file EigenmodeStrategy.h.

                                                         {
  return s.totalForceCalls;
}

eigenmodeTotalIterations()

long eonc::eigenmodeTotalIterations ( LowestEigenmode & s )

inline

Definition at line 60 of file EigenmodeStrategy.h.

                                                         {
  return s.totalIterations;
}

enableFPE()

void eonc::enableFPE

(

)

Definition at line 491 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__)
  // ARM: trap-enable bits live in FPCR (IOE/DZE/OFE), not FPSR flags.
  fenv_t env;
  fegetenv(&env);
  env.__fpcr |= ((1u << 8) | (1u << 9) | (1u << 10));
  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);
  }
}

evaluateTogether()

void eonc::evaluateTogether	(	Potential &	pot,
		std::span< Matter *const >	systems )

Evaluates every system that needs a force update.

With a potential that batches, the dirty systems go through forceBatch in one call, so calculator groups take them together; otherwise each computes on its own. Systems that are current are left alone.

Definition at line 847 of file Matter.cpp.

                                                                      {
  std::vector<Matter *> dirty;
  for (Matter *m : systems) {
    if (m != nullptr && m->needsForceUpdate()) {
      dirty.push_back(m);
    }
  }
  if (dirty.empty()) {
    return;
  }
  if (dirty.size() == 1 || !pot.supportsBatchEvaluation()) {
    for (Matter *m : dirty) {
      m->getForcesRaw();
    }
    return;
  }
  const long n = dirty.size();
  const long atoms = dirty.front()->numberOfAtoms();
  std::vector<VectorXi> nrs(n);
  std::vector<Matrix3d> boxes(n);
  std::vector<const double *> posPtr, boxPtr;
  std::vector<const int *> nrsPtr;
  std::vector<double *> frcPtr;
  for (long j = 0; j < n; ++j) {
    Matter *m = dirty[j];
    if (m->numberOfAtoms() != atoms) {
      throw std::invalid_argument(
          "evaluateTogether: systems differ in atom count");
    }
    nrs[j] = m->getAtomicNrs();
    // A non-periodic system hands the potential a zero box, as
    // computePotential does.
    boxes[j] = m->getPeriodic() ? m->getCell() : Matrix3d::Zero().eval();
  }
  for (long j = 0; j < n; ++j) {
    posPtr.push_back(dirty[j]->getPositions().data());
    nrsPtr.push_back(nrs[j].data());
    frcPtr.push_back(dirty[j]->forcesData());
    boxPtr.push_back(boxes[j].data());
  }
  std::vector<double> energies(n), variances(n);
  pot.forceBatch(n, atoms, posPtr.data(), nrsPtr.data(), frcPtr.data(),
                 energies.data(), variances.data(), boxPtr.data());
  for (long j = 0; j < n; ++j) {
    dirty[j]->setComputedPotential(energies[j], variances[j]);
  }
}

fdForceDerivative()

template<class M>

M eonc::fdForceDerivative	(	FdScheme	scheme,
		double	dr,
		const M &	f0,
		const M &	fPlus,
		const M &	fMinus,
		const M &	fPlus2,
		const M &	fMinus2 )

Derivative of a sampled force map along one real step of length dr.

Fourth-order central: [-f(+2h) + 8 f(+h) - 8 f(-h) + f(-2h)] / (12 h).

Definition at line 46 of file FiniteDifference.h.

                                                                        {
  M slope = fPlus;
  switch (scheme) {
  case FdScheme::Fourth:
    slope = (-fPlus2 + 8.0 * fPlus - 8.0 * fMinus + fMinus2) / (12.0 * dr);
    break;
  case FdScheme::Central:
    slope = (fPlus - fMinus) / (2.0 * dr);
    break;
  case FdScheme::OneSided:
    slope = (fPlus - f0) / dr;
    break;
  }
  return slope;
}

fdHessianVector()

template<class Eval>

VectorXd eonc::fdHessianVector	(	FdScheme	scheme,
		double	dr,
		const VectorXd &	force0,
		Eval &&	eval )

Energy Hessian-vector product -dF.

eval(scale) is the force at x + scale * dr * v. One-sided and central read only the samples they need; fourth reads scale in {1, -1, 2, -2}.

Definition at line 67 of file FiniteDifference.h.

                                      {
  const VectorXd zero = VectorXd::Zero(force0.size());
  switch (scheme) {
  case FdScheme::Fourth: {
    const VectorXd fPlus = eval(1.0);
    const VectorXd fMinus = eval(-1.0);
    const VectorXd fPlus2 = eval(2.0);
    const VectorXd fMinus2 = eval(-2.0);
    return -fdForceDerivative(scheme, dr, force0, fPlus, fMinus, fPlus2,
                              fMinus2);
  }
  case FdScheme::Central: {
    const VectorXd fPlus = eval(1.0);
    const VectorXd fMinus = eval(-1.0);
    return -fdForceDerivative(scheme, dr, force0, fPlus, fMinus, zero, zero);
  }
  case FdScheme::OneSided:
    break;
  }
  const VectorXd fPlus = eval(1.0);
  return -fdForceDerivative(FdScheme::OneSided, dr, force0, fPlus, zero, zero,
                            zero);
}

forceJobRegistration()

void eonc::forceJobRegistration

(

)

Definition at line 41 of file Job.cpp.

{}

forEachImage()

template<typename Work>

void eonc::forEachImage ( long n, Work && work )

inline

Definition at line 19 of file ForEachImage.h.

                                                                       {
  if (n <= 0)
    return;
  const long hw =
      std::max(1L, static_cast<long>(std::thread::hardware_concurrency()));
  const long nThreads = std::min(n, hw);
  std::atomic<long> next{1};
  std::exception_ptr failure;
  std::mutex failureMutex;
  auto worker = [&] {
    for (long i = next.fetch_add(1); i <= n; i = next.fetch_add(1)) {
      try {
        work(i);
      } catch (...) {
        std::lock_guard<std::mutex> lock(failureMutex);
        if (!failure)
          failure = std::current_exception();
      }
    }
  };
  std::vector<std::thread> threads;
  threads.reserve(static_cast<size_t>(nThreads - 1));
  try {
    for (long t = 1; t < nThreads; t++)
      threads.emplace_back(worker);
  } catch (...) {
    // Thread creation failed; the threads already running finish the band.
    std::lock_guard<std::mutex> lock(failureMutex);
    if (!failure)
      failure = std::current_exception();
  }
  worker();
  for (auto &t : threads)
    t.join();
  if (failure)
    std::rethrow_exception(failure);
}

fpe_signal_handler()

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

static

Definition at line 289 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 volatile sig_atomic_t reported_int = 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;
 
  // Integer #DE has no mask bit. Returning here re-executes the divide.
  if (sip->si_code == FPE_INTDIV || sip->si_code == FPE_INTOVF) {
    if (reported_int == 0) {
      reported_int = 1;
      static constexpr char iprefix[] = "FPE (continuing, skipping divide): ";
      static constexpr char msg_idiv[] = "integer divide\n";
      static constexpr char msg_iovf[] = "integer overflow\n";
      const char *imsg = sip->si_code == FPE_INTDIV ? msg_idiv : msg_iovf;
      size_t imsg_len = sizeof(msg_iovf) - 1;
      if (sip->si_code == FPE_INTDIV) {
        imsg_len = sizeof(msg_idiv) - 1;
      }
      write(STDERR_FILENO, iprefix, sizeof(iprefix) - 1);
      write(STDERR_FILENO, imsg, imsg_len);
      write_fault_rip(scp);
    }
    if (!advance_integer_div(scp) && sip->si_code == FPE_INTDIV) {
      static constexpr char stuck[] =
          "FPE integer divide: could not skip faulting instruction\n";
      write(STDERR_FILENO, stuck, sizeof(stuck) - 1);
      _exit(128 + SIGFPE);
    }
    return;
  }
 
  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);
    // First-fault RIP for post-mortem addr2line / offline diagnosis.
    write_fault_rip(scp);
  }
 
#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
    }
  }
#elif defined(__linux__) && defined(__aarch64__)
  // ARM polarity is the opposite of MXCSR: FPCR trap-enable bits SET mean
  // trap. Clearing sticky FPSR flags alone re-executes with trapping still
  // armed on aarch64. Clear the matching FPCR enables.
  constexpr uint32_t kFpsimdMagic = 0x46508001u;
  constexpr unsigned kFpcrIoe = 1u << 8;
  constexpr unsigned kFpcrDze = 1u << 9;
  constexpr unsigned kFpcrOfe = 1u << 10;
  unsigned fpcr_clear = kFpcrIoe | kFpcrDze | kFpcrOfe;
  if (mxcsr_mask_bits == MXCSR_MASK_ZM) {
    fpcr_clear = kFpcrDze;
  } else if (mxcsr_mask_bits == MXCSR_MASK_IM) {
    fpcr_clear = kFpcrIoe;
  } else if (mxcsr_mask_bits == MXCSR_MASK_OM) {
    fpcr_clear = kFpcrOfe;
  }
  auto *ctx = static_cast<ucontext_t *>(scp);
  unsigned char *p =
      reinterpret_cast<unsigned char *>(ctx->uc_mcontext.__reserved);
  unsigned char *end = p + sizeof(ctx->uc_mcontext.__reserved);
  struct A64Head {
    uint32_t magic;
    uint32_t size;
  };
  struct Fpsimd {
    A64Head head;
    uint32_t fpsr;
    uint32_t fpcr;
  };
  while (p + sizeof(A64Head) <= end) {
    auto *h = reinterpret_cast<A64Head *>(p);
    if (h->magic == 0 || h->size < sizeof(A64Head)) {
      break;
    }
    if (h->magic == kFpsimdMagic && h->size >= sizeof(Fpsimd) &&
        p + h->size <= end) {
      auto *f = reinterpret_cast<Fpsimd *>(p);
      f->fpsr &= ~0x1Fu;
      f->fpcr &= ~fpcr_clear;
      break;
    }
    if (h->size == 0) {
      break;
    }
    p += h->size;
  }
#elif defined(__APPLE__) && defined(__x86_64__)
  // Darwin restores SSE state from uc_mcontext->__fs. Mask bits have the
  // same polarity as Linux MXCSR: set means the class does not trap. Without
  // that update the faulting instruction re-executes and re-raises forever.
  auto *ctx = static_cast<ucontext_t *>(scp);
  if (ctx->uc_mcontext) {
    auto &fs = ctx->uc_mcontext->__fs;
    fs.__fpu_mxcsr &= ~0x3Fu;
    fs.__fpu_mxcsr |= mxcsr_mask_bits;
    if (mxcsr_mask_bits & MXCSR_MASK_ZM) {
      fs.__fpu_fcw.__zdiv = 1;
    }
    if (mxcsr_mask_bits & MXCSR_MASK_IM) {
      fs.__fpu_fcw.__invalid = 1;
    }
    if (mxcsr_mask_bits & MXCSR_MASK_OM) {
      fs.__fpu_fcw.__ovrfl = 1;
    }
    fs.__fpu_fsw.__invalid = 0;
    fs.__fpu_fsw.__denorm = 0;
    fs.__fpu_fsw.__zdiv = 0;
    fs.__fpu_fsw.__ovrfl = 0;
    fs.__fpu_fsw.__undfl = 0;
    fs.__fpu_fsw.__precis = 0;
  }
#elif defined(__APPLE__) && defined(__aarch64__)
  constexpr unsigned kFpcrIoe = 1u << 8;
  constexpr unsigned kFpcrDze = 1u << 9;
  constexpr unsigned kFpcrOfe = 1u << 10;
  unsigned fpcr_clear = kFpcrIoe | kFpcrDze | kFpcrOfe;
  if (mxcsr_mask_bits == MXCSR_MASK_ZM) {
    fpcr_clear = kFpcrDze;
  } else if (mxcsr_mask_bits == MXCSR_MASK_IM) {
    fpcr_clear = kFpcrIoe;
  } else if (mxcsr_mask_bits == MXCSR_MASK_OM) {
    fpcr_clear = kFpcrOfe;
  }
  auto *ctx = static_cast<ucontext_t *>(scp);
  if (ctx->uc_mcontext) {
    ctx->uc_mcontext->__ns.__fpsr &= ~0x1Fu;
    ctx->uc_mcontext->__ns.__fpcr &= ~fpcr_clear;
  }
#endif
  (void)sig;
}

freeAtomIndices()

VectorXi eonc::freeAtomIndices

(

const Matter *

matter

)

Free (unfixed) atom indices in ascending order.

Definition at line 49 of file MobileAtoms.cpp.

                                               {
  if (!matter) {
    throw std::invalid_argument("freeAtomIndices: null Matter");
  }
  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 171 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 127 of file IRAResource.h.

{ return IRAResource::instance(); }

getBundleSize()

int eonc::getBundleSize

(

)

Definition at line 27 of file Bundling.cpp.

                    {
  int num_bundle = -1;
 
  for (const auto &entry : fs::directory_iterator(".")) {
    std::string name = entry.path().filename().string();
 
    if (name.empty() || 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);
    int value = 0;
    const auto parsed =
        std::from_chars(numstr.data(), numstr.data() + numstr.size(), value);
    if (parsed.ec == std::errc{} && parsed.ptr != numstr.data()) {
      const int i = value + 1;
      if (i > num_bundle) {
        num_bundle = i;
      }
    }
  }
 
  return num_bundle;
}

greedyColorCutoffGraph()

std::vector< int > eonc::greedyColorCutoffGraph

(

const std::vector< std::vector< int > > &

adj

)

Greedy coloring of an undirected graph.

adj[v] lists neighbors of v (self-loops ignored). Colors are dense from 0 in vertex order.

Definition at line 241 of file Hessian.cpp.

                                                             {
  const int n = static_cast<int>(adj.size());
  std::vector<int> color(static_cast<std::size_t>(n), -1);
  std::vector<int> used(static_cast<std::size_t>(std::max(n, 0)), 0);
  int epoch = 0;
  for (int v = 0; v < n; ++v) {
    ++epoch;
    for (int u : adj[static_cast<std::size_t>(v)]) {
      if (u < 0 || u >= n || u == v) {
        continue;
      }
      const int cu = color[static_cast<std::size_t>(u)];
      if (cu >= 0 && cu < n) {
        used[static_cast<std::size_t>(cu)] = epoch;
      }
    }
    int c = 0;
    while (c < n && used[static_cast<std::size_t>(c)] == epoch) {
      ++c;
    }
    color[static_cast<std::size_t>(v)] = c;
  }
  return color;
}

jobTable()

std::map< JobType, JobFactory > & eonc::jobTable

(

)

Definition at line 14 of file JobRegistry.cpp.

                                        {
  static std::map<JobType, JobFactory> t;
  return t;
}

lammpsOpenArgs()

std::vector< std::string > eonc::lammpsOpenArgs ( bool logging, bool with_omp, const std::string & screen )

inline

LAMMPS argv.

The log file stays off. A screen path is copied into the process logger by the caller.

Definition at line 51 of file LAMMPSPot.h.

                                                                        {
  std::vector<std::string> args{"liblammps", "-echo", "screen", "-log", "none"};
  if (logging) {
    args.insert(args.end(), {"-screen", screen});
  } else {
    args.insert(args.end(), {"-screen", "none"});
  }
  if (with_omp) {
    args.insert(args.end(), {"-suffix", "omp"});
  }
  return args;
}

lammpsScreenCursor()

std::int64_t eonc::lammpsScreenCursor ( std::int64_t pos, std::int64_t fileSize, bool restarted )

inline

Byte offset at which to keep copying a LAMMPS screen file.

A new LAMMPS open truncates that file, so a restart or a shorter file reads from the start.

Definition at line 41 of file LAMMPSPot.h.

                                                       {
  if (restarted || pos < 0 || fileSize < pos) {
    return 0;
  }
  return pos;
}

lammpsWorkerReaped()

bool eonc::lammpsWorkerReaped ( long got, long child, int err )

inline

True when waitpid has collected the child. EINTR is not a collection.

Definition at line 31 of file LAMMPSPot.h.

                                                              {
  if (got == child) {
    return true;
  }
  return got < 0 && err != EINTR;
}

lattice_rows_to_fortran_box()

void eonc::lattice_rows_to_fortran_box ( const Matrix3d & cell, double * box )

inline

Pack an eOn cell for pARTn artn_step.

Lattice vector i is row i here and Fortran column i there (box(:,i)). Row-major cell memory is already that column-major layout. Filling box so Fortran box(i,j) equals cell(i,j) sends the transpose.

Definition at line 71 of file Eigen.h.

                                                                           {
  for (int vec = 0; vec < 3; ++vec) {
    for (int comp = 0; comp < 3; ++comp) {
      box[vec * 3 + comp] = cell(vec, comp);
    }
  }
}

maskWindowsMxcsrForContinue()

std::uint32_t eonc::maskWindowsMxcsrForContinue ( std::uint32_t mxcsr )

constexpr

Definition at line 24 of file fpe_handler.h.

                                                                     {
  return (mxcsr & ~std::uint32_t{0x3Fu}) | kWindowsMxcsrExceptionMasks;
}

maxFreeAtomForceNorm()

double eonc::maxFreeAtomForceNorm ( const double * forces, const double * fixed, long nAtoms )

nodiscard

Max Euclidean norm over N x 3 row-major force rows.

An atom is ignored when fixed is non-null and all three of its mask entries are greater than 0.5 (fully fixed). fixed == nullptr keeps every atom. Returns 0 when nAtoms is not positive, and NaN when any free atom's norm is NaN, on every SIMD target.

Definition at line 106 of file ForceNorm.cpp.

                                         {
  return detail::maxFreeAtomForceNormScalar(forces, fixed, 0, nAtoms);
}

minImageRemoveRigidDrift()

AtomMatrix eonc::minImageRemoveRigidDrift	(	const Matter &	reference,
		AtomMatrix	diff,
		Eigen::RowVector3d *	totalDrift )

Minimum-image a free-atom difference and remove rigid translation.

One pbc pass wraps boundary atoms while a uniform drift remains, so the primary guideline and each symmetry product share this fixed point.

Definition at line 71 of file OHTSTJob.cpp.

                                                                  {
  // AV-embedded frames ride the defect (drift = one hop vector, a/2<011>
  // observed). Atoms near a cell boundary min-image inconsistently until
  // that drift is gone, so min-image and de-drift iterate to a fixed point.
  // The residual is the localized reaction coordinate.
  Eigen::RowVector3d total = Eigen::RowVector3d::Zero();
  for (int pass = 0; pass < 6; ++pass) {
    diff = reference.pbc(diff);
    const Eigen::RowVector3d drift =
        diff.colwise().sum() / static_cast<double>(diff.rows());
    diff.rowwise() -= drift;
    total += drift;
    if (drift.norm() < 1e-6) {
      break;
    }
  }
  if (totalDrift != nullptr) {
    *totalDrift = total;
  }
  return diff;
}

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 142 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 127 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;
}

parseFdScheme()

FdScheme eonc::parseFdScheme ( std::string_view scheme )

inline

Definition at line 27 of file FiniteDifference.h.

                                                     {
  std::string lower;
  lower.reserve(scheme.size());
  for (unsigned char c : scheme) {
    lower.push_back(static_cast<char>(std::tolower(c)));
  }
  if (lower == "central") {
    return FdScheme::Central;
  }
  if (lower == "fourth" || lower == "fourth_order" || lower == "central4") {
    return FdScheme::Fourth;
  }
  return FdScheme::OneSided;
}

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 232 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::ranges::transform(pot_str, pot_str.begin(), [](unsigned char c) {
      return static_cast<char>(std::tolower(c));
    });
 
    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;
}

pmfScanS()

double eonc::pmfScanS ( long plane, long nScan, double guideLen )

inline

Uniform PMF-scan coordinate.

Plane 0 is the reactant (s = 0) and plane nScan-1 is the product (s = guideLen). s_init is not applied.

Definition at line 26 of file OHTSTJob.h.

                                                                {
  const long n = nScan < 2L ? 2L : nScan;
  return static_cast<double>(plane) * guideLen / static_cast<double>(n - 1);
}

potAllowsSharedInstance()

template<class P>
requires requires(const P &p) { { p.isSharedInstanceThreadSafe() } -> std::convertible_to<bool>; }

bool eonc::potAllowsSharedInstance ( const P & p )

nodiscardnoexcept

Definition at line 38 of file PotCapabilities.h.

                                                                {
  return p.isSharedInstanceThreadSafe();
}

potIsThreadSafe()

template<class P>
requires ThreadSafeQueryable<P>

bool eonc::potIsThreadSafe ( const P & p )

nodiscardnoexcept

Definition at line 30 of file PotCapabilities.h.

                                                        {
  return p.isThreadSafe();
}

registerJob()

void eonc::registerJob	(	JobType	type,
		JobFactory	factory )

Definition at line 19 of file JobRegistry.cpp.

                                                   {
  jobTable()[type] = std::move(factory);
}

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 68 of file MobileAtoms.cpp.

                                                                             {
  if (!matter) {
    throw std::invalid_argument("resolveMobileAtoms: null Matter");
  }
  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 105 of file MobileAtoms.cpp.

                                                                              {
  if (!matter) {
    throw std::invalid_argument("resolveMobileAtoms: null Matter");
  }
  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 203 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 170 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 58 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 81 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;
    ParametersLoadAccess::potential_options(params).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;
      ParametersLoadAccess::potential_options(params).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 136 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 187 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 105 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);
}

trivialModeCountIsPhysical()

bool eonc::trivialModeCountIsPhysical	(	long	removed,
		long	fixedAtoms )

Whether removed zero-frequency modes are what the structure's symmetries give: 6 for a free cluster (3 translations and 3 rotations), 5 for a linear one, 3 for a periodic cell, where rotations are no symmetry of the lattice, and none once any atom is fixed.

Definition at line 798 of file Hessian.cpp.

                                                               {
  if (fixedAtoms > 0) {
    return removed == 0;
  }
  return removed == 3 || removed == 5 || removed == 6;
}

unbundle()

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

(

int

number

)

Definition at line 71 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.empty() || originalFilename[0] == '.') {
      continue;
    }
 
    if (std::ranges::count(originalFilename, '_') < 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;
    }
 
    // bundle() writes results_3.con.gz. The span from the last underscore
    // to the last dot is "3.con", so the index is only the digit run.
    const size_t numBegin = upos + 1;
    size_t numEnd = numBegin;
    while (numEnd < originalFilename.size() &&
           std::isdigit(static_cast<unsigned char>(originalFilename[numEnd]))) {
      ++numEnd;
    }
    if (numEnd == numBegin || numEnd >= originalFilename.size() ||
        originalFilename[numEnd] != '.') {
      continue;
    }
    int bundleNumber = 0;
    const auto parsed =
        std::from_chars(originalFilename.data() + numBegin,
                        originalFilename.data() + numEnd, bundleNumber);
    if (parsed.ec != std::errc{} ||
        parsed.ptr != originalFilename.data() + numEnd) {
      continue;
    }
    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 135 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;
}

write_fault_rip()

void eonc::write_fault_rip ( void * scp )

static

Definition at line 272 of file fpe_handler.cpp.

                                       {
#if defined(__linux__) && defined(__x86_64__)
  auto *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);
#else
  (void)scp;
#endif
}

writeNormalModes()

bool eonc::writeNormalModes	(	Matter &	matter,
		const VectorXi &	atoms,
		const VectorXd &	eigenvalues,
		const MatrixXd &	modes,
		const std::string &	path )

Writes one frame of matter per mode to path, the mode as the displacements section and mode_eigenvalue (eV / (Angstrom^2 amu)), hbar_omega (eV, negative for an imaginary mode) and wavenumber (cm^-1, same sign) as frame metadata.

Definition at line 775 of file Hessian.cpp.

                                             {
  if (modes.cols() != eigenvalues.size() || modes.rows() != 3 * atoms.size()) {
    return false;
  }
  for (long k = 0; k < eigenvalues.size(); ++k) {
    const double lambda = eigenvalues(k);
    const double hw =
        std::copysign(tunneling::kHbar * std::sqrt(std::abs(lambda)), lambda);
    io::ConFrameMetadata meta;
    meta.frame_index = static_cast<uint64_t>(k);
    meta.scalars = {{"mode_eigenvalue", lambda},
                    {"hbar_omega", hw},
                    {"wavenumber", hw * kEvToWavenumber}};
    meta.displacements = cartesianMode(matter, atoms, modes.col(k));
    if (!io::io_ok(matter.matter2con(path, k > 0, &meta))) {
      return false;
    }
  }
  return true;
}

x86_div_regs()

X86DivRegs eonc::x86_div_regs ( void * scp )

static

Definition at line 215 of file fpe_handler.cpp.

                                          {
  X86DivRegs regs{nullptr, nullptr, nullptr};
  if (scp == nullptr) {
    return regs;
  }
  auto *ctx = static_cast<ucontext_t *>(scp);
#if defined(__linux__) && defined(__x86_64__)
  regs.ip = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext.gregs[REG_RIP]);
  regs.ax = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext.gregs[REG_RAX]);
  regs.dx = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext.gregs[REG_RDX]);
#elif defined(__linux__) && defined(__i386__)
  regs.ip = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext.gregs[REG_EIP]);
  regs.ax = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext.gregs[REG_EAX]);
  regs.dx = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext.gregs[REG_EDX]);
#elif defined(__APPLE__) && defined(__x86_64__)
  if (ctx->uc_mcontext != nullptr) {
    regs.ip = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext->__ss.__rip);
    regs.ax = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext->__ss.__rax);
    regs.dx = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext->__ss.__rdx);
  }
#elif defined(__APPLE__) && defined(__i386__)
  if (ctx->uc_mcontext != nullptr) {
    regs.ip = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext->__ss.__eip);
    regs.ax = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext->__ss.__eax);
    regs.dx = reinterpret_cast<uintptr_t *>(&ctx->uc_mcontext->__ss.__edx);
  }
#else
  (void)ctx;
#endif
  return regs;
}

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.

kEvToWavenumber

double eonc::kEvToWavenumber = 8065.543937349212

inlineconstexpr

1 eV in cm^-1, e / (h c) from the exact SI values.

Definition at line 31 of file Hessian.h.

kWindowsMxcsrExceptionMasks

std::uint32_t eonc::kWindowsMxcsrExceptionMasks = 0x1F80u

constexpr

Definition at line 23 of file fpe_handler.h.

MXCSR_MASK_IM

unsigned eonc::MXCSR_MASK_IM = 1u << 7

staticconstexpr

Definition at line 106 of file fpe_handler.cpp.

MXCSR_MASK_OM

unsigned eonc::MXCSR_MASK_OM = 1u << 10

staticconstexpr

Definition at line 108 of file fpe_handler.cpp.

MXCSR_MASK_ZM

unsigned eonc::MXCSR_MASK_ZM = 1u << 9

staticconstexpr

Definition at line 107 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.