Nudged elastic band¶

The nudged elastic band (NEB) is a method for finding saddle points and minimum energy paths between known reactants and products. The method works by optimizing a number of intermediate images along the reaction path. Each image finds the lowest energy possible while maintaining equal spacing to neighboring images. This constrained optimization is done by adding spring forces along the band between images and by projecting out the component of the force due to the potential perpendicular to the band.

Details may be found in Jonsson et al. [NEB_JMJ98], Sheppard and Henkelman [NEB_SH11], and Ásgeirsson and Jónsson [NEB_AsgeirssonJonsson18].

To run a nudged elastic band calculation, set job to nudged_elastic_band in the [Main] section. Details of the optimizer can be set as per the Optimizer document.

Tip

Python API. Prefer pyeonclient for in-process NEB: build a list[Matter] from ASE images, then NudgedElasticBand(path, params, pot).compute() — same shape as ASE’s NEB + LBFGS, without a workdir.

For a full walkthrough (ASE NEB vs eOn energy-weighted springs + OCI dimer), see the atomistic-cookbook PET-MAD example.

For a built-in Morse Pt NEB with current rgpycrumbs eon plt-neb 1D/2D figures (full history, 1:1 reaction-valley panel, structure strip), see Morse Pt NEB (built-in potential).

Variants¶

Classic nudged elastic band of Mills and Jónsson [NEB_MJonsson94] and Schenter et al. [NEB_SMJonsson94].
Improved tangent method of Henkelman and Jónsson [NEB_HJonsson00].
Climbing image NEB of Henkelman et al. [NEB_HUJonsson00].
Doubly nudged method of Trygubenko and Wales [NEB_TW04].
Solid-state band of Sheppard et al. [NEB_SXC+12], enabled with solid_state = true. Interior images relax the cell with the atoms. The cell stays lower triangular, and the tangent uses one Jacobian for atomic displacements and cell strain (doi:10.1063/1.3684549).

Added in version 2.0:

The energy weighted varying springs method of Ásgeirsson et al. [NEB_AsgeirssonBB+21].

A conjugate-gradient band takes its first step length from one finite-difference probe. Later lengths use the previous displacement, so an iteration after that probe is one evaluation of the images. Minimizers and a dimer translation keep a probe on every step. If the band force more than doubles, the next conjugate-gradient step is shorter, down to a fifth of max_move. Twelve iterations without a lower force drop the search direction and shorten the step again. A later drop in the force lengthens the step back toward max_move. LBFGS is left on the configured length.

Dimer seeds from every band peak¶

After the band is written, eOn walks every spline maximum. Each interior maximum more than mmf_peak_tolerance above the reactant is written as peakNN_pos.con plus peakNN_mode.dat (the interpolated tangent). That is the native gen-dimer seed: run a saddle_search from each pair. setup_mmf_peaks defaults to true; set it false to skip the files.

[Nudged Elastic Band]
setup_mmf_peaks = true
mmf_peak_tolerance = 0.05

Isomer endpoints with scrambled atom order can be aligned before interpolation with match_endpoints = true (default off). The ira method rigid-rotates and permutes the reactant onto the product via IRACompare. Hungarian assignment is not in-tree; match_method = hungarian currently uses IRA. match_endpoints and match_method are client keys. Neither key is in eon/config.yaml, and the server exits on the unknown option.

Note

eOn, like many other codes after Sheppard et al. [NEB_STH08] uses one optimizer instance for moving the whole band of images.

Added in version 2.8: Via the surrogate potential interface, a native C++ implementation of the Gaussian Process accelerated NEB first described in Koistinen et al. [NEB_KDagbjartsdottirAsgeirsson+17] and Koistinen et al. [NEB_KAsgeirssonVJonsson19].

Added in version 2.12:

Onsager-Machlup action-based NEB for minimum action paths.
OCINEB (Off-Path Climbing Image NEB) Goswami et al. [NEB_GGJonsson26]: hybrid CI-NEB + Min-Mode Following with hessian eigenmode alignment for automated saddle point refinement.
Parallel image force evaluation ([Main] parallel on the client). In 2.12 it required TBB and -Dwith_parallel_neb=true; see the note under Parallel evaluation.
IDPP (Image Dependent Pair Potential) path initialization.
Modular strategy pattern for tangent, projection, and spring force components.

Spring law¶

