mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-28 18:56:06 +00:00
999 lines
38 KiB
C++
999 lines
38 KiB
C++
MODULE kinds
|
|
INTEGER, PARAMETER :: DP = selected_real_kind(14,200)
|
|
PRIVATE
|
|
PUBLIC :: DP
|
|
END MODULE kinds
|
|
|
|
MODULE constants
|
|
USE kinds, ONLY : DP
|
|
IMPLICIT NONE
|
|
SAVE
|
|
REAL(DP), PARAMETER :: pi = 3.14159265358979323846_DP
|
|
REAL(DP), PARAMETER :: tpi= 2.0_DP * pi
|
|
REAL(DP), PARAMETER :: fpi= 4.0_DP * pi
|
|
REAL(DP), PARAMETER :: sqrtpi = 1.77245385090551602729_DP
|
|
REAL(DP), PARAMETER :: sqrtpm1= 1.0_DP / sqrtpi
|
|
REAL(DP), PARAMETER :: sqrt2 = 1.41421356237309504880_DP
|
|
REAL(DP), PARAMETER :: H_PLANCK_SI = 6.6260693D-34 ! J s
|
|
REAL(DP), PARAMETER :: K_BOLTZMANN_SI = 1.3806505D-23 ! J K^-1
|
|
REAL(DP), PARAMETER :: ELECTRON_SI = 1.60217653D-19 ! C
|
|
REAL(DP), PARAMETER :: ELECTRONVOLT_SI = 1.60217653D-19 ! J
|
|
REAL(DP), PARAMETER :: ELECTRONMASS_SI = 9.1093826D-31 ! Kg
|
|
REAL(DP), PARAMETER :: HARTREE_SI = 4.35974417D-18 ! J
|
|
REAL(DP), PARAMETER :: RYDBERG_SI = HARTREE_SI/2.0_DP! J
|
|
REAL(DP), PARAMETER :: BOHR_RADIUS_SI = 0.5291772108D-10 ! m
|
|
REAL(DP), PARAMETER :: AMU_SI = 1.66053886D-27 ! Kg
|
|
REAL(DP), PARAMETER :: K_BOLTZMANN_AU = K_BOLTZMANN_SI / HARTREE_SI
|
|
REAL(DP), PARAMETER :: K_BOLTZMANN_RY = K_BOLTZMANN_SI / RYDBERG_SI
|
|
REAL(DP), PARAMETER :: AUTOEV = HARTREE_SI / ELECTRONVOLT_SI
|
|
REAL(DP), PARAMETER :: RYTOEV = AUTOEV / 2.0_DP
|
|
REAL(DP), PARAMETER :: AMU_AU = AMU_SI / ELECTRONMASS_SI
|
|
REAL(DP), PARAMETER :: AMU_RY = AMU_AU / 2.0_DP
|
|
REAL(DP), PARAMETER :: AU_SEC = H_PLANCK_SI/tpi/HARTREE_SI
|
|
REAL(DP), PARAMETER :: AU_PS = AU_SEC * 1.0D+12
|
|
REAL(DP), PARAMETER :: AU_GPA = HARTREE_SI / BOHR_RADIUS_SI ** 3 &
|
|
/ 1.0D+9
|
|
REAL(DP), PARAMETER :: RY_KBAR = 10.0_dp * AU_GPA / 2.0_dp
|
|
!
|
|
REAL(DP), PARAMETER :: DEBYE_SI = 3.3356409519 * 1.0D-30 ! C*m
|
|
REAL(DP), PARAMETER :: AU_DEBYE = ELECTRON_SI * BOHR_RADIUS_SI / &
|
|
DEBYE_SI
|
|
REAL(DP), PARAMETER :: eV_to_kelvin = ELECTRONVOLT_SI / K_BOLTZMANN_SI
|
|
REAL(DP), PARAMETER :: ry_to_kelvin = RYDBERG_SI / K_BOLTZMANN_SI
|
|
REAL(DP), PARAMETER :: eps4 = 1.0D-4
|
|
REAL(DP), PARAMETER :: eps6 = 1.0D-6
|
|
REAL(DP), PARAMETER :: eps8 = 1.0D-8
|
|
REAL(DP), PARAMETER :: eps14 = 1.0D-14
|
|
REAL(DP), PARAMETER :: eps16 = 1.0D-16
|
|
REAL(DP), PARAMETER :: eps32 = 1.0D-32
|
|
REAL(DP), PARAMETER :: gsmall = 1.0d-12
|
|
REAL(DP), PARAMETER :: e2 = 2.D0 ! the square of the electron charge
|
|
REAL(DP), PARAMETER :: degspin = 2.D0 ! the number of spins per level
|
|
REAL(DP), PARAMETER :: amconv = AMU_RY
|
|
REAL(DP), PARAMETER :: uakbar = RY_KBAR
|
|
REAL(DP), PARAMETER :: bohr_radius_cm = bohr_radius_si * 100.0
|
|
REAL(DP), PARAMETER :: BOHR_RADIUS_ANGS = bohr_radius_cm * 1.0D8
|
|
REAL(DP), PARAMETER :: ANGSTROM_AU = 1.0/BOHR_RADIUS_ANGS
|
|
REAL(DP), PARAMETER :: DIP_DEBYE = AU_DEBYE
|
|
REAL(DP), PARAMETER :: AU_TERAHERTZ = AU_PS
|
|
REAL(DP), PARAMETER :: AU_TO_OHMCMM1 = 46000.0D0 ! (ohm cm)^-1
|
|
!
|
|
|
|
END MODULE constants
|
|
|
|
!
|
|
! Copyright (C) 2001-2005 Quantum-ESPRESSO group
|
|
! This file is distributed under the terms of the
|
|
! GNU General Public License. See the file `License'
|
|
! in the root directory of the present distribution,
|
|
! or http://www.gnu.org/copyleft/gpl.txt .
|
|
!
|
|
!
|
|
!---------------------------------------------------------------------------
|
|
MODULE parameters
|
|
!---------------------------------------------------------------------------
|
|
!
|
|
IMPLICIT NONE
|
|
SAVE
|
|
!
|
|
INTEGER, PARAMETER :: &
|
|
ntypx = 10, &! max number of different types of atom
|
|
npsx = ntypx, &! max number of different PPs (obsolete)
|
|
npk = 40000, &! max number of k-points
|
|
lmaxx = 3, &! max non local angular momentum (l=0 to lmaxx)
|
|
nchix = 6, &! max number of atomic wavefunctions per atom
|
|
ndmx = 2000 ! max number of points in the atomic radial mesh
|
|
!
|
|
INTEGER, PARAMETER :: &
|
|
nbrx = 14, &! max number of beta functions
|
|
lqmax= 2*lmaxx+1, &! max number of angular momenta of Q
|
|
nqfx = 8 ! max number of coefficients in Q smoothing
|
|
!
|
|
INTEGER, PARAMETER :: nacx = 10 ! max number of averaged
|
|
! quantities saved to the restart
|
|
INTEGER, PARAMETER :: nsx = ntypx ! max number of species
|
|
INTEGER, PARAMETER :: natx = 5000 ! max number of atoms
|
|
INTEGER, PARAMETER :: npkx = npk ! max number of K points
|
|
INTEGER, PARAMETER :: ncnsx = 101 ! max number of constraints
|
|
INTEGER, PARAMETER :: nspinx = 2 ! max number of spinors
|
|
!
|
|
INTEGER, PARAMETER :: nhclm = 4 ! max number NH chain length, nhclm can be
|
|
! easily increased since the restart file
|
|
! should be able to handle it, perhaps
|
|
! better to align nhclm by 4
|
|
!
|
|
INTEGER, PARAMETER :: max_nconstr = 100
|
|
!
|
|
INTEGER, PARAMETER :: maxcpu = 2**17 ! Maximum number of CPU
|
|
INTEGER, PARAMETER :: maxgrp = 128 ! Maximum number of task-groups
|
|
!
|
|
END MODULE parameters
|
|
|
|
MODULE control_flags
|
|
USE kinds
|
|
USE parameters
|
|
IMPLICIT NONE
|
|
SAVE
|
|
TYPE convergence_criteria
|
|
!
|
|
LOGICAL :: active
|
|
INTEGER :: nstep
|
|
REAL(DP) :: ekin
|
|
REAL(DP) :: derho
|
|
REAL(DP) :: force
|
|
!
|
|
END TYPE convergence_criteria
|
|
!
|
|
TYPE ionic_conjugate_gradient
|
|
!
|
|
LOGICAL :: active
|
|
INTEGER :: nstepix
|
|
INTEGER :: nstepex
|
|
REAL(DP) :: ionthr
|
|
REAL(DP) :: elethr
|
|
!
|
|
END TYPE ionic_conjugate_gradient
|
|
!
|
|
CHARACTER(LEN=4) :: program_name = ' ' ! used to control execution flow inside module
|
|
!
|
|
LOGICAL :: tvlocw = .FALSE. ! write potential to unit 46 (only cp, seldom used)
|
|
LOGICAL :: trhor = .FALSE. ! read rho from unit 47 (only cp, seldom used)
|
|
LOGICAL :: trhow = .FALSE. ! CP code, write rho to restart dir
|
|
!
|
|
LOGICAL :: tsde = .FALSE. ! electronic steepest descent
|
|
LOGICAL :: tzeroe = .FALSE. ! set to zero the electronic velocities
|
|
LOGICAL :: tfor = .FALSE. ! move the ions ( calculate forces )
|
|
LOGICAL :: tsdp = .FALSE. ! ionic steepest descent
|
|
LOGICAL :: tzerop = .FALSE. ! set to zero the ionic velocities
|
|
LOGICAL :: tprnfor = .FALSE. ! print forces to standard output
|
|
LOGICAL :: taurdr = .FALSE. ! read ionic position from standard input
|
|
LOGICAL :: tv0rd = .FALSE. ! read ionic velocities from standard input
|
|
LOGICAL :: tpre = .FALSE. ! calculate stress, and (in fpmd) variable cell dynamic
|
|
LOGICAL :: thdyn = .FALSE. ! variable-cell dynamics (only cp)
|
|
LOGICAL :: tsdc = .FALSE. ! cell geometry steepest descent
|
|
LOGICAL :: tzeroc = .FALSE. ! set to zero the cell geometry velocities
|
|
LOGICAL :: tstress = .FALSE. ! print stress to standard output
|
|
LOGICAL :: tortho = .FALSE. ! use iterative orthogonalization
|
|
LOGICAL :: tconjgrad = .FALSE. ! use conjugate gradient electronic minimization
|
|
LOGICAL :: timing = .FALSE. ! print out timing information
|
|
LOGICAL :: memchk = .FALSE. ! check for memory leakage
|
|
LOGICAL :: tprnsfac = .FALSE. ! print out structure factor
|
|
LOGICAL :: toptical = .FALSE. ! print out optical properties
|
|
LOGICAL :: tcarpar = .FALSE. ! tcarpar is set TRUE for a "pure" Car Parrinello simulation
|
|
LOGICAL :: tdamp = .FALSE. ! Use damped dinamics for electrons
|
|
LOGICAL :: tdampions = .FALSE. ! Use damped dinamics for electrons
|
|
LOGICAL :: tatomicwfc = .FALSE. ! Use atomic wavefunctions as starting guess for ch. density
|
|
LOGICAL :: tscreen = .FALSE. ! Use screened coulomb potentials for cluster calculations
|
|
LOGICAL :: twfcollect = .FALSE. ! Collect wave function in the restart file at the end of run.
|
|
LOGICAL :: tuspp = .FALSE. ! Ultra-soft pseudopotential are being used
|
|
INTEGER :: printwfc = -1 ! Print wave functions, temporarely used only by ensemble-dft
|
|
LOGICAL :: force_pairing = .FALSE. ! ... Force pairing
|
|
LOGICAL :: tchi2 = .FALSE. ! Compute Chi^2
|
|
!
|
|
TYPE (convergence_criteria) :: tconvthrs
|
|
! thresholds used to check GS convergence
|
|
!
|
|
! ... Ionic vs Electronic step frequency
|
|
! ... When "ion_nstep > 1" and "electron_dynamics = 'md' | 'sd' ", ions are
|
|
! ... propagated every "ion_nstep" electronic step only if the electronic
|
|
! ... "ekin" is lower than "ekin_conv_thr"
|
|
!
|
|
LOGICAL :: tionstep = .FALSE.
|
|
INTEGER :: nstepe = 1
|
|
! parameters to control how many electronic steps
|
|
! between ions move
|
|
|
|
LOGICAL :: tsteepdesc = .FALSE.
|
|
! parameters for electronic steepest desceent
|
|
|
|
TYPE (ionic_conjugate_gradient) :: tconjgrad_ion
|
|
! conjugate gradient for ionic minimization
|
|
|
|
INTEGER :: nbeg = 0 ! internal code for initialization ( -1, 0, 1, 2, .. )
|
|
INTEGER :: ndw = 0 !
|
|
INTEGER :: ndr = 0 !
|
|
INTEGER :: nomore = 0 !
|
|
INTEGER :: iprint = 0 ! print output every iprint step
|
|
INTEGER :: isave = 0 ! write restart to ndr unit every isave step
|
|
INTEGER :: nv0rd = 0 !
|
|
INTEGER :: iprsta = 0 ! output verbosity (increasing from 0 to infinity)
|
|
!
|
|
! ... .TRUE. if only gamma point is used
|
|
!
|
|
LOGICAL :: gamma_only = .TRUE.
|
|
!
|
|
LOGICAL :: tnewnfi = .FALSE.
|
|
INTEGER :: newnfi = 0
|
|
!
|
|
! This variable is used whenever a timestep change is requested
|
|
!
|
|
REAL(DP) :: dt_old = -1.0D0
|
|
!
|
|
! ... Wave function randomization
|
|
!
|
|
LOGICAL :: trane = .FALSE.
|
|
REAL(DP) :: ampre = 0.D0
|
|
!
|
|
! ... Ionic position randomization
|
|
!
|
|
LOGICAL :: tranp(nsx) = .FALSE.
|
|
REAL(DP) :: amprp(nsx) = 0.D0
|
|
!
|
|
! ... Read the cell from standard input
|
|
!
|
|
LOGICAL :: tbeg = .FALSE.
|
|
!
|
|
! ... This flags control the calculation of the Dipole Moments
|
|
!
|
|
LOGICAL :: tdipole = .FALSE.
|
|
!
|
|
! ... Flags that controls DIIS electronic minimization
|
|
!
|
|
LOGICAL :: t_diis = .FALSE.
|
|
LOGICAL :: t_diis_simple = .FALSE.
|
|
LOGICAL :: t_diis_rot = .FALSE.
|
|
!
|
|
! ... Flag controlling the Nose thermostat for electrons
|
|
!
|
|
LOGICAL :: tnosee = .FALSE.
|
|
!
|
|
! ... Flag controlling the Nose thermostat for the cell
|
|
!
|
|
LOGICAL :: tnoseh = .FALSE.
|
|
!
|
|
! ... Flag controlling the Nose thermostat for ions
|
|
!
|
|
LOGICAL :: tnosep = .FALSE.
|
|
LOGICAL :: tcap = .FALSE.
|
|
LOGICAL :: tcp = .FALSE.
|
|
REAL(DP) :: tolp = 0.D0 ! tolerance for temperature variation
|
|
!
|
|
REAL(DP), PUBLIC :: &
|
|
ekin_conv_thr = 0.D0, &! conv. threshold for fictitious e. kinetic energy
|
|
etot_conv_thr = 0.D0, &! conv. threshold for DFT energy
|
|
forc_conv_thr = 0.D0 ! conv. threshold for atomic forces
|
|
INTEGER, PUBLIC :: &
|
|
ekin_maxiter = 100, &! max number of iter. for ekin convergence
|
|
etot_maxiter = 100, &! max number of iter. for etot convergence
|
|
forc_maxiter = 100 ! max number of iter. for atomic forces conv.
|
|
!
|
|
! ... Several variables controlling the run ( used mainly in PW calculations )
|
|
!
|
|
! ... logical flags controlling the execution
|
|
!
|
|
LOGICAL, PUBLIC :: &
|
|
lfixatom, &! if .TRUE. some atom is kept fixed
|
|
lscf, &! if .TRUE. the calc. is selfconsistent
|
|
lbfgs, &! if .TRUE. the calc. is a relaxation based on new BFGS scheme
|
|
lmd, &! if .TRUE. the calc. is a dynamics
|
|
lmetadyn, &! if .TRUE. the calc. is a meta-dynamics
|
|
lpath, &! if .TRUE. the calc. is a path optimizations
|
|
lneb, &! if .TRUE. the calc. is NEB dynamics
|
|
lsmd, &! if .TRUE. the calc. is string dynamics
|
|
lwf, &! if .TRUE. the calc. is with wannier functions
|
|
lphonon, &! if .TRUE. the calc. is phonon
|
|
lbands, &! if .TRUE. the calc. is band structure
|
|
lconstrain, &! if .TRUE. the calc. is constraint
|
|
ldamped, &! if .TRUE. the calc. is a damped dynamics
|
|
lrescale_t, &! if .TRUE. the ionic temperature is rescaled
|
|
langevin_rescaling, &! if .TRUE. the ionic dynamics is overdamped Langevin
|
|
lcoarsegrained, &! if .TRUE. a coarse-grained phase-space is used
|
|
restart ! if .TRUE. restart from results of a preceding run
|
|
!
|
|
LOGICAL, PUBLIC :: &
|
|
remove_rigid_rot ! if .TRUE. the total torque acting on the atoms is
|
|
! removed
|
|
!
|
|
! ... pw self-consistency
|
|
!
|
|
INTEGER, PUBLIC :: &
|
|
ngm0, &! used in mix_rho
|
|
niter, &! the maximum number of iteration
|
|
nmix, &! the number of iteration kept in the history
|
|
imix ! the type of mixing (0=plain,1=TF,2=local-TF)
|
|
REAL(DP), PUBLIC :: &
|
|
mixing_beta, &! the mixing parameter
|
|
tr2 ! the convergence threshold for potential
|
|
LOGICAL, PUBLIC :: &
|
|
conv_elec ! if .TRUE. electron convergence has been reached
|
|
!
|
|
! ... pw diagonalization
|
|
!
|
|
REAL(DP), PUBLIC :: &
|
|
ethr ! the convergence threshold for eigenvalues
|
|
INTEGER, PUBLIC :: &
|
|
david, &! used on Davidson diagonalization
|
|
isolve, &! Davidson or CG or DIIS diagonalization
|
|
max_cg_iter, &! maximum number of iterations in a CG di
|
|
diis_buff, &! dimension of the buffer in diis
|
|
diis_ndim ! dimension of reduced basis in DIIS
|
|
LOGICAL, PUBLIC :: &
|
|
diago_full_acc ! if true all the empty eigenvalues have the same
|
|
! accuracy of the occupied ones
|
|
!
|
|
! ... wfc and rho extrapolation
|
|
!
|
|
REAL(DP), PUBLIC :: &
|
|
alpha0, &! the mixing parameters for the extrapolation
|
|
beta0 ! of the starting potential
|
|
INTEGER, PUBLIC :: &
|
|
history, &! number of old steps available for potential updating
|
|
pot_order, &! type of potential updating ( see update_pot )
|
|
wfc_order ! type of wavefunctions updating ( see update_pot )
|
|
!
|
|
! ... ionic dynamics
|
|
!
|
|
INTEGER, PUBLIC :: &
|
|
nstep, &! number of ionic steps
|
|
istep = 0 ! current ionic step
|
|
LOGICAL, PUBLIC :: &
|
|
conv_ions ! if .TRUE. ionic convergence has been reached
|
|
REAL(DP), PUBLIC :: &
|
|
upscale ! maximum reduction of convergence threshold
|
|
!
|
|
! ... system's symmetries
|
|
!
|
|
LOGICAL, PUBLIC :: &
|
|
nosym, &! if .TRUE. no symmetry is used
|
|
noinv = .FALSE. ! if .TRUE. eliminates inversion symmetry
|
|
!
|
|
! ... phonon calculation
|
|
!
|
|
INTEGER, PUBLIC :: &
|
|
modenum ! for single mode phonon calculation
|
|
!
|
|
! ... printout control
|
|
!
|
|
LOGICAL, PUBLIC :: &
|
|
reduce_io ! if .TRUE. reduce the I/O to the strict minimum
|
|
INTEGER, PUBLIC :: &
|
|
iverbosity ! type of printing ( 0 few, 1 all )
|
|
LOGICAL, PUBLIC :: &
|
|
use_para_diago = .FALSE. ! if .TRUE. a parallel Householder algorithm
|
|
INTEGER, PUBLIC :: &
|
|
para_diago_dim = 0 ! minimum matrix dimension above which a parallel
|
|
INTEGER :: ortho_max = 0 ! maximum number of iterations in routine ortho
|
|
REAL(DP) :: ortho_eps = 0.D0 ! threshold for convergence in routine ortho
|
|
LOGICAL, PUBLIC :: &
|
|
use_task_groups = .FALSE. ! if TRUE task groups parallelization is used
|
|
INTEGER, PUBLIC :: iesr = 1
|
|
LOGICAL, PUBLIC :: tvhmean = .FALSE.
|
|
REAL(DP), PUBLIC :: vhrmin = 0.0d0
|
|
REAL(DP), PUBLIC :: vhrmax = 1.0d0
|
|
CHARACTER(LEN=1), PUBLIC :: vhasse = 'Z'
|
|
LOGICAL, PUBLIC :: tprojwfc = .FALSE.
|
|
CONTAINS
|
|
SUBROUTINE fix_dependencies()
|
|
END SUBROUTINE fix_dependencies
|
|
SUBROUTINE check_flags()
|
|
END SUBROUTINE check_flags
|
|
END MODULE control_flags
|
|
|
|
!
|
|
! Copyright (C) 2002 FPMD group
|
|
! This file is distributed under the terms of the
|
|
! GNU General Public License. See the file `License'
|
|
! in the root directory of the present distribution,
|
|
! or http://www.gnu.org/copyleft/gpl.txt .
|
|
!
|
|
|
|
!=----------------------------------------------------------------------------=!
|
|
MODULE gvecw
|
|
!=----------------------------------------------------------------------------=!
|
|
USE kinds, ONLY: DP
|
|
|
|
IMPLICIT NONE
|
|
SAVE
|
|
|
|
! ... G vectors less than the wave function cut-off ( ecutwfc )
|
|
INTEGER :: ngw = 0 ! local number of G vectors
|
|
INTEGER :: ngwt = 0 ! in parallel execution global number of G vectors,
|
|
! in serial execution this is equal to ngw
|
|
INTEGER :: ngwl = 0 ! number of G-vector shells up to ngw
|
|
INTEGER :: ngwx = 0 ! maximum local number of G vectors
|
|
INTEGER :: ng0 = 0 ! first G-vector with nonzero modulus
|
|
! needed in the parallel case (G=0 is on one node only!)
|
|
|
|
REAL(DP) :: ecutw = 0.0d0
|
|
REAL(DP) :: gcutw = 0.0d0
|
|
|
|
! values for costant cut-off computations
|
|
|
|
REAL(DP) :: ecfix = 0.0d0 ! value of the constant cut-off
|
|
REAL(DP) :: ecutz = 0.0d0 ! height of the penalty function (above ecfix)
|
|
REAL(DP) :: ecsig = 0.0d0 ! spread of the penalty function around ecfix
|
|
LOGICAL :: tecfix = .FALSE. ! .TRUE. if constant cut-off is in use
|
|
|
|
! augmented cut-off for k-point calculation
|
|
|
|
REAL(DP) :: ekcut = 0.0d0
|
|
REAL(DP) :: gkcut = 0.0d0
|
|
|
|
! array of G vectors module plus penalty function for constant cut-off
|
|
! simulation.
|
|
!
|
|
! ggp = g + ( agg / tpiba**2 ) * ( 1 + erf( ( tpiba2 * g - e0gg ) / sgg ) )
|
|
|
|
REAL(DP), ALLOCATABLE, TARGET :: ggp(:)
|
|
|
|
CONTAINS
|
|
|
|
SUBROUTINE deallocate_gvecw
|
|
IF( ALLOCATED( ggp ) ) DEALLOCATE( ggp )
|
|
END SUBROUTINE deallocate_gvecw
|
|
|
|
!=----------------------------------------------------------------------------=!
|
|
END MODULE gvecw
|
|
!=----------------------------------------------------------------------------=!
|
|
|
|
!=----------------------------------------------------------------------------=!
|
|
MODULE gvecs
|
|
!=----------------------------------------------------------------------------=!
|
|
USE kinds, ONLY: DP
|
|
|
|
IMPLICIT NONE
|
|
SAVE
|
|
|
|
! ... G vectors less than the smooth grid cut-off ( ? )
|
|
INTEGER :: ngs = 0 ! local number of G vectors
|
|
INTEGER :: ngst = 0 ! in parallel execution global number of G vectors,
|
|
! in serial execution this is equal to ngw
|
|
INTEGER :: ngsl = 0 ! number of G-vector shells up to ngw
|
|
INTEGER :: ngsx = 0 ! maximum local number of G vectors
|
|
|
|
INTEGER, ALLOCATABLE :: nps(:), nms(:)
|
|
|
|
REAL(DP) :: ecuts = 0.0d0
|
|
REAL(DP) :: gcuts = 0.0d0
|
|
|
|
REAL(DP) :: dual = 0.0d0
|
|
LOGICAL :: doublegrid = .FALSE.
|
|
|
|
CONTAINS
|
|
|
|
SUBROUTINE deallocate_gvecs()
|
|
IF( ALLOCATED( nps ) ) DEALLOCATE( nps )
|
|
IF( ALLOCATED( nms ) ) DEALLOCATE( nms )
|
|
END SUBROUTINE deallocate_gvecs
|
|
|
|
!=----------------------------------------------------------------------------=!
|
|
END MODULE gvecs
|
|
!=----------------------------------------------------------------------------=!
|
|
|
|
MODULE electrons_base
|
|
USE kinds, ONLY: DP
|
|
IMPLICIT NONE
|
|
SAVE
|
|
|
|
INTEGER :: nbnd = 0 ! number electronic bands, each band contains
|
|
! two spin states
|
|
INTEGER :: nbndx = 0 ! array dimension nbndx >= nbnd
|
|
INTEGER :: nspin = 0 ! nspin = number of spins (1=no spin, 2=LSDA)
|
|
INTEGER :: nel(2) = 0 ! number of electrons (up, down)
|
|
INTEGER :: nelt = 0 ! total number of electrons ( up + down )
|
|
INTEGER :: nupdwn(2) = 0 ! number of states with spin up (1) and down (2)
|
|
INTEGER :: iupdwn(2) = 0 ! first state with spin (1) and down (2)
|
|
INTEGER :: nudx = 0 ! max (nupdw(1),nupdw(2))
|
|
INTEGER :: nbsp = 0 ! total number of electronic states
|
|
! (nupdwn(1)+nupdwn(2))
|
|
INTEGER :: nbspx = 0 ! array dimension nbspx >= nbsp
|
|
|
|
LOGICAL :: telectrons_base_initval = .FALSE.
|
|
LOGICAL :: keep_occ = .FALSE. ! if .true. when reading restart file keep
|
|
! the occupations calculated in initval
|
|
|
|
REAL(DP), ALLOCATABLE :: f(:) ! occupation numbers ( at gamma )
|
|
REAL(DP) :: qbac = 0.0d0 ! background neutralizing charge
|
|
INTEGER, ALLOCATABLE :: ispin(:) ! spin of each state
|
|
!
|
|
!------------------------------------------------------------------------------!
|
|
CONTAINS
|
|
!------------------------------------------------------------------------------!
|
|
|
|
|
|
SUBROUTINE electrons_base_initval( zv_ , na_ , nsp_ , nelec_ , nelup_ , neldw_ , nbnd_ , &
|
|
nspin_ , occupations_ , f_inp, tot_charge_, multiplicity_, tot_magnetization_ )
|
|
REAL(DP), INTENT(IN) :: zv_ (:), tot_charge_
|
|
REAL(DP), INTENT(IN) :: nelec_ , nelup_ , neldw_
|
|
REAL(DP), INTENT(IN) :: f_inp(:,:)
|
|
INTEGER, INTENT(IN) :: na_ (:) , nsp_, multiplicity_, tot_magnetization_
|
|
INTEGER, INTENT(IN) :: nbnd_ , nspin_
|
|
CHARACTER(LEN=*), INTENT(IN) :: occupations_
|
|
END SUBROUTINE electrons_base_initval
|
|
|
|
|
|
subroutine set_nelup_neldw ( nelec_, nelup_, neldw_, tot_magnetization_, &
|
|
multiplicity_)
|
|
!
|
|
REAL (KIND=DP), intent(IN) :: nelec_
|
|
REAL (KIND=DP), intent(INOUT) :: nelup_, neldw_
|
|
INTEGER, intent(IN) :: tot_magnetization_, multiplicity_
|
|
end subroutine set_nelup_neldw
|
|
|
|
!----------------------------------------------------------------------------
|
|
|
|
|
|
SUBROUTINE deallocate_elct()
|
|
IF( ALLOCATED( f ) ) DEALLOCATE( f )
|
|
IF( ALLOCATED( ispin ) ) DEALLOCATE( ispin )
|
|
telectrons_base_initval = .FALSE.
|
|
RETURN
|
|
END SUBROUTINE deallocate_elct
|
|
|
|
|
|
!------------------------------------------------------------------------------!
|
|
END MODULE electrons_base
|
|
!------------------------------------------------------------------------------!
|
|
|
|
|
|
|
|
!------------------------------------------------------------------------------!
|
|
MODULE electrons_nose
|
|
!------------------------------------------------------------------------------!
|
|
|
|
USE kinds, ONLY: DP
|
|
!
|
|
IMPLICIT NONE
|
|
SAVE
|
|
|
|
REAL(DP) :: fnosee = 0.0d0 ! frequency of the thermostat ( in THz )
|
|
REAL(DP) :: qne = 0.0d0 ! mass of teh termostat
|
|
REAL(DP) :: ekincw = 0.0d0 ! kinetic energy to be kept constant
|
|
|
|
REAL(DP) :: xnhe0 = 0.0d0
|
|
REAL(DP) :: xnhep = 0.0d0
|
|
REAL(DP) :: xnhem = 0.0d0
|
|
REAL(DP) :: vnhe = 0.0d0
|
|
CONTAINS
|
|
subroutine electrons_nose_init( ekincw_ , fnosee_ )
|
|
REAL(DP), INTENT(IN) :: ekincw_, fnosee_
|
|
end subroutine electrons_nose_init
|
|
|
|
|
|
function electrons_nose_nrg( xnhe0, vnhe, qne, ekincw )
|
|
real(8) :: electrons_nose_nrg
|
|
real(8), intent(in) :: xnhe0, vnhe, qne, ekincw
|
|
electrons_nose_nrg = 0.0
|
|
end function electrons_nose_nrg
|
|
|
|
subroutine electrons_nose_shiftvar( xnhep, xnhe0, xnhem )
|
|
implicit none
|
|
real(8), intent(out) :: xnhem
|
|
real(8), intent(inout) :: xnhe0
|
|
real(8), intent(in) :: xnhep
|
|
end subroutine electrons_nose_shiftvar
|
|
|
|
subroutine electrons_nosevel( vnhe, xnhe0, xnhem, delt )
|
|
implicit none
|
|
real(8), intent(inout) :: vnhe
|
|
real(8), intent(in) :: xnhe0, xnhem, delt
|
|
end subroutine electrons_nosevel
|
|
|
|
subroutine electrons_noseupd( xnhep, xnhe0, xnhem, delt, qne, ekinc, ekincw, vnhe )
|
|
implicit none
|
|
real(8), intent(out) :: xnhep, vnhe
|
|
real(8), intent(in) :: xnhe0, xnhem, delt, qne, ekinc, ekincw
|
|
end subroutine electrons_noseupd
|
|
|
|
|
|
SUBROUTINE electrons_nose_info()
|
|
END SUBROUTINE electrons_nose_info
|
|
END MODULE electrons_nose
|
|
|
|
module cvan
|
|
use parameters, only: nsx
|
|
implicit none
|
|
save
|
|
integer nvb, ish(nsx)
|
|
integer, allocatable:: indlm(:,:)
|
|
contains
|
|
subroutine allocate_cvan( nind, ns )
|
|
integer, intent(in) :: nind, ns
|
|
end subroutine allocate_cvan
|
|
|
|
subroutine deallocate_cvan( )
|
|
end subroutine deallocate_cvan
|
|
|
|
end module cvan
|
|
|
|
MODULE cell_base
|
|
USE kinds, ONLY : DP
|
|
IMPLICIT NONE
|
|
SAVE
|
|
REAL(DP) :: alat = 0.0d0
|
|
REAL(DP) :: celldm(6) = (/ 0.0d0, 0.0d0, 0.0d0, 0.0d0, 0.0d0, 0.0d0 /)
|
|
REAL(DP) :: a1(3) = (/ 0.0d0, 0.0d0, 0.0d0 /)
|
|
REAL(DP) :: a2(3) = (/ 0.0d0, 0.0d0, 0.0d0 /)
|
|
REAL(DP) :: a3(3) = (/ 0.0d0, 0.0d0, 0.0d0 /)
|
|
REAL(DP) :: b1(3) = (/ 0.0d0, 0.0d0, 0.0d0 /)
|
|
REAL(DP) :: b2(3) = (/ 0.0d0, 0.0d0, 0.0d0 /)
|
|
REAL(DP) :: b3(3) = (/ 0.0d0, 0.0d0, 0.0d0 /)
|
|
REAL(DP) :: ainv(3,3) = 0.0d0
|
|
REAl(DP) :: omega = 0.0d0 ! volume of the simulation cell
|
|
REAL(DP) :: tpiba = 0.0d0 ! = 2 PI / alat
|
|
REAL(DP) :: tpiba2 = 0.0d0 ! = ( 2 PI / alat ) ** 2
|
|
REAL(DP) :: at(3,3) = RESHAPE( (/ 0.0d0 /), (/ 3, 3 /), (/ 0.0d0 /) )
|
|
REAL(DP) :: bg(3,3) = RESHAPE( (/ 0.0d0 /), (/ 3, 3 /), (/ 0.0d0 /) )
|
|
INTEGER :: ibrav ! index of the bravais lattice
|
|
CHARACTER(len=9) :: symm_type ! 'cubic' or 'hexagonal' when ibrav=0
|
|
REAL(DP) :: h(3,3) = 0.0d0 ! simulation cell at time t
|
|
REAL(DP) :: hold(3,3) = 0.0d0 ! simulation cell at time t-delt
|
|
REAL(DP) :: hnew(3,3) = 0.0d0 ! simulation cell at time t+delt
|
|
REAL(DP) :: velh(3,3) = 0.0d0 ! simulation cell velocity
|
|
REAL(DP) :: deth = 0.0d0 ! determinant of h ( cell volume )
|
|
INTEGER :: iforceh(3,3) = 1 ! if iforceh( i, j ) = 0 then h( i, j )
|
|
LOGICAL :: thdiag = .FALSE. ! True if only cell diagonal elements
|
|
REAL(DP) :: wmass = 0.0d0 ! cell fictitious mass
|
|
REAL(DP) :: press = 0.0d0 ! external pressure
|
|
REAL(DP) :: frich = 0.0d0 ! firction parameter for cell damped dynamics
|
|
REAL(DP) :: greash = 1.0d0 ! greas parameter for damped dynamics
|
|
LOGICAL :: tcell_base_init = .FALSE.
|
|
CONTAINS
|
|
SUBROUTINE updatecell(box_tm1, box_t0, box_tp1)
|
|
integer :: box_tm1, box_t0, box_tp1
|
|
END SUBROUTINE updatecell
|
|
SUBROUTINE dgcell( gcdot, box_tm1, box_t0, delt )
|
|
REAL(DP), INTENT(OUT) :: GCDOT(3,3)
|
|
REAL(DP), INTENT(IN) :: delt
|
|
integer, intent(in) :: box_tm1, box_t0
|
|
END SUBROUTINE dgcell
|
|
|
|
SUBROUTINE cell_init_ht( box, ht )
|
|
integer :: box
|
|
REAL(DP) :: ht(3,3)
|
|
END SUBROUTINE cell_init_ht
|
|
|
|
SUBROUTINE cell_init_a( box, a1, a2, a3 )
|
|
integer :: box
|
|
REAL(DP) :: a1(3), a2(3), a3(3)
|
|
END SUBROUTINE cell_init_a
|
|
|
|
SUBROUTINE r_to_s1 (r,s,box)
|
|
REAL(DP), intent(out) :: S(3)
|
|
REAL(DP), intent(in) :: R(3)
|
|
integer, intent(in) :: box
|
|
END SUBROUTINE r_to_s1
|
|
|
|
SUBROUTINE r_to_s3 ( r, s, na, nsp, hinv )
|
|
REAL(DP), intent(out) :: S(:,:)
|
|
INTEGER, intent(in) :: na(:), nsp
|
|
REAL(DP), intent(in) :: R(:,:)
|
|
REAL(DP), intent(in) :: hinv(:,:) ! hinv = TRANSPOSE( box%m1 )
|
|
integer :: i, j, ia, is, isa
|
|
isa = 0
|
|
DO is = 1, nsp
|
|
DO ia = 1, na(is)
|
|
isa = isa + 1
|
|
DO I=1,3
|
|
S(I,isa) = 0.D0
|
|
DO J=1,3
|
|
S(I,isa) = S(I,isa) + R(J,isa)*hinv(i,j)
|
|
END DO
|
|
END DO
|
|
END DO
|
|
END DO
|
|
RETURN
|
|
END SUBROUTINE r_to_s3
|
|
|
|
!------------------------------------------------------------------------------!
|
|
|
|
SUBROUTINE r_to_s1b ( r, s, hinv )
|
|
REAL(DP), intent(out) :: S(:)
|
|
REAL(DP), intent(in) :: R(:)
|
|
REAL(DP), intent(in) :: hinv(:,:) ! hinv = TRANSPOSE( box%m1 )
|
|
integer :: i, j
|
|
DO I=1,3
|
|
S(I) = 0.D0
|
|
DO J=1,3
|
|
S(I) = S(I) + R(J)*hinv(i,j)
|
|
END DO
|
|
END DO
|
|
RETURN
|
|
END SUBROUTINE r_to_s1b
|
|
|
|
|
|
SUBROUTINE s_to_r1 (S,R,box)
|
|
REAL(DP), intent(in) :: S(3)
|
|
REAL(DP), intent(out) :: R(3)
|
|
integer, intent(in) :: box
|
|
END SUBROUTINE s_to_r1
|
|
|
|
SUBROUTINE s_to_r1b (S,R,h)
|
|
REAL(DP), intent(in) :: S(3)
|
|
REAL(DP), intent(out) :: R(3)
|
|
REAL(DP), intent(in) :: h(:,:) ! h = TRANSPOSE( box%a )
|
|
END SUBROUTINE s_to_r1b
|
|
|
|
SUBROUTINE s_to_r3 ( S, R, na, nsp, h )
|
|
REAL(DP), intent(in) :: S(:,:)
|
|
INTEGER, intent(in) :: na(:), nsp
|
|
REAL(DP), intent(out) :: R(:,:)
|
|
REAL(DP), intent(in) :: h(:,:) ! h = TRANSPOSE( box%a )
|
|
END SUBROUTINE s_to_r3
|
|
|
|
SUBROUTINE gethinv(box)
|
|
IMPLICIT NONE
|
|
integer, INTENT (INOUT) :: box
|
|
END SUBROUTINE gethinv
|
|
|
|
|
|
FUNCTION get_volume( hmat )
|
|
IMPLICIT NONE
|
|
REAL(DP) :: get_volume
|
|
REAL(DP) :: hmat( 3, 3 )
|
|
get_volume = 4.4
|
|
END FUNCTION get_volume
|
|
|
|
FUNCTION pbc(rin,box,nl) RESULT (rout)
|
|
IMPLICIT NONE
|
|
integer :: box
|
|
REAL (DP) :: rin(3)
|
|
REAL (DP) :: rout(3), s(3)
|
|
INTEGER, OPTIONAL :: nl(3)
|
|
rout = 4.4
|
|
END FUNCTION pbc
|
|
|
|
SUBROUTINE get_cell_param(box,cell,ang)
|
|
IMPLICIT NONE
|
|
integer, INTENT(in) :: box
|
|
REAL(DP), INTENT(out), DIMENSION(3) :: cell
|
|
REAL(DP), INTENT(out), DIMENSION(3), OPTIONAL :: ang
|
|
END SUBROUTINE get_cell_param
|
|
|
|
SUBROUTINE pbcs_components(x1, y1, z1, x2, y2, z2, m)
|
|
USE kinds
|
|
INTEGER, INTENT(IN) :: M
|
|
REAL(DP), INTENT(IN) :: X1,Y1,Z1
|
|
REAL(DP), INTENT(OUT) :: X2,Y2,Z2
|
|
REAL(DP) MIC
|
|
END SUBROUTINE pbcs_components
|
|
|
|
SUBROUTINE pbcs_vectors(v, w, m)
|
|
USE kinds
|
|
INTEGER, INTENT(IN) :: m
|
|
REAL(DP), INTENT(IN) :: v(3)
|
|
REAL(DP), INTENT(OUT) :: w(3)
|
|
REAL(DP) :: MIC
|
|
END SUBROUTINE pbcs_vectors
|
|
|
|
SUBROUTINE cell_base_init( ibrav_ , celldm_ , trd_ht, cell_symmetry, rd_ht, cell_units, &
|
|
a_ , b_ , c_ , cosab, cosac, cosbc, wc_ , total_ions_mass , press_ , &
|
|
frich_ , greash_ , cell_dofree )
|
|
|
|
IMPLICIT NONE
|
|
INTEGER, INTENT(IN) :: ibrav_
|
|
REAL(DP), INTENT(IN) :: celldm_ (6)
|
|
LOGICAL, INTENT(IN) :: trd_ht
|
|
CHARACTER(LEN=*), INTENT(IN) :: cell_symmetry
|
|
REAL(DP), INTENT(IN) :: rd_ht (3,3)
|
|
CHARACTER(LEN=*), INTENT(IN) :: cell_units
|
|
REAL(DP), INTENT(IN) :: a_ , b_ , c_ , cosab, cosac, cosbc
|
|
CHARACTER(LEN=*), INTENT(IN) :: cell_dofree
|
|
REAL(DP), INTENT(IN) :: wc_ , frich_ , greash_ , total_ions_mass
|
|
REAL(DP), INTENT(IN) :: press_ ! external pressure from imput ( GPa )
|
|
END SUBROUTINE cell_base_init
|
|
|
|
|
|
SUBROUTINE cell_base_reinit( ht )
|
|
REAL(DP), INTENT(IN) :: ht (3,3)
|
|
END SUBROUTINE cell_base_reinit
|
|
|
|
SUBROUTINE cell_steepest( hnew, h, delt, iforceh, fcell )
|
|
REAL(DP), INTENT(OUT) :: hnew(3,3)
|
|
REAL(DP), INTENT(IN) :: h(3,3), fcell(3,3)
|
|
INTEGER, INTENT(IN) :: iforceh(3,3)
|
|
REAL(DP), INTENT(IN) :: delt
|
|
END SUBROUTINE cell_steepest
|
|
|
|
SUBROUTINE cell_verlet( hnew, h, hold, delt, iforceh, fcell, frich, tnoseh, hnos )
|
|
REAL(DP), INTENT(OUT) :: hnew(3,3)
|
|
REAL(DP), INTENT(IN) :: h(3,3), hold(3,3), hnos(3,3), fcell(3,3)
|
|
INTEGER, INTENT(IN) :: iforceh(3,3)
|
|
REAL(DP), INTENT(IN) :: frich, delt
|
|
LOGICAL, INTENT(IN) :: tnoseh
|
|
END SUBROUTINE cell_verlet
|
|
|
|
subroutine cell_hmove( h, hold, delt, iforceh, fcell )
|
|
REAL(DP), intent(out) :: h(3,3)
|
|
REAL(DP), intent(in) :: hold(3,3), fcell(3,3)
|
|
REAL(DP), intent(in) :: delt
|
|
integer, intent(in) :: iforceh(3,3)
|
|
end subroutine cell_hmove
|
|
|
|
subroutine cell_force( fcell, ainv, stress, omega, press, wmass )
|
|
REAL(DP), intent(out) :: fcell(3,3)
|
|
REAL(DP), intent(in) :: stress(3,3), ainv(3,3)
|
|
REAL(DP), intent(in) :: omega, press, wmass
|
|
end subroutine cell_force
|
|
|
|
subroutine cell_move( hnew, h, hold, delt, iforceh, fcell, frich, tnoseh, vnhh, velh, tsdc )
|
|
REAL(DP), intent(out) :: hnew(3,3)
|
|
REAL(DP), intent(in) :: h(3,3), hold(3,3), fcell(3,3)
|
|
REAL(DP), intent(in) :: vnhh(3,3), velh(3,3)
|
|
integer, intent(in) :: iforceh(3,3)
|
|
REAL(DP), intent(in) :: frich, delt
|
|
logical, intent(in) :: tnoseh, tsdc
|
|
end subroutine cell_move
|
|
|
|
subroutine cell_gamma( hgamma, ainv, h, velh )
|
|
REAL(DP) :: hgamma(3,3)
|
|
REAL(DP), intent(in) :: ainv(3,3), h(3,3), velh(3,3)
|
|
end subroutine cell_gamma
|
|
|
|
subroutine cell_kinene( ekinh, temphh, velh )
|
|
REAL(DP), intent(out) :: ekinh, temphh(3,3)
|
|
REAL(DP), intent(in) :: velh(3,3)
|
|
end subroutine cell_kinene
|
|
|
|
function cell_alat( )
|
|
real(DP) :: cell_alat
|
|
cell_alat = 4.4
|
|
end function cell_alat
|
|
END MODULE cell_base
|
|
|
|
|
|
MODULE ions_base
|
|
USE kinds, ONLY : DP
|
|
USE parameters, ONLY : ntypx
|
|
IMPLICIT NONE
|
|
SAVE
|
|
INTEGER :: nsp = 0
|
|
INTEGER :: na(5) = 0
|
|
INTEGER :: nax = 0
|
|
INTEGER :: nat = 0
|
|
REAL(DP) :: zv(5) = 0.0d0
|
|
REAL(DP) :: pmass(5) = 0.0d0
|
|
REAL(DP) :: amass(5) = 0.0d0
|
|
REAL(DP) :: rcmax(5) = 0.0d0
|
|
INTEGER, ALLOCATABLE :: ityp(:)
|
|
REAL(DP), ALLOCATABLE :: tau(:,:) ! initial positions read from stdin (in bohr)
|
|
REAL(DP), ALLOCATABLE :: vel(:,:) ! initial velocities read from stdin (in bohr)
|
|
REAL(DP), ALLOCATABLE :: tau_srt(:,:) ! tau sorted by specie in bohr
|
|
REAL(DP), ALLOCATABLE :: vel_srt(:,:) ! vel sorted by specie in bohr
|
|
INTEGER, ALLOCATABLE :: ind_srt(:) ! index of tau sorted by specie
|
|
INTEGER, ALLOCATABLE :: ind_bck(:) ! reverse of ind_srt
|
|
CHARACTER(LEN=3) :: atm( 5 )
|
|
CHARACTER(LEN=80) :: tau_units
|
|
|
|
|
|
INTEGER, ALLOCATABLE :: if_pos(:,:) ! if if_pos( x, i ) = 0 then x coordinate of
|
|
! the i-th atom will be kept fixed
|
|
INTEGER, ALLOCATABLE :: iforce(:,:) ! if_pos sorted by specie
|
|
INTEGER :: fixatom = -1 ! to be removed
|
|
INTEGER :: ndofp = -1 ! ionic degree of freedom
|
|
INTEGER :: ndfrz = 0 ! frozen degrees of freedom
|
|
|
|
REAL(DP) :: fricp ! friction parameter for damped dynamics
|
|
REAL(DP) :: greasp ! friction parameter for damped dynamics
|
|
REAL(DP), ALLOCATABLE :: taui(:,:)
|
|
REAL(DP) :: cdmi(3), cdm(3)
|
|
REAL(DP) :: cdms(3)
|
|
LOGICAL :: tions_base_init = .FALSE.
|
|
CONTAINS
|
|
SUBROUTINE packtau( taup, tau, na, nsp )
|
|
REAL(DP), INTENT(OUT) :: taup( :, : )
|
|
REAL(DP), INTENT(IN) :: tau( :, :, : )
|
|
INTEGER, INTENT(IN) :: na( : ), nsp
|
|
END SUBROUTINE packtau
|
|
|
|
SUBROUTINE unpacktau( tau, taup, na, nsp )
|
|
REAL(DP), INTENT(IN) :: taup( :, : )
|
|
REAL(DP), INTENT(OUT) :: tau( :, :, : )
|
|
INTEGER, INTENT(IN) :: na( : ), nsp
|
|
END SUBROUTINE unpacktau
|
|
|
|
SUBROUTINE sort_tau( tausrt, isrt, tau, isp, nat, nsp )
|
|
REAL(DP), INTENT(OUT) :: tausrt( :, : )
|
|
INTEGER, INTENT(OUT) :: isrt( : )
|
|
REAL(DP), INTENT(IN) :: tau( :, : )
|
|
INTEGER, INTENT(IN) :: nat, nsp, isp( : )
|
|
INTEGER :: ina( nsp ), na( nsp )
|
|
END SUBROUTINE sort_tau
|
|
|
|
SUBROUTINE unsort_tau( tau, tausrt, isrt, nat )
|
|
REAL(DP), INTENT(IN) :: tausrt( :, : )
|
|
INTEGER, INTENT(IN) :: isrt( : )
|
|
REAL(DP), INTENT(OUT) :: tau( :, : )
|
|
INTEGER, INTENT(IN) :: nat
|
|
END SUBROUTINE unsort_tau
|
|
|
|
SUBROUTINE ions_base_init( nsp_, nat_, na_, ityp_, tau_, vel_, amass_, &
|
|
atm_, if_pos_, tau_units_, alat_, a1_, a2_, &
|
|
a3_, rcmax_ )
|
|
INTEGER, INTENT(IN) :: nsp_, nat_, na_(:), ityp_(:)
|
|
REAL(DP), INTENT(IN) :: tau_(:,:)
|
|
REAL(DP), INTENT(IN) :: vel_(:,:)
|
|
REAL(DP), INTENT(IN) :: amass_(:)
|
|
CHARACTER(LEN=*), INTENT(IN) :: atm_(:)
|
|
CHARACTER(LEN=*), INTENT(IN) :: tau_units_
|
|
INTEGER, INTENT(IN) :: if_pos_(:,:)
|
|
REAL(DP), INTENT(IN) :: alat_, a1_(3), a2_(3), a3_(3)
|
|
REAL(DP), INTENT(IN) :: rcmax_(:)
|
|
END SUBROUTINE ions_base_init
|
|
|
|
SUBROUTINE deallocate_ions_base()
|
|
END SUBROUTINE deallocate_ions_base
|
|
|
|
SUBROUTINE ions_vel3( vel, taup, taum, na, nsp, dt )
|
|
REAL(DP) :: vel(:,:), taup(:,:), taum(:,:)
|
|
INTEGER :: na(:), nsp
|
|
REAL(DP) :: dt
|
|
END SUBROUTINE ions_vel3
|
|
|
|
SUBROUTINE ions_vel2( vel, taup, taum, nat, dt )
|
|
REAL(DP) :: vel(:,:), taup(:,:), taum(:,:)
|
|
INTEGER :: nat
|
|
REAL(DP) :: dt
|
|
END SUBROUTINE ions_vel2
|
|
|
|
SUBROUTINE cofmass1( tau, pmass, na, nsp, cdm )
|
|
REAL(DP), INTENT(IN) :: tau(:,:,:), pmass(:)
|
|
REAL(DP), INTENT(OUT) :: cdm(3)
|
|
INTEGER, INTENT(IN) :: na(:), nsp
|
|
END SUBROUTINE cofmass1
|
|
|
|
SUBROUTINE cofmass2( tau, pmass, na, nsp, cdm )
|
|
REAL(DP), INTENT(IN) :: tau(:,:), pmass(:)
|
|
REAL(DP), INTENT(OUT) :: cdm(3)
|
|
INTEGER, INTENT(IN) :: na(:), nsp
|
|
END SUBROUTINE cofmass2
|
|
|
|
SUBROUTINE randpos(tau, na, nsp, tranp, amprp, hinv, ifor )
|
|
REAL(DP) :: hinv(3,3)
|
|
REAL(DP) :: tau(:,:)
|
|
INTEGER, INTENT(IN) :: ifor(:,:), na(:), nsp
|
|
LOGICAL, INTENT(IN) :: tranp(:)
|
|
REAL(DP), INTENT(IN) :: amprp(:)
|
|
REAL(DP) :: oldp(3), rand_disp(3), rdisp(3)
|
|
|
|
END SUBROUTINE randpos
|
|
|
|
SUBROUTINE ions_kinene( ekinp, vels, na, nsp, h, pmass )
|
|
REAL(DP), intent(out) :: ekinp ! ionic kinetic energy
|
|
REAL(DP), intent(in) :: vels(:,:) ! scaled ionic velocities
|
|
REAL(DP), intent(in) :: pmass(:) ! ionic masses
|
|
REAL(DP), intent(in) :: h(:,:) ! simulation cell
|
|
integer, intent(in) :: na(:), nsp
|
|
integer :: i, j, is, ia, ii, isa
|
|
END SUBROUTINE ions_kinene
|
|
|
|
subroutine ions_temp( tempp, temps, ekinpr, vels, na, nsp, h, pmass, ndega, nhpdim, atm2nhp, ekin2nhp )
|
|
REAL(DP), intent(out) :: ekinpr, tempp
|
|
REAL(DP), intent(out) :: temps(:)
|
|
REAL(DP), intent(out) :: ekin2nhp(:)
|
|
REAL(DP), intent(in) :: vels(:,:)
|
|
REAL(DP), intent(in) :: pmass(:)
|
|
REAL(DP), intent(in) :: h(:,:)
|
|
integer, intent(in) :: na(:), nsp, ndega, nhpdim, atm2nhp(:)
|
|
end subroutine ions_temp
|
|
|
|
subroutine ions_thermal_stress( stress, pmass, omega, h, vels, nsp, na )
|
|
REAL(DP), intent(inout) :: stress(3,3)
|
|
REAL(DP), intent(in) :: pmass(:), omega, h(3,3), vels(:,:)
|
|
integer, intent(in) :: nsp, na(:)
|
|
integer :: i, j, is, ia, isa
|
|
end subroutine ions_thermal_stress
|
|
|
|
subroutine ions_vrescal( tcap, tempw, tempp, taup, tau0, taum, na, nsp, fion, iforce, &
|
|
pmass, delt )
|
|
logical, intent(in) :: tcap
|
|
REAL(DP), intent(inout) :: taup(:,:)
|
|
REAL(DP), intent(in) :: tau0(:,:), taum(:,:), fion(:,:)
|
|
REAL(DP), intent(in) :: delt, pmass(:), tempw, tempp
|
|
integer, intent(in) :: na(:), nsp
|
|
integer, intent(in) :: iforce(:,:)
|
|
end subroutine ions_vrescal
|
|
subroutine ions_shiftvar( varp, var0, varm )
|
|
REAL(DP), intent(in) :: varp
|
|
REAL(DP), intent(out) :: varm, var0
|
|
end subroutine ions_shiftvar
|
|
SUBROUTINE cdm_displacement( dis, tau )
|
|
REAL(DP) :: dis
|
|
REAL(DP) :: tau
|
|
END SUBROUTINE cdm_displacement
|
|
SUBROUTINE ions_displacement( dis, tau )
|
|
REAL (DP), INTENT(OUT) :: dis
|
|
REAL (DP), INTENT(IN) :: tau
|
|
END SUBROUTINE ions_displacement
|
|
END MODULE ions_base
|