Davidson solver

Davidson solver module

Davidson object

add_product_vector!(dav::Davidson, prods, state=0, customdots=())

Add a product vector for state to Davidson object and update effective Hamiltonian matrix.

customdots() is a Tuple of custom dot-product functions for each tensor in the product vector of the form f(tvec, prod, state) or f(tvec, prod) for state=0.

add_trial_vector!(dav::Davidson, tvecs, state=0, customdots=())

Add a trial vector for state to Davidson object and update effective overlap and Hamiltonian matrix.

Note: the trial vector will be normalized and either orthogonalized to the existing trial vectors, or the effective overlap matrix will be updated (in non-hermitian case). customdots is a Tuple of custom dot-product functions for each tensor in the trial vector of the form f(tvec, prod, state) or f(tvec, prod) for state=0.

do_refresh(dav::Davidson, nstates=dav.nstates)

Check if Davidson object needs to be refreshed.

The Davidson object needs to be refreshed if the total number of trial vectors after the new iteration will exceed the maximum number of trial vectors times the number of states.

get_current_trial_vector!(dav::Davidson, tvecs, state=0)

Copy the current trial vector from Davidson object to tvecs. If state > 0, check if the trial vector is for that state.

get_eigenvector!(dav::Davidson, vecs, state)

Get eigenvector for state from Davidson object and store it in vecs.

The eigenvector is loaded from the corresponding file.

get_eigenvector(dav::Davidson, state)

Get eigenvector for state from Davidson object.

The eigenvector is loaded from the corresponding file.

get_residual!(dav::Davidson, vecs, state)

Calculate residual for state and store it in vecs.

The residual is calculated as res = H * eigvec - eigval * eigvec. The eigenvector is loaded from the corresponding file.

perform!(dav::Davidson)

Perform Davidson diagonalization of effective Hamiltonian matrix.

Store the eigenvalues and eigenvectors in the Davidson object.

refresh!(dav::Davidson, evec, custom_dots=())

Refresh Davidson object by resetting the effective Hamiltonian and overlap matrices and adding the eigenvectors as trial vectors.

combine!(dav::Davidson, outvec, vecfiles, coeffs)

Combine vectors from files with coefficients.

outvec is the output vector.

combine(dav::Davidson, vecfiles, coeffs)

Combine vectors from files with coefficients.

custom_dot(customdots, tens, vecs, state=0)

Compute dot product of vectors using custom dot-product functions customdots::Tuple.

customdots is a Tuple of custom dot-product functions for each tensor in the product vector of the form f(tvec, prod, state) or f(tvec, prod) for state=0. If customdots is empty, the standard dot product is used. vecs are reshaped to the shape of tensors tens.

dav_normalize!(vecs, state, customdots)

Normalize vectors.

diagonalize(dav::Davidson)

Diagonalize effective Hamiltonian matrix.

loadprods(dav::Davidson, ipos)

Load product vectors from file at position ipos as Vector{Vector{Float64}}.

loadtvecs(dav::Davidson, ipos)

Load trial vectors from file at position ipos as Vector{Vector{Float64}}.

loadvecs(file)

Load vectors from file as Vector{Vector{Float64}}.

orthogonalize!(dav::Davidson, vecs, state, customdots=())

Orthogonalize vectors to trial vectors.

saveeigvecs(dav::Davidson, vecs, state)

Save eigenvectors to file for state.

saveprods(dav::Davidson, vecs)

Save vectors to next file.

savetvecs(dav::Davidson, vecs, state)

Save trial vectors to next file and store state index.

update_Heff!(dav::Davidson, prods, state, customdots=())

Update effective Hamiltonian matrix.

prods are product vectors (for one state) for the current iteration of Davidson algorithm (stored at dav.nDim+1 position). customdots is a Tuple of custom dot-product functions for each tensor in the product vector of the form f(tvec, prod, state) or f(tvec, prod) for state=0.

update_Heff_dagger!(dav::Davidson, tvecs, state, customdots=())

Update effective Hamiltonian matrix (transpose, for non-hermitian problems).

tvecs are trial vectors (for one state) for the current iteration of Davidson algorithm (stored at dav.nDimTrial+1 position). customdots is a Tuple of custom dot-product functions for each tensor in the product and trial vector of the form f(tvec, prod, state) or f(tvec, prod) for state=0.

update_Seff!(dav::Davidson, tvecs, state, customdots=())

Update effective overlap matrix.

tvecs are trial vectors (for one state) for the current iteration of Davidson algorithm (stored at dav.nDimTrial+1 position). customdots is a Tuple of custom dot-product functions for each tensor in the trial vector of the form f(tvec, prod, state) or f(tvec, prod) for state=0.

use_overlap(dav::Davidson)

Check if smat is used.