Miscellaneous objects and functions

class gpaw.lfc.LocalizedFunctionsCollection(gd, spline_aj, kd=None, cut=False, dtype=<class 'float'>, integral=None, forces=None)[source]

Utilizes that localized functions can be stored on a spherical subset of the uniform grid, as opposed to LocalizedFunctionsCollection which is just a wrapper around the old localized_functions which use rectangular grids.

add(a_xG, c_axi=1.0, q=- 1)[source]

Add localized functions to extended arrays.

         --  a     a
a (G) += >  c   Phi (G)
 x       --  xi    i
add_derivative(a, v, a_xG, c_axi=1.0, q=- 1)[source]

Add derivative of localized functions on atom to extended arrays.


a: int

Atomic index of the derivative

v: int

Cartesian coordinate of the derivative (0, 1 or 2)

This function adds the following sum to the extended arrays:

         --  a      a
a (G) += >  c   dPhi  (G)
 x       --  xi     iv


    a        d     a
dPhi  (G) =  -- Phi (g)
    iv       dv    i

is the derivative of the Phi^a and v is either x, y, or z.

derivative(a_xG, c_axiv, q=- 1)[source]

Calculate x-, y-, and z-derivatives of localized function integrals.

          /              a*
c_axiv =  | dG a (G) dPhi  (G)
          /     x        iv


    a        d     a
dPhi  (G) =  -- Phi (g)
    iv       dv    i

and v is either x, y, or z, and R^a_v is the center of Phi^a.

Notice that d Phi^a_i / dR^a_v == - d Phi^a_i / d v.


Iterate over grid points.

integrate(a_xG, c_axi, q=- 1)[source]

Calculate integrals of arrays times localized functions.

         /             a*
c_axi =  | dG a (G) Phi  (G)
         /     x       i
second_derivative(a_xG, c_axivv, q=- 1)[source]

Calculate second derivatives.

Works only for this type of input for now:

second_derivative(self, a_G, c_avv, q=-1)
                    2 a _ _a
         /  _   _  d f (r-R )
c_avv =  | dr a(r) ----------
         /             a  a
                     dR dR
                       i  j
class gpaw.spline.Spline(l, rmax, f_g)[source]

Spline object

The integer l gives the angular momentum quantum number and the list contains the spline values from r=0 to r=rcut.

The array f_g gives the radial part of the function on the grid. The radial function is multiplied by a real solid spherical harmonics (r^l * Y_lm).


Return the angular momentum quantum number.


Return the radial cutoff.


Return the value and derivative.

class gpaw.poisson.FDPoissonSolver(nn=3, relax='J', eps=2e-10, maxiter=1000, remove_moment=None, use_charge_center=False, metallic_electrodes=False)[source]
create_laplace(gd, scale=1.0, n=1, dtype=<class 'float'>)[source]

Instantiate and return a Laplace operator

Allows subclasses to change the Laplace operator

iterate2(step, level=0)[source]

Smooths the solution in every multigrid level

class gpaw.xc.functional.XCFunctional(name, type)[source]
calculate(gd, n_sg, v_sg=None, e_g=None)[source]

Calculate energy and potential.

gd: GridDescriptor

Descriptor for 3-d grid.

n_sg: rank-4 ndarray

Spin densities.

v_sg: rank-4 ndarray

Array for potential. The XC potential is added to the values already there.

e_g: rank-3 ndarray

Energy density. Values must be written directly, not added.

The total XC energy is returned.


Get long description of functional as a string, or None.


Write summary of last calculation to file.


Get dictionary representation of XC functional.

This representation works for libxc kernels; other classes should likely override this function and should probably not rely on this implementation.


Get string representation of XC functional.

This will give the name for libxc functionals but other data for hybrids.

class gpaw.xc.gga.GGA(kernel, stencil=2)[source]

Get long description of functional as a string, or None.


Get dictionary representation of XC functional.

This representation works for libxc kernels; other classes should likely override this function and should probably not rely on this implementation.

gpaw.forces.calculate_forces(wfs, dens, ham, log=None)[source]

Return the atomic forces.

class gpaw.grid_descriptor.GridDescriptor(N_c, cell_cv=[1, 1, 1], pbc_c=True, comm=None, parsize_c=None, allow_empty_domains=False)[source]

Descriptor-class for uniform 3D grid

A GridDescriptor object holds information on how functions, such as wave functions and electron densities, are discreticed in a certain domain in space. The main information here is how many grid points are used in each direction of the unit cell.

There are methods for tasks such as allocating arrays, performing symmetry operations and integrating functions over space. All methods work correctly also when the domain is parallelized via domain decomposition.

This is how a 2x2x2 3D array is laid out in memory:

|\    |\
| \   | \
|  1-----5      z
2--|--6  |   y  |
 \ |   \ |    \ |
  \|    \|     \|
   0-----4      +-----x


