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 a,i
- add_derivative(a, v, a_xG, c_axi=1.0, q=- 1)[source]¶
Add derivative of localized functions on atom to extended arrays.
Parameters:
- 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 i
where:
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
where:
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.
- 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).
- class gpaw.poisson.FDPoissonSolver(nn=3, relax='J', eps=2e-10, maxiter=1000, remove_moment=None, use_charge_center=False, metallic_electrodes=False)[source]¶
- 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.
- 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:
3-----7 |\ |\ | \ | \ | 1-----5 z 2--|--6 | y | \ | \ | \ | \| \| \| 0-----4 +-----x
Example
>>> a = np.zeros((2, 2, 2)) >>> a.ravel()[:] = range(8) >>> a array([[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]]])
Construct grid-descriptor object.
parameters:
- 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].
Attributes:
dv
Volume per grid point.
h_cv
Array of the grid spacing along the three axes.
N_c
Array of the number of grid points along the three axes.
n_c
Number of grid points on this CPU.
beg_c
Beginning of grid-point indices (inclusive).
end_c
End of grid-point indices (exclusive).
comm
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.
- coarsen()[source]¶
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]) plt.show()
- 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 withn=dim
. A global array spanning all domains can be allocated withglobal_array=True
.
- 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.
- plane_wave(k_c)[source]¶
Evaluate plane wave on grid.
Returns:
_ _ ik.r e ,
where the wave vector is given by k_c (in units of reciprocal lattice vectors).
- refine()[source]¶
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)
- 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.
- 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
Example
>>> 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.
Parameters:
- 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.
Attributes:
nbands
Number of bands in total.
mynbands
Number of bands on this CPU.
beg
Beginning of band indices in group (inclusive).
end
End of band indices in group (exclusive).
step
Stride for band indices between
beg
andend
.comm
MPI-communicator for band distribution.
- 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 withn=dim
. A global array spanning all domains can be allocated withglobal_array=True
.
- get_band_indices(band_rank=None)[source]¶
Return the global band indices which belong to a given rank.
- 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).
- 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).
Parameters:
- 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-pointibzk_kc
Unknownibzk_qc
Unknownsym_k
Unknowntime_reversal_k
Unknownbz2ibz_k
Unknownibz2bz_k
Unknownbz2bz_ks
Unknownsymmetry
Object representing symmetries =================== =================================================- 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.
Parameters:
- 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.
- 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.
- 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_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.
- 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() → Optional[numpy.ndarray][source]¶
Collect all bands and atoms to master.
- redist(atom_partition) → gpaw.projections.Projections[source]¶
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.
- gd:
Grid-descriptor.
- psit_nG:
Wave functions in atomic units.
- P_nI:
PAW projections.
- setups:
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: Å).