Rimu

Random Integrator for Many-Body Quantum Systems

Keep dτ constant.

DelayedLogUpdate(ζ = 0.3, a = 10) <: ShiftStrategy

Strategy for updating the shift according to the log formula with damping parameter ζ and delay of a steps.

DelayedLogUpdateAfterTargetWalkers(targetwalkers, ζ = 0.3, a = 10) <: ShiftStrategy

Strategy for updating the shift: After targetwalkers is reached, update the shift according to the log formula with damping parameter ζ and delay of a steps. See DelayedLogUpdate.

DeltaMemory(Δ::Int) <: MemoryStrategy

Before updating the shift, memory noise with a memory length of Δ is applied, where Δ = 1 means no memory noise.

r̃ = (pnorm - tnorm)/(dτ*pnorm) + shift
r = r̃ - <r̃>

DontUpdate() <: ShiftStrategy Don't update the shift.

DoubleLogUpdate(targetwalkers, ζ = 0.3, ξ = 0.0225) <: ShiftStrategy

Strategy for updating the shift according to the log formula with damping parameter ζ and ξ.

LogUpdateAfterTargetWalkers(targetwalkers, ζ = 0.3, ξ = 0.0225) <: ShiftStrategy

Strategy for updating the shift: After targetwalkers is reached, update the shift according to the log formula with damping parameter ζ and ξ. See DoubleLogUpdate.

LogUpdateAfterTargetWalkersSwitch(targetwalkers, ζ = 0.3, ξ = 0.0225) <: ShiftStrategy

Strategy for updating the shift: After targetwalkers is reached, update the shift according to the log formula with damping parameter ζ and ξ. After a steps the strategy swiches to LogUpdate. See DoubleLogUpdate.

EveryKthStep(;k = 10)

Report every kth step.

Report every time step.

Abstract type representing the strategy for running and terminating fciqmc!(). Implemented strategies:

• RunTillLastStep

HistoryLogUpdate(df::DataFrame; d = 100, k=1, ζ= 0.3)

Strategy for updating the shift according to log formula but with walker numbers accumulated from k samples of the history with delay d. A recent history has to be passed with the data frame df for initialisation.

IsStochasticWithThreshold(threshold::Float16)

Trait for generalised vector of configurations indicating stochastic propagation with real walker numbers and cutoff threshold.

> StochasticStyle(V) = IsStochasticWithThreshold(threshold)

During stochastic propoagation, walker numbers small than threshold will be stochastically projected to either zero or threshold.

LogUpdate(ζ = 0.3) <: ShiftStrategy

Strategy for updating the shift according to the log formula with damping parameter ζ.

LogUpdateAfterTargetWalkers(targetwalkers, ζ = 0.3) <: ShiftStrategy

Strategy for updating the shift: After targetwalkers is reached, update the shift according to the log formula with damping parameter ζ. See LogUpdate.

Simple wrapper used for signaling that this data is part of a distributed data structure and communication should happen with MPI.

MPIDefault(nprocs, my_rank, comm)

Strategy for point-to-point MPI communication.

MPIOSWin(nprocs, myrank, comm, ::Type{T}, capacity)

Communication buffer for use with MPI one-sided communication (remote memory access). Up to capacity elements of type T can be exchanged between MPI ranks via put. It is important that isbitstype(T) == true. Objects of type MPIOSWin have to be freed manually with a (blocking) call to free().

Abstract type for defining the strategy for injectimg memory noise. Implemented strategies:

• NoMemory
• DeltaMemory
• ShiftMemory

NoMemory <: MemoryStrategy

Default strategy for MemoryStrategy indicating that no memory noise will be used.

Do not project the walker amplitudes. See norm_project.

Slow down/Speed up dτ to control the psips overshoot.

Abstract type for defining the stategy of projection for fciqmc with floating point walker number with norm_project. Implemented stategies:

• NoProjection
• ThresholdProject
• ScaledThresholdProject

ReportDFAndInfo(; k=10, i=100, io=stdout, writeinfo=true)

