d_artn_params

namespace d_artn_params

This module contains the variables accessible from the input, and the runtime variables (flags, counters, push, eigenvec) used in the ARTn plugin.

Author

Matic Poberznik, Miha Gunde, Nicolas Salles, Antoine Jay

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)

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

interface check_d_artn_params

interface fill_param_step

interface get_param

Generic routine for getting the param group variables. Actual implementation in file: get_param.f90.

Fortran:

! signature:
! subroutine get_param( name, val, ierr )
!
! description:
! name : character(*), name of variable
! val  : the obtained value
! ierr : integer, negative on error, zero otherwise
use d_artn_params, only: get_param
integer :: ierr
integer, allocatable :: p_id(:)
call get_param( "push_ids", p_id, ierr )

The C-wrapper:

// signature:
// int get_param ( const char *name, void* val );
//
// description:
// name  : string of variable name
// val   : void ptr to obtained data
#include artn.h
void *c_val;
int ierr = get_param( "forc_thr", &c_val );
// read the double value from void *
double forc_thr = *(double *) c_val;

interface get_runparam

Generic routine for getting the runparam group variables. Actual implementation in file: get_runparam.f90.

Fortran:

! signature:
! subroutine get_runparam( name, val, ierr )
!
! description:
! name : character(*), name of variable
! val  : the obtained value
! ierr : integer, negative on error, zero otherwise
use d_artn_params, only: get_runparam
integer :: ierr
character, allocatable :: errmsg
call get_runparam( "errmsg", errmsg, ierr )

The C-wrapper:

// signature:
// int get_runparam ( const char *name, void* val );
//
// description:
// name  : string of variable name
// val   : void ptr to obtained data
#include artn.h

// obtain data on current eigenvec value; the memory is allocated in pARTn
// the 2D array of ARTn is reshaped into contiguous 1D array.
void *c_val;
int ierr = get_runparam( "eigenvec", &c_val );

// read double* value from void *
double * eigvec1d = (double *) c_val;

// reshape into 2D vec if needed.
// get drank, dsize, use that to help in reshaping (artn_get_drank, artn_get_dsize)
// NOTE: the size of C-array needs to be transposed

free(c_val);

interface set_param

Generic function for setting values to the param group of variables. Actual implementation in file: set_param.f90. The returned value ierr has value zero on normal execution, and negative on error.

Fortran:

! signature:
! function set_param( name, val ) result( ierr )
!
! description:
! name : character(*), name of variable
! val  : the value to set
! ierr : integer, negative on error, zero otherwise
use d_artn_params, only: set_param
integer :: ierr
ierr = set_param( "nperp_limitation", [6,10,14,18,-1] )

The C-wrapper has some additional arguments:

// signature:
// int set_param( const char * const name, const int rank, const int* size, const void *val );
//
// description:
// name  : string of variable name
// rank  : rank of data in `val`
// size  : array of size `rank`, each element is size of `val` on each dimension
// val   : ptr to data
#include artn.h
double f_thr = 0.01;
int ierr = set_param( "forc_thr", 0, 0, &f_thr );

interface set_runparam

Generic function for setting values to the runparam group of variables. Actual implementation in file: set_runparam.f90. The returned value ierr has value zero on normal execution, and negative on error.

Fortran:

! signature:
! function set_runparam( name, val ) result( ierr )
!
! description:
! name : character(*), name of variable
! val  : the value to set
! ierr : integer, negative on error, zero otherwise
use d_artn_params, only: set_runparam
integer :: ierr
ierr = set_runparam( "llanczos", .true. )

The C-wrapper has some additional arguments:

// signature:
// int set_runparam( const char * const name, const int rank, const int* size, const void *val );
//
// description:
// name  : string of variable name
// rank  : rank of data in `val`
// size  : array of size `rank`, each element is size of `val` on each dimension
// val   : ptr to data
#include artn.h
int istep = 4;
int ierr = set_runparam( "istep", 0, 0, &istep );