The default parallel spring force on image $i$ is Hooke’s law,

$$ F_i^{s\parallel} = k\left(|R_{i+1} - R_i| - |R_i - R_{i-1}|\right)\hat\tau_i , $$

as Henkelman and Jónsson [NEB_HJonsson00] write it with the improved tangent and Henkelman et al. [NEB_HUJonsson00] use it for the climbing image. Jonsson et al. [NEB_JMJ98] project the spring difference $(R_{i+1} - R_i) - (R_i - R_{i-1})$ onto the tangent, which is linear in the distances as well. It vanishes when the two neighbour distances are equal, and its stiffness there is k whatever the image spacing.

geometric_spring = true selects

$$ F_i^{s\parallel} = k\left(|R_{i+1} - R_i|^2 - |R_i - R_{i-1}|^2\right)\hat\tau_i , $$

the form of the SVN client (tag svn-Jul_01_2024, where both distances are squaredNorm()), and the default until 6a89efd32 moved to Hooke’s law (gh-210). It is Hooke’s law times $|R_{i+1} - R_i| + |R_i - R_{i-1}|$, so it has the same fixed point, equal neighbour distances, with a stiffness of $2k|R_{i+1} - R_i|$ there: it softens as the band gets denser. client/validation/neb_spring_fixed_point.py derives both fixed points, shows that on a curved path equal chords are equal arc lengths, and shows the effect described below.

With every atom free the client removes the net translation from each projected force. When the tangent itself carries a translation, as it does when the endpoints differ by the motion of one atom, a band converges with its perpendicular force and spring cancelling up to a common translation, so the converged spacing is unequal and depends on the spring law. On the LJ13 pair with atom 0 displaced 0.5 A (the SVN parity case, 3 images), Hooke’s law converges with chords from 0.093 to 0.289 A and image energies 0.000049, 0.259018 and 2.851935 eV in 236 force calls; the squared law with SVN’s first-step finite-difference L-BFGS scaling converges to SVN’s band, 0.000135, 0.056816 and 1.800656 eV, in 209.

For a climbing-image band the spacing carries no answer: the climbing image does, the barrier and the saddle geometry, and both laws give the same climbing image. Unequal spacing at convergence is acceptable there; spacing matters for a plain NEB.

On a well-posed path the two laws agree. For the LJ13 reactant and product in client/unit_tests/data/systems/neb_lj13, with the climbing image on and 3, 7, 15 and 31 images, the climbing image lies within 5e-6 eV and 7e-4 A (RMSD) of the eonclient dimer saddle (-38.963676 eV) under both laws, and the largest distance of an image from the steepest-descent path off that saddle falls from 0.032 to 0.010 A. Hooke’s law keeps the spacing closer to even: the longest over the shortest chord is 1.12, 1.18, 1.30 and 1.48, against 1.12, 1.25, 2.53 and 1.77 for the squared law.

Onsager-Machlup NEB¶

The Onsager-Machlup variant replaces the standard spring force with an action-based spring that adapts per-image based on the local force magnitude. Enable with onsager_machlup = true in the NEB section.

Zoom-NEB¶

Zoom-NEB packs the images onto a window around the climbing image once that image index has stayed fixed for zoom_ci_stability iterations and the band force is below zoom_after. A zoom_after of 0 uses ten times converged_force. The window endpoints become the fixed ends of the band, and the images are placed at equal arc length inside it.

zoom_mode = auto keeps the contiguous images whose energy is above zoom_alpha of the barrier, measured from the lower endpoint. If that test leaves only the climbing image, the window falls back to zoom_offset images on each side. zoom_mode = manual uses the offset directly. zoom_interpolation is cubic (default) or linear.

Zoom does not turn off climbing-image NEB or OCINEB. The dimer step is skipped on the redistribution iteration so it runs on the packed band. zoom_max_iterations limits the steps after the pack; 0 keeps max_iterations.

[Nudged Elastic Band]
zoom_neb = true
zoom_mode = auto
zoom_alpha = 0.5
zoom_offset = 1
zoom_after = 0.0
zoom_interpolation = cubic
zoom_ci_stability = 5
ci_mmf = true

Solid-state band¶