>>> a = np.zeros((2, 2, 2))
>>> a.ravel()[:] = range(8)
>>> a
array([[[0., 1.],
        [2., 3.]],

       [[4., 5.],
        [6., 7.]]])

Construct grid-descriptor object.


N_c: 3 ints

Number of grid points along axes.

cell_cv: 3 float’s or 3x3 floats

Unit cell.

pbc_c: one or three bools

Periodic boundary conditions flag(s).

comm: MPI-communicator

Communicator for domain-decomposition.

parsize_c: tuple of 3 ints, a single int or None

Number of domains.

allow_empty_domains: bool

Allow parallelization that would generate empty domains.

Note that if pbc_c[c] is False, then the actual number of gridpoints along axis c is one less than N_c[c].



Volume per grid point.


Array of the grid spacing along the three axes.


Array of the number of grid points along the three axes.


Number of grid points on this CPU.


Beginning of grid-point indices (inclusive).


End of grid-point indices (exclusive).


MPI-communicator for domain decomposition.

The length unit is Bohr.

bytecount(dtype=<class 'float'>)[source]

Get the number of bytes used by a grid of specified dtype.

calculate_dipole_moment(rho_g, center=False, origin_c=None)[source]

Calculate dipole moment of density.


Return coarsened \(GridDescriptor\) object.

Reurned descriptor has 2x2x2 fewer grid points.

collect(a_xg, out=None, broadcast=False)[source]

Collect distributed array to master-CPU or all CPU’s.

coords(c, pad=True)[source]

Return coordinates along one of the three axes.

Useful for plotting:

import matplotlib.pyplot as plt
plt.plot(gd.coords(0), data[:, 0, 0])
dipole_moment(rho_R: numpy.ndarray, center_v: Optional[Iterable[float]] = None)numpy.ndarray[source]

Calculate dipole moment of density.

Integration region will be centered on center_v. Default center is center of unit cell.

distribute(B_xg, out=None)[source]

Distribute full array B_xg to subdomains, result in b_xg.

B_xg is not used by the slaves (i.e. it should be None on all slaves) b_xg must be allocated on all nodes and will be overwritten.

empty(n=(), dtype=<class 'float'>, global_array=False, pad=False)[source]

Return new uninitialized 3D array for this domain.

The type can be set with the dtype keyword (default: float). Extra dimensions can be added with n=dim. A global array spanning all domains can be allocated with global_array=True.


Calculate center of positive function.

get_boxes(spos_c, rcut, cut=True)[source]

Find boxes enclosing sphere.

get_grid_point_coordinates(dtype=<class 'float'>, global_array=False)[source]

Construct cartesian coordinates of grid points in the domain.

get_grid_point_distance_vectors(r_v, mic=True, dtype=<class 'float'>)[source]

Return distances to a given vector in the domain.

mic: if true adopts the mininimum image convention procedure by W. Smith in ‘The Minimum image convention in Non-Cubic MD cells’ March 29, 1989

get_nearest_grid_point(spos_c, force_to_this_domain=False)[source]

Return index of nearest grid point.

The nearest grid point can be on a different CPU than the one the nucleus belongs to (i.e. return can be negative, or larger than gd.end_c), in which case something clever should be done. The point can be forced to the grid descriptors domain to be consistent with self.get_rank_from_position(spos_c).

integrate(a_xg, b_yg=None, global_integral=True, hermitian=False, _transposed_result=None)[source]

Integrate function(s) over domain.

a_xg: ndarray

Function(s) to be integrated.

b_yg: ndarray

If present, integrate a_xg.conj() * b_yg.

global_integral: bool

If the array(s) are distributed over several domains, then the total sum will be returned. To get the local contribution only, use global_integral=False.

hermitian: bool

Result is hermitian.

_transposed_result: ndarray

Long story. Don’t use this unless you are a method of the MatrixOperator class …

interpolate_grid_points(spos_nc, vt_g)[source]

Return interpolated values.

Calculate interpolated values from array vt_g based on the scaled coordinates on spos_c.

This doesn’t work in parallel, since it would require communication between neighbouring grids.

new_descriptor(N_c=None, cell_cv=None, pbc_c=None, comm=None, parsize_c=None, allow_empty_domains=False)[source]

Create new descriptor based on this one.

The new descriptor will use the same class (possibly a subclass) and all arguments will be equal to those of this descriptor unless new arguments are provided.


Evaluate plane wave on grid.


  _ _
e    ,

where the wave vector is given by k_c (in units of reciprocal lattice vectors).


Return refined \(GridDescriptor\) object.

Returned descriptor has 2x2x2 more grid points.

wannier_matrix(psit_nG, psit_nG1, G_c, nbands=None)[source]

Wannier localization integrals

The soft part of Z is given by (Eq. 27 ref1):

