Wave functions¶

class
gpaw.wavefunctions.base.
WaveFunctions
(gd, nvalence, setups, bd, dtype, collinear, world, kd, kptband_comm, timer)[source]¶ …
 setups:
 List of setup objects.
 symmetry:
 Symmetry object.
 kpt_u:
 List of kpoint objects.
 nbands: int
 Number of bands.
 nspins: int
 Number of spins.
 dtype: dtype
 Data type of wave functions (float or complex).
 bzk_kc: ndarray
 Scaled kpoints used for sampling the whole Brillouin zone  values scaled to [0.5, 0.5).
 ibzk_kc: ndarray
 Scaled kpoints in the irreducible part of the Brillouin zone.
 weight_k: ndarray
 Weights of the kpoints in the irreducible part of the Brillouin zone (summing up to 1).
 kpt_comm:
 MPIcommunicator for parallelization over kpoints.

calculate_atomic_density_matrices
(D_asp)[source]¶ Calculate atomic density matrices from projections.

calculate_atomic_density_matrices_with_occupation
(D_asp, f_un)[source]¶ Calculate atomic density matrices from projections with custom occupation f_un.

calculate_density_contribution
(nt_sG)[source]¶ Calculate contribution to pseudo density from wave functions.
Array entries are written to (not added to).

collect_array
(name, k, s, subset=None)[source]¶ Helper method for collect_eigenvalues and collect_occupations.
For the parallel case find the rank in kpt_comm that contains the (k,s) pair, for this rank, collect on the corresponding domain a full array on the domain master and send this to the global master.

collect_auxiliary
(value, k, s, shape=1, dtype=<class 'float'>)[source]¶ Helper method for collecting bandindependent scalars/arrays.
For the parallel case find the rank in kpt_comm that contains the (k,s) pair, for this rank, collect on the corresponding domain a full array on the domain master and send this to the global master.

collect_projections
(k, s)[source]¶ Helper method for collecting projector overlaps across domains.
For the parallel case find the rank in kpt_comm that contains the (k,s) pair, for this rank, send to the global master.

get_orbital_density_matrix
(a, kpt, n)[source]¶ Add the nth band density from kpt to density matrix D_sp

get_wave_function_array
(n, k, s, realspace=True, periodic=False)[source]¶ Return pseudowavefunction array on master.
 n: int
 Global band index.
 k: int
 Global IBZ kpoint index.
 s: int
 Spin index (0 or 1).
 realspace: bool
 Transform plane wave or LCAO expansion coefficients to realspace.
For the parallel case find the ranks in kd.comm and bd.comm that contains to (n, k, s), and collect on the corresponding domain a full array on the domain master and send this to the global master.

kpt_u
¶ Old name.

class
gpaw.wavefunctions.fd.
FDWaveFunctions
(stencil, parallel, initksl, gd, nvalence, setups, bd, dtype, world, kd, kptband_comm, timer, reuse_wfs_method=None, collinear=True)[source]¶

class
gpaw.wavefunctions.pw.
PWWaveFunctions
(ecut, gammacentered, fftwflags, dedepsilon, parallel, initksl, reuse_wfs_method, collinear, gd, nvalence, setups, bd, dtype, world, kd, kptband_comm, timer)[source]¶ 
apply_pseudo_hamiltonian
(kpt, ham, psit_xG, Htpsit_xG)[source]¶ Apply the pseudo Hamiltonian i.e. without PAW corrections.

get_wave_function_array
(n, k, s, realspace=True, cut=True, periodic=False)[source]¶ Return pseudowavefunction array on master.
 n: int
 Global band index.
 k: int
 Global IBZ kpoint index.
 s: int
 Spin index (0 or 1).
 realspace: bool
 Transform plane wave or LCAO expansion coefficients to realspace.
For the parallel case find the ranks in kd.comm and bd.comm that contains to (n, k, s), and collect on the corresponding domain a full array on the domain master and send this to the global master.


class
gpaw.wavefunctions.pw.
PW
(ecut=340, fftwflags=0, cell=None, gammacentered=False, pulay_stress=None, dedecut=None, force_complex_dtype=False)[source]¶ Planewave basis mode.
 ecut: float
 Planewave cutoff in eV.
 gammacentered: bool
 Center the grid of chosen plane waves around the gamma point or q/kvector
 dedecut: float or None or ‘estimate’
 Estimate of derivative of total energy with respect to planewave cutoff. Used to calculate pulay_stress.
 pulay_stress: float or None
 Pulaystress correction.
 fftwflags: int