solid_state = true gives each interior image its own cell. The reactant and product cells stay fixed. A proper rotation puts every cell into lower triangular form before the band moves: the first lattice vector lies on x and the second lies in the xy plane. That removes the three rotations of the cell. The initial path for initializer = linear is a fractional interpolation of those oriented endpoints. initializer = file keeps the supplied frames after the same rotation.

The spring and the perpendicular force are evaluated in the joint metric of Sheppard et al. [NEB_SXC+12]. solid_state_weight multiplies the cell block of the Jacobian. The default, 1, gives a cell strain the same weight as an atomic displacement. solid_state_pressure is a hydrostatic pressure in eV/Angstrom^3 added to that metric. Positive pressure favors a smaller cell. Zero leaves the potential-energy surface.

temperature is in kelvin. Above zero, each image carries quantum_free_energy, the potential energy plus kT ln(2 sinh(beta hbar omega / 2)) summed over its vibrations, and zpe_corrected_barrier, the highest of those free energies minus the reactant. The end images are minima and keep every vibration, the one along the band included; between them the tangent is the reaction coordinate and leaves the sum, so the barrier compares the generalized transition state’s modes with all of the reactant’s. With no atom fixed, the three translations, and each rotation the reactant’s Hessian leaves null (a free cluster, in a periodic cell or not), are rigid motions and are projected out of every image’s Hessian, not summed as near-zero frequencies. Zero temperature is the limit V + ZPE and does not turn the profile on.

The cell force is the stress tensor. A potential that implements the Cauchy stress, with the sign sigma = (1/V) dE/dε for the right strain h <- h (I+ε) at fixed fractional coordinates, is used directly: the band reads the stress the potential returned with each image’s force call, so an iteration costs one call per moved image. A potential that does not report the Cauchy stress is refused. The band does not estimate that tensor.

A reference case, and why its cell has two atoms¶

client/unit_tests/SolidStateBainTest.cpp runs the band on a transformation whose saddle is known without a band. The case is the Bain path from bcc to fcc of LJ (u0 1 eV, psi 1 Angstrom), switched to zero over [2.0, 2.2] Angstrom. Both atoms of the body-centred tetragonal cell diag(a, a, c) sit on inversion centres, so the atomic force vanishes at any cell. A relaxed scan of the energy over c/a (validation/bain_lj_reference.py in rgsaddle, spacing 2.5e-4) puts the saddle at c/a 1.09331985, 0.0590356373 eV/atom above bcc. The band reaches c/a 1.09331984 and the same barrier to ten digits, in 187 iterations and 1311 force calls.

That saddle is unstable to the k = (1/2, 0, 1/2) phonon, which shuffles alternate planes (eigenvalue -51.5 eV/Angstrom^2). The two-atom cell has no wave vector but k = 0, so its saddle is the scan’s. A supercell does carry the shuffle. A 5 x 5 x 4 supercell (200 atoms, pair_cutoff = 2.2, pair_switch_width = 0.2) has k = (2/5, 0, 1/2) with eigenvalue -38.4. Its band first settles on the tetragonal saddle. Rounding then seeds the shuffle, the cells shear, and the band moves to a lower path near 0.026 eV/atom. That path is a correct NEB answer for the supercell, but the scan does not describe it. A solid-state test should use a cell whose only soft mode is the strain it studies.

A ring on this band is one centroid and one cell. The force and the stress the band follows are the averages of that image’s beads. The band spring stays on the centroids, and the ring springs stay inside the image. The Jacobian remains the fixed factor from the two endpoint volumes. The dimer on the physical potential finds the classical saddle. A dimer on the ring-polymer potential is the instanton, so it is not a step of this band. The transmission coefficient is not a band iteration.

With -Dwith_rgsaddle=true, opt_method lbfgs, fire and xtsci step the band on rgsaddle’s solid-state band (rgsaddle ABI minor 17 or newer). The image cells move with the atoms, rgsaddle reads each image’s Cauchy stress from the same force call, and eOn rebuilds its own joint projection for the convergence test after every step. An older rgsaddle refuses a solid-state band instead of stepping it with the cells fixed.

ci_mmf, zoom_neb, onsager_machlup, neb_doubly_nudged, and neb_elastic_band are refused. The climbing image itself is the joint-space reflection of the force. Peak files still carry the atomic block of the tangent.

[Nudged Elastic Band]
solid_state = true
solid_state_weight = 1.0
solid_state_pressure = 0.0

Parallel evaluation¶

