use_only_3.inc

用于进行gcc测试

    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
  !