Report every kth step in DataFrame and write info message to io every ith step (unless writeinfo == false). The flag writeinfo is useful for controlling info messages in MPI codes.

Abstract type for strategies for reporting data in a DataFrame with report!(). Implemented strategies:

• EveryTimeStep
• EveryKthStep
• ReportDFAndInfo

RunTillLastStep(step::Int = 0 # number of current/starting timestep
             laststep::Int = 50 # number of final timestep
             shiftMode::Bool = false # whether to adjust shift
             shift::Float64 = 0.0 # starting/current value of shift
             dτ::Float64 = 0.01 # current value of time step
) <: FciqmcRunStrategy

Parameters for running fciqmc!() for a fixed number of time steps. For alternative strategies, see FciqmcRunStrategy.

ScaledThresholdProject(threshold = 1.0) <: ProjectStrategy

Project stochastically for walker amplitudes below threshold and scale configuration array as to keep the norm constant. As a consequence, the final configuration amplitudes may be smaller than threshold. See norm_project.

ShiftMemory(Δ::Int) <: MemoryStrategy

Effectively replaces the fluctuating shift update procedure for the coefficient vector by an averaged shift over Δ timesteps, where Δ = 1 means no averaging.

StochasticStyle(v)
StochasticStyle(typeof(v))

StochasticStyle specifies the native style of the generalised vector v that determines how simulations are to proceed. This can be fully stochastic (with IsStochastic), fully deterministic (with IsDeterministic), or semistochastic (with IsSemistochastic).

ThresholdProject(threshold = 1.0) <: ProjectStrategy

Project stochastically for walker amplitudes below threshold. See norm_project.

Abstract type for strategies for updating the time step with update_dτ(). Implemented strategies:

• ConstantTimeStep

fciqmc!(v, pa::FciqmcRunStrategy, [df,]
         ham, s_strat::ShiftStrategy,
         [r_strat::ReportingStrategy, τ_strat::TimeStepStrategy, w])
-> df

Perform the FCIQMC algorithm for determining the lowest eigenvalue of ham. v can be a single starting vector of type :<AbstractDVec or a vector of such structures. In the latter case, independent replicas are constructed. Returns a DataFrame df with statistics about the run, or a tuple of DataFrames for a replica run. Strategies can be given for updating the shift (see ShiftStrategy) and (optionally), for reporting (see ReportingStrategy), and for updating the time step dτ (see TimeStepStrategy).

A pre-allocated data structure w for working memory can be passed as argument, and controls multi-threading behaviour. By default multi-threading is turned on. To turn multi-threading off, pass similar(localpart(v)) for w.

This function mutates v, the parameter struct pa as well as df, and w.

free(obj::MPIOSWin)

De-reference the object, call finalizer and the garbage collector immediately. This is a syncronizing MPI call. Make sure that the object is not used later.

brief greeting

mpi_default(data, comm = MPI.COMM_WORLD, root = 0)

Declare data as mpi-distributed and set communication strategy to default. Sets up the MPIData structure with MPIDefault strategy.

mpi_no_exchange(data, comm = MPI.COMM_WORLD, root = 0)

Declare data as mpi-distributed and set communication strategy to MPINoWalkerExchange. Sets up the MPIData structure with MPINoWalkerExchange strategy.

mpi_one_sided(data, comm = MPI.COMM_WORLD, root = 0)

Declare data as mpi-distributed and set communication strategy to one-sided with remote memory access (RMA). Sets up the MPIData structure with MPIOSWin strategy.

put(buf::Vector{T}, [len,] targetrank, s::MPIOSWin{T})
put(obj::T, targetrank, s::MPIOSWin{T})

Deposit a single obj or vector buf into the MPI window s on rank targetrank. If len is given, only the first len elements are transmitted.

targetrank(key, np, hash = hash(key))

Compute the rank where the key belongs.

DeltaMemory2(Δ::Int) <: MemoryStrategy

Before updating the shift, memory noise with a memory length of Δ is applied, where Δ = 1 means no memory noise.