Changed in version 3.5.0: The image pool is plain std::thread, so GCC and Clang builds need no TBB. -Dwith_parallel_neb is deprecated and has no effect.

[Main] parallel is a client key and defaults to true. eon/config.yaml has no parallel key in [Main]. Setting that key makes the server exit before the client runs. With parallel = true, a band that reaches the projection step projects each image’s tangent, spring, and projected force on one pool. Dirty-image force calls use that pool too. The pool starts once and stays for the process. On Linux the pool sizes itself to the affinity mask, so a Slurm or taskset limit sets the thread count. Other systems take the size from std::thread::hardware_concurrency(). The caller is one of those workers, so a 20-image band on 8 allowed cores keeps 8 threads busy. The pool reports an error in one image after the other images finish. The pool needs no extra library. nvc++ builds with -Dstdpar=cpu / -Dstdpar=gpu use std::execution::par for those force calls instead; see nvc++ stdpar (NEB image forces). Python-based potentials fall back to serial evaluation unless they report thread-safe shared instances or per-image copies. Morse and other host potentials stay on the CPU.

Configuration¶

The NEB section can be specified in config.ini:

[Nudged Elastic Band]
images = 7
converged_force = 0.01
climbing_image_method = true

In a client built with -Dwith_rgsaddle=true, opt_method = lbfgs, fire or xtsci with a non-geometric spring steps the band in an rgsaddle session; cg, sd and qm keep eOn’s band optimizer. The table in Optimizer lists which input runs where. [Optimizer] opt_backend = rgmin does not move the band step; it moves the endpoint relaxations.

Or programmatically via rgpycrumbs:

from rgpycrumbs.eon.helpers import write_eon_config

config = {
    "Main": {"job": "nudged_elastic_band"},
    "Nudged Elastic Band": {
        "images": 7,
        "converged_force": 0.01,
        "climbing_image_method": True,
    },
}
write_eon_config(config, Path("config.ini"))

See Dictionary-Style Configuration for the full programmatic workflow.

[Nudged Elastic Band]

pydantic model eon.schema.NudgedElasticBandConfig[source]¶

Fields:

images (int)
spring (float)
solid_state (bool)
solid_state_weight (float)
temperature (float)
tunnel_wall_points (int)
solid_state_pressure (float)
climbing_image_method (bool)
old_tangent (bool)
neb_max_iterations (int)
neb_climbing_image_converged_only (bool)
neb_climbing_image_band_slack (float)
neb_doubly_nudged (bool)
neb_doubly_nudged_switching (bool)
neb_elastic_band (bool)
converged_force (float)
onsager_machlup (bool)
om_optimize_k (bool)
om_k_scale (float)
om_k_min (float)
om_k_max (float)
geometric_spring (bool)
energy_weighted (bool)
ew_trigger (float)
ew_ksp_min (float)
ew_ksp_max (float)
initial_path_in (str)
initializer (Literal['linear', 'idpp', 'idpp_collective', 'sidpp', 'file'])
init_max_iterations (int)
init_max_move (float)
init_force_threshold (float)
sidpp_growth_alpha (float)
minimize_endpoints (bool)
minimize_endpoints_for_ipath (bool)
ci_after (float)
ci_mmf (bool)
ci_mmf_after (float)
ci_mmf_nsteps (int)
ci_mmf_ci_stability_count (int)
ci_mmf_angle (float)
ci_mmf_restore_unhelpful (bool)
setup_mmf_peaks (bool)
mmf_peak_tolerance (float)
zoom_neb (bool)
zoom_alpha (float)
zoom_offset (int)
zoom_mode (Literal['auto', 'manual'])
zoom_after (float)
zoom_interpolation (Literal['cubic', 'linear'])
zoom_ci_stability (int)
zoom_max_iterations (int)

field images: int = 5¶: Number of NEB images between the fixed endpoints.

field spring: float = 5.0¶: The spring constant, in eV/Ang^2 between the images.

field solid_state: bool = False¶

The cell of each interior image moves with the atoms. The cell stays lower triangular: the first lattice vector lies on x and the second lies in the xy plane, so the band cannot rotate as a rigid body. Atomic displacements and cell strain share one Jacobian (doi:10.1063/1.3684549). Periodic boundaries are required. A potential that does not report the Cauchy stress is refused. ci_mmf, zoom_neb, onsager_machlup, neb_doubly_nudged, and neb_elastic_band are refused, and initializer must be linear or file.

