def get_all_electron_density(self, atoms=None, gridrefinement=2, spos_ac=None):
"""Return real all-electron density array.
Usage: Either get_all_electron_density(atoms) or
get_all_electron_density(spos_ac=spos_ac) """
if spos_ac is None:
spos_ac = atoms.get_scaled_positions() % 1.0
# Refinement of coarse grid, for representation of the AE-density
if gridrefinement == 1:
gd = self.gd
n_sg = self.nt_sG.copy()
elif gridrefinement == 2:
gd = self.finegd
if self.nt_sg is None:
self.interpolate_pseudo_density()
n_sg = self.nt_sg.copy()
elif gridrefinement == 4:
# Extra fine grid
gd = self.finegd.refine()
# Interpolation function for the density:
interpolator = Transformer(self.finegd, gd, 3)
# Transfer the pseudo-density to the fine grid:
n_sg = gd.empty(self.nspins)
if self.nt_sg is None:
self.interpolate_pseudo_density()
for s in range(self.nspins):
interpolator.apply(self.nt_sg[s], n_sg[s])
else:
raise NotImplementedError
# Add corrections to pseudo-density to get the AE-density
splines = {}
phi_aj = []
phit_aj = []
nc_a = []
nct_a = []
for a, id in enumerate(self.setups.id_a):
if id in splines:
phi_j, phit_j, nc, nct = splines[id]
else:
# Load splines:
phi_j, phit_j, nc, nct = self.setups[a].get_partial_waves()[:4]
splines[id] = (phi_j, phit_j, nc, nct)
phi_aj.append(phi_j)
phit_aj.append(phit_j)
nc_a.append([nc])
nct_a.append([nct])
# Create localized functions from splines
phi = BasisFunctions(gd, phi_aj)
phit = BasisFunctions(gd, phit_aj)
nc = LFC(gd, nc_a)
nct = LFC(gd, nct_a)
phi.set_positions(spos_ac)
phit.set_positions(spos_ac)
nc.set_positions(spos_ac)
nct.set_positions(spos_ac)
I_sa = np.zeros((self.nspins, len(spos_ac)))
a_W = np.empty(len(phi.M_W), np.intc)
W = 0
for a in phi.atom_indices:
nw = len(phi.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
x_W = phi.create_displacement_arrays()[0]
rho_MM = np.zeros((phi.Mmax, phi.Mmax))
for s, I_a in enumerate(I_sa):
M1 = 0
for a, setup in enumerate(self.setups):
ni = setup.ni
D_sp = self.D_asp.get(a)
if D_sp is None:
D_sp = np.empty((self.nspins, ni * (ni + 1) // 2))
else:
I_a[a] = ((setup.Nct - setup.Nc) / self.nspins -
sqrt(4 * pi) *
np.dot(D_sp[s], setup.Delta_pL[:, 0]))
if gd.comm.size > 1:
gd.comm.broadcast(D_sp, self.rank_a[a])
M2 = M1 + ni
rho_MM[M1:M2, M1:M2] = unpack2(D_sp[s])
M1 = M2
phi.lfc.ae_valence_density_correction(rho_MM, n_sg[s], a_W, I_a,
x_W)
phit.lfc.ae_valence_density_correction(-rho_MM, n_sg[s], a_W, I_a,
x_W)
a_W = np.empty(len(nc.M_W), np.intc)
W = 0
for a in nc.atom_indices:
nw = len(nc.sphere_a[a].M_w)
a_W[W:W + nw] = a
W += nw
scale = 1.0 / self.nspins
for s, I_a in enumerate(I_sa):
nc.lfc.ae_core_density_correction(scale, n_sg[s], a_W, I_a)
nct.lfc.ae_core_density_correction(-scale, n_sg[s], a_W, I_a)
gd.comm.sum(I_a)
N_c = gd.N_c
g_ac = np.around(N_c * spos_ac).astype(int) % N_c - gd.beg_c
for I, g_c in zip(I_a, g_ac):
if (g_c >= 0).all() and (g_c < gd.n_c).all():
n_sg[s][tuple(g_c)] -= I / gd.dv
return n_sg, gd
def get_pseudo_core_kinetic_energy_density_lfc(self):
return LFC(self.gd,
[[setup.tauct] for setup in self.setups],
forces=True, cut=True)
from gpaw.test import equal from gpaw.grid_descriptor import GridDescriptor from gpaw.spline import Spline import gpaw.mpi as mpi from gpaw.lfc import LocalizedFunctionsCollection as LFC s = Spline(0, 1.0, [1.0, 0.5, 0.0]) n = 40 a = 8.0 gd = GridDescriptor((n, n, n), (a, a, a), comm=mpi.serial_comm) c = LFC(gd, [[s], [s], [s]], kpt_comm=mpi.world) c.set_positions([(0.5, 0.5, 0.25 + 0.25 * i) for i in [0, 1, 2]]) b = gd.zeros() c.add(b) x = gd.integrate(b) gd = GridDescriptor((n, n, n), (a, a, a), comm=mpi.serial_comm) c = LFC(gd, [[s], [s], [s]], kpt_comm=mpi.world) c.set_positions([(0.5, 0.5, 0.25 + 0.25 * i) for i in [0, 1, 2]]) b = gd.zeros() c.add(b) y = gd.integrate(b) equal(x, y, 1e-13)
from gpaw.gaunt import gaunt as G_LLL
from gpaw.spherical_harmonics import Y
from gpaw.response.math_func import two_phi_planewave_integrals
# Initialize s, p, d (9 in total) wave and put them on grid
rc = 2.0
a = 2.5 * rc
n = 64
lmax = 2
b = 8.0
m = (lmax + 1)**2
gd = GridDescriptor([n, n, n], [a, a, a])
r = np.linspace(0, rc, 200)
g = np.exp(-(r / rc * b)**2)
splines = [Spline(l=l, rmax=rc, f_g=g) for l in range(lmax + 1)]
c = LFC(gd, [splines])
c.set_positions([(0.5, 0.5, 0.5)])
psi = gd.zeros(m)
d0 = c.dict(m)
if 0 in d0:
d0[0] = np.identity(m)
c.add(psi, d0)
# Calculate on 3d-grid < phi_i | e**(-ik.r) | phi_j >
R_a = np.array([a / 2, a / 2, a / 2])
rr = gd.get_grid_point_coordinates()
for dim in range(3):
rr[dim] -= R_a[dim]
k_G = np.array([[11., 0.2, 0.1], [10., 0., 10.]])
nkpt = k_G.shape[0]
def __init__(self, nbands, kpt_u, setups, kd, gd, dtype=float):
"""Store and initialize required attributes.
Parameters
----------
nbands: int
Number of occupied bands.
kpt_u: list of KPoints
List of KPoint instances from a ground-state calculation (i.e. the
attribute ``calc.wfs.kpt_u``).
setups: Setups
LocalizedFunctionsCollection setups.
kd: KPointDescriptor
K-point and symmetry related stuff.
gd: GridDescriptor
Descriptor for the coarse grid.
dtype: dtype
This is the ``dtype`` for the wave-function derivatives (same as
the ``dtype`` for the ground-state wave-functions).
"""
self.dtype = dtype
# K-point related attributes
self.kd = kd
# Number of occupied bands
self.nbands = nbands
# Projectors
self.pt = LFC(gd, [setup.pt_j for setup in setups],
kd,
dtype=self.dtype)
# Store grid
self.gd = gd
# Unfold the irreducible BZ to the full BZ
# List of KPointContainers for the k-points in the full BZ
self.kpt_u = []
# No symmetries or only time-reversal symmetry used
assert kd.symmetry.point_group == False
if kd.symmetry.time_reversal == False:
# For now, time-reversal symmetry not allowed
assert len(kpt_u) == kd.nbzkpts
for k in range(kd.nbzkpts):
kpt_ = kpt_u[k]
psit_nG = gd.empty(nbands, dtype=self.dtype)
for n, psit_G in enumerate(psit_nG):
psit_G[:] = kpt_.psit_nG[n]
# psit_0 = psit_G[0, 0, 0]
# psit_G *= psit_0.conj() / (abs(psit_0))
# Strip off KPoint attributes and store in the KPointContainer
# Note, only the occupied GS wave-functions are retained here !
kpt = KPointContainer(weight=kpt_.weight,
k=kpt_.k,
s=kpt_.s,
phase_cd=kpt_.phase_cd,
eps_n=kpt_.eps_n[:nbands],
psit_nG=psit_nG,
psit1_nG=None,
P_ani=None,
dP_aniv=None)
# q=kpt.q,
# f_n=kpt.f_n[:nbands])
self.kpt_u.append(kpt)
else:
assert len(kpt_u) == kd.nibzkpts
for k, k_c in enumerate(kd.bzk_kc):
# Index of symmetry related point in the irreducible BZ
ik = kd.bz2ibz_k[k]
# Index of point group operation
s = kd.sym_k[k]
# Time-reversal symmetry used
time_reversal = kd.time_reversal_k[k]
# Coordinates of symmetry related point in the irreducible BZ
ik_c = kd.ibzk_kc[ik]
# Point group operation
op_cc = kd.symmetry.op_scc[s]
# KPoint from ground-state calculation
kpt_ = kpt_u[ik]
weight = 1. / kd.nbzkpts * (2 - kpt_.s)
phase_cd = np.exp(2j * pi * gd.sdisp_cd * k_c[:, np.newaxis])
psit_nG = gd.empty(nbands, dtype=self.dtype)
for n, psit_G in enumerate(psit_nG):
#XXX Seems to corrupt my memory somehow ???
psit_G[:] = kd.symmetry.symmetrize_wavefunction(
kpt_.psit_nG[n], ik_c, k_c, op_cc, time_reversal)
# Choose gauge
# psit_0 = psit_G[0, 0, 0]
# psit_G *= psit_0.conj() / (abs(psit_0))
kpt = KPointContainer(weight=weight,
k=k,
s=kpt_.s,
phase_cd=phase_cd,
eps_n=kpt_.eps_n[:nbands],
psit_nG=psit_nG,
psit1_nG=None,
P_ani=None,
dP_aniv=None)
self.kpt_u.append(kpt)
import numpy as np
from gpaw.lfc import LocalizedFunctionsCollection as LFC
from gpaw.grid_descriptor import GridDescriptor
from gpaw.spline import Spline
a = 4.0
gd = GridDescriptor(N_c=[16, 20, 20],
cell_cv=[a, a + 1, a + 2],
pbc_c=(0, 1, 1))
spos_ac = np.array([[0.25, 0.15, 0.35], [0.5, 0.5, 0.5]])
kpts_kc = None
s = Spline(l=0, rmax=2.0, f_g=np.array([1, 0.9, 0.1, 0.0]))
p = Spline(l=1, rmax=2.0, f_g=np.array([1, 0.9, 0.1, 0.0]))
spline_aj = [[s], [s, p]]
c = LFC(gd, spline_aj, cut=True, forces=True)
if kpts_kc is not None:
c.set_k_points(kpts_kc)
c.set_positions(spos_ac)
C_ani = c.dict(3, zero=True)
if 1 in C_ani:
C_ani[1][:, 1:] = np.eye(3)
psi = gd.zeros(3)
c.add(psi, C_ani)
c.integrate(psi, C_ani)
if 1 in C_ani:
d = C_ani[1][:, 1:].diagonal()
assert d.ptp() < 4e-6
C_ani[1][:, 1:] -= np.diag(d)
assert abs(C_ani[1]).max() < 5e-17
d_aniv = c.dict(3, derivative=True)
c.derivative(psi, d_aniv)
if 1 in d_aniv:
def initialize(self):
self.eta /= Hartree
self.ecut /= Hartree
calc = self.calc
self.nspins = self.calc.wfs.nspins
# kpoint init
self.kd = kd = calc.wfs.kd
self.nikpt = kd.nibzkpts
self.ftol /= kd.nbzkpts
# cell init
self.acell_cv = calc.wfs.gd.cell_cv
self.acell_cv, self.bcell_cv, self.vol, self.BZvol = \
get_primitive_cell(self.acell_cv,rpad=self.rpad)
# grid init
gd = calc.wfs.gd.new_descriptor(comm=serial_comm)
self.pbc = gd.pbc_c
self.gd = gd
self.nG0 = np.prod(gd.N_c)
# Number of grid points and volume including zero padding
self.nGrpad = gd.N_c * self.rpad
self.nG0rpad = np.prod(self.nGrpad)
self.d_c = [
Gradient(gd, i, n=4, dtype=complex).apply for i in range(3)
]
# obtain eigenvalues, occupations
nibzkpt = kd.nibzkpts
kweight_k = kd.weight_k
self.eFermi = self.calc.occupations.get_fermi_level()
try:
self.e_skn
self.printtxt('Use eigenvalues from user.')
except:
self.printtxt('Use eigenvalues from the calculator.')
self.e_skn = {}
self.f_skn = {}
for ispin in range(self.nspins):
self.e_skn[ispin] = np.array([
calc.get_eigenvalues(kpt=k, spin=ispin)
for k in range(nibzkpt)
]) / Hartree
self.f_skn[ispin] = np.array([
calc.get_occupation_numbers(kpt=k, spin=ispin) /
kweight_k[k] for k in range(nibzkpt)
]) / kd.nbzkpts
#self.printtxt('Eigenvalues(k=0) are:')
#print >> self.txt, self.e_skn[0][0] * Hartree
self.enoshift_skn = {}
for ispin in range(self.nspins):
self.enoshift_skn[ispin] = self.e_skn[ispin].copy()
if self.eshift is not None:
self.add_discontinuity(self.eshift)
self.printtxt('Shift unoccupied bands by %f eV' % (self.eshift))
# k + q init
if self.q_c is not None:
self.qq_v = np.dot(self.q_c, self.bcell_cv) # summation over c
if self.optical_limit:
kq_k = np.arange(kd.nbzkpts)
self.expqr_g = 1.
else:
r_vg = gd.get_grid_point_coordinates() # (3, nG)
qr_g = gemmdot(self.qq_v, r_vg, beta=0.0)
self.expqr_g = np.exp(-1j * qr_g)
del r_vg, qr_g
kq_k = kd.find_k_plus_q(self.q_c)
self.kq_k = kq_k
# Plane wave init
if self.G_plus_q:
self.npw, self.Gvec_Gc, self.Gindex_G = set_Gvectors(self.acell_cv,
self.bcell_cv,
self.gd.N_c,
self.ecut,
q=self.q_c)
else:
self.npw, self.Gvec_Gc, self.Gindex_G = set_Gvectors(
self.acell_cv, self.bcell_cv, self.gd.N_c, self.ecut)
# band init
if self.nbands is None:
self.nbands = calc.wfs.bd.nbands
self.nvalence = calc.wfs.nvalence
# Projectors init
setups = calc.wfs.setups
self.spos_ac = calc.atoms.get_scaled_positions()
if self.pwmode:
self.pt = PWLFC([setup.pt_j for setup in setups], self.calc.wfs.pd)
self.pt.set_positions(self.spos_ac)
else:
self.pt = LFC(gd, [setup.pt_j for setup in setups],
KPointDescriptor(self.kd.bzk_kc),
dtype=complex,
forces=True)
self.pt.set_positions(self.spos_ac)
# Printing calculation information
self.print_stuff()
return
def initialize(self, density, hamiltonian, wfs, occupations):
self.xc.initialize(density, hamiltonian, wfs, occupations)
self.nspins = wfs.nspins
self.setups = wfs.setups
self.density = density
self.kpt_u = wfs.kpt_u
self.gd = density.gd
self.kd = wfs.kd
self.bd = wfs.bd
N_c = self.gd.N_c
N = self.gd.N_c.prod()
vol = self.gd.dv * N
if self.alpha is None:
self.alpha = 6 * vol**(2 / 3.0) / pi**2
self.gamma = (vol / (2 * pi)**2 * sqrt(pi / self.alpha) *
self.kd.nbzkpts)
ecut = 0.5 * pi**2 / (self.gd.h_cv**2).sum(1).max()
if self.kd.N_c is None:
self.bzk_kc = np.zeros((1, 3))
dfghdfgh
else:
n = self.kd.N_c * 2 - 1
bzk_kc = np.indices(n).transpose((1, 2, 3, 0))
bzk_kc.shape = (-1, 3)
bzk_kc -= self.kd.N_c - 1
self.bzk_kc = bzk_kc.astype(float) / self.kd.N_c
self.pwd = PWDescriptor(ecut, self.gd, self.bzk_kc)
n = 0
for k_c, Gpk2_G in zip(self.bzk_kc[:], self.pwd.G2_qG):
if (k_c > -0.5).all() and (k_c <= 0.5).all(): #XXX???
if k_c.any():
self.gamma -= np.dot(np.exp(-self.alpha * Gpk2_G),
Gpk2_G**-1)
else:
self.gamma -= np.dot(np.exp(-self.alpha * Gpk2_G[1:]),
Gpk2_G[1:]**-1)
n += 1
assert n == self.kd.N_c.prod()
self.ghat = LFC(self.gd, [setup.ghat_l for setup in density.setups],
dtype=complex)
self.ghat.set_k_points(self.bzk_kc)
self.fullkd = KPointDescriptor(self.kd.bzk_kc, nspins=1)
class S:
id_a = []
def set_symmetry(self, s):
pass
self.fullkd.set_symmetry(Atoms(pbc=True), S(), False)
self.fullkd.set_communicator(world)
self.pt = LFC(self.gd, [setup.pt_j for setup in density.setups],
dtype=complex)
self.pt.set_k_points(self.fullkd.ibzk_kc)
self.interpolator = density.interpolator
def get_projections(self, locfun, spin=0):
"""Project wave functions onto localized functions
Determine the projections of the Kohn-Sham eigenstates
onto specified localized functions of the format::
locfun = [[spos_c, l, sigma], [...]]
spos_c can be an atom index, or a scaled position vector. l is
the angular momentum, and sigma is the (half-) width of the
radial gaussian.
Return format is::
f_kni = <psi_kn | f_i>
where psi_kn are the wave functions, and f_i are the specified
localized functions.
As a special case, locfun can be the string 'projectors', in which
case the bound state projectors are used as localized functions.
"""
wfs = self.wfs
if locfun == 'projectors':
f_kin = []
for kpt in wfs.kpt_u:
if kpt.s == spin:
f_in = []
for a, P_ni in kpt.P_ani.items():
i = 0
setup = wfs.setups[a]
for l, n in zip(setup.l_j, setup.n_j):
if n >= 0:
for j in range(i, i + 2 * l + 1):
f_in.append(P_ni[:, j])
i += 2 * l + 1
f_kin.append(f_in)
f_kni = np.array(f_kin).transpose(0, 2, 1)
return f_kni.conj()
from gpaw.lfc import LocalizedFunctionsCollection as LFC
from gpaw.spline import Spline
from math import factorial as fac
nkpts = len(wfs.kd.ibzk_kc)
nbf = np.sum([2 * l + 1 for pos, l, a in locfun])
f_kni = np.zeros((nkpts, wfs.bd.nbands, nbf), wfs.dtype)
spos_xc = []
splines_x = []
for spos_c, l, sigma in locfun:
if isinstance(spos_c, int):
spos_c = self.spos_ac[spos_c]
spos_xc.append(spos_c)
alpha = .5 * Bohr**2 / sigma**2
r = np.linspace(0, 10. * sigma, 500)
f_g = (fac(l) * (4 * alpha)**(l + 3 / 2.) * np.exp(-alpha * r**2) /
(np.sqrt(4 * np.pi) * fac(2 * l + 1)))
splines_x.append([Spline(l, rmax=r[-1], f_g=f_g)])
lf = LFC(wfs.gd, splines_x, wfs.kd, dtype=wfs.dtype)
lf.set_positions(spos_xc)
assert wfs.gd.comm.size == 1
k = 0
f_ani = lf.dict(wfs.bd.nbands)
for kpt in wfs.kpt_u:
if kpt.s != spin:
continue
lf.integrate(kpt.psit_nG[:], f_ani, kpt.q)
i1 = 0
for x, f_ni in f_ani.items():
i2 = i1 + f_ni.shape[1]
f_kni[k, :, i1:i2] = f_ni
i1 = i2
k += 1
return f_kni.conj()
def update(self):
if self.ranges is None: # First time
self.ranges = []
self.nbands = self.lcao.wfs.bd.nbands
start = 0
if self.ranges_str != 'full':
for rng in self.ranges_str.split(','):
print("rng", rng)
rng = eval(rng)
self.ranges.append(range(start, rng))
start = rng
self.ranges.append(range(start, self.nbands))
print(self.ranges)
self.ghat = LFC(
self.lcao.wfs.gd,
[setup.ghat_l for setup in self.lcao.density.setups],
integral=sqrt(4 * pi),
forces=False)
spos_ac = self.lcao.atoms.get_scaled_positions() % 1.0
self.ghat.set_positions(spos_ac)
# Clear files
for rid, rng in enumerate(self.ranges):
f = open(self.filename + '.' + str(rid) + '.density', 'w')
print("# Density file", file=f)
N_c = self.lcao.wfs.gd.N_c
print(N_c[0], N_c[1], N_c[2], file=f)
print(
"# This header is 10 lines long, then double precision binary data starts.",
file=f)
for i in range(7):
print("#", file=f)
f.close()
#self.lcao.timer.start('Dump density')
for rid, rng in enumerate(self.ranges):
assert len(self.lcao.wfs.kpt_u) == 1
f_un = [self.lcao.wfs.kpt_u[0].f_n.copy()]
for n in range(self.lcao.wfs.bd.nbands):
band_rank, myn = self.lcao.wfs.bd.who_has(n)
if self.lcao.wfs.bd.rank == band_rank:
if not n in rng:
f_un[0][myn] = 0.0
n_sG = self.lcao.wfs.gd.zeros(1)
self.lcao.wfs.add_to_density_from_k_point_with_occupation(
n_sG, self.lcao.wfs.kpt_u[0], f_un[0])
self.lcao.wfs.kptband_comm.sum(n_sG)
D_asp = {}
for a in self.lcao.density.D_asp:
ni = self.lcao.density.setups[a].ni
D_asp[a] = np.zeros((1, ni * (ni + 1) // 2))
self.lcao.wfs.calculate_atomic_density_matrices_with_occupation(
D_asp, f_un)
Q_aL = {}
for a, D_sp in D_asp.items():
Q_aL[a] = np.dot(D_sp.sum(0),
self.lcao.density.setups[a].Delta_pL)
self.ghat.add(n_sG, Q_aL)
n_sg = self.lcao.wfs.gd.collect(n_sG, broadcast=False)
if world.rank == 0:
f = open(self.filename + '.' + str(rid) + '.density', 'a+')
#n_sg.astype(np.float32).tofile(f)
#print "max", np.max(n_sg), np.min(n_sg)
n_sg.tofile(f)
f.close()
s = n_sg.shape
f = open(self.filename + '.info', 'w')
print(s[0], s[1], s[2], file=f)
f.close()
def set_setups(self, setups):
self.pt = LFC(self.gd, [setup.pt_j for setup in setups],
self.kd,
dtype=self.dtype,
forces=True)
FDPWWaveFunctions.set_setups(self, setups)
def ibz2bz(self, atoms):
"""Transform wave functions in IBZ to the full BZ."""
assert self.kd.comm.size == 1
# New k-point descriptor for full BZ:
kd = KPointDescriptor(self.kd.bzk_kc, nspins=self.nspins)
kd.set_communicator(serial_comm)
self.pt = LFC(self.gd, [setup.pt_j for setup in self.setups],
kd,
dtype=self.dtype)
self.pt.set_positions(atoms.get_scaled_positions())
self.initialize_wave_functions_from_restart_file()
weight = 2.0 / kd.nspins / kd.nbzkpts
# Build new list of k-points:
kpt_u = []
for s in range(self.nspins):
for k in range(kd.nbzkpts):
# Index of symmetry related point in the IBZ
ik = self.kd.bz2ibz_k[k]
r, u = self.kd.get_rank_and_index(s, ik)
assert r == 0
kpt = self.mykpts[u]
phase_cd = np.exp(2j * np.pi * self.gd.sdisp_cd *
kd.bzk_kc[k, :, np.newaxis])
# New k-point:
kpt2 = KPoint(weight, s, k, k, phase_cd)
kpt2.f_n = kpt.f_n / kpt.weight / kd.nbzkpts * 2 / self.nspins
kpt2.eps_n = kpt.eps_n.copy()
# Transform wave functions using symmetry operation:
Psit_nG = self.gd.collect(kpt.psit_nG)
if Psit_nG is not None:
Psit_nG = Psit_nG.copy()
for Psit_G in Psit_nG:
Psit_G[:] = self.kd.transform_wave_function(Psit_G, k)
kpt2.psit = UniformGridWaveFunctions(self.bd.nbands,
self.gd,
self.dtype,
kpt=k,
dist=(self.bd.comm,
self.bd.comm.size),
spin=kpt.s,
collinear=True)
self.gd.distribute(Psit_nG, kpt2.psit_nG)
# Calculate PAW projections:
nproj_a = [setup.ni for setup in self.setups]
kpt2.projections = Projections(self.bd.nbands,
nproj_a,
kpt.projections.atom_partition,
self.bd.comm,
collinear=True,
spin=s,
dtype=self.dtype)
kpt2.psit.matrix_elements(self.pt, out=kpt2.projections)
kpt_u.append(kpt2)
self.kd = kd
self.mykpts = kpt_u
def get_pseudo_partial_waves(self):
phit_aj = [
setup.get_partial_waves_for_atomic_orbitals()
for setup in self.setups
]
return LFC(self.gd, phit_aj, kd=self.kd, cut=True, dtype=self.dtype)
kd = KPointDescriptor(kpts)
spos_ac = np.array([(0.15, 0.5, 0.95)])
pd = PWDescriptor(45, gd, complex, kd)
eikr = np.ascontiguousarray(
np.exp(2j * np.pi * np.dot(np.indices(gd.N_c).T, (kpts / gd.N_c).T).T)[0])
from gpaw.fftw import FFTPlan
print(FFTPlan)
for l in range(3):
print(l)
s = Spline(l, rc, 2 * x**1.5 / np.pi * np.exp(-x * r**2))
lfc1 = LFC(gd, [[s]], kd, dtype=complex)
lfc2 = PWLFC([[s]], pd)
c_axi = {0: np.zeros((1, 2 * l + 1), complex)}
c_axi[0][0, 0] = 1.9 - 4.5j
c_axiv = {0: np.zeros((1, 2 * l + 1, 3), complex)}
b1 = gd.zeros(1, dtype=complex)
b2 = pd.zeros(1, dtype=complex)
for lfc, b in [(lfc1, b1), (lfc2, b2)]:
lfc.set_positions(spos_ac)
lfc.add(b, c_axi, 0)
b2 = pd.ifft(b2[0]) * eikr
equal(abs(b2 - b1[0]).max(), 0, 0.001)
import numpy as np
from gpaw.lfc import LocalizedFunctionsCollection as LFC
from gpaw.grid_descriptor import GridDescriptor
from gpaw.spline import Spline
gd = GridDescriptor([20, 16, 16], [(4, 2, 0), (0, 4, 0), (0, 0, 4)])
spos_ac = np.array([[0.252, 0.15, 0.35], [0.503, 0.5, 0.5]])
s = Spline(l=0, rmax=2.0, f_g=np.array([1, 0.9, 0.1, 0.0]))
spline_aj = [[s], [s]]
c = LFC(gd, spline_aj)
c.set_positions(spos_ac)
c_ai = c.dict(zero=True)
if 1 in c_ai:
c_ai[1][0] = 2.0
psi = gd.zeros()
c.add(psi, c_ai)
d_avv = dict([(a, np.zeros((3, 3))) for a in c.my_atom_indices])
c.second_derivative(psi, d_avv)
if 0 in d_avv:
print d_avv[0]
eps = 0.000001
d_aiv = c.dict(derivative=True)
pos_av = np.dot(spos_ac, gd.cell_cv)
for v in range(3):
pos_av[0, v] += eps
c.set_positions(np.dot(pos_av, gd.icell_cv.T))
c.derivative(psi, d_aiv)
if 0 in d_aiv:
d0_v = d_aiv[0][0].copy()
