class pele.transition_states.FindTransitionState(coords, pot, tol=0.0001, event=None, nsteps=100, nfail_max=200, eigenvec0=None, iprint=-1, orthogZeroEigs=0, nsteps_tangent1=10, nsteps_tangent2=100, lowestEigenvectorQuenchParams=None, tangentSpaceQuenchParams=None, max_uphill_step=0.5, max_uphill_step_initial=0.2, demand_initial_negative_vec=False, negatives_before_check=10, verbosity=1, check_negative=True, invert_gradient=False, hessian_diagonalization=False)[source]

This class implements the hybrid eigenvector following routine for finding the nearest transition state

*orthogZeroEigs is system dependent, don’t forget to set it*

Parameters :

coords :

the starting coordinates

pot :

the potential class

tol :

the tolerance for the rms gradient

nsteps :

number of iterations

eigenvec0 :

a guess for the initial lowest eigenvector

nsteps_tangent1, nsteps_tangent2 : int

the number of iterations for tangent space minimization before and after the eigenvalue is deemed to be converged

event : callable

This will be called after each step

iprint :

the interval at which to print status messages

verbosity : int

how much debugging information to print (only partially implemented)

orthogZeroEigs : callable

this function makes a vector orthogonal to the known zero eigenvectors

orthogZeroEigs=0 : default behavior, assume translational and

rotational symmetry

orthogZeroEigs=None : the vector is unchanged

lowestEigenvectorQuenchParams : dict

these parameters are passed to the quench routine for he lowest eigenvector search

tangentSpaceQuenchParams : dict

these parameters are passed quench routine for the minimization in the space tabgent to the lowest eigenvector

max_uphill_step_initial : float

The initial maximum uphill step along the direction of the lowest eigenvector. The maximum uphill step is adjusted dynamically using a trust radius

max_uphill_step : float

The maximum value of the maximum uphill step. The maximum uphill step is adjusted using a trust radius, but it can never become larger than this.

check_negative : bool

If True then the sign of the lowest eigenvalue is required to remain negative. If the sign becomes positive, then the step is retaken with smaller step size

demand_initial_negative_vec : bool

if True then abort if the initial lowest eigenvalue is positive

negatives_before_check : int

If starting with positive curvature, disable negative eigenvalue check. This will be re-enabled as soon as the eigenvalue becomes negative. Allow a certain number of good iterations with negative eigenvalues before demanding that the eigenvalue stay negative.

nfail_max :

if the lowest eigenvector search fails this many times in a row than the algorithm ends

hessian_diagonalization : bool

Diagonalize the Hessian matrix to find the lowest eigenvector rather than using the iterative procedure

See also

function wrapper for this class
a core algorithm
the class which most often calls this routine


It is composed of the following steps:

  1. Find eigenvector corresponding to the lowest nonzero eigenvector.
  2. Step uphill in the direction of the lowest eigenvector
  3. minimize in the space tangent to the lowest eigenvector

The tolerances for the various steps of this algorithm must be correlated. if the tolerance for tangent space search is lower than the total tolerance, then it will never finish


get_energy() return the already computed energy at the current position
get_gradient() return the already computed gradient at the current position
run() The main loop of the algorithm

Previous topic


Next topic