Relax the lattice vectors of each interior image with the atoms.

field solid_state_weight: float = 1.0¶: Multiplier on the cell block of the solid-state Jacobian (doi:10.1063/1.3684549). 1 weights a cell strain like an atomic move.

field temperature: float = 0.0¶: Temperature in kelvin for the harmonic quantum free energy along the band. Zero leaves the profile on the potential energy.

field tunnel_wall_points: int = 0¶

Force calls past each end minimum of the converged band, along its end segment continued outward, for the outer walls of the one-dimensional tunnelling levels. 0 continues each well by its fit.

Constraints:

ge = 0

field solid_state_pressure: float = 0.0¶: External hydrostatic pressure in eV/Angstrom^3 on the solid-state band. Positive pressure favors a smaller cell. 0 keeps the potential-energy band.

field climbing_image_method: bool = True¶

As discussed in Henkelman et al. [NEB_HUJonsson00].

Indicates if the climbing image method is used.

field old_tangent: bool = False¶

From Mills and Jónsson [NEB_MJonsson94], before Henkelman and Jónsson [NEB_HJonsson00].

Indicates if the old tangent method is used.

field neb_max_iterations: int = 1000¶: Maximum number of iterations allowed for the NEB.

field neb_climbing_image_converged_only: bool = True¶: If true, NEB convergence compares the climbing image to the force tolerance, but only after the rest of the band is within climbing_image_band_slack times that tolerance.

field neb_climbing_image_band_slack: float = 10.0¶: When climbing_image_converged_only is true, reject convergence if any non-CI image exceeds this multiple of the force tolerance.

field neb_doubly_nudged: bool = False¶: Indicates if the doubly nudged method is used.

field neb_doubly_nudged_switching: bool = False¶

Method as demonstrated in Trygubenko and Wales [NEB_TW04].

Indicates if the doubly nudged switching method is used.

field neb_elastic_band: bool = False¶: Indicates if the elastic band method is used.

field converged_force: float = 0.01¶

This defaults to being the same as eon.schema.OptimizerConfig.converged_force

Converged force threshold for the NEB.

field onsager_machlup: bool = False¶

Method as demonstrated in Mandelli and Parrinello [NEB_MP21].

Indicates if the Onsager-Machlup (OM) Action is used.

field om_optimize_k: bool = True¶: Indicates if the Onsager-Machlup (OM) Action spacing is recalculated at each step.

field om_k_scale: float = 1.0¶

Stiffness: - > 1 (stiff) provides a smoother path but may “cut corners” near the saddle - < 1 (softer) hugs valleys but paths may become jagged/noisy

Indicates stiffness of OM adaption of springs.

field om_k_min: float = 0.1¶: Minimum stiffness.

field om_k_max: float = 100¶: Minimum stiffness.

field geometric_spring: bool = False¶: Parallel spring from the difference of squared neighbour distances.

field energy_weighted: bool = False¶

Method as demonstrated in Ásgeirsson et al. [NEB_AsgeirssonBB+21].

Indicates if the energy-weighted method is used.

field ew_trigger: float = 10.0¶: Threshold for the energy-weighted method.

field ew_ksp_min: float = 0.972¶: Minimum value for KSP in the energy-weighted method.

field ew_ksp_max: float = 9.72¶: Maximum value for KSP in the energy-weighted method.

field initial_path_in: str = ''¶

This file must contain a list of .con files, one per image on the path.

File from which the initial path is read.

field initializer: Literal['linear', 'idpp', 'idpp_collective', 'sidpp', 'file'] = 'linear'¶

Options: - linear: Euclidean distance based image interpolation for initial NEB paths. - idpp: Image depedent pair potential initialzation Smidstrup et al. [NEB_SPSJonsson14]. - idpp_collective: IDPP as a potential initialized with the NEB. - sidpp: Sequential Image depedent pair potential initialzation Schmerwitz et al. [NEB_SAsgeirssonJonsson24]. - file: Start from an arbitrary path, needs initial_path_in set as well.

Initialization strategy.

field init_max_iterations: int = 5000¶: Steps to run the IDPP for.

field init_max_move: float = 0.1¶: Max move for NEB initialization.

field init_force_threshold: float = 0.001¶: Force threshold for NEB IDPP initialization.

