# eigensolver keywords

Eigensolver parameters

## eigensolver.algo

Determine the algorithm used for real space diagonalization.

**type**: `string`

**default**: `'cfsi'`

**allowed**: `'cfsi','lobpcg'`

**example**: `eigensolver.algo = 'lobpcg'`

## eigensolver.algoproj

Determine the algorithm used for projected (dense) eigenvalue problems;
required by ScaLAPACK;
\'DSYEV\',\'DSYEVD\',\'DSYEVR\',\'DSYEVX\',\'DSYGV\' only used in LCAO
calculations; if \'DSYEV\', use the overlap matrix factor to tranform
the generalized eigenvalue problem into a standard eigenvalue problem,
find all eigenpairs, transform eigenpairs back to the non-orthonormal
basis; if \'DSYEVD\', use the overlap matrix factor to tranform the
generalized eigenvalue problem into a standard eigenvalue problem, find
all eigenpairs by the divide-and-conquer method, transform eigenpairs
back to the non-orthonormal basis; if \'DSYEVR\', use the overlap matrix
factor to tranform the generalized eigenvalue problem into a standard
eigenvalue problem, find the occupied eigenpairs by the MRRR method,
transform eigenpairs back to the non-orthonormal basis; if \'DSYEVX\'
use the overlap matrix factor to tranform the generalized eigenvalue
problem into a standard eigenvalue problem, find the occupied
eigenpairs, transform eigenpairs back to the non-orthonormal basis; if
\'DSYGV\' find all eigenpairs of the generalized eigenvalue problem; if
\'DSYGVX\' find occupied eigenpairs of the generalized eigenvalue
problem; \'DSYGV\' is most robust and stable in our experience while
\'DSYGVX\' is fastest.

**type**: `string`

**default**: `'DSYGVX'`

**allowed**: `'DSYEV', 'DSYEVD', 'DSYEVR', 'DSYEVX', 'DSYGV', 'DSYGVX'`

**example**: `eigensolver.algoproj = 'DSYEVD'`

## eigensolver.adapCFD

Use adaptive Chebyshev filtering degree; development option, use at your
own risk.

**type**: `scalar`

**default**: `false`

**allowed**: `true,false`

**example**: `eigensolver.adapCFD = false`

## eigensolver.bandi

Index range of the energy bands. If eigensolver.bandi = \[il,iu\] is
defined, the eigensolver will find the eigenvalues and/or eigenvectors
with an index between il and iu. il \<= iu is assumed. In real space, il
is forced to be 1. iu is generally chosen as
nval2+max(16,ceil(natom/4)), where nval2 is the number of valence bands
(accounting for spin degeneracy) and natom is the number of atoms.

**type**: `array`

**size**: `[1,2]`

**example**: `eigensolver.bandi = [430,470]`

## eigensolver.emptyBand

Number of bands included in the calculation in addition to the number of
valence bands (nval2). If eigensolver.emptyBand is set and
eigensolver.bandi isn\'t set, then eigensolver.bandi =
\[1,nval2+st.emptyBand\].

**type**: `scalar`

**example**: `eigensolver.emptyBand = 47`

## eigensolver.xband

Number of buffer bands included in the calculation. This keyword is only
relevant if eigensolver.algo = \'cfsi\' and when performing a
non-self-consistent calculation. Simply put, if the required bands
(eigensolver.bandi) are well separated from the non-required bands, the
later converge more rapidly. The introduction of buffer bands on top of
the required bands creates this separation. Note, however, that using
buffer bands comes at a cost. A value around natom/4 is usually
profitable, where natom is the number of atoms.

**type**: `scalar`

**default**: `0`

**example**: `eigensolver.xband = 128`

## eigensolver.init

Determine the procedure to initialize the occupied Kohn-Sham subspace;
only referenced if lcao.status = false (real space calculation); if
\'lcao\' RESCU solves the Kohn-Sham equation once using atomic orbitals
and then pursues in real space; if \'sin/cos\' RESCU uses sines and
cosines for an initial basis; if \'sin/cos/rr\' RESCU uses sines and
cosines an performs the Rayleigh-Ritz procedure for an initial basis; if
\'rand\' RESCU uses a randomly generated initial subspace.

**type**: `string`

**default**: `'lcao'`

**allowed**: `'lcao','sin/cos','sin/cos/rr','rand'`

**example**: `eigensolver.init = 'lcao'`

## eigensolver.maxit

Determine the maximal number of Hamiltonian-vector products per vector
per self-consistent step; if texttt{eigensolver.algo = \'cfsi\'} then it
corresponds to the degree of the Chebyshev polynomial. If a
non-self-consistent calculation is performed, then the default is to use
1000 iterations since convergence must be guaranteed.

**type**: `scalar`

**default**: `15`

**example**: `eigensolver.maxit = 15`

## eigensolver.maxRestart

Number of restarts allowed in a self-consistent cycle. The default is to
use no restart. For non-self-consistent calculations, this corresponds
to the total number of restarts. The default is then 4.

**type**: `scalar`

**default**: `1`

**example**: `eigensolver.maxRestart = 2`

## eigensolver.nsym

eigensolver.nsym give you control over the number of eigenvectors that
are calculated at once by the eigensolver. This is relevant for LOBPCG
which requires many workspaces, and hence eigensolver.nsym may be
crucial in limiting the memory requirements. The default value is
equivalent to the number of bands included in the DFT calculations. It
is suggested to set eigensolver.nsym if memory is scarce or if the
number of bands exceeds 200.

**type**: `scalar`

**example**: `eigensolver.nsym = 64`

## eigensolver.orthogonalize

Determine whether to explicitly orthogonalize before the Rayleigh-Ritz
procedure.

**type**: `scalar`

**default**: `false`

**allowed**: `true,false`

**example**: `eigensolver.orthogonalize = false`

## eigensolver.precond

Eigensolver preconditioning method. This is most important when using
LOBPCG. To turn off preconditioning, set eigensolver.precond = -1.
eigensolver.precond = 3 is the preconditioner of Teter, Corning and
Payne.

**type**: `scalar`

**default**: `4`

**allowed**: `[-1,0,1,2,3,4,5,6,7]`

**example**: `eigensolver.precond = 4`

## eigensolver.pwmode

Determine whether to store the wave-functions using their plane-wave
coefficients.

**type**: `scalar`

**default**: `false`

**allowed**: `true,false`

**example**: `eigensolver.pwmode = false`

## eigensolver.tol

Maximal tolerance for the eigenvector residuals. When doing a
self-consistent calculation, the eigensolvers use the minimum of
eigensolver.tol and dRho/10.

**type**: `scalar`

**default**: `0.1`

**example**: `eigensolver.tol = 5e-2`

## eigensolver.ubmaxit

Determine the number of Hamiltonian products used to estimate the
spectrum upper bound using Lanczos algorithm.

**type**: `scalar`

**default**: `12`

**example**: `eigensolver.ubmaxit = 10`