Flags for making an FFTW plan. There are 4 possibilities (default is MEASURE):
from gpaw.fftw import ESTIMATE, MEASURE, PATIENT, EXHAUSTIVE
 cell: 3x3 ndarray
 Use this unit cell to chose the planewaves.
Only one of dedecut and pulay_stress can be used.

class
gpaw.wavefunctions.lcao.
LCAOWaveFunctions
(ksl, gd, nvalence, setups, bd, dtype, world, kd, kptband_comm, timer, atomic_correction=None, collinear=True)[source]¶ 
add_to_density_from_k_point_with_occupation
(nt_sG, kpt, f_n)[source]¶ Add contribution to pseudo electrondensity. Do not use the standard occupation numbers, but ones given with argument f_n.

calculate_atomic_density_matrices_with_occupation
(D_asp, f_un)[source]¶ Calculate atomic density matrices from projections with custom occupation f_un.

initialize_wave_functions_from_lcao
()[source]¶ Fill the calc.wfs.kpt_[u].psit_nG arrays with useful data.
Normally psit_nG is NOT used in lcao mode, but some extensions (like ase.dft.wannier) want to have it. This code is adapted from fd.py / initialize_from_lcao_coefficients() and fills psit_nG with data constructed from the current lcao coefficients (kpt.C_nM).
(This may or may not work in bandparallel case!)


class
gpaw.kpoint.
KPoint
(weight, s, k, q, phase_cd)[source]¶ Class for a single kpoint.
The KPoint class takes care of all wave functions for a certain kpoint and a certain spin.
XXX This needs to be updated.
Attributes:
 phase_cd: complex ndarray
 Bloch phasefactors for translations  axis c=0,1,2 and direction d=0,1.
 eps_n: float ndarray
 Eigenvalues.
 f_n: float ndarray
 Occupation numbers. The occupation numbers already include the kpoint weight in supercell calculations.
 psit_nG: ndarray
 Wave functions.
 nbands: int
 Number of bands.
Parallel stuff:
 comm: Communicator object
 MPIcommunicator for domain.
 root: int
 Rank of the CPU that does the matrix diagonalization of H_nn and the Cholesky decomposition of S_nn.
Construct kpoint object.
Parameters:
 gd: GridDescriptor object
 Descriptor for wavefunction grid.
 weight: float
 Weight of this kpoint.
 s: int
 Spin index: up or down (0 or 1).
 k: int
 kpoint index.
 q: int
 local kpoint index.
 dtype: type object
 Data type of wave functions (float or complex).
 timer: Timer object
 Optional.
Note that s and k are global spin/kpoint indices, whereas u is a local spin/kpoint pair index for this processor. So if we have \(S\) spins and \(K\) kpoints, and the spins/kpoints are parallelized over \(P\) processors (kpt_comm), then we have this equation relating s, k and u:
rSK  + u = sK + k, P
where \(r\) is the processor rank within kpt_comm. The total number of spin/kpoint pairs, \(SK\), is always a multiple of the number of processors, \(P\).

class
gpaw.eigensolvers.eigensolver.
Eigensolver
(keep_htpsit=True, blocksize=1)[source]¶ 
calculate_residuals
(kpt, wfs, ham, psit, P, eps_n, R, C, n_x=None, calculate_change=False)[source]¶ Calculate residual.
From R=Ht*psit calculate R=H*psiteps*S*psit.

iterate
(ham, wfs)[source]¶ Solves eigenvalue problem iteratively
This method is inherited by the actual eigensolver which should implement iterate_one_k_point method for a single iteration of a single kpoint.

subspace_diagonalize
(ham, wfs, kpt)[source]¶ Diagonalize the Hamiltonian in the subspace of kpt.psit_nG
Htpsit_nG is a work array of same size as psit_nG which contains the local part of the Hamiltonian times psit on exit
First, the Hamiltonian (defined by kin, vt_sG, and dH_asp) is applied to the wave functions, then the H_nn matrix is calculated and diagonalized, and finally, the wave functions (and also Htpsit_nG are rotated. Also the projections P_ani are rotated.
It is assumed that the wave functions psit_nG are orthonormal and that the integrals of projector functions and wave functions P_ani are already calculated.
Return rotated wave functions and H applied to the rotated wave functions if self.keep_htpsit is True.