field sidpp_growth_alpha: float = 0.33¶: The step size for adding new images in S-IDPP.

field minimize_endpoints: bool = False¶: Minimize the reactant and product before the NEB.

field minimize_endpoints_for_ipath: bool = False¶: Minimize the reactant and product before the NEB, even if an initial path is provided.

field ci_after: float = inf¶: Convergence before the CI is turned on.

field ci_mmf: bool = False¶: Use an MMF method for the CI.

field ci_mmf_after: float = 0.5¶: Convergence before the CI is turned on.

field ci_mmf_nsteps: int = 10¶: Number of steps for which the MMF is run at the CI image.

field ci_mmf_ci_stability_count: int = 5¶: Number of stable iterations before settling on a CI image index.

field ci_mmf_angle: float = 0.8¶: Alignment threshold w.r.t NEB mode.

field ci_mmf_restore_unhelpful: bool = False¶: Restore the walked image after an alignment reject or force increase on that image. A CI-index hop after a downhill dimer step is not a force increase. False is the Frontiers OCI-NEB protocol (doi:10.3389/fchem.2026.1807063, Algorithm 1): restore only on positive curvature.

field setup_mmf_peaks: bool = True¶: Generate modes and peak configurations.

field mmf_peak_tolerance: float = 0.05¶: Generate modes and peak configurations.

field zoom_neb: bool = False¶: After the climbing image is stable, pack every image onto a window around it and continue the band, including OCINEB.

field zoom_alpha: float = 0.5¶: Auto window keeps images above this fraction of the barrier height, measured from the lower endpoint.

field zoom_offset: int = 1¶: Manual window half-width in images on each side of the climbing image.

field zoom_mode: Literal['auto', 'manual'] = 'auto'¶: auto uses zoom_alpha; manual uses zoom_offset.

field zoom_after: float = 0.0¶: Band force that arms Zoom-NEB. 0 uses ten times converged_force.

field zoom_interpolation: Literal['cubic', 'linear'] = 'cubic'¶: Arc-length interpolation used to pack images into the window.

field zoom_ci_stability: int = 5¶: Iterations the climbing-image index must stay fixed before zoom.

field zoom_max_iterations: int = 0¶: Iterations allowed after zoom. 0 keeps the band iteration cap.

Outputs¶

NEB writes the usual results.dat, neb.dat, and the final band neb.con.

With write_movies = true in [Debug], eOn also writes per-iteration neb_path_*.con movie files and neb_maximage.con. These .con outputs now embed structured frame metadata via readcon-core, including fields such as energy, frame_index, neb_bead, optional neb_band, reaction_coordinate, relative_energy, and parallel_force.

The existing neb.dat and neb_*.dat outputs are still written and remain the primary compatibility path for current plotting tools.

References¶

[NEB_GGJonsson26] (1,2)

Rohit Goswami, Miha Gunde, and Hannes Jónsson. Enhanced climbing image nudged elastic band method with hessian eigenmode alignment. Frontiers in Chemistry, 2026. arXiv:2601.12630, doi:10.3389/fchem.2026.1807063.

[NEB_HJonsson00] (1,2,3)

Graeme Henkelman and Hannes Jónsson. Improved tangent estimate in the nudged elastic band method for finding minimum energy paths and saddle points. The Journal of Chemical Physics, 113(22):9978–9985, December 2000. doi:10.1063/1.1323224.

[NEB_HUJonsson00] (1,2,3)

Graeme Henkelman, Blas P. Uberuaga, and Hannes Jónsson. A climbing image nudged elastic band method for finding saddle points and minimum energy paths. The Journal of Chemical Physics, 113(22):9901–9904, November 2000. doi:10.1063/1.1329672.

[NEB_JMJ98] (1,2)

Hannes Jonsson, Greg Mills, and Karsten W. Jacobsen. Nudged elastic band method for finding minimum energy paths of transitions. In Classical and Quantum Dynamics in Condensed Phase Simulations, pages 385–404. World Scientific, June 1998. doi:10.1142/9789812839664_0016.

[NEB_KDagbjartsdottirAsgeirsson+17]

Olli-Pekka Koistinen, Freyja B. Dagbjartsdóttir, Vilhjálmur Ásgeirsson, Aki Vehtari, and Hannes Jónsson. Nudged elastic band calculations accelerated with Gaussian process regression. The Journal of Chemical Physics, 147(15):152720, September 2017. doi:10.1063/1.4986787.