r̃ = pnorm - tnorm + shift*dτ*pnorm
r = (r̃ - <r̃>)/(dτ*pnorm)

The long-term average of r is not guaranteed to be zero.

IsSemistochastic(threshold::Float16, d_space)

Trait for generalised vector of configurations indicating semistochastic propagation. Set with setSemistochastic!.

> StochasticStyle(V) = IsSemistochastic(threshold, d_space)

where d_space is a vector of addresses defining the the stochastic subspace.

MPINoWalkerExchange(nprocs, my_rank, comm)

Strategy for for not exchanging walkers between ranks. Consequently there will be no cross-rank annihilations.

Abstract type for defining the strategy for updating the shift with update_shift(). Implemented strategies:

• DontUpdate
• LogUpdate
• DelayedLogUpdate
• LogUpdateAfterTargetWalkers
• DelayedLogUpdateAfterTargetWalkers
• HistoryLogUpdate

length(md::MPIData)

Compute the length of the distributed data on every MPI rank with MPI.Allreduce.

norm(md::MPIData, p=2)

Compute the norm of the distributed data on every MPI rank with MPI.Allreduce.

applyMemoryNoise!(w, v, shift, dτ, pnorm, m_strat::MemoryStrategy)

Apply memory noise to w according to the strategy m_strat. Note that the strategy needs to be compatible with StochasticStyle(w). The default is to not add memory noise. See MemoryStrategy.

w is the walker array after fciqmc step, v the previous one, pnorm the norm of v.

clearDFlags!(dv)

Clear all flags in dv of the deterministic bit (rightmost bit).

fciqmc_col!(w, ham, add, num, shift, dτ)
fciqmc_col!(::Type{T}, args...)
-> spawns, deaths, clones, antiparticles, annihilations

Spawning and diagonal step of FCIQMC for single column of ham. In essence it computes

w .+= (1 .+ dτ.*(shift .- ham[:,add])).*num.

Depending on T ==StochasticStyle(w), a stochastic or deterministic algorithm will be chosen. The possible values for T are:

• IsDeterministic() deteministic algorithm
• IsStochastic() stochastic version where the changes added to w are purely integer, according to the FCIQMC algorithm
• IsStochasticNonlinear(c) stochastic algorithm with nonlinear diagonal
• IsSemistochastic() semistochastic version: TODO

fciqmc_step!(Ĥ, v, shift, dτ, pnorm, w;
                      m_strat::MemoryStrategy = NoMemory()) -> ṽ, w̃, stats

Perform a single matrix(/operator)-vector multiplication:

where Ĥ == ham and S == shift. Whether the operation is performed in stochastic, semistochastic, or determistic way is controlled by the trait StochasticStyle(w). See StochasticStyle. w is a local data structure with the same size and type as v and used for working. Both v and w are modified.

Returns the result ṽ, a (possibly changed) reference to working memory w̃, and the array stats = [spawns, deaths, clones, antiparticles, annihilations]. Stats will contain zeros when running in deterministic mode.

next_mpiID()

Produce a new ID number for MPI distributed objects. Uses an internal counter.

norm_project!(w, p_strat::ProjectStrategy) -> norm

Computes the 1-norm of w. Project all elements of w to s.threshold preserving the sign if StochasticStyle(w) requires projection according to p_strat. See ProjectStrategy.

report!(df::DataFrame, t::Tuple, s<:ReportingStrategy)

Record results in df and write informational messages according to strategy s. See ReportingStrategy.

setSemistochastic!(dv, threshold::Float16, d_space)

Set the deterministic space for dv with threshold threshold, where d_space is a vector of addresses defining the the stochastic subspace.

sort_into_targets!(target, source, stats) -> agg, wm, agg_stats

Aggregate coefficients from source to agg and from stats to agg_stats according to thread- or MPI-level parallelism. wm passes back a reference to working memory.

sort_into_targets!(target::MPIData, source)

Distribute the entries of source to the target data structure such that all entries in the target dictionaries are on the process with the correct rank as controlled by targetrank().

