Groups of variables

The variables of pARTn are divided into three groups:

Group param

group group_params

Variables

integer verbose = 2

Verbose Level.

integer zseed = 0

random number generator seed

integer nperp = -1

number of perp-relax iterations to perform

integer nevalf_max = NAN_INT

max nr steps. Must be < max_step of the F engine to have an effect

integer ninit = 3

number of initial pushes before lanczos start

integer neigen = 1

number of steps made with eigenvector before perp relax

integer lanczos_max_size = 16

size of the lanczos tridiagonal matrix

integer lanczos_min_size = 3

minimal size of lanzos matrix (use with care)

integer nsmooth = 0

number of smoothing steps from push to eigenvec

integer nnewchance = 0

number of new attemps after loosing eigenvalue

integer nrelax_print = 5

print at every nrelax step

integer restart_freq = 0
real(dp) push_dist_thr   = def_push_dist_thr

distance threshold for push mode “rad”

real(dp) delr_thr   = def_delr_thr

length Threshold to consider an atomic has moved

real(dp) push_over   = 1.0_DP

EigenVec fraction Push_over the saddle point for the relax.

real(dp) alpha_mix_cr   = def_alpha_mix_cr

Mixing coeff used into convex region.

real(dp) lanczos_eval_conv_thr   = def_lanczos_eval_conv_thr
real(dp) forc_thr   = NAN_REAL

force criterion for the saddle point

real(dp) eigval_thr   = NAN_REAL

threshold for eigenvalue

real(dp) etot_diff_limit   = NAN_REAL

limit for energy difference, if above exit the research

real(dp) push_step_size   = NAN_REAL

step size of inital push in units of positions

real(dp) push_step_size_per_atom   = NAN_REAL

step size of inital push per atom

real(dp) eigen_step_size   = NAN_REAL

max step size for push with eigenvector

real(dp) current_step_size   = NAN_REAL

controls the current size of eigenvector step

real(dp) lanczos_disp   = NAN_REAL
character(len=5) push_mode   = NAN_STR

type of initial push (all , list or rad)

character(len=255) engine_units   = NAN_STR

variable contains the Engine[/units]

character(len=255) push_guess   = NAN_STR

user file where the initial push is defined

character(len=255) eigenvec_mode   = NAN_STR

type of initial eigenvec

character(len=255) eigenvec_guess   = NAN_STR

file where the first vector of lanczos is defined

character(len=10) struc_format_out   = NAN_STR

output format for the configuration

character(len=255) filin   = 'artn.in'

input file

character(len=255) filout   = 'artn.out'

ouput file

character(len=255) initpfname   = 'initp'

prefix for initial push file

character(len=255) eigenfname   = 'latest_eigenvec'

prefix for latest eigenvector file

character(len=255) restartfname   = 'artn.restart'

restart file

character(len=255) prefix_min   = 'min'

prefix fore minimum configuration file

character(len=255) prefix_sad   = 'sad'

prefix fore saddle configuration file

character(:), allocatable converge_property

way to compute the force convergence (MAXVAL or NORM)

logical lmove_nextmin = .false.

move the structure to further minimum after finish

logical lnperp_limitation = .true.

Constrain on the nperp-relax above the inflection point.

logical lrestart = .false.

restart calculation by reading artn.restart

logical lpush_final = .false.

push to adjacent minimum

logical lanczos_always_random = .false.

always start lanczos with random vector

logical lanczos_at_min = .false.

Do lanczos when the new minima are reached to check EV.

logical lserialize_output = .false.

flag if we are in serialize data mode

integer, dimension(:), allocatable nperp_limitation

array of nperp values

integer, dimension(:), allocatable push_ids

IDs of atoms to be pushed.

real(dp), dimension(:,:), allocatable push_add_const

constraints on initial push

real(dp), dimension(:,:), allocatable push

initial push vector

real(dp), dimension(:,:), allocatable eigenvec

lanczos eigenvector

character(len=3), dimension(:), allocatable elements

element names (needed if xsf)

Group data

group group_data

Variables

integer natoms = -10

Number of atoms, to test coherence in structure between steps.

real(dp), dimension(3, 3) lat

lattice vectors in columns, lat(:,1)=v1, lat(:,2)=v2, lat(:,3)=v3

logical has_error = .false.
integer nevalf
integer, dimension(:), allocatable typ_step

atomic types

real(dp), dimension(:,:), allocatable tau_step

current coordinates (restart)

real(dp), dimension(:,:), allocatable force_step

current force (restart)

real(dp), dimension(:,:), allocatable eigen_step

