MAPLE Logo MAPLE

AutoNEB (Automated NEB)

Overview

AutoNEB is an automated multi-step NEB workflow designed for complex reactions that involve multiple intermediates and transition states. Rather than requiring the user to manually identify each elementary step, AutoNEB recursively subdivides the reaction path between a given reactant and product, automatically discovering all stationary points along the way.

This method is particularly valuable for multi-step reaction mechanisms where the number and nature of intermediates are not known in advance. AutoNEB handles the entire workflow automatically: running NEB calculations, identifying intermediates, and recursively refining each segment of the path until all transition states and intermediates have been located.

How It Works

The AutoNEB algorithm proceeds through the following stages:

  1. Initial NEB. A standard NEB calculation is performed between the overall reactant and product structures, producing an initial minimum energy path.
  2. Identify highest-energy images. The highest-energy images (HEIs) along the converged path are identified as candidate transition states. Images in local energy minima along the path are identified as candidate intermediates.
  3. Optimize intermediates. Candidate intermediate structures are optimized to true local minima using geometry optimization.
  4. Recursive subdivision. New NEB calculations are launched between each pair of adjacent stationary points (minima). This process repeats recursively, building a tree of NEB calculations that progressively resolves the full reaction mechanism.
  5. Collect results. All transition state and intermediate structures are collected into a unified global MEP. The recursion terminates when no new intermediates are found in any segment, or when the maximum tree depth is reached.

Parameters

Parameter Type Default Description
n_images int 20 Number of initial NEB images.
k_min float 0.03 Minimum spring constant (Eh/Ang²).
k_max float 0.3 Maximum spring constant (Eh/Ang²).
use_dynamic_k bool True Enable dynamic spring constants.
k_decay float 0.5 Dynamic spring constant decay factor.
max_iter int 256 Maximum NEB iterations per sub-path.
lbfgs_m int 10 L-BFGS memory for band optimization.
step0 float 2e-2 Initial L-BFGS step size.
ifidpp int 1 IDPP interpolation flag (1=IDPP, 0=linear).
ang_max float 0.3 Max distance between adjacent images (Angstrom).
ang_iter int 20 Check for image insertion every N iterations.
path_iter int 50 Check for local minima every N iterations.
min_e_drop float 0.001 Energy drop threshold for minima detection (Eh).
ep_iter int 30 Check endpoint updates every N iterations.
ep_e_drop float 0.0005 Energy drop for endpoint update (Eh).
autoneb_f_max_th float 9.5e-3 Max force convergence threshold.
autoneb_f_rms_th float 5e-3 RMS force convergence threshold.
max_depth int 5 Maximum recursion depth for path subdivision.
max_paths int 10 Maximum number of sub-paths.
do_final_refine bool True Perform final CI-NEB refinement.
final_refine_factor float 2.0 Image density factor for final refinement.
final_refine_max_iter int 200 Max iterations for final refinement.
final_refine_ep_iter int 20 Endpoint check interval during final refinement.
verbose int 1 Output verbosity level.

Input Example

#model=ani1xnr
#ts(method=autoneb)
#device=gpu0

XYZ /path/to/reactant.xyz
XYZ /path/to/product.xyz

Output Files

  • *_autoneb_global_mep.xyz — The complete global minimum energy path spanning all elementary steps, from the initial reactant through all intermediates to the final product.
  • *_autoneb_intermediates.xyz — Optimized geometries of all intermediate structures discovered during the recursive search.
  • *_autoneb_ts_list.xyz — All transition state geometries found across every segment of the reaction mechanism.
  • *_autoneb_path_*.xyz — Individual MEP files for each NEB segment in the recursive tree (numbered sequentially).
  • *_autoneb_tree.json — JSON file describing the recursion tree structure, including parent-child relationships between NEB segments, energies, and convergence status.
Tip

AutoNEB is ideal for reactions with multiple intermediates, such as enzyme mechanisms, catalytic cycles, or multi-step organic transformations. If you suspect your reaction has more than one elementary step, AutoNEB can discover the full mechanism automatically without requiring you to guess the intermediates.

Warning

AutoNEB can be computationally expensive for deep reaction networks. Each level of recursion spawns additional NEB calculations, and the total cost grows with the number of elementary steps discovered. For very complex mechanisms, consider limiting max_depth or using a smaller n_images value for the initial exploration, then refining specific segments with higher resolution.