mirror of https://gitlab.com/QEF/q-e.git
391 lines
22 KiB
Fortran
391 lines
22 KiB
Fortran
!
|
|
! Copyright (C) 2001-2013 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 input_gw
|
|
!thsi module contain the definition and routines to read
|
|
!input parameters from file
|
|
USE kinds, ONLY: DP
|
|
|
|
TYPE input_options
|
|
!structure defining all the inputs required
|
|
INTEGER :: n!number of time intervals in the positive or negative range, total of 2n+1 samples
|
|
REAL(kind=DP) :: tau=0.d0!imaginary positive time interval
|
|
LOGICAL :: whole_s=.false.!if .true. also off-diagonal elements of self energy are calculated
|
|
INTEGER :: max_i!maximum state to be calculated
|
|
CHARACTER(len=256) :: prefix = 'prefix'!prefix to designate the files same as in PW
|
|
CHARACTER(len=256) :: outdir = './'!outdir to designate the files same as in PW
|
|
INTEGER :: num_rows=50!number of rows of polarization to be taken together for FFT
|
|
LOGICAL :: xc_together=.false.!if true exchange and correlation treated together, usually NOT
|
|
LOGICAL :: debug=.false.!if .true. debug output is considered
|
|
!the following options are for the fit
|
|
INTEGER :: n_multipoles=2!number of poles used in the fit
|
|
REAL(kind=DP) :: fit_dt!delta for verlet
|
|
REAL(kind=DP) :: fit_thres=1.d-5!threshold for convergence
|
|
REAL(kind=DP) :: fit_ma_0!mass paremeter for verlet
|
|
REAL(kind=DP) :: fit_ma!mass paremeter for verlet
|
|
REAL(kind=DP) :: fit_mb!mass paremeter for verlet
|
|
REAL(kind=DP) :: fit_frice!frice for verlet
|
|
INTEGER :: fit_maxiter=5000 !max number of iterations
|
|
INTEGER :: starting_point=1!defines the starting point: 1-all 2-from polarization 3-from W 4-from Sigma
|
|
!5-from fit... HAS BEEN CHANGED A BIT
|
|
INTEGER :: ending_point=7!defines the ending point
|
|
LOGICAL :: use_contractions=.false.!if true perform contraction for calculating the self energy
|
|
LOGICAL :: lnonorthogonal=.false.!if true a non orthogonal basis set is considered
|
|
LOGICAL :: l_hf_energies=.false.! if true uses perturbative HF energies for calculating G and W
|
|
INTEGER :: n_fit!number of time intervals in the positive or negative range to be used for fit
|
|
LOGICAL :: lconduction=.true.!if true accurate calculation of self_energy for conduction states
|
|
LOGICAL :: l_contraction_single_state=.true.!if true write the contractions on disk state by state for saving memory
|
|
!the following options are for the treatment of time/frequency with user defined grids
|
|
|
|
LOGICAL :: l_fft_timefreq=.false.!if true performs usual fft treatment of time/frequency
|
|
INTEGER :: grid_time=3!0 = Gauss Legendre 1 = Gauss Laguerre 2 Gauss Legendre 0-T 3 = equally spaced 0 centered 4 = equally spaced
|
|
INTEGER :: grid_freq=3!0 = Gauss Legendre 1 = Gauss Laguerre 2 Gauss Legendre 0-T 3 = equally spaced 0 centered 4 = equally spaced 5=double equally spaced grid
|
|
REAL(kind=DP) :: omega!max frequency if required
|
|
! the following for fitting tails
|
|
LOGICAL :: l_fourier_fit_time=.false.!if true fits the tails in time
|
|
LOGICAL :: l_fourier_fit_freq=.false.!if true fits the tails in frequency
|
|
REAL(kind=DP) :: r_tau=0.d0!ratio for finding outer time point
|
|
REAL(kind=DP) :: r_omega=0.d0!ratio for finding outer frequency point
|
|
REAL(kind=DP) :: g_tau=0.d0!ratio for treating bad cases in time
|
|
REAL(kind=DP) :: g_omega=0.d0!ration for treating bad cases in frequency
|
|
!the following for defining the grid for fitting the self energy
|
|
|
|
INTEGER :: grid_fit=1!grid for self energy ON FREQUENCY: 0 uses the same as for P,W, 1 equally spaced, 2 GL
|
|
REAL(kind=DP) :: omega_fit!max frequency to be considered
|
|
INTEGER :: n_grid_fit!number of grid points on half-axes
|
|
!the following defines the range of states we want to studi
|
|
INTEGER :: i_min!minimum state
|
|
INTEGER :: i_max!maximum state
|
|
|
|
INTEGER :: n_max_minpack=20000!maximum number of minpack iterations
|
|
INTEGER :: cyc_minpack=1!number of minpack cycles
|
|
|
|
LOGICAL :: l_lda_hartree=.true.!if true uses LDA previously calculated hartree, otherwise recalculate
|
|
LOGICAL :: l_lda_exchange=.true.!if true uses LDA previously calculated exchange, otherwise recalculate
|
|
|
|
LOGICAL :: l_read_exchange=.false.!force to read again exchange energies from disk
|
|
|
|
LOGICAL :: l_symm_epsilon=.true.!if true calculates the symmetrized dielectric matrix for calculating W
|
|
LOGICAL :: l_head_epsilon=.true.!if true the head of the symmetrized dielectric matrix is taken from
|
|
!a RPA external calculation, OTHERWISE it's set to zero
|
|
INTEGER :: w_divergence!treatment of G=0,G=0 divergence of W: 0 no treatment potentially wrong
|
|
!1 W=v^1/2 Epsi^-1 v^1/2 with v truncated, 2 calculates terms from external file
|
|
!3 Lanczos chain and Gygi Baldereschi algorithm
|
|
LOGICAL :: l_wing_epsilon=.true.!if true the wings of the symmetrized dielectric matrix are taken from
|
|
!a RPA external calculation, OTHERWISE it's set to zero
|
|
INTEGER :: offset_fit=2!offset for fit from 0
|
|
|
|
LOGICAL :: lcprim_file=.false. !if true read S_{ c' c i} terms from file
|
|
LOGICAL :: lvcprim_file=.true. !if truem read S_{ i, v,c i} terms from file
|
|
LOGICAL :: l_dft_xc_file=.false.!if true read dft exchange and correlation energies from file
|
|
LOGICAL :: lpola_file=.true.!if true calculates the polarization directly from the psi_v psi_c \tilde{w}^P_i file
|
|
|
|
LOGICAL :: l_self_from_pola=.false.!if true calculates the self energies terms directly from the dresses polarization
|
|
!and not from dress interaction NOW ONLY FOR polarization analysis, it requires
|
|
!the wp_v file
|
|
LOGICAL :: l_pola_beta=.false.!if true calculate the polarization with beta strategy (optimized)
|
|
LOGICAL :: l_self_beta=.false.!if true calculate the self-energy with beta strategy (optimized)
|
|
|
|
LOGICAL :: l_pola_upper=.false.!if true uses reduced conduction states for calculating the polarization
|
|
LOGICAL :: l_self_upper=.false.!if true uses reduced conduction states for calculating the self-energy
|
|
|
|
LOGICAL :: l_pola_lanczos=.true.!if true calculate the polarization through a lanczos scheme
|
|
LOGICAL :: l_self_lanczos=.true.!if true calculate the self-energy through a lanczos scheme
|
|
LOGICAL :: l_lanczos_conv=.true.!if the convolution is done analytically
|
|
INTEGER :: n_set=100!block length over frequency in do_self_lanczos
|
|
INTEGER :: n_set_ii=5!block length over KS states in do_self_lanczos
|
|
INTEGER :: n_set_pola=4!block length over valence states in do_pola_lanczos
|
|
INTEGER :: n_set_self=1!block length over frequency states in do_self_lanczos
|
|
LOGICAL :: l_yet_pola=.false.!if true it assumes that (restarting at point 6) the
|
|
!polaw's contain already the dress polarization
|
|
LOGICAL :: l_reduce_io=.true. !if true reduces disk I/O
|
|
!options for grid_freq=5
|
|
INTEGER :: second_grid_n=10!sub spacing for second grid
|
|
INTEGER :: second_grid_i=1!max regular step using the second grid
|
|
INTEGER :: grid_levels=1!for grid type = 6
|
|
LOGICAL :: l_t_wannier=.true.!if true t vectors have been constructed from wannier valence functions
|
|
LOGICAL :: l_truncated_coulomb=.true.!if true the system is finite otherwise is extended (with head and wings)
|
|
LOGICAL :: l_self_time=.true.!if true calculates the self energy in imaginary time
|
|
|
|
LOGICAL :: l_g_grid=.false.!if true use a dedicated grid on frequency for G
|
|
INTEGER :: grid_freq_g=3!for G grid:0 = Gauss Legendre 1 = Gauss Laguerre 2 Gauss Legendre 0-T 3 = equally spaced 0 centered 4 = equally spaced 5=double spaced grid
|
|
INTEGER :: n_g!for G grid: number of time intervals in the positive or negative range, total of 2n+1 samples
|
|
INTEGER :: second_grid_n_g=10!for G grid: sub spacing for second grid
|
|
INTEGER :: second_grid_i_g=1!for G grid: max regular step using the second grid
|
|
REAL(kind=DP) :: omega_g! for G: max frequency
|
|
|
|
INTEGER :: i_min_whole=0!set the minimum of range for off diagonal elements of self-energy
|
|
INTEGER :: i_max_whole=0!set the maximum of range for off diagonal elements of self-energy
|
|
INTEGER :: nspin=1!spin multiplicity
|
|
|
|
LOGICAL :: l_frac_occ=.false.!if true uses routines for fractional occupancy
|
|
LOGICAL :: l_semicore=.false.!if true add to the self energy semicore terms
|
|
|
|
LOGICAL :: l_order=.false.!just for gww_fit if true from file order.dat takes the right order of the self_energies
|
|
|
|
LOGICAL :: l_verbose=.false.
|
|
REAL(kind=DP) :: real_energy_min=-1.0!minimum energy on real frequency axis
|
|
REAL(kind=DP) :: real_energy_max=1.0!maximum energy on real frequency axis
|
|
INTEGER :: n_real_axis=0!number of grid points on real frequency axis
|
|
LOGICAL :: l_big_system=.false.!if true calculate the self-energy state by state only through local s vectors
|
|
LOGICAL :: l_list=.false.!if true uses startegy for large systems from list of states included in i_min im_max
|
|
LOGICAL :: l_full=.false.!if true in points 6 calls routine for full relativistic calculations EXPERTS only
|
|
INTEGER :: n_full=0!number of KS states with explicit treatment in G
|
|
|
|
LOGICAL :: l_scissor=.false.!if true shifts DFT occupied bands of scissor
|
|
REAL(kind=DP) :: scissor(2)=0.d0!value for scissor of valence manifold (1) and conduction manifold (2) in eV
|
|
|
|
|
|
END TYPE input_options
|
|
|
|
CONTAINS
|
|
|
|
SUBROUTINE read_input_gww( ggwin )
|
|
!this subroutines reads the input structure from file
|
|
!a namelist scheme is used
|
|
USE io_global, ONLY : stdout, ionode, ionode_id
|
|
USE mp, ONLY : mp_bcast
|
|
USE mp_world, ONLY : world_comm
|
|
USE io_files, ONLY : tmp_dir,prefix
|
|
|
|
implicit none
|
|
|
|
CHARACTER(LEN=256), EXTERNAL :: trimcheck
|
|
|
|
INTEGER, EXTERNAL :: find_free_unit
|
|
|
|
TYPE(input_options) :: ggwin!in output the input parameters
|
|
INTEGER :: iun
|
|
|
|
NAMELIST/inputgww/ ggwin
|
|
|
|
!read namelist
|
|
|
|
if(ionode) then
|
|
iun=find_free_unit()
|
|
!open(iun,file='inputgww')
|
|
!read(iun, NML=inputgww)
|
|
!close(iun)
|
|
read(*, NML=inputgww)
|
|
!OBM: file handling in a more QE manner
|
|
IF ( TRIM( ggwin%outdir ) == ' ' ) ggwin%outdir = './'
|
|
tmp_dir = trimcheck(ggwin%outdir)
|
|
prefix = trim(ggwin%prefix)
|
|
!set up parameter for calculation with Lanczos scheme
|
|
|
|
if(ggwin%l_self_lanczos.and.ggwin%l_lanczos_conv.and. .not. ggwin%l_self_time) then
|
|
ggwin%grid_fit=1
|
|
ggwin%omega_fit=ggwin%omega
|
|
ggwin%n_grid_fit=ggwin%n
|
|
endif
|
|
!writes on screen
|
|
|
|
write(stdout,*) 'Number of intervals: ', ggwin%n
|
|
write(stdout,*) 'Number of intervals for fit:', ggwin%n_fit
|
|
if(ggwin%tau==0.d0) ggwin%tau=2.d0/ggwin%omega*dble(ggwin%n)
|
|
write(stdout,*) 'Maximum imaginary time: ',ggwin%tau
|
|
write(stdout,*) 'Print whole Sigma: ', ggwin%whole_s
|
|
write(stdout,*) 'Maximum state considered:', ggwin%max_i
|
|
write(stdout,*) 'Prefix:', trim(ggwin%prefix)
|
|
write(stdout,*) 'Rows together in FFT:',ggwin%num_rows
|
|
if(ggwin%use_contractions) write(stdout,*) 'Uses contraction'
|
|
if(ggwin%lnonorthogonal) write(stdout,*) 'Ultralocalized generalized Wanniers are assumed'
|
|
if(ggwin%l_hf_energies) write(stdout, *) ' Uses perturbative HF energies for G and W'
|
|
if(ggwin%lconduction) write(stdout, *) 'Accurate treatment of conduction states'
|
|
if(ggwin%l_contraction_single_state) write(stdout,*) 'Uses contractions on single states'
|
|
if(.not.ggwin%l_fft_timefreq) then
|
|
write(stdout,*) 'Uses no fft grid for time/space integrations'
|
|
write(stdout,*) 'Time grid :', ggwin%grid_time
|
|
write(stdout,*) 'Frequency grid :', ggwin%grid_freq
|
|
write(stdout,*) 'Max frequency :', ggwin%omega
|
|
if(ggwin%l_fourier_fit_time) then
|
|
write(stdout,*) 'Uses fit of long tails in time'
|
|
write(stdout,*) 'Ratio: Time', ggwin%r_tau
|
|
write(stdout,*) 'Ratio recover: Time', ggwin%g_tau
|
|
endif
|
|
if(ggwin%l_fourier_fit_freq) then
|
|
write(stdout,*) 'Uses fit of long tails in frequency'
|
|
write(stdout,*) 'Ratio: Freq', ggwin%r_omega
|
|
write(stdout,*) 'Ratio recover: Freq', ggwin%g_omega
|
|
endif
|
|
endif
|
|
write(stdout,*) 'Consider states from:', ggwin%i_min, ' to ', ggwin%i_max
|
|
write(stdout,*) 'Maximum number of iterations in minpack: ', ggwin%n_max_minpack
|
|
write(stdout,*) 'Number of cycles over minpack: ', ggwin%cyc_minpack
|
|
write(stdout,*) 'Uses LDA Hartree :', ggwin%l_lda_hartree
|
|
write(stdout,*) 'Uses LDA Exchange :', ggwin%l_lda_exchange
|
|
if(ggwin%l_read_exchange) write(stdout,*) 'ReREAD EXCHANGE FROM DISK'
|
|
if(ggwin%l_symm_epsilon) write(stdout,*) 'Uses SYMMETRIZED DIELECTRIC MATRIX'
|
|
if(ggwin%l_head_epsilon) write(stdout,*) 'Head of dielectric matrix from file'
|
|
write(stdout,*) 'Treatment of W divergence:', ggwin%w_divergence
|
|
if(ggwin%l_wing_epsilon) write(stdout,*) 'Wings of dielectric matrix from file'
|
|
write(stdout,*) 'Offset fit :', ggwin%offset_fit
|
|
if(ggwin%lcprim_file) write(stdout,*) 'Read cprim terms from file'
|
|
if(ggwin%lvcprim_file) write(stdout,*) 'Read vcprim terms from file'
|
|
if(ggwin%l_dft_xc_file) write(stdout,*) 'Read DFT XC from file'
|
|
if(ggwin%lpola_file) write(stdout,*) 'Calculates the polarization directly from the overlaps'
|
|
if(ggwin%l_self_from_pola) write(stdout,*) 'Calculates Self Energy from Dresses Polarization'
|
|
if(ggwin%l_pola_beta) write(stdout,*) 'Calculate polarization with BETA strategy'
|
|
if(ggwin%l_self_beta) write(stdout,*) 'Calculate self-energy with BETA strategy'
|
|
if(ggwin%l_pola_upper) write(stdout,*) 'Reduced Upper states for Polarization'
|
|
if(ggwin%l_self_upper) write(stdout,*) 'Reduced Upper states for Self-Energy'
|
|
if(ggwin%l_pola_lanczos) write(stdout,*) 'Polarization Calculated through Lanczos scheme'
|
|
if(ggwin%l_self_lanczos) write(stdout,*) 'Self-energy Calculated through Lanczos scheme'
|
|
if(ggwin%l_lanczos_conv) write(stdout,*) 'Convolution done analytically'
|
|
if(ggwin%l_self_lanczos) write(stdout,*) 'Block length fequency', ggwin%n_set
|
|
if(ggwin%l_self_lanczos) write(stdout,*) 'Block length states', ggwin%n_set_ii
|
|
if(ggwin%l_pola_lanczos) write(stdout,*) 'Block length valence states', ggwin%n_set_pola
|
|
if(ggwin%l_self_lanczos) write(stdout,*) 'Block length fequency lc', ggwin%n_set_self
|
|
if(ggwin%starting_point < 6 ) then
|
|
ggwin%l_yet_pola=.false.
|
|
else
|
|
if(ggwin%l_self_lanczos) write(stdout,*) 'Dressed polarization already calculated'
|
|
endif
|
|
if(ggwin%l_reduce_io) write(stdout,*) 'Reduced disk I/O'
|
|
if(ggwin%grid_freq==5) then
|
|
write(stdout,*) 'Uses double grid, subdivisions:', ggwin%second_grid_n,' till :', ggwin%second_grid_i
|
|
endif
|
|
if(ggwin%l_t_wannier) write(stdout,*) 't vectors from Wannier products'
|
|
if(ggwin%l_truncated_coulomb) then
|
|
write(stdout,*) 'Use truncated Coulomb interaction'
|
|
ggwin%w_divergence=0
|
|
ggwin%l_head_epsilon=.false.
|
|
ggwin%l_wing_epsilon=.false.
|
|
else
|
|
write(stdout,*) 'Use truncated Extended interaction'
|
|
ggwin%w_divergence=3
|
|
endif
|
|
if(ggwin%l_self_time) write(stdout,*) 'Calculate Self-energy through FT'
|
|
if(ggwin%l_g_grid) write(stdout,*) 'Uses dedicated grid for G'
|
|
if(ggwin%whole_s) then
|
|
if(ggwin%i_min_whole==0) ggwin%i_min_whole=ggwin%i_min
|
|
if(ggwin%i_max_whole==0) ggwin%i_max_whole=ggwin%i_max
|
|
write(stdout,*) 'Calculate off-diagonal elements in range:', ggwin%i_min_whole,ggwin%i_max_whole
|
|
endif
|
|
write(stdout,*) 'Spin multiplicity:', ggwin%nspin
|
|
write(stdout,*) 'Partiallly occpuied states:', ggwin%l_frac_occ
|
|
if(ggwin%l_semicore) write(stdout,*) 'Add semicore terms to self-energy'
|
|
if(ggwin%n_real_axis /=0) then
|
|
write(stdout,*) 'N of grid points on REAL frequency:', ggwin%n_real_axis
|
|
write(stdout,*) 'REAL frequency range:', ggwin%real_energy_min,ggwin%real_energy_max
|
|
endif
|
|
if(ggwin%l_big_system) write(stdout,*) 'USING ONLY LOCAL S VECTORS'
|
|
if(ggwin%l_list) write(stdout,*) 'FROM LIST'
|
|
if(ggwin%l_full) write(stdout,*) 'FULL RELATIVISTIC CALCULATION with:', ggwin%n_full
|
|
if(ggwin%l_scissor) write(stdout,*) 'USE SCISSOR:', ggwin%scissor
|
|
endif
|
|
#if defined(__MPI)
|
|
CALL mp_bcast( tmp_dir,ionode_id, world_comm )
|
|
CALL mp_bcast( prefix,ionode_id, world_comm )
|
|
call mp_bcast(ggwin%n,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%tau,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%whole_s,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%max_i,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%prefix,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%num_rows,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%xc_together,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%debug, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_multipoles,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%fit_dt,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%fit_thres,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%fit_ma_0,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%fit_ma,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%fit_mb,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%fit_frice,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%fit_maxiter,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%starting_point, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%ending_point, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%use_contractions,ionode_id,world_comm)
|
|
call mp_bcast(ggwin%lnonorthogonal, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_fit, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_hf_energies, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%lconduction, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_contraction_single_state, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_fft_timefreq, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%grid_time, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%grid_freq, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%omega, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_fourier_fit_time, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_fourier_fit_freq, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%r_tau, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%r_omega, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%g_tau, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%g_omega, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%grid_fit, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%omega_fit, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_grid_fit, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%i_min, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%i_max, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_max_minpack, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%cyc_minpack, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_lda_hartree, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_lda_exchange, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_read_exchange, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_symm_epsilon, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_head_epsilon, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%w_divergence, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_wing_epsilon, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%offset_fit, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%lcprim_file, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%lvcprim_file, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_dft_xc_file, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%lpola_file, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_self_from_pola, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_pola_beta, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_self_beta, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_pola_upper, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_self_upper, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_pola_lanczos, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_self_lanczos, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_lanczos_conv, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_set, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_set_ii, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_set_pola, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_set_self, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_yet_pola, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_reduce_io, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%second_grid_n, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%second_grid_i, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_t_wannier, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_truncated_coulomb, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_self_time, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_g_grid, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%grid_freq_g, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_g, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%second_grid_n_g, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%second_grid_i_g, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%omega_g, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%i_min_whole, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%i_max_whole, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%nspin, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_frac_occ, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_semicore, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_order, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_verbose, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_real_axis, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%real_energy_min, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%real_energy_max, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%grid_levels, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_big_system, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_list, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_full, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%n_full, ionode_id,world_comm)
|
|
call mp_bcast(ggwin%l_scissor, ionode_id, world_comm)
|
|
call mp_bcast(ggwin%scissor, ionode_id, world_comm)
|
|
#endif
|
|
|
|
return
|
|
END SUBROUTINE read_input_gww
|
|
|
|
|
|
|
|
END MODULE
|
|
|