~       ~     -i G.r   ~
Z   = <psi | e      |psi >
 nm       n             m

psit_nG and psit_nG1 are the set of wave functions for the two different spin/kpoints in question.

ref1: Thygesen et al, Phys. Rev. B 72, 125119 (2005)

zero_pad(a_xg, global_array=True)[source]

Pad array with zeros as first element along non-periodic directions.

Array may either be local or in standard decomposition.

zeros(n=(), dtype=<class 'float'>, global_array=False, pad=False)[source]

Return new zeroed 3D array for this domain.

The type can be set with the dtype keyword (default: float). Extra dimensions can be added with n=dim. A global array spanning all domains can be allocated with global_array=True.

class gpaw.scf.SCFLoop(eigenstates=0.1, energy=0.1, density=0.1, force=inf, maxiter=100, niter_fixdensity=None, nvalence=None)[source]

Self-consistent field loop.

collect_errors(dens, ham, wfs)[source]

Check convergence of eigenstates, energy and density.

log(log, niter, wfs, ham, dens, errors)[source]

Output from each iteration.

class gpaw.band_descriptor.BandDescriptor(nbands: int, comm=None, strided=False)[source]

Descriptor-class for ordered lists of bands

A BandDescriptor object holds information on how functions, such as wave functions and corresponding occupation numbers, are divided into groups according to band indices. The main information here is how many bands are stored on each processor and who gets what.

This is how a 12 band array is laid out in memory on 3 cpu’s:

 a) Blocked groups       b) Strided groups

      3    7   11             9   10   11
myn   2 \  6 \ 10       myn   6    7    8
 |    1  \ 5  \ 9        |    3    4    5
 |    0    4    8        |    0    1    2
 |                       |
 +----- band_rank        +----- band_rank


>>> a = np.zeros((3, 4))
>>> a.ravel()[:] = range(12)
>>> a
array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.]])
>>> b = np.zeros((4, 3))
>>> b.ravel()[:] = range(12)
>>> b.T
array([[ 0.,  3.,  6.,  9.],
       [ 1.,  4.,  7., 10.],
       [ 2.,  5.,  8., 11.]])

Construct band-descriptor object.


nbands: int

Global number of bands.

comm: MPI-communicator

Communicator for band-groups.

strided: bool

Enable strided band distribution for better load balancing with many unoccupied bands.

Note that if comm.size is 1, then all bands are contained on a single CPU and blocked/strided grouping loses its meaning.



Number of bands in total.


Number of bands on this CPU.


Beginning of band indices in group (inclusive).


End of band indices in group (exclusive).


Stride for band indices between beg and end.


MPI-communicator for band distribution.

collect(a_nx, broadcast=False)[source]

Collect distributed array to master-CPU or all CPU’s.

distribute(B_nx, b_nx)[source]

distribute full array B_nx to band groups, result in b_nx. b_nx must be allocated.

empty(n=(), dtype=<class 'float'>, global_array=False)[source]

Return new uninitialized 3D array for this domain.

The type can be set with the dtype keyword (default: float). Extra dimensions can be added with n=dim. A global array spanning all domains can be allocated with global_array=True.


Return the global band indices which belong to a given rank.


Return array of ranks as a function of global band indices.


Return the slice of global bands which belong to a given rank.

global_index(myn, band_rank=None)[source]

Convert rank information and local index to global index.


Convert global band index to rank information and local index.

zeros(n=(), dtype=<class 'float'>, global_array=False)[source]

Return new zeroed 3D array for this domain.

The type can be set with the dtype keyword (default: float). Extra dimensions can be added with n=dim. A global array spanning all domains can be allocated with global_array=True.

class gpaw.spinorbit.BZWaveFunctions(kd: gpaw.kpt_descriptor.KPointDescriptor, wfs: Dict[int, gpaw.spinorbit.WaveFunction], occ: Optional[gpaw.occupations.OccupationNumberCalculator], nelectrons: float)[source]

Container for eigenvalues and PAW projections (all of BZ).


Calculate sum over occupied eigenvalues.

eigenvalues(broadcast: bool = True)numpy.ndarray[source]

Eigenvalues in eV for the whole BZ.

eigenvectors(broadcast: bool = True)numpy.ndarray[source]

Eigenvectors for the whole BZ.

pdos_weights(a: int, indices: List[int], broadcast: bool = True)numpy.ndarray[source]

Projections for PDOS.

Returns (nbzkpts, nbands, 2)-shaped ndarray of the square of absolute value of the projections.

spin_projections(broadcast: bool = True)numpy.ndarray[source]

Spin projections for the whole BZ.

class gpaw.spinorbit.WaveFunction(eigenvalues: numpy.ndarray, projections: gpaw.projections.Projections, bz_index: Optional[int] = None)[source]
add_soc(dVL_avii: Dict[int, numpy.ndarray], s_vss: List[numpy.ndarray], C_ss: numpy.ndarray)None[source]