update_dτ(s<:TimeStepStrategy, dτ, args...) -> new dτ

Update the time step according to the strategy s.

update_shift(s <: ShiftStrategy, shift, shiftMode, tnorm, pnorm, dτ, step, df)

Update the shift according to strategy s. See ShiftStrategy.

BSAdd128 <: BitStringAddressType

Address type that encodes a bistring address in a UInt128.

BSAdd64 <: BitStringAddressType

Address type that encodes a bistring address in a UInt64.

BStringAdd <: BitStringAddressType

Address type that encodes a bistring address in a one-dim. BitArray.

BitAdd{I,B} <: BitStringAddressType
BitAdd(address::Integer, B)
BitAdd(chunks::T, B) where T<:Union{Tuple,SVector}
BitAdd{B}(address)

Address type that encodes a bistring address with B bits. The bits are stored efficiently as SVector of I chunks of type UInt64. The two-argument constructor is preferred due to safety (consistency checks). In hot loops there maybe gain from the (unsafe) parametric constructor. If an integer address is passed, its bit representation is used to initialize BitAdd. For large bit numbers, BigInt is convenient. BitAdd[i] will return bit i (as Bool), counting from right to left.

• BitAdd{B}() creates a BitAdd with all ones.
• zero(BitAdd{B}) creates a BitAdd with all zeros.

Note that no checking for ghost bits occurs when constructing BitAdd from SVector or Tuple. See bitadd(), check_consistency(), and remove_ghost_bits() methods!

BitStringAddressType

Abstract type for configuration addresses with the nature of a bitstring. A number of methods need to be implemented, in particular Base.isless(a,b), numBits(), numChunks().

BoseFS{N,M,A} <: BosonicFockStateAddress <: BitStringAddressType
BoseFS(bs::A) where A <: BitAdd
BoseFS(bs::A, b)

Address type that represents a Fock state of N spinless bosons in M orbitals by wrapping a bitstring of type A. Orbitals are stored in reverse order, i.e. the first orbital in a BoseFS is stored rightmost in the bitstring bs. If the number of significant bits b is not encoded in A it must be passed as an argument (e.g. for BSAdd64 and BSAdd128).

BoseFS(onr::T) where T<:Union{AbstractVector,Tuple}
BoseFS{BST}(onr::T)

Create BoseFS address from an occupation number representation, specifying the occupation number of each orbital. If a type BST is given it will define the underlying bit string type. Otherwise, the bit string type is chosen to fit the onr.

bitaddr(onr, Type)

Calculate a bitstring address from an occupation number representation the type of the bitstring address is passed as the second argument.

nearUniform(N, M) -> onr::SVector{M,Int}

Create occupation number representation onr distributing N particles in M modes in a close-to-uniform fashion with each orbital filled with at least N ÷ M particles and at most with N ÷ M + 1 particles.

nearUniform(BoseFS{N,M})
nearUniform(BoseFS{N,M,A}) -> bfs::BoseFS{N,M,A}

Create bosonic Fock state with near uniform occupation number of M modes with a total of N particles. Specifying the bit address type A is optional.

Examples

julia> nearUniform(BoseFS{7,5,BitAdd})
BoseFS{BitAdd}((2,2,1,1,1))

julia> nearUniform(BoseFS{7,5})
BoseFS{BSAdd64}((2,2,1,1,1))

numBits(a)

Number of bit chunks representing a.

numChunks(a)

Number of 64-bit chunks representing a.

numModes(a)

Number of modes represented by a.

numParticles(a)

Number of particles represented by a.

onr(address, m)

Compute and return the occupation number representation as an array of Int corresponding to the given address.

onr(bs)

Compute and return the occupation number representation of the bit string address bs as an SVector{M,Int}, where M is the number of orbitals.

BosonicFockStateAddress <: BitStringAddressType

Supertype representing a bosonic Fock state. Implement numModes() and numParticles().

<<(b::BitAdd,n::Integer)