[NEB_KAsgeirssonVJonsson19]

Olli-Pekka Koistinen, Vilhjálmur Ásgeirsson, Aki Vehtari, and Hannes Jónsson. Nudged Elastic Band Calculations Accelerated with Gaussian Process Regression Based on Inverse Interatomic Distances. Journal of Chemical Theory and Computation, 15(12):6738–6751, December 2019. doi:10.1021/acs.jctc.9b00692.

[NEB_MP21]

D. Mandelli and M. Parrinello. A modified nudged elastic band algorithm with adaptive spring lengths. Journal of Chemical Physics, 155(7):74103, August 2021. doi:10.1063/5.0059593.

[NEB_MJonsson94] (1,2)

Greg Mills and Hannes Jónsson. Quantum and thermal effects in H 2 dissociative adsorption: Evaluation of free energy barriers in multidimensional quantum systems. Physical Review Letters, 72(7):1124–1127, February 1994. doi:10.1103/PhysRevLett.72.1124.

[NEB_SMJonsson94]

Gregory K. Schenter, Gregory Mills, and Hannes Jónsson. Reversible work based quantum transition state theory. The Journal of Chemical Physics, 101(10):8964–8971, November 1994. doi:10.1063/1.468447.

[NEB_SAsgeirssonJonsson24]

Yorick L. A. Schmerwitz, Vilhjálmur Ásgeirsson, and Hannes Jónsson. Improved Initialization of Optimal Path Calculations Using Sequential Traversal over the Image-Dependent Pair Potential Surface. Journal of Chemical Theory and Computation, 20(1):155–163, January 2024. doi:10.1021/acs.jctc.3c01111.

[NEB_SH11]

Daniel Sheppard and Graeme Henkelman. Paths to which the nudged elastic band converges. Journal of Computational Chemistry, 32(8):1769–1771, 2011. doi:10.1002/jcc.21748.

[NEB_STH08]

Daniel Sheppard, Rye Terrell, and Graeme Henkelman. Optimization methods for finding minimum energy paths. The Journal of Chemical Physics, 128(13):134106, April 2008. doi:10.1063/1.2841941.

[NEB_SXC+12] (1,2)

Daniel Sheppard, Penghao Xiao, William Chemelewski, Duane D. Johnson, and Graeme Henkelman. A generalized solid-state nudged elastic band method. Journal of Chemical Physics, 136(7):74103, February 2012. doi:10.1063/1.3684549.

[NEB_SPSJonsson14]

Søren Smidstrup, Andreas Pedersen, Kurt Stokbro, and Hannes Jónsson. Improved initial guess for minimum energy path calculations. The Journal of Chemical Physics, 140(21):214106, June 2014. doi:10.1063/1.4878664.

[NEB_TW04] (1,2)

Semen A. Trygubenko and David J. Wales. A doubly nudged elastic band method for finding transition states. The Journal of Chemical Physics, 120(5):2082–2094, February 2004. doi:10.1063/1.1636455.

[NEB_AsgeirssonBB+21] (1,2)

Vilhjálmur Ásgeirsson, Benedikt Orri Birgisson, Ragnar Bjornsson, Ute Becker, Frank Neese, Christoph Riplinger, and Hannes Jónsson. Nudged Elastic Band Method for Molecular Reactions Using Energy-Weighted Springs Combined with Eigenvector Following. Journal of Chemical Theory and Computation, 17(8):4929–4945, August 2021. doi:10.1021/acs.jctc.1c00462.

[NEB_AsgeirssonJonsson18]

Vilhjálmur Ásgeirsson and Hannes Jónsson. Exploring Potential Energy Surfaces with Saddle Point Searches. In Wanda Andreoni and Sidney Yip, editors, Handbook of Materials Modeling, pages 1–26. Springer International Publishing, Cham, 2018. doi:10.1007/978-3-319-42913-7_28-1.

Nudged elastic band¶

Variants¶

Dimer seeds from every band peak¶

Spring law¶

Onsager-Machlup NEB¶

OCINEB (hybrid dimer refinement)¶

Zoom-NEB¶

Solid-state band¶

A reference case, and why its cell has two atoms¶

Parallel evaluation¶

Configuration¶

Outputs¶

Refinement¶

References¶