Evaluate H in a basis of S_z eigenstates.

pdos_weights(a: int, indices: List[int])numpy.ndarray[source]

PDOS weights.

transform(kd: gpaw.kpt_descriptor.KPointDescriptor, setups: List[gpaw.setup.Setup], spos_ac: numpy.ndarray, bz_index: int)gpaw.spinorbit.WaveFunction[source]

Transforms PAW projections from IBZ to BZ k-point.

class gpaw.kpt_descriptor.KPointDescriptor(kpts, nspins: int = 1)[source]

Descriptor-class for k-points.

Construct descriptor object for kpoint/spin combinations (ks-pair).


kpts: None, sequence of 3 ints, or (n,3)-shaped array

Specification of the k-point grid. None=Gamma, list of ints=Monkhorst-Pack, ndarray=user specified.

nspins: int

Number of spins.

Attributes =================== ================================================= N_c Number of k-points in the different directions. nspins Number of spins in total. mynspins Number of spins on this CPU. nibzkpts Number of irreducible kpoints in 1st BZ. mynks Number of k-point/spin combinations on this CPU. gamma Boolean indicator for gamma point calculation. comm MPI-communicator for kpoint distribution. weight_k Weights of each k-point ibzk_kc Unknown ibzk_qc Unknown sym_k Unknown time_reversal_k Unknown bz2ibz_k Unknown ibz2bz_k Unknown bz2bz_ks Unknown symmetry Object representing symmetries =================== =================================================

collect(a_ux, broadcast: bool)[source]

Collect distributed data to all.

copy(comm=<gpaw.mpi.SerialCommunicator object>)[source]

Create a copy with shared symmetry object.

create_k_points(sdisp_cd, collinear)[source]

Return a list of KPoints.

find_ibzkpt(symrel, ibzk_kc, bzk_c)[source]

Find index in IBZ and related symmetry operations.

find_k_plus_q(q_c, kpts_k=None)[source]

Find the indices of k+q for all kpoints in the Brillouin zone.

In case that k+q is outside the BZ, the k-point inside the BZ corresponding to k+q is given.


q_c: ndarray

Coordinates for the q-vector in units of the reciprocal lattice vectors.

kpts_k: list of ints

Restrict search to specified k-points.


Return the q=k1-k2. q-mesh is always Gamma-centered.


Return the number of ks-pairs which belong to a given rank.

get_ibz_q_points(bzq_qc, op_scc)[source]

Return ibz q points and the corresponding symmetry operations that work for k-mesh as well.


Return the global ks-pair indices which belong to a given rank.


Return the offset of the first ks-pair on a given rank.


Find rank and local index of k-point/spin combination.

get_transform_wavefunction_index(nG, k)[source]

Get the “wavefunction transform index”.

This is a permutation of the numbers 1, 2, .. N which associates k + q to some k, and where N is the total number of grid points as specified by nG which is a 3D tuple.

Returns index_G and phase_G which are one-dimensional arrays on the grid.


Set k-point communicator.

set_symmetry(atoms, symmetry, comm=None)[source]

Create symmetry object and construct irreducible Brillouin zone.

atoms: Atoms object

Defines atom positions and types and also unit cell and boundary conditions.

symmetry: Symmetry object

Symmetry object.

transform_wave_function(psit_G, k, index_G=None, phase_G=None)[source]

Transform wave function from IBZ to BZ.

k is the index of the desired k-point in the full BZ.

where_is_q(q_c, bzq_qc)[source]

Find the index of q points in BZ.


Convert global index to rank information and local index.

class gpaw.projections.Projections(nbands: int, nproj_a: Any, atom_partition: gpaw.utilities.partition.AtomPartition, bcomm: Optional[Any] = None, collinear=True, spin=0, dtype=None, data=None, bdist=None)[source]

Collect all bands and atoms to master.


Redistribute atoms.

class gpaw.utilities.partition.AtomPartition(comm, rank_a, name='unnamed')[source]

Represents atoms distributed on a standard grid descriptor.

gpaw.utilities.dipole.dipole_matrix_elements(gd: gpaw.grid_descriptor.GridDescriptor, psit_nR: List[numpy.ndarray], P_nI: numpy.ndarray, position_av: numpy.ndarray, setups: List[gpaw.setup.Setup], center: Iterable[float])numpy.ndarray[source]

Calculate dipole matrix-elements.




Wave functions in atomic units.


PAW projections.


PAW setups.

Returns matrix elements in atomic units.

gpaw.utilities.dipole.dipole_matrix_elements_from_calc(calc: gpaw.calculator.GPAW, n1: int, n2: int, center: Optional[Iterable[float]] = None)List[numpy.ndarray][source]

Calculate dipole matrix-elements (units: Å).