Bitshift b to the left by n bits and fill from the right with zeros.

>>>(b::BitAdd,n::Integer)

Bitshift b to the right by n bits and fill from the left with zeros.

lbshr(c,k)

Apply logical bit shift to the right by k bits to c.

remove_ghost_bits(bs)

Remove set bits outside data field if any are present.

Module that provides data structures that behave similar to sparse vectors, but are indexed by arbitrary types (could be non-integers) similarly to dictionaries. The idea is to do linear algebra with data structures that are neither subtyped to AbstractVector nor to AbstractDict and are suitable for use with KrylovKit.jl. For this, the abstract type and interface AbstractDVec is provided, with the following concrete subtypes:

• DVec
• DFVec
• FastDVec

DictVectors.AbstractDVec{K,V}

Abstract type for sparse vectors with valtype() V based on dictionary-like structures. They behave like vectors except that indexing is performed with an arbitrary keytype() K (no order required). getindex() returns zero(V) for any unknown key and zeroed elements should be deleted with delete!(). Thus, iteration typically returns only non-zero entries. In variance to AbstractVector, length() will return the number of non-zero elements, while capacity() returns the holding capacity (assumed fixed) of the object. Even though AbstractDVec is similar to both AbstractDict and AbstractVector, it is explicitly not subtyped to either. The aim is to create data structures suitable for FCIQMC and compatible with KrylovKit.jl.

Interface

The interface is similar to the AbstractDict interface. Implement what would be needed for the AbstractDict interface (setindex!, getindex, delete!, length, haskey, empty!, isempty) and, in addition:

• capacity(dv): holding capacity
• similar(dv [,Type])
• iterate(): should return values of type V
• pairs(): should return an iterator over key::K => content pairs. If content ≠ value::V the provide values() iterator as well!

DFVec{K,V,F}(capacity) <: AbstractDVec{K,V <: Number}
DFVec(d::Dict [, capacity])
DFVec(v::Vector{V} [, capacity])

Construct a wrapped dictionary with minimum capacity capacity to represent a vector-like object with valtype(dv) == V. The value of the Dict are of type Tuple{V,F}, which allows for storing a flag of type F for each entry. Indexing is done with an arbitrary (in general non-integer) keytype(dv) == K. When constructed from a Vector{V}, the keys will be integers ∈ [1, length(v)] and the flag zero(UInt16). See AbstractDVec. The method capacity() is defined but not a strict upper limit as Dict objects can expand.

DVec{K,T}(capacity) <: AbstractDVec{K,T}
DVec(d::Dict [, capacity])
DVec(v::Vector{T} [, capacity])

Construct a wrapped dictionary with minimum capacity capacity to represent a vector-like object with eltype(dv) == T, which corresponds to the values of the Dict. Indexing is done with an arbitrary (in general non-integer) keytype(dv) == K. When constructed from a Vector, the keys will be integers ∈ [0, length(v)]. See AbstractDVec. The method capacity() is defined but not a strict upper limit as Dict objects can expand.

DictVectors.FastDVec{K,V}(capacity)

Create a dictionary-like array indexed by keys of type K and values of type V with a maximum capacity of capacity.

FastDVec(a::AbstractArray, [capacity = length(a)])
FastDVec(d::AbstractDict{K,V}, [capacity = length(d)])
FastDVec(d::AbstractDVec{K,V}, [capacity = length(d)])

Construct a FastDVec object from an existing array or dictionary.

NormProjector()

Results in computing the one-norm when used in dot(). E.g.

dot(NormProjector(),x)
-> norm(x,1) # with type valtype(x)

NormProjector() thus represents the vector sign.(x).

UniformProjector()

Represents a vector with all elements 1. To be used with dot(). Minimizes memory allocations.

UniformProjector()⋅v == sum(v)
dot(UniformProjector(), LO, v) == sum(LO*v)

add!(x::AbstractDVec,y::AbstactDVec)

Inplace add x+y and store result in x.

