#include "macros.h"
! data module of the real-time implementation of FCIQMC
module real_time_data
use constants
use MemoryManager, only: TagIntType
use FciMCData, only: perturbation, ll_node, fcimc_iter_data
implicit none
! number of copies to start the real-time simulation from
integer :: n_real_time_copies, cnt_real_time_copies
logical :: t_prepare_real_time
! for the actual calculation:
! global flag indicating real-time calculation
! rotated_time_setup: flag to indicate whether pure real time is
! used or not
logical :: t_real_time_fciqmc, t_new_stats_file, t_rotated_time, tStaticShift, &
tDynamicCoreSpace, tRealTimePopsfile, tStabilizerShift, tLimitShift, &
tDynamicAlpha, tDynamicDamping, tInfInit, tStartVariation, tOverpopulate, &
tNewOverlap, tOnlyPositiveShift, tHFOverlap
logical :: tLowerThreshold
! also use a second iter_data type to keep track of the 2 distinct
! spawning events
type(fcimc_iter_data) :: second_spawn_iter_data
! store the type of greensfunction as an integer, or maybe later on even
! create a type like nick did, to store all the general information like
! timestep, which orbitals are manipulated etc. in it
integer :: gf_type ! -1 indicates a the lesser, 1 the greater GF
integer :: normsize ! number of combinations avaliable for calculating overlaps
integer :: gf_count ! number of different Green's functions to be evaluated
integer :: allGfs ! 0 -> only one GF, 1 -> all lesser GFs, 2 -> all greater GFs
integer :: stepsAlpha ! number of cycles after which the rotation angle is updated
integer :: rotThresh ! number of walkers on which variation of alpha starts
! prefactors for rescaling of the wavefunction, if enabled
real(dp) :: alphaDamping, etaDamping ! prefactors for adjustment of rotation angle and damping
real(dp) :: stabilizerThresh
! the angle used for rotation of time into complex plane
! it is better readable to use new variables for real and imaginary part
! of the rotated time
real(dp) :: tau_imag, tau_real
! logging the total elapsed time on both axes
real(dp) :: elapsedRealTime, elapsedImagTime
! value of static shift if enabled
real(dp) :: asymptoticShift
! maximum shift that can be used and counter to track the cycles
real(dp) :: shiftLimit
integer, allocatable :: numCycShiftExcess(:)
real(dp), allocatable :: popSnapshot(:), allPopSnapShot(:)
integer, allocatable :: snapshotOrbs(:)
integer :: numSnapshotOrbs
! averaged overlaps
real(dp), allocatable :: overlap_real(:), overlap_imag(:)
! and dynamic reduced norm, used only when rescaling the wave function
! i.e. outdated feature
complex(dp), allocatable :: dyn_norm_red(:, :)
! norms are complex because they are taken between different replicas
! -> not necesserily entirely real
! need a global variable for the overlap
! determined by the max. cycle
! real(dp), allocatable :: gf_overlap(:)
! for tests now only make it of length 1
complex(dp), allocatable :: gf_overlap(:, :)
! also store the norm of the time-evolved wavefunction
complex(dp), allocatable :: dyn_norm_psi(:)
! the ground state energy of the N-particle problem which is added as a global shift
real(dp), allocatable :: gs_energy(:)
! the damping due to the DiagSft contribution in the imaginary time propagation
real(dp), allocatable :: shift_damping(:)
real(dp), allocatable :: TotPartsPeak(:)
! Buffer to store values of alpha when dynamically updating it to get some
! information on trends in alpha
real(dp), allocatable :: alphaLog(:)
integer :: alphaLogSize, alphaLogPos
! also store the current overlap of the cycle..
complex(dp), allocatable :: current_overlap(:, :)
! flag to indicate usage of verlet scheme
logical :: tVerletScheme, tVerletSweep
! buffers for the verlet scheme
integer(n_int), allocatable :: spawnBuf(:, :)
integer :: spawnBufSize
! initialization variables for the verlet scheme
integer :: iterInit
! cache for delta psi
integer(n_int), pointer :: dpsi_cache(:, :)
integer :: dpsi_size, max_cache_size, backup_size
! also store the norm of the perturbed ground state to adjust the overlap
complex(dp), allocatable :: pert_norm(:, :)
! need additional info of the original walker number and the number of
! walkers remaining in the perturbed ground state
integer(int64) :: TotWalkers_orig
type perturbed_state
! type for a state that is used as a reference state for the overlap
integer :: nDets
integer(n_int), allocatable :: dets(:, :)
end type perturbed_state
type(perturbed_state), allocatable :: overlap_states(:)
type real_time_type
! and a end time to stop the simulation afterwards
real(dp) :: max_time = -1.0_dp
! later also store the type of operators and spinorbitals in this
! type!
! store the type of the greensfunction calculated
! 1 ... greater GF: creation operator applied!
! -1 ... lesser GF: annihilation operator applied!
integer :: gf_type = 0
! to reduce the explosive spread of walkers through the
! Hilbert space a small imaginery energy can be introduced in
! the Schroedinger equation id/dt y(t) = (H-E0-ie)y(t)
real(dp) :: damping = 0.0_dp
real(dp) :: time_angle = 0.0_dp
real(dp) :: quad_damp_fac = 0.0_dp
end type real_time_type
type(real_time_type) :: real_time_info
! for hubbard model: Info if the perturbation operators are in k-space
logical :: t_kspace_operators
! and the corresponding phases for the fourier transformation
real(dp), allocatable :: phase_factors(:)
! need a 2nd list to combine y(n) + k1/2 in the 2nd order RK method
! from this list the spawns k2 are created, which can be stored in a
! reinitialized spawnvec arrays
integer(n_int), allocatable, target :: temp_det_list(:, :)
integer(n_int), pointer :: temp_det_pointer(:, :)
! also use hash table to access those lists
type(ll_node), pointer :: temp_det_hash(:)
integer :: temp_n_hashes
real(dp) :: temp_hash_frac
! also need to store the original number of determinants(and walkers maybe)
! of the y(n) list to reload correctly
integer(int64) :: temp_totWalkers
integer :: MaxSpawnedDiag
! also start to store the diagonal "spawns" in the second rt-fciqmc loop
! in a seperate Spawned Parts array, to better keep track of stats and
! do seperate different distinct processes
integer(n_int), pointer :: DiagParts(:, :)
! also need the associated actual arrays to point to
integer(n_int), allocatable, target :: DiagVec(:, :)
! i dont think i need a hash table to go with that..
! but i need this valid_spawned list thingy..
! which holds the next free slot to spawn to.. for each proc
integer, allocatable :: temp_freeslot(:)
integer :: temp_iendfreeslot, valid_diag_spawns
! also keep a global var. of the number of diag-spawns in a cycle
! and limit the number of spawns per determinant
integer :: n_diag_spawned, nspawnMax
! keep stats track of the two runge kutta steps seperately -> need new
! global variables!
real(dp), allocatable :: TotPartsStorage(:), TotPartsLastAlpha(:)
integer(TagIntType) :: DiagVecTag = 0
! use a global integer to specifiy the current runge-kutta step (1 or 2)
! to keep stats correclty
integer :: runge_kutta_step
! for saving/loading the trajectories
logical :: tLogTrajectory, tReadTrajectory, tLiveTrajectory
integer :: iunitCycLog
real(dp), allocatable :: tauCache(:), alphaCache(:)
character(255) :: trajFile
! These are required in the extended semi-stochastic treatment
logical :: tGenerateCoreSpace, tGZero
! For corespace construction
real(dp) :: wn_threshold
integer(n_int), pointer :: core_space_buf(:, :)
integer :: csbuf_size, corespace_log_interval
type(ll_node), pointer :: ssht(:)
end module real_time_data