ImageDependentPairPotential

class ImageDependentPairPotential(spring_constant=None, constraints=None, break_symmetry=None, exponent=None, max_forces=None, max_steps=None, max_step_length=None, memory_size=None)

Use the Image Dependent Pair Potential method for interpolating images.

Parameters:

  • spring_constant (PhysicalQuantity of type force per length) – The spring constant used between the images.
    Default: 5.0*eV/Ang**2.

  • constraints (sequence of ints | list of str | str) – List of atom indices that are kept fixed during interpolation or the list of tags of the atoms whose positions should be constrained.
    Default: []

  • break_symmetry (bool) – If the symmetry should be broken. This can be necessary for interpolation to work and to prevent unphysically close atoms if the endpoints are symmetry equivalent.

  • exponent (float) – The exponent used in the 1/distance weight function. The larger the exponent the more short bonds are emphasized.
    Default: 4.0.

  • max_forces (PhysicalQuantity of type eV/Ang) – The maximum forces when the optimization should stop.
    Default: 0.02*eV/Ang.

  • max_steps (int) – The maximum number of optimization steps to take after adding an image.
    Default: 200.

  • max_step_length (PhysicalQuantity of type length) – The maximum step length the optimizer may take.
    Default: 0.2*Ang.

  • memory_size (int) – The maximum number of previous steps that will be stored in memory in order to approximate the Hessian matrix.
    Default: 9

breakSymmetry()
Returns:

True, if the symmetry should be broken.

Return type:

bool

constraints()
Returns:

The constrained atoms.

Return type:

list of type int

exponent()
Returns:

The exponent used in the 1/distance weight function. The larger the exponent the more short bonds are emphasized.

Return type:

float

maxForces()
Returns:

The maximum forces when the optimization should stop.

Return type:

PhysicalQuantity of type eV/Ang

maxStepLength()
Returns:

The maximum step length the optimizer may take.

Return type:

PhysicalQuantity of type length

maxSteps()
Returns:

The maximum number of optimization steps to take after adding an image.

Return type:

int

memorySize()
Returns:

The memory size which is use for the LBFGS method.

Return type:

int

setConstraints(constraints)

Set the constraints.

Parameters:

constraints (sequence of ints | list of str | str) – List of atom indices that are kept fixed during interpolation or the list of tags of the atoms whose positions should be constrained.

springConstant()
Returns:

The spring constant used between the images.

Return type:

PhysicalQuantity of type force per length

tags()
Returns:

The tags used for defining the constraints.

Return type:

bool

uniqueString()

Return a unique string representing the state of the object.

Notes

The ImageDependentPairPotential [1] (IDPP) class is a robust interpolation algorithm for generating initial images for a NudgedElasticBand (NEB) in Cartesian coordinates. Compared to linear interpolation, it can reduce the computational effort needed for optimizing the NEB path due to finding a initial guess closer to the minimum path, in particular if rotations are involved. Furthermore the IDPP can improve convergence of electronic structure calculations by avoiding atoms getting unphysically close.

The pairwise distances \(d_{ij}\) of atom pairs \(i, j\) are scaled linearly between the the initial (\(\alpha\)) and final (\(\beta\)) images. This defines the target values for the pairwise distances at the image with index \(\kappa\),

\[d_{ij}^{\kappa} = d_{ij}^{\alpha} + \kappa (d_{ij}^{\beta} - d_{ij}^{\alpha}) / p,\]

with \(p\) being the total number of images.

Since there are more distances than independent degrees of freedom, the interpolated atomic coordinates cannot satisfy all distance constraints rigorously. Therefore the images in the IDPP-path are optimized using an objective function \(S_{\kappa}^{IDPP}\) that attains its minimum when the pair distances in an image are as close to the target values as possible:

\[S_{\kappa}^{IDPP} = \sum_i^N \sum_{j>i}^N \omega(d_{ij}) \left ( d_{ij}^{\kappa} - \sqrt{\sum_{\sigma} (r_{i, \sigma} - r_{j, \sigma})^2} \right )^2\]

where \(\sigma=x, y, z\) and \(\omega=1/d^{exponent}\) is a weight function whose exponent can be used to penalize short bonds.