DictVectors.capacity(dv::AbstractDVec, [s = :effective])
capacity(dvs::Tuple, [s = :effective])

gives the effective holding capacity of dv. If a tuple of dvs is given it aggregates the capacities.

Optional argument s:

• :effective the number of elements that

can be stored savely (default)

• :allocated actual internal memory allocation

flags(dv::DFVec)

An iterator that yields flags stored in the DFVec dv.

gettuple(dv::DFVec, key)

Retrieve the tuple (v,f) stored at the given key. If the key is not found, return a tuple of zeros.

kvpairs(collection)

Return an iterator over key => value pairs ignoring any flags. If no flags are present, eg. for generic AbstractDVec, this falls back to Base.pairs.

kvpairs(dv::DFVec)

An iterator that yields key => value pairs stored in the DFVec dv ignoring any flags. In contrast, Base.pairs() will return pairs key => (value, flag).

pairtype(dv)

Returns the type of stored data, as returned by the pairs() iterator.

tuples(dv::DFVec)

An iterator that yields tuples (v, f) with value v and flag f stored in the DFVec dv.

zero!(v::AbstractDVec)

Replace v by a zero vector as an inplace operation. For AbstractDVec types it means removing all non-zero elements.

ADVPairsIterator

Iterator type for pairs from a AbstractDVec.

FlagsIterator

Iterator type returned by flags().

KVPairsIterator

Iterator type returned by kvpairs().

fill!(da::AbstractDVec, x)

Empties da if x==zero(valtype(da)) and throws an error otherwise.

get(dv::DFVec, key, deftup::Tuple)

Return tuple containing value and flag if key exists and otherwise deftup.

get(dv::DFVec, key, defnum::Number)

Return value only if key exists and otherwise defnum

isequal(l::AbstractDVec, r::AbstractDVec)

Returns true if all non-zero entries have the same value. Equality of flags is not tested unless both l and r support flags.

isequal(l::DFVec, r::DFVec)

Returns true if all non-zero entries have the same value and the same flag.

axpy!(α::Number, X::AbstractDVec, Y::AbstractDVec)
axpy!(α::Number, X::AbstractDVec, Ys::Tuple, batchsize)

Overwrite Y with α*X + Y where α is scalar for AbstractDVecs. If a tuple Ys is passed with Threads.nthreads() AbstractDVecs, then perform the operation in parallel over threads with batchsize elements at a time.

norm(x::AbstractDVec, p)

Computes the p-norm of the DVec x. Implemented for p ∈ {1, 2, Inf}. Returns zero if x is empty.

norm(x::AbstractDVec{K,V})

Computes the 2-norm of the DVec x.

normInf(x::AbstractDVec)

Infinity norm: largest absolute value of entries.

norm_sqr(x::AbstractDVec)

Fast calculation of the square of the 2-norm of x.

Blocking

Module that contains functions performing the Flyvbjerg-Petersen blocking analysis for evaluating the standard error on a correlated data set.

Reblock the data by successively taking the mean of adjacent data points

perform a blocking analysis for two data sets

perform a blocking analysis for single data set

estimating stnadard error from blocking analysis based on the overlapping of error bars, if all the error bars (or more than 3 on a roll) behind current one are overlapping with it, return the current standard error with error bar.

The "M test" based on Jonsson, M. Physical Review E, 98(4), 043304, (2018). If the blocking analysis (BA) has passed the M test, an error estimation will be given based on the smallest k (i.e. meaningful results at the k-th data point on a BA plot).

find the standard error on standard errors on two datasets

Calculate the covariance between the two data sets vi and vj.

Calculate the standard deviation of the dataset v

Calculate the standard error of the dataset v

Calculate the variance of the dataset v

Provides the FastBuf data structure.

FastBuf{T}(n)

Create a first-in-last-out buffer of maximum capacity n. The element type is T. Fill a FastBuf with push!(), retrieve with pop!(). Accessing elements with getindex() and setindex!() as well as iteration are also supported. Check the capacity of a FastBuf with capacity().

Gives the capacity of a FastBuf object.