pele.transition_states._transition_state_refinement#

class pele.transition_states._transition_state_refinement.FindTransitionState[source]

Source

class FindTransitionState:

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_tangent2int

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

eventcallable

This will be called after each step

iprint

the interval at which to print status messages

verbosityint

how much debugging information to print (only partially implemented)

orthogZeroEigscallable

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
index_seedint or None

Seed for the private random generator used by the additional-mode screen. None uses fresh entropy without consuming the global NumPy random stream.

lowestEigenvectorQuenchParamsdict

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

tangentSpaceQuenchParamsdict

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

max_uphill_step_initialfloat

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_stepfloat

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_negativebool

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_vecbool

if True then abort if the initial lowest eigenvalue is positive

negatives_before_checkint

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_diagonalizationbool

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

See also

findTransitionState

function wrapper for this class

findLowestEigenVector

a core algorithm

pele.landscape.LocalConnect

the class which most often calls this routine

Notes

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

A converged candidate is screened for additional unstable physical modes using two iterative searches from independent random starts. This uses linear memory; a passing screen is not an exhaustive certificate of Hessian index. The default secondary-search tolerance bounds the gradient norm rather than a dimension- dependent RMS. An explicitly supplied quench tolerance retains its RMS meaning.

FindTransitionState.get_energy()[source]

Source

def get_energy(self):

return the already computed energy at the current position

FindTransitionState.get_gradient()[source]

Source

def get_gradient(self):

return the already computed gradient at the current position

FindTransitionState.run()[source]

Source

def run(self):

The main loop of the algorithm

pele.transition_states._transition_state_refinement.findTransitionState()[source]

Source

def findTransitionState(*args, **kwargs):

simply a wrapper for initializing and running FindTransitionState

See also

FindTransitionState

for all documentation