geometricOptimizationParameters

	Core NanoLanguage elements
executeSelfConsistentCalculation	iterationControlParameters

Name

geometricOptimizationParameters — Parameters controlling the geometric optimization of an atomic configuration.

Synopsis

Namespace: ATK.KohnSham or ATK.TwoProbe

dictionary geometricOptimizationParameters(
force_tolerance,
max_steps,
optimizer,
trust_radius
)

dictionary geometricOptimizationParameters(
force_tolerance,
max_steps,
optimizer,
time_step
)

Description

This function returns a dictionary containing parameters that control certain numerical aspects of the geometric optimization algorithm. For more details, see calculateOptimizedAtomicGeometry().

List of arguments

force_tolerance

The convergence criterion for the optimization is that the absolute value of the largest force component should be smaller than this value.

Default: 0.05*eV/Ang

max_steps

The maximum number of optimization steps.

Default: 200

optimizer

The algorithm used for performing the geometry optimization. Possible choices are Optimizer.QuasiNewton and Optimizer.SteepestDescent.

Default: Optimizer.QuasiNewton

trust_radius

Initial value of the quasi-Newton trust radius. The trust radius is the estimate of the range for which a step can be safely taken. This radius is updated iteratively during the geometry optimization. If the starting configuration contains large forces, setting a small trust radius can ensure that a downhill step is taking. This option can be specified only if optimizer is set to Optimizer.QuasiNewton.

Default: 0.5*Ang

time_step

Time step for the molecular dynamics integrator. This option can be specified only if optimizer is set to Optimizer.SteepestDescent.

Default: 0.5*femtosecond

Usage examples

from ATK.KohnSham import *

opt_parms = geometricOptimizationParameters(
    force_tolerance = 0.001*eV/Ang,
    max_steps = 300,
    optimizer = Optimizer.SteepestDescent,
    time_step = 0.05*femtosecond
    )

Notes

The default value of force_tolerance is quite liberal. For simple systems such as small molecules, it is recommended to lower it by an order of magnitude for more careful calculations. However, for very complex systems, reasonable results can be still obtained for larger values of the tolerance. In general, it is a good idea to use the result of a optimization with a large force tolerance as the starting guess for the more accurate optimization (see, e.g. the examples given in Restarting a finished job).
The step counter includes all the performed self-consistent calculations. Therefore, the actual number of available steps in the relaxation part might be lower than max_steps. The default is however large enough that most calculations should converge before reaching this maximum. If not, the optimization can always be restarted using calculateOptimizedAtomicGeometry().
Available algorithms:

The variable optimizer can assume only one of the following values:
- Optimizer.QuasiNewton
  
  Quasi-Newton method based on [18]. Notice that the optimization algorithm might require to lower the tolerance for the self-consistent calculations, in order to converge when using very small values of the force_tolerance parameter.
- Optimizer.SteepestDescent
  
  Steepest descent algorithm based on a damped velocity-Verlet MD algorithm.
The best choice for the value of the time_step parameter is often system dependent. An approximation to the optimal value could be found, e.g. by performing test calculations with different values of the time step and analyzing the corresponding trends: Selecting a too large value for can make the Optimizer.SteepestDescent algorithm divergent; on the other hand, a too small value will slow down the convergence.

Further examples


executeSelfConsistentCalculation		iterationControlParameters