eigenvector value at current step (updated every step)

real(dp) etot_step   = NAN_REAL

@brief total energy of the current step

real(dp) delr_step   = NAN_REAL

@brief delr of current step

real(dp) eigval_step   = NAN_REAL
integer, dimension(:), allocatable typ_init
real(dp), dimension(:,:), allocatable tau_init

initial coordinates

real(dp), dimension(:,:), allocatable push_init

initial push vector

real(dp) etot_init   = NAN_REAL
real(dp) delr_init   = NAN_REAL
logical has_sad = .false.
real(dp) etot_sad   = NAN_REAL
real(dp) delr_sad   = NAN_REAL
real(dp) eigval_sad   = NAN_REAL
integer nevalf_sad = -NAN_INT

number of force evaluations to reach saddle

integer, dimension(:), allocatable typ_sad
real(dp), dimension(:,:), allocatable tau_sad

coordinates of saddle point

real(dp), dimension(:,:), allocatable eigen_sad

saddle point eigenvector

character(len=maxlen_fname) fname_sad

filename with saddle point (if saved)

logical has_min1 = .false.
real(dp) etot_min1   = NAN_REAL
real(dp) delr_min1   = NAN_REAL
real(dp) eigval_min1   = NAN_REAL
integer nevalf_min1 = -NAN_INT
integer, dimension(:), allocatable typ_min1
real(dp), dimension(:,:), allocatable tau_min1
character(len=maxlen_fname) fname_min1
logical has_min2 = .false.
real(dp) etot_min2   = NAN_REAL
real(dp) delr_min2   = NAN_REAL
real(dp) eigval_min2   = NAN_REAL
integer nevalf_min2 = -NAN_INT
integer, dimension(:), allocatable typ_min2
real(dp), dimension(:,:), allocatable tau_min2
character(len=maxlen_fname) fname_min2
real(dp), dimension(:,:), allocatable tau_nextmin

coordinates of the new minimum

real(dp) etot_final

the total energy of the next minimum along eigenvector

real(dp) de_saddle

change in E from starting point

real(dp) de_back

backward barrier

real(dp) de_fwd

forward barrier

Group runparam

group group_runparams

Variables

character(len=255) artn_resume

variable store the 2 minimum and saddle point configuration file

integer, parameter void   = 1
integer, parameter init   = 2
integer, parameter perp   = 3
integer, parameter eign   = 4
integer, parameter lanc   = 5
integer, parameter relx   = 6
integer, parameter over   = 7
integer, parameter smth   = 8
integer, parameter rset   = 9
character(len=4), dimension(9) str_move
integer current_disp_code = VOID

save the disp_code of current call

logical linit

initial push OF THE MACROSTEP

logical lperp

perpendicular relax

logical leigen

push with lanczos eigenvector

logical llanczos

lanczos algorithm

logical lbasin

true while in basin

logical lpush_over

saddle point obtained

logical lrelax

start the relaxation to adjacent minima from the saddle point

logical in_lanczos_at_min

Set to true when lanczos loop is the one done at min.

logical lbackward = .true.

start relax from SP in backward sense

logical lend = .false.

turn the flag to true when artn finishes, to know if we re-enter

integer iartn

counter of current ARTn macro step

integer istep

counter of current step

integer iinit

counter of pushes made with initial push, before Lanczos

integer iperp

number of steps in perpendicular relaxation

integer ieigen

counter of pushes made with eigenvector

integer irelax

counter of relaxation steps

integer iover

number of push_over step

integer inewchance

number of new attemps after loosing eigenvalue

integer ismooth

counter of current smoothing step

integer nlanc

number of lanczos iterations (after lanczos converge)

integer ifound = 0

Number of saddle point found (only used in write_header_report)

integer isearch = 0

Number of saddle point research, initialise here, implicit save!

integer ifails = 0

number of failures, initialize in setup_artn

integer nperp_step

nperp_limitation step

integer nmin

count the number of minimum found

integer nsaddle

count the number of saddle point found

real(dp), dimension(:,:), allocatable delr_vec

displacement vector

real(dp), dimension(:,:), allocatable push_initial_vector

copy of the initial push

logical luser_choose_per_atom

Flag to distinguish the 2 push_step_size definition.

integer fpush_factor

internal factor for the final push direction

character(:), dimension(:), allocatable words

Use for parser : remove the worning.

logical lserialize_input

flag if we are in serialize data mode

character(*), parameter serial_input_fname   ="artn_serial_input"
integer called_from = CALLER_IS_ENGINE