module kp_fciqmc_data_mod
use CalcData, only: subspace_in
use constants
use FciMCData, only: ll_node, perturbation
implicit none
save
type kp_fciqmc_data
! The number of different initial walker configurations to start
! calculations from.
integer :: nconfigs
! This is only used in the excited-state KP algorithm.
! The number of times that data about the subspace Hamiltonian and
! overlap matrices are output during a single run.
integer :: nreports
! The number of simulations to perform for each initial walker
! configuration.
integer :: nrepeats
! The number of different Krylov vectors to sample (the number of
! vectors which form the Krylov subspace at the end of a calculation).
integer :: nvecs
! The number of iterations to perform *between each Krylov vector being
! sampled*. niters(i) holds the number to be performed between the
! i-th and (i+1)th vectors. The final element is not set by the user,
! it is always set to 1 (because we don't want to go any further
! beyond the final Krylov vector).
integer, allocatable :: niters(:)
end type
! If true then we generate the initial Krylov subspace by using estimates
! of the lowest excited states, and project all of these trial states
! every iteration.
logical :: tExcitedStateKP
! If true then calculate and output the spin squared operator in the
! Krylov basis.
logical :: tCalcSpin
! Information for the krylov_vecs arrays, which holds all of the Krylov
! vectors together simultaneously.
! The number of hash values for the hash table used to access krylov_vecs.
integer :: nhashes_kp
! The total number of slots in the krylov_vecs arrays (the number of
! different determinants which it can hold).
integer :: krylov_vecs_length
character(2) :: kp_length_fmt
! krylov_vecs_length is calculated as the total number of walkers requested
! (by the TotalWalkers option in the Calc block) multipled by this factor,
! and then multipled by the number of Krylov vectors (for now...).
real(dp) :: memory_factor_kp
! The current number of different determinants held in krylov_vecs.
integer :: TotWalkersKP
integer(n_int), allocatable :: krylov_vecs(:, :)
! The diagonal Hamiltonian elements of the vectors in krylov_vecs, in the
! same order.
real(dp), allocatable :: krylov_helems(:)
! The hash is table used to access determinant data in krylov_vecs.
type(ll_node), pointer :: krylov_vecs_ht(:)
! These arrays are used if tExcitedStateKP = .false. in calc_projected_hamil
! in semi-stochasti calculations. They are used to store the deterministic
! vectors before and after the deterministic projection occurs. They have
! the same purpose as partial_determ_vecs and full_determ_vecs, except they
! are allocated to hold more vectors (all Krylov vectors), as is necessary
! if tExcitedStateKP = .false.
real(dp), allocatable, dimension(:, :) :: partial_determ_vecs_kp
real(dp), allocatable, dimension(:, :) :: full_determ_vecs_kp
! The number of elements in krylov_vecs which are used to store amplitudes.
integer(int64) :: nkrylov_amp_elems_tot
! The nunber of amplitude elements in krylov_vecs which are non-zero.
integer(int64) :: nkrylov_amp_elems_used
! The values of these variables for the current initial walker configuration.
! These are held in these variables so that, when we restart from this
! configuration, we can instantly reset the corresponding values.
integer(int64) :: TotWalkersInit, AllTotWalkersInit
real(dp), allocatable :: TotPartsInit(:)
real(dp), allocatable :: AllTotPartsInit(:)
! If true then don't use a fixed number of iterations between each Krylov
! vector is taken, but vary the number.
logical :: vary_niters
! The total sign length for all Krylov vectors together.
integer :: lenof_all_signs
! If true then, in the stochastic determination of the projected
! Hamiltonian, perform spawning from more highly weighted determinants
! exactly.
logical :: tExactHamilSpawning
! If true then calculate the projected Hamiltonian exactly (useful for
! testing only, in practice).
logical :: tExactHamil
! If true, use the spawning from the main FCIQMC iterations to
! calculate the projected Hamiltonian.
logical :: tHamilOnFly
! If true then use the semi-stochastic approach in the calculation
! of the projected Hamiltonian. This is on by default, if
! tSemiStochastic is true. If tFullyStochasticHamil if true then
! this logical will be false.
logical :: tSemiStochasticKPHamil
! If true, don't use the semi-stochastic approach when calculating
! the projected Hamiltonian. False by default.
logical :: tFullyStochasticHamil
! If true then a finite-temperature calculation is performed.
logical :: tFiniteTemp
! If true then perform multiple kp-fciqmc calculations starting from
! several POPSFILEs in the running directory. POPSFILEs labelled
! between 0 and nconfigs-1 will be used.
logical :: tMultiplePopStart
! For finite-temperature calculations, when creating the inital vector,
! this variable specifies how many walkers should be added to each
! chosen site.
real(dp) :: nwalkers_per_site_init
! When estimating the projected Hamiltonian, this variable determines
! how many spawns (on average) each of the walkers in each of the
! Kyrlov vectors contribute.
real(dp) :: av_mc_excits_kp
! When estimating the projected Hamiltonian, this parameter will be
! used to decide how many determinants have *exact* spawning performed
! for them. Specifically, if the total population on a determinant
! (across all replicas) multiplied by kp_hamil_exact_frac is greater
! than or equal to the number of determinants connected to the
! Hartree-Fock, then exact spawning is performed.
real(dp) :: kp_hamil_exact_frac
! If true then use generate_init_config_this_proc to generate the initial
! walker distribution for finite-temperature calculations. This will always
! generate the requested number of walkers (except for rounding when splitting
! this number between processors).
logical :: tInitCorrectNWalkers
! If true then always occupy the deterministic space first when generating
! an initial configuration for finite-temperature calculations. Only after
! this is filled will other states be randomly occupied.
logical :: tOccDetermInit
! In the projected Hamiltonian calculation, this holds the fraction of the
! spawning array to be filled before a communication round is performed.
integer :: MaxSpawnedEachProc
! If true then the random number generator will be reset before genearting
! the next initial configuration (in a finite-temperature job) by using
! the values in init_config_seeds.
logical :: tUseInitConfigSeeds
! See comments above.
integer, allocatable :: init_config_seeds(:)
! If true then the averaged projected Hamiltonian and overlap matrices
! will be output after completing all repeats of a given initial configuration.
! If more than one repeat has been performed, then the standard error
! will also be output.
logical :: tOutputAverageKPMatrices
! If true then, after the perturbation operator has been applied (which
! will reduce the population), scale up the initial wave function to the
! requested population.
logical :: tScalePopulation
real(dp) :: scaling_factor
! This variable is used to store the state of tSinglePartPhase on input so
! that we can reset it to this value on each repeat.
logical, allocatable :: tSinglePartPhaseKPInit(:)
! If true then calculate the overlap of the final Hamiltonian eigenstates
! with a vector which is calculated by applying a perturbation operator
! (overlap_pert) to the popsfile wave function.
logical :: tOverlapPert
type(perturbation), allocatable :: overlap_pert(:)
! The result of overlap_pert applied to the wave function read in from
! a popsfile.
integer(n_int), allocatable :: perturbed_ground(:, :)
! The overlaps of perturbed_ground with the various Krylov vectors.
real(dp), allocatable :: pert_overlaps(:)
! The sum of pert_overlaps across all processes, calculated after all
! iterations in a repeat have been performed and only stored on the
! root process.
real(dp), allocatable :: kp_all_pert_overlaps(:)
! After all repeats for a given initial configuration are complete, these
! arrays will hold the means and standard errors of the projected
! Hamiltonian and overlap matrices (unless only one sample was obtained,
! in which case the standard errors will be zero).
real(dp), allocatable :: kp_hamil_mean(:, :)
real(dp), allocatable :: kp_overlap_mean(:, :)
real(dp), allocatable :: kp_hamil_se(:, :)
real(dp), allocatable :: kp_overlap_se(:, :)
! These are used in the calculation of the final eigenvalues.
! Allocate these arrays once during initialisation and reuse them,
! as reallocating arrays over and over again isn't great to do...
! Arrays holding the eigenvalues of the Hamiltonian and overlap matrices.
real(dp), allocatable :: kp_overlap_eigv(:)
! The overlap of the final vectors with the initial configuration.
! (the first Krylov vector).
real(dp), allocatable :: kp_init_overlaps(:)
! The eigenvectors of the overlap matrix.
real(dp), allocatable :: kp_overlap_eigenvecs(:, :)
! The matrix used to transform the Krylov vectors to a orthonormal basis.
real(dp), allocatable :: kp_transform_matrix(:, :)
! Matrix used as temporary space during the transformation of the
! projected matrices into an orthonormal basis, in the Lowdin approach.
real(dp), allocatable :: kp_inter_matrix(:, :)
! The final eigenvectors, but in the basis of Krylov vectors.
! This is used in the Lowdin approach: diagonalising kp_final_hamil
! will give the final eigenvectors in the orthonormal basis, then
! we do the inverse of the transformation procedure to get back to
! the Krylov basis.
real(dp), allocatable :: kp_eigenvecs_krylov(:, :)
! If true then use an estimate of an excited state (or linear
! combination of excited states) to form the initial wave function.
logical :: tExcitedInitState
! When using the excited-init-state option, this array is read in
! from the input file and specifies which excited states to take
! a weighted average of to form the initial state.
integer, allocatable :: kpfciqmc_ex_labels(:)
! How much weight do we give to each trial state in the initial
! Krylov vector?
real(dp), allocatable :: kpfciqmc_ex_weights(:)
! Type for the trial wave function space for excited-state calculations.
type(subspace_in) :: kp_trial_space_in
! Arrays used to access the signs of different Krylov vector signs in the
! Krylov vector arrays. If tPairedReplicas is .false. then these arrays
! are identical, otherwise the first array gives access to the first set
! of vectors and the second array to the second set.
integer, allocatable :: kp_ind_1(:), kp_ind_2(:)
! If true then perform an orthogonalisation step at the end of each
! iteration. This only applies to the CFQMC approach.
logical :: tOrthogKPReplicas
! After which iteration should we start performing the orthogonalisation
! step?
integer :: orthog_kp_iter
end module