# Climbing-Image Nudged Elastic Band¶

Note

This page describes the internal ADF implementation of the NEB method.

For NEB calculations with ADF we **do not recommend** using this implementation. Instead, we recommend using the AMS NEB implementation with ADF used as an AMS engine. See also the NEB GUI tutorial.

The reaction path can be found by simultaneous optimization of a number of replicas of the system in question starting from some rough approximation [1]. In the simplest case, implemented in ADF, the initial approximation is just a polynomial interpolation between initial and final states (see keyword geovar). The images are optimized not independently of each other but, in fact, forces on each image depend on its neighbors. At each step the forces parallel to the reaction path are eliminated and a so-called spring force is added which keeps the image in the middle between its neighbors. This does not let images slide to the initial or final reaction state and ensures that they are evenly distributed along the reaction path. There are also options to distribute images more densely near the transition state (energy-dependent spring force).

Below is the list of NEB options:

```
GEOMETRY
CINEB {NumImages}
{NEBSPRING Nspring Spring Spring2 Spower}
{NEBOPT OptMethod}
{NEBECONO}
{NOCLIMB}
{NONEBOPTENDS}
End
```

`CINEB`

- The runtype. Nudged will also be recognized.
`NumImages`

- The number of NEB images excluding initial and final stated. The default is 8.
`NEBSPRING Nspring Spring Spring2 Spower`

Nspring determines the type of spring used, which, in turn, determines which of the spring parameters are used:

- constant spring, spring=Spring
- exponential scaling, spring = Spring+Spring2*exp((dE-dEmax)**Spower)
- power scaling, spring = Spring+Spring2*(dE/dEmax)**Spower
- another exponential with different meaning of Spower, spring = Spring+Spring2*exp((dE-dEmax)*Spower)
- another exponential scaling very close to #4, spring = Spring+Spring2*(2**(dE-dEmax))**Spower)

Units for Spring and Spring2 are Hartree/bohr. Default values, when NEBSPRING is not present in the input, are 1 for Nspring and 0.1 for Spring. If NEBSPRING is specified with Nspring 1 then the Spring parameter is required. If Nspring>1 is specified then also Spring2 and Spower are required.

`NEBOPT OptMethod`

Specifies the optimization procedure. Since NEB is conceptually different from simple optimization, not all or not always options used in simple geometry optimization applicable to NEB. There are two optimization modes available for NEB: global (covering all images simultaneously) and local (that is, local to each image). Each method has its pro’s and con’s. The global method usually converges in fewer steps than local because its Hessian takes into account all degrees of freedom at once. On the other hand, the size of the matrix may become too large for moderate-size system, which might lead to problems (one dimension of the Hessian matrix may be as large as N(atoms)*3*N(images)). There are two geometry update methods available for both global and local optimization: Quasi-Newton and Conjugate-Gradient. Quasi-Newton is the preferred method at all times. NEB optimization in Z-matrix coordinates is not available at this time.

- OptMethod can take any of the following values:
GLOBALQN: global Quasi-Newton.

QN: Local Quasi-Newton. The preferred (and default) method.

`NEBECONO`

- (local optimization only) Requests that when at some point an image’s geometry converges this image will not be recalculated in subsequent steps. This option can be used to speed up calculation in the end when some images have already converged. Please note though that even if an image has converged at one point it may become “un-converged” at a subsequent point due to increase in spring force (which is determined by position of the image with respect to its neighbors). This option is irrelevant in case of the global optimization because then the convergence state of a single image is not determined.
`NOCLIMB`

- Switches off the climbing-image feature. This option is generally not recommended and exists for debugging and troubleshooting purposes.
`NONEBOPTENDS`

- Do not optimize geometries the initial and final reaction states during NEB optimization.

## Recommendations concerning the NEB method¶

**Preparing input** Please pay attention to the following points when preparing input for a NEB calculation:

- If an approximated transition state is known then try to use this information when preparing the input: do not just specify the initial and final state coordinates in the GEOVAR input section but also add some values in between to take advantage of the higher-order interpolation of the initial reaction path approximation.
- Try to optimize geometries of the initial and final reaction states (the end-points) as good as possible. ADF will by default optimize them too but doing this in advance can save quite a bit of time.
- If you do not want to optimize the end-points during NEB optimization you can use the NoNEBOptEnds input keyword and you know that the end-point geometries do
**not**correspond to local minima, then you**must**make sure that they lie on the reaction path. If one (or both) of the end-points lie off the path then this may result in the images next to them sliding downhill behind the end-points, which will inevitably break the optimization. **Choosing an optimization method.**There are several optimization methods used in NEB but you should probably use one of the two Quasi-Newton methods: local (default) or global (*NEBOPT GlobalQN*input option). The main difference in functionality between the two methods is that the Climbing image technique is possible only with the GlobalQN method. In the default (local) method, the images are optimized in such a way that the Cartesian distance between them is always constant. This means that the image with the highest energy is not necessarily the transition state. With the GlobalQN method, you are guaranteed that the image with the highest energy is at the point of the maximum energy on the reaction path.

**Problems during optimization**

Many problems may be avoided if you follow the recommendations above. If, however, you did follow the recommendations and still have problems then please read below. Here follows a list of common problems with possible solutions: **Optimization stops with a message that the angle has become too small.**

- Provided that the end-points
**are**local minima, this may still happen if the initial guess for the reaction path was too rough an approximation. This usually result in very large forces on some of the images, which may result in very large steps. This is not a problem in itself but a problem may be that neighboring images get significantly different steps. If this happens, the NEB chain becomes jagged. This may get quickly out of hands if the Cartesian distances between images are comparable with the steps taken during optimization. The cure in this case is to either reduce the number of images (to increase distances between them) or to decrease the max step size (the*STEP RAD=*parameter). - Another reason for the angle becoming too sharp is that the reaction path is very complex. In this case, it may help to use more images to “smoothen” it.

In all other cases it is recommended to contact the SCM support and specify exactly what went wrong and send along the input and output files. It is recommended to use the *DEBUG NEB* input keyword, which produces extra debugging information. Doing so will speed things up a lot because we won’t have to repeat your calculation.

References

[1] | G. Henkelman, B.P. Uberuaga and H. Jonssón, A climbing image nudged elastic band method for finding saddle points and minimum energy paths, Journal of Chemical Physics 113, 9901 (2000) |