0:
return
Q_G = np.empty(self.pd.ngmax, np.int32)
for r in range(self.kd.comm.size):
for q, ks in enumerate(self.kd.get_indices(r)):
s, k = divmod(ks, self.kd.nibzkpts)
ng = self.ng_k[k]
if s == 1:
return
if r == self.kd.comm.rank:
Q_G[:ng] = self.pd.Q_qG[q]
if r > 0:
self.kd.comm.send(Q_G, 0)
if self.kd.comm.rank == 0:
if r > 0:
self.kd.comm.receive(Q_G, r)
Q_G[ng:] = -1
writer.fill(Q_G, k)
def read(self, reader, hdf5):
assert reader['version'] >= 3
for kpt in self.kpt_u:
if kpt.s == 0:
Q_G = reader.get('PlaneWaveIndices', kpt.k)
ng = self.ng_k[kpt.k]
assert (Q_G[:ng] == self.pd.Q_qG[kpt.q]).all()
assert (Q_G[ng:] == -1).all()
assert not hdf5
if self.bd.comm.size == 1:
for kpt in self.kpt_u:
ng = self.ng_k[kpt.k]
kpt.psit_nG = reader.get_reference('PseudoWaveFunctions',
(kpt.s, kpt.k),
length=ng)
return
for kpt in self.kpt_u:
kpt.psit_nG = self.empty(self.bd.mynbands, q=kpt.q)
ng = self.ng_k[kpt.k]
for myn, psit_G in enumerate(kpt.psit_nG):
n = self.bd.global_index(myn)
psit_G[:] = reader.get('PseudoWaveFunctions',
kpt.s, kpt.k, n)[..., :ng]
def hs(self, ham, q=-1, s=0, md=None):
npw = len(self.pd.Q_qG[q])
N = self.pd.tmp_R.size
if md is None:
H_GG = np.zeros((npw, npw), complex)
S_GG = np.zeros((npw, npw), complex)
G1 = 0
G2 = npw
else:
H_GG = md.zeros(dtype=complex)
S_GG = md.zeros(dtype=complex)
G1, G2 = next(md.my_blocks(S_GG))[:2]
H_GG.ravel()[G1::npw + 1] = (0.5 * self.pd.gd.dv / N *
self.pd.G2_qG[q][G1:G2])
for G in range(G1, G2):
x_G = self.pd.zeros(q=q)
x_G[G] = 1.0
H_GG[G - G1] += (self.pd.gd.dv / N *
self.pd.fft(ham.vt_sG[s] *
self.pd.ifft(x_G, q), q))
S_GG.ravel()[G1::npw + 1] = self.pd.gd.dv / N
f_IG = self.pt.expand(q)
nI = len(f_IG)
dH_II = np.zeros((nI, nI))
dS_II = np.zeros((nI, nI))
I1 = 0
for a in self.pt.my_atom_indices:
dH_ii = unpack(ham.dH_asp[a][s])
dS_ii = self.setups[a].dO_ii
I2 = I1 + len(dS_ii)
dH_II[I1:I2, I1:I2] = dH_ii / N**2
dS_II[I1:I2, I1:I2] = dS_ii / N**2
I1 = I2
H_GG += np.dot(f_IG.T[G1:G2].conj(), np.dot(dH_II, f_IG))
S_GG += np.dot(f_IG.T[G1:G2].conj(), np.dot(dS_II, f_IG))
return H_GG, S_GG
@timer('Full diag')
def diagonalize_full_hamiltonian(self, ham, atoms, occupations, txt,
nbands=None, scalapack=None,
expert=False):
assert self.dtype == complex
if nbands is None:
nbands = self.pd.ngmin // self.bd.comm.size * self.bd.comm.size
else:
assert nbands <= self.pd.ngmin
if expert:
iu = nbands
else:
iu = None
self.bd = bd = BandDescriptor(nbands, self.bd.comm)
p = functools.partial(print, file=txt)
p('Diagonalizing full Hamiltonian ({0} lowest bands)'.format(nbands))
p('Matrix size (min, max): {0}, {1}'.format(self.pd.ngmin,
self.pd.ngmax))
mem = 3 * self.pd.ngmax**2 * 16 / bd.comm.size / 1024**2
p('Approximate memory usage per core: {0:.3f} MB'.format(mem))
if bd.comm.size > 1:
if isinstance(scalapack, (list, tuple)):
nprow, npcol, b = scalapack
else:
nprow = int(round(bd.comm.size**0.5))
while bd.comm.size % nprow != 0:
nprow -= 1
npcol = bd.comm.size // nprow
b = 64
p('ScaLapack grid: {0}x{1},'.format(nprow, npcol),
'block-size:', b)
bg = BlacsGrid(bd.comm, bd.comm.size, 1)
bg2 = BlacsGrid(bd.comm, nprow, npcol)
scalapack = True
else:
nprow = npcol = 1
scalapack = False
self.pt.set_positions(atoms.get_scaled_positions())
self.kpt_u[0].P_ani = None
self.allocate_arrays_for_projections(self.pt.my_atom_indices)
myslice = bd.get_slice()
pb = ProgressBar(txt)
nkpt = len(self.kpt_u)
for u, kpt in enumerate(self.kpt_u):
pb.update(u / nkpt)
npw = len(self.pd.Q_qG[kpt.q])
if scalapack:
mynpw = -(-npw // bd.comm.size)
md = BlacsDescriptor(bg, npw, npw, mynpw, npw)
md2 = BlacsDescriptor(bg2, npw, npw, b, b)
else:
md = md2 = MatrixDescriptor(npw, npw)
with self.timer('Build H and S'):
H_GG, S_GG = self.hs(ham, kpt.q, kpt.s, md)
if scalapack:
r = Redistributor(bd.comm, md, md2)
H_GG = r.redistribute(H_GG)
S_GG = r.redistribute(S_GG)
psit_nG = md2.empty(dtype=complex)
eps_n = np.empty(npw)
with self.timer('Diagonalize'):
if not scalapack:
md2.general_diagonalize_dc(H_GG, S_GG, psit_nG, eps_n,
iu=iu)
else:
md2.general_diagonalize_dc(H_GG, S_GG, psit_nG, eps_n)
del H_GG, S_GG
kpt.eps_n = eps_n[myslice].copy()
if scalapack:
md3 = BlacsDescriptor(bg, npw, npw, bd.mynbands, npw)
r = Redistributor(bd.comm, md2, md3)
psit_nG = r.redistribute(psit_nG)
kpt.psit_nG = psit_nG[:bd.mynbands].copy()
del psit_nG
with self.timer('Projections'):
self.pt.integrate(kpt.psit_nG, kpt.P_ani, kpt.q)
kpt.f_n = None
pb.finish()
occupations.calculate(self)
def initialize_from_lcao_coefficients(self, basis_functions, mynbands):
N_c = self.gd.N_c
psit_nR = self.gd.empty(mynbands, self.dtype)
for kpt in self.kpt_u:
if self.kd.gamma:
emikr_R = 1.0
else:
k_c = self.kd.ibzk_kc[kpt.k]
emikr_R = np.exp(-2j * pi *
np.dot(np.indices(N_c).T, k_c / N_c).T)
psit_nR[:] = 0.0
basis_functions.lcao_to_grid(kpt.C_nM, psit_nR, kpt.q)
kpt.C_nM = None
kpt.psit_nG = self.pd.empty(self.bd.mynbands, q=kpt.q)
for n in range(mynbands):
kpt.psit_nG[n] = self.pd.fft(psit_nR[n] * emikr_R, kpt.q)
def random_wave_functions(self, mynao):
rs = np.random.RandomState(self.world.rank)
for kpt in self.kpt_u:
psit_nG = kpt.psit_nG[mynao:]
weight_G = 1.0 / (1.0 + self.pd.G2_qG[kpt.q])
psit_nG.real = rs.uniform(-1, 1, psit_nG.shape) * weight_G
psit_nG.imag = rs.uniform(-1, 1, psit_nG.shape) * weight_G
def estimate_memory(self, mem):
FDPWWaveFunctions.estimate_memory(self, mem)
self.pd.estimate_memory(mem.subnode('PW-descriptor'))
def get_kinetic_stress(self):
sigma_vv = np.zeros((3, 3), dtype=complex)
pd = self.pd
dOmega = pd.gd.dv / pd.gd.N_c.prod()
if pd.dtype == float:
dOmega *= 2
K_qv = self.pd.K_qv
for kpt in self.kpt_u:
G_Gv = pd.get_reciprocal_vectors(q=kpt.q, add_q=False)
psit2_G = 0.0
for n, f in enumerate(kpt.f_n):
psit2_G += f * np.abs(kpt.psit_nG[n])**2
for alpha in range(3):
Ga_G = G_Gv[:, alpha] + K_qv[kpt.q, alpha]
for beta in range(3):
Gb_G = G_Gv[:, beta] + K_qv[kpt.q, beta]
sigma_vv[alpha, beta] += (psit2_G * Ga_G * Gb_G).sum()
sigma_vv *= -dOmega
self.bd.comm.sum(sigma_vv)
self.kd.comm.sum(sigma_vv)
return sigma_vv
def ft(spline):
l = spline.get_angular_momentum_number()
rc = 50.0
N = 2**10
assert spline.get_cutoff() <= rc
dr = rc / N
r_r = np.arange(N) * dr
dk = pi / 2 / rc
k_q = np.arange(2 * N) * dk
f_r = spline.map(r_r) * (4 * pi)
f_q = fbt(l, f_r, r_r, k_q)
f_q[1:] /= k_q[1:]**(2 * l + 1)
f_q[0] = (np.dot(f_r, r_r**(2 + 2 * l)) *
dr * 2**l * fac(l) / fac(2 * l + 1))
return Spline(l, k_q[-1], f_q)
class PWLFC(BaseLFC):
def __init__(self, spline_aj, pd, blocksize=5000):
"""Reciprocal-space plane-wave localized function collection.
spline_aj: list of list of spline objects
Splines.
pd: PWDescriptor
Plane-wave descriptor object.
blocksize: int
Block-size to use when looping over G-vectors. Default is to do
all G-vectors in one big block."""
self.pd = pd
self.spline_aj = spline_aj
self.dtype = pd.dtype
self.initialized = False
# These will be filled in later:
self.lf_aj = []
self.Y_qLG = []
if blocksize is not None:
if pd.ngmax <= blocksize:
# No need to block G-vectors
blocksize = None
self.blocksize = blocksize
# These are set later in set_potitions():
self.eikR_qa = None
self.my_atom_indices = None
self.indices = None
self.pos_av = None
self.nI = None
def initialize(self):
if self.initialized:
return
cache = {}
lmax = -1
# Fourier transform radial functions:
for a, spline_j in enumerate(self.spline_aj):
self.lf_aj.append([])
for spline in spline_j:
l = spline.get_angular_momentum_number()
if spline not in cache:
f = ft(spline)
f_qG = []
for G2_G in self.pd.G2_qG:
G_G = G2_G**0.5
f_qG.append(f.map(G_G))
cache[spline] = f_qG
else:
f_qG = cache[spline]
self.lf_aj[a].append((l, f_qG))
lmax = max(lmax, l)
# Spherical harmonics:
for q, K_v in enumerate(self.pd.K_qv):
G_Gv = self.pd.get_reciprocal_vectors(q=q)
Y_LG = np.empty(((lmax + 1)**2, len(G_Gv)))
for L in range((lmax + 1)**2):
Y_LG[L] = Y(L, *G_Gv.T)
self.Y_qLG.append(Y_LG)
self.initialized = True
def estimate_memory(self, mem):
splines = set()
lmax = -1
for spline_j in self.spline_aj:
for spline in spline_j:
splines.add(spline)
l = spline.get_angular_momentum_number()
lmax = max(lmax, l)
nbytes = ((len(splines) + (lmax + 1)**2) *
sum(G2_G.nbytes for G2_G in self.pd.G2_qG))
mem.subnode('Arrays', nbytes)
def get_function_count(self, a):
return sum(2 * l + 1 for l, f_qG in self.lf_aj[a])
def __iter__(self):
I1 = 0
for a in self.my_atom_indices:
j = 0
i1 = 0
for l, f_qG in self.lf_aj[a]:
i2 = i1 + 2 * l + 1
I2 = I1 + 2 * l + 1
yield a, j, i1, i2, I1, I2
i1 = i2
I1 = I2
j += 1
def set_positions(self, spos_ac):
self.initialize()
kd = self.pd.kd
if kd is None or kd.gamma:
self.eikR_qa = np.ones((1, len(spos_ac)))
else:
self.eikR_qa = np.exp(2j * pi * np.dot(kd.ibzk_qc, spos_ac.T))
self.pos_av = np.dot(spos_ac, self.pd.gd.cell_cv)
self.my_atom_indices = np.arange(len(spos_ac))
self.indices = []
I1 = 0
for a in self.my_atom_indices:
I2 = I1 + self.get_function_count(a)
self.indices.append((a, I1, I2))
I1 = I2
self.nI = I1
def expand(self, q=-1, G1=0, G2=None):
if G2 is None:
G2 = self.Y_qLG[q].shape[1]
f_IG = np.empty((self.nI, G2 - G1), complex)
emiGR_Ga = np.exp(-1j * np.dot(self.pd.G_Qv[self.pd.Q_qG[q][G1:G2]],
self.pos_av.T))
for a, j, i1, i2, I1, I2 in self:
l, f_qG = self.lf_aj[a][j]
f_IG[I1:I2] = (emiGR_Ga[:, a] * f_qG[q][G1:G2] * (-1.0j)**l *
self.Y_qLG[q][l**2:(l + 1)**2, G1:G2])
return f_IG
def block(self, q=-1):
nG = self.Y_qLG[q].shape[1]
if self.blocksize:
G1 = 0
while G1 < nG:
G2 = min(G1 + self.blocksize, nG)
yield G1, G2
G1 = G2
else:
yield 0, nG
def add(self, a_xG, c_axi=1.0, q=-1, f0_IG=None):
if isinstance(c_axi, float):
assert q == -1, a_xG.dims == 1
a_xG += (c_axi / self.pd.gd.dv) * self.expand(-1).sum(0)
return
c_xI = np.empty(a_xG.shape[:-1] + (self.nI,), self.pd.dtype)
for a, I1, I2 in self.indices:
c_xI[..., I1:I2] = c_axi[a] * self.eikR_qa[q][a].conj()
c_xI = c_xI.reshape((np.prod(c_xI.shape[:-1], dtype=int), self.nI))
a_xG = a_xG.reshape((-1, a_xG.shape[-1])).view(self.pd.dtype)
for G1, G2 in self.block(q):
if f0_IG is None:
f_IG = self.expand(q, G1, G2)
else:
f_IG = f0_IG
if self.pd.dtype == float:
f_IG = f_IG.view(float)
G1 *= 2
G2 *= 2
gemm(1.0 / self.pd.gd.dv, f_IG, c_xI, 1.0, a_xG[:, G1:G2])
def integrate(self, a_xG, c_axi=None, q=-1):
c_xI = np.zeros(a_xG.shape[:-1] + (self.nI,), self.pd.dtype)
b_xI = c_xI.reshape((np.prod(c_xI.shape[:-1], dtype=int), self.nI))
a_xG = a_xG.reshape((-1, a_xG.shape[-1]))
alpha = 1.0 / self.pd.gd.N_c.prod()
if self.pd.dtype == float:
alpha *= 2
a_xG = a_xG.view(float)
if c_axi is None:
c_axi = self.dict(a_xG.shape[:-1])
x = 0.0
for G1, G2 in self.block(q):
f_IG = self.expand(q, G1, G2)
if self.pd.dtype == float:
if G1 == 0:
f_IG[:, 0] *= 0.5
f_IG = f_IG.view(float)
G1 *= 2
G2 *= 2
gemm(alpha, f_IG, a_xG[:, G1:G2], x, b_xI, 'c')
x = 1.0
for a, I1, I2 in self.indices:
c_axi[a][:] = self.eikR_qa[q][a] * c_xI[..., I1:I2]
return c_axi
def derivative(self, a_xG, c_axiv, q=-1):
c_vxI = np.zeros((3,) + a_xG.shape[:-1] + (self.nI,), self.pd.dtype)
b_vxI = c_vxI.reshape((3, np.prod(c_vxI.shape[1:-1], dtype=int),
self.nI))
a_xG = a_xG.reshape((-1, a_xG.shape[-1])).view(self.pd.dtype)
alpha = 1.0 / self.pd.gd.N_c.prod()
K_v = self.pd.K_qv[q]
x = 0.0
for G1, G2 in self.block(q):
f_IG = self.expand(q, G1, G2)
G_Gv = self.pd.G_Qv[self.pd.Q_qG[q][G1:G2]]
if self.pd.dtype == float:
for v in range(3):
gemm(2 * alpha,
(f_IG * 1.0j * G_Gv[:, v]).view(float),
a_xG[:, 2 * G1:2 * G2],
x, b_vxI[v], 'c')
else:
for v in range(3):
gemm(-alpha,
f_IG * (G_Gv[:, v] + K_v[v]),
a_xG[:, G1:G2],
x, b_vxI[v], 'c')
x = 1.0
for v in range(3):
if self.pd.dtype == float:
for a, I1, I2 in self.indices:
c_axiv[a][..., v] = c_vxI[v, ..., I1:I2]
else:
for a, I1, I2 in self.indices:
c_axiv[a][..., v] = (1.0j * self.eikR_qa[q][a] *
c_vxI[v, ..., I1:I2])
def stress_tensor_contribution(self, a_xG, c_axi=1.0, q=-1):
cache = {}
for a, j, i1, i2, I1, I2 in self:
spline = self.spline_aj[a][j]
if spline not in cache:
s = ft(spline)
G_G = self.pd.G2_qG[q]**0.5
f_G = []
dfdGoG_G = []
for G in G_G:
f, dfdG = s.get_value_and_derivative(G)
if G < 1e-10:
G = 1.0
f_G.append(f)
dfdGoG_G.append(dfdG / G)
f_G = np.array(f_G)
dfdGoG_G = np.array(dfdGoG_G)
cache[spline] = (f_G, dfdGoG_G)
else:
f_G, dfdGoG_G = cache[spline]
if isinstance(c_axi, float):
c_axi = dict((a, c_axi) for a in range(len(self.pos_av)))
G0_Gv = self.pd.get_reciprocal_vectors(q=q)
stress_vv = np.zeros((3, 3))
for G1, G2 in self.block(q):
G_Gv = G0_Gv[G1:G2]
aa_xG = a_xG[..., G1:G2]
for v1 in range(3):
for v2 in range(3):
stress_vv[v1, v2] += self._stress_tensor_contribution(
v1, v2, cache, G1, G2, G_Gv, aa_xG, c_axi, q)
return stress_vv
def _stress_tensor_contribution(self, v1, v2, cache, G1, G2,
G_Gv, a_xG, c_axi, q):
f_IG = np.empty((self.nI, G2 - G1), complex)
K_v = self.pd.K_qv[q]
for a, j, i1, i2, I1, I2 in self:
l = self.lf_aj[a][j][0]
spline = self.spline_aj[a][j]
f_G, dfdGoG_G = cache[spline]
emiGR_G = np.exp(-1j * np.dot(G_Gv, self.pos_av[a]))
f_IG[I1:I2] = (emiGR_G * (-1.0j)**l *
np.exp(1j * np.dot(K_v, self.pos_av[a])) * (
dfdGoG_G[G1:G2] * G_Gv[:, v1] * G_Gv[:, v2] *
self.Y_qLG[q][l**2:(l + 1)**2, G1:G2] +
f_G[G1:G2] * G_Gv[:, v1] *
[nablarlYL(L, G_Gv.T)[v2]
for L in range(l**2, (l + 1)**2)]))
c_xI = np.zeros(a_xG.shape[:-1] + (self.nI,), self.pd.dtype)
b_xI = c_xI.reshape((np.prod(c_xI.shape[:-1], dtype=int), self.nI))
a_xG = a_xG.reshape((-1, a_xG.shape[-1]))
alpha = 1.0 / self.pd.gd.N_c.prod()
if self.pd.dtype == float:
alpha *= 2
if G1 == 0:
f_IG[:, 0] *= 0.5
f_IG = f_IG.view(float)
a_xG = a_xG.copy().view(float)
gemm(alpha, f_IG, a_xG, 0.0, b_xI, 'c')
stress = 0.0
for a, I1, I2 in self.indices:
stress -= self.eikR_qa[q][a] * (c_axi[a] * c_xI[..., I1:I2]).sum()
return stress.real
class PseudoCoreKineticEnergyDensityLFC(PWLFC):
def add(self, tauct_R):
tauct_R += self.pd.ifft(1.0 / self.pd.gd.dv * self.expand(-1).sum(0))
def derivative(self, dedtaut_R, dF_aiv):
PWLFC.derivative(self, self.pd.fft(dedtaut_R), dF_aiv)
class ReciprocalSpaceDensity(Density):
def __init__(self, gd, finegd, nspins, charge, collinear=True):
Density.__init__(self, gd, finegd, nspins, charge, collinear)
self.ecut2 = 0.5 * pi**2 / (self.gd.h_cv**2).sum(1).max() * 0.9999
self.pd2 = PWDescriptor(self.ecut2, self.gd)
self.ecut3 = 0.5 * pi**2 / (self.finegd.h_cv**2).sum(1).max() * 0.9999
self.pd3 = PWDescriptor(self.ecut3, self.finegd)
self.G3_G = self.pd2.map(self.pd3)
def initialize(self, setups, timer, magmom_av, hund):
Density.initialize(self, setups, timer, magmom_av, hund)
spline_aj = []
for setup in setups:
if setup.nct is None:
spline_aj.append([])
else:
spline_aj.append([setup.nct])
self.nct = PWLFC(spline_aj, self.pd2)
self.ghat = PWLFC([setup.ghat_l for setup in setups], self.pd3)
def set_positions(self, spos_ac, atom_partition):
Density.set_positions(self, spos_ac, atom_partition)
self.nct_q = self.pd2.zeros()
self.nct.add(self.nct_q, 1.0 / self.nspins)
self.nct_G = self.pd2.ifft(self.nct_q)
def interpolate_pseudo_density(self, comp_charge=None):
"""Interpolate pseudo density to fine grid."""
if comp_charge is None:
comp_charge = self.calculate_multipole_moments()
if self.nt_sg is None:
self.nt_sg = self.finegd.empty(self.nspins * self.ncomp**2)
self.nt_sQ = self.pd2.empty(self.nspins * self.ncomp**2)
for nt_G, nt_Q, nt_g in zip(self.nt_sG, self.nt_sQ, self.nt_sg):
nt_g[:], nt_Q[:] = self.pd2.interpolate(nt_G, self.pd3)
def interpolate(self, in_xR, out_xR=None):
"""Interpolate array(s)."""
if out_xR is None:
out_xR = self.finegd.empty(in_xR.shape[:-3])
a_xR = in_xR.reshape((-1,) + in_xR.shape[-3:])
b_xR = out_xR.reshape((-1,) + out_xR.shape[-3:])
for in_R, out_R in zip(a_xR, b_xR):
out_R[:] = self.pd2.interpolate(in_R, self.pd3)[0]
return out_xR
def calculate_pseudo_charge(self):
self.nt_Q = self.nt_sQ[:self.nspins].sum(axis=0)
self.rhot_q = self.pd3.zeros()
self.rhot_q[self.G3_G] = self.nt_Q * 8
self.ghat.add(self.rhot_q, self.Q_aL)
self.rhot_q[0] = 0.0
def get_pseudo_core_kinetic_energy_density_lfc(self):
return PseudoCoreKineticEnergyDensityLFC(
[[setup.tauct] for setup in self.setups], self.pd2)
def calculate_dipole_moment(self):
if np.__version__ < '1.6.0':
raise NotImplementedError
pd = self.pd3
N_c = pd.tmp_Q.shape
m0_q, m1_q, m2_q = [i_G == 0
for i_G in np.unravel_index(pd.Q_qG[0], N_c)]
rhot_q = self.rhot_q.imag
rhot_cs = [rhot_q[m1_q & m2_q],
rhot_q[m0_q & m2_q],
rhot_q[m0_q & m1_q]]
d_c = [np.dot(rhot_s[1:], 1.0 / np.arange(1, len(rhot_s)))
for rhot_s in rhot_cs]
return -np.dot(d_c, pd.gd.cell_cv) / pi * pd.gd.dv
class ReciprocalSpaceHamiltonian(Hamiltonian):
def __init__(self, gd, finegd, pd2, pd3, nspins, setups, timer, xc,
world, kptband_comm, vext=None, collinear=True):
Hamiltonian.__init__(self, gd, finegd, nspins, setups, timer, xc,
world, kptband_comm, vext, collinear)
self.vbar = PWLFC([[setup.vbar] for setup in setups], pd2)
self.pd2 = pd2
self.pd3 = pd3
class PS:
def initialize(self):
pass
def get_stencil(self):
return '????'
def estimate_memory(self, mem):
pass
self.poisson = PS()
self.npoisson = 0
def summary(self, fd):
Hamiltonian.summary(self, fd)
fd.write('Interpolation: FFT\n')
fd.write('Poisson solver: FFT\n')
def set_positions(self, spos_ac, atom_partition):
Hamiltonian.set_positions(self, spos_ac, atom_partition)
self.vbar_Q = self.pd2.zeros()
self.vbar.add(self.vbar_Q)
def update_pseudo_potential(self, density):
self.ebar = self.pd2.integrate(self.vbar_Q, density.nt_sQ.sum(0))
self.timer.start('Poisson')
self.vHt_q = 4 * pi * density.rhot_q
self.vHt_q[1:] /= self.pd3.G2_qG[0][1:]
self.epot = 0.5 * self.pd3.integrate(self.vHt_q, density.rhot_q)
self.timer.stop('Poisson')
self.vt_Q = self.vbar_Q + self.vHt_q[density.G3_G] / 8
self.vt_sG[:] = self.pd2.ifft(self.vt_Q)
self.timer.start('XC 3D grid')
vxct_sg = self.finegd.zeros(self.nspins)
self.exc = self.xc.calculate(self.finegd, density.nt_sg, vxct_sg)
for vt_G, vxct_g in zip(self.vt_sG, vxct_sg):
vxc_G, vxc_Q = self.pd3.restrict(vxct_g, self.pd2)
vt_G += vxc_G
self.vt_Q += vxc_Q / self.nspins
self.timer.stop('XC 3D grid')
eext = 0.0
return self.epot, self.ebar, eext, self.exc
def calculate_atomic_hamiltonians(self, density):
W_aL = {}
for a in density.D_asp:
W_aL[a] = np.empty((self.setups[a].lmax + 1)**2)
density.ghat.integrate(self.vHt_q, W_aL)
return W_aL
def calculate_kinetic_energy(self, density):
ekin = 0.0
for vt_G, nt_G in zip(self.vt_sG, density.nt_sG):
ekin -= self.gd.integrate(vt_G, nt_G)
ekin += self.gd.integrate(self.vt_sG, density.nct_G).sum()
return ekin
def restrict(self, in_xR, out_xR=None):
"""Restrict array."""
if out_xR is None:
out_xR = self.gd.empty(in_xR.shape[:-3])
a_xR = in_xR.reshape((-1,) + in_xR.shape[-3:])
b_xR = out_xR.reshape((-1,) + out_xR.shape[-3:])
for in_R, out_R in zip(a_xR, b_xR):
out_R[:] = self.pd3.restrict(in_R, self.pd2)[0]
return out_xR
def calculate_forces2(self, dens, ghat_aLv, nct_av, vbar_av):
dens.ghat.derivative(self.vHt_q, ghat_aLv)
dens.nct.derivative(self.vt_Q, nct_av)
self.vbar.derivative(dens.nt_sQ.sum(0), vbar_av)
gpaw-0.11.0.13004/gpaw/wavefunctions/lcao.py 0000664 0001750 0001750 00000116240 12553643470 020601 0 ustar jensj jensj 0000000 0000000 import numpy as np
from gpaw.lfc import BasisFunctions
from gpaw.utilities import unpack
from gpaw.utilities.tools import tri2full
from gpaw import debug
from gpaw.lcao.overlap import NewTwoCenterIntegrals as NewTCI
from gpaw.utilities.blas import gemm, gemmdot
from gpaw.wavefunctions.base import WaveFunctions
from gpaw.lcao.atomic_correction import get_atomic_correction
class LCAO:
name = 'lcao'
def __init__(self, atomic_correction=None):
self.atomic_correction = atomic_correction
def __call__(self, collinear, *args, **kwargs):
if collinear:
cls = LCAOWaveFunctions
else:
from gpaw.xc.noncollinear import \
NonCollinearLCAOWaveFunctions
cls = NonCollinearLCAOWaveFunctions
return cls(*args, atomic_correction=self.atomic_correction,
**kwargs)
# replace by class to make data structure perhaps a bit less confusing
def get_r_and_offsets(nl, spos_ac, cell_cv):
r_and_offset_aao = {}
def add(a1, a2, R_c, offset):
if not (a1, a2) in r_and_offset_aao:
r_and_offset_aao[(a1, a2)] = []
r_and_offset_aao[(a1, a2)].append((R_c, offset))
for a1, spos1_c in enumerate(spos_ac):
a2_a, offsets = nl.get_neighbors(a1)
for a2, offset in zip(a2_a, offsets):
spos2_c = spos_ac[a2] + offset
R_c = np.dot(spos2_c - spos1_c, cell_cv)
add(a1, a2, R_c, offset)
if a1 != a2 or offset.any():
add(a2, a1, -R_c, -offset)
return r_and_offset_aao
class LCAOWaveFunctions(WaveFunctions):
mode = 'lcao'
def __init__(self, ksl, gd, nvalence, setups, bd,
dtype, world, kd, kptband_comm, timer,
atomic_correction=None):
WaveFunctions.__init__(self, gd, nvalence, setups, bd,
dtype, world, kd, kptband_comm, timer)
self.ksl = ksl
self.S_qMM = None
self.T_qMM = None
self.P_aqMi = None
if atomic_correction is None:
if ksl.using_blacs:
atomic_correction = 'distributed'
else:
atomic_correction = 'dense'
if isinstance(atomic_correction, str):
atomic_correction = get_atomic_correction(atomic_correction)
self.atomic_correction = atomic_correction
self.timer.start('TCI: Evaluate splines')
self.tci = NewTCI(gd.cell_cv, gd.pbc_c, setups, kd.ibzk_qc, kd.gamma)
self.timer.stop('TCI: Evaluate splines')
self.basis_functions = BasisFunctions(gd,
[setup.phit_j
for setup in setups],
kd,
dtype=dtype,
cut=True)
def empty(self, n=(), global_array=False, realspace=False):
if realspace:
return self.gd.empty(n, self.dtype, global_array)
else:
if isinstance(n, int):
n = (n,)
nao = self.setups.nao
return np.empty(n + (nao,), self.dtype)
def summary(self, fd):
fd.write('Wave functions: LCAO\n')
fd.write(' Diagonalizer: %s\n' % self.ksl.get_description())
fd.write(' Atomic Correction: %s\n'
% self.atomic_correction.description)
fd.write(" Datatype: %s\n" % self.dtype.__name__)
def set_eigensolver(self, eigensolver):
WaveFunctions.set_eigensolver(self, eigensolver)
eigensolver.initialize(self.gd, self.dtype, self.setups.nao, self.ksl)
def set_positions(self, spos_ac, atom_partition=None):
self.timer.start('Basic WFS set positions')
WaveFunctions.set_positions(self, spos_ac, atom_partition)
self.timer.stop('Basic WFS set positions')
self.timer.start('Basis functions set positions')
self.basis_functions.set_positions(spos_ac)
self.timer.stop('Basis functions set positions')
if self.ksl is not None:
self.basis_functions.set_matrix_distribution(self.ksl.Mstart,
self.ksl.Mstop)
nq = len(self.kd.ibzk_qc)
nao = self.setups.nao
mynbands = self.bd.mynbands
Mstop = self.ksl.Mstop
Mstart = self.ksl.Mstart
mynao = Mstop - Mstart
if self.ksl.using_blacs: # XXX
# S and T have been distributed to a layout with blacs, so
# discard them to force reallocation from scratch.
#
# TODO: evaluate S and T when they *are* distributed, thus saving
# memory and avoiding this problem
self.S_qMM = None
self.T_qMM = None
S_qMM = self.S_qMM
T_qMM = self.T_qMM
if S_qMM is None: # XXX
# First time:
assert T_qMM is None
if self.ksl.using_blacs: # XXX
self.tci.set_matrix_distribution(Mstart, mynao)
S_qMM = np.empty((nq, mynao, nao), self.dtype)
T_qMM = np.empty((nq, mynao, nao), self.dtype)
for kpt in self.kpt_u:
if kpt.C_nM is None:
kpt.C_nM = np.empty((mynbands, nao), self.dtype)
self.P_aqMi = {}
for a in self.basis_functions.my_atom_indices:
ni = self.setups[a].ni
self.P_aqMi[a] = np.empty((nq, nao, ni), self.dtype)
self.timer.start('TCI: Calculate S, T, P')
# Calculate lower triangle of S and T matrices:
self.tci.calculate(spos_ac, S_qMM, T_qMM, self.P_aqMi)
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
if self.atomic_correction.name != 'dense':
from gpaw.lcao.newoverlap import newoverlap
self.P_neighbors_a, self.P_aaqim = newoverlap(self, spos_ac)
self.atomic_correction.gobble_data(self)
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
self.atomic_correction.add_overlap_correction(self, S_qMM)
self.timer.stop('TCI: Calculate S, T, P')
if self.atomic_correction.implements_distributed_projections():
my_atom_indices = self.atomic_correction.get_a_values()
else:
my_atom_indices = self.basis_functions.my_atom_indices
self.allocate_arrays_for_projections(my_atom_indices)
S_MM = None # allow garbage collection of old S_qMM after redist
S_qMM = self.ksl.distribute_overlap_matrix(S_qMM, root=-1)
T_qMM = self.ksl.distribute_overlap_matrix(T_qMM, root=-1)
for kpt in self.kpt_u:
q = kpt.q
kpt.S_MM = S_qMM[q]
kpt.T_MM = T_qMM[q]
if (debug and self.band_comm.size == 1 and self.gd.comm.rank == 0 and
nao > 0 and not self.ksl.using_blacs):
# S and T are summed only on comm master, so check only there
from numpy.linalg import eigvalsh
self.timer.start('Check positive definiteness')
for S_MM in S_qMM:
tri2full(S_MM, UL='L')
smin = eigvalsh(S_MM).real.min()
if smin < 0:
raise RuntimeError('Overlap matrix has negative '
'eigenvalue: %e' % smin)
self.timer.stop('Check positive definiteness')
self.positions_set = True
self.S_qMM = S_qMM
self.T_qMM = T_qMM
def initialize(self, density, hamiltonian, spos_ac):
self.timer.start('LCAO WFS Initialize')
if density.nt_sG is None:
if self.kpt_u[0].f_n is None or self.kpt_u[0].C_nM is None:
density.initialize_from_atomic_densities(self.basis_functions)
else:
# We have the info we need for a density matrix, so initialize
# from that instead of from scratch. This will be the case
# after set_positions() during a relaxation
density.initialize_from_wavefunctions(self)
# Initialize GLLB-potential from basis function orbitals
if hamiltonian.xc.type == 'GLLB':
hamiltonian.xc.initialize_from_atomic_orbitals(\
self.basis_functions)
else:
# After a restart, nt_sg doesn't exist yet, so we'll have to
# make sure it does. Of course, this should have been taken care
# of already by this time, so we should improve the code elsewhere
density.calculate_normalized_charges_and_mix()
#print "Updating hamiltonian in LCAO initialize wfs"
hamiltonian.update(density)
self.timer.stop('LCAO WFS Initialize')
def initialize_wave_functions_from_lcao(self):
"""
Fill the calc.wfs.kpt_[u].psit_nG arrays with usefull 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 band-parallel case!)
"""
#print('initialize_wave_functions_from_lcao')
bfs = self.basis_functions
for kpt in self.kpt_u:
#print("kpt: {0}".format(kpt))
kpt.psit_nG = self.gd.zeros(self.bd.nbands, self.dtype)
bfs.lcao_to_grid(kpt.C_nM, kpt.psit_nG[:self.bd.mynbands], kpt.q)
# kpt.C_nM = None
def initialize_wave_functions_from_restart_file(self):
"""Dummy function to ensure compatibility to fd mode"""
self.initialize_wave_functions_from_lcao()
def calculate_density_matrix(self, f_n, C_nM, rho_MM=None):
# ATLAS can't handle uninitialized output array:
#rho_MM.fill(42)
self.timer.start('Calculate density matrix')
rho_MM = self.ksl.calculate_density_matrix(f_n, C_nM, rho_MM)
self.timer.stop('Calculate density matrix')
return rho_MM
# ----------------------------
if 1:
# XXX Should not conjugate, but call gemm(..., 'c')
# Although that requires knowing C_Mn and not C_nM.
# that also conforms better to the usual conventions in literature
Cf_Mn = C_nM.T.conj() * f_n
self.timer.start('gemm')
gemm(1.0, C_nM, Cf_Mn, 0.0, rho_MM, 'n')
self.timer.stop('gemm')
self.timer.start('band comm sum')
self.bd.comm.sum(rho_MM)
self.timer.stop('band comm sum')
else:
# Alternative suggestion. Might be faster. Someone should test this
from gpaw.utilities.blas import r2k
C_Mn = C_nM.T.copy()
r2k(0.5, C_Mn, f_n * C_Mn, 0.0, rho_MM)
tri2full(rho_MM)
def calculate_atomic_density_matrices_with_occupation(self, D_asp, f_un):
ac = self.atomic_correction
if ac.implements_distributed_projections():
D2_asp = ac.redistribute(self, D_asp, type='asp', op='forth')
WaveFunctions.calculate_atomic_density_matrices_with_occupation(
self, D2_asp, f_un)
D3_asp = ac.redistribute(self, D2_asp, type='asp', op='back')
for a in D_asp:
D_asp[a][:] = D3_asp[a]
else:
WaveFunctions.calculate_atomic_density_matrices_with_occupation(
self, D_asp, f_un)
def calculate_density_matrix_delta(self, d_nn, C_nM, rho_MM=None):
# ATLAS can't handle uninitialized output array:
#rho_MM.fill(42)
self.timer.start('Calculate density matrix')
rho_MM = self.ksl.calculate_density_matrix_delta(d_nn, C_nM, rho_MM)
self.timer.stop('Calculate density matrix')
return rho_MM
def add_to_density_from_k_point_with_occupation(self, nt_sG, kpt, f_n):
"""Add contribution to pseudo electron-density. Do not use the standard
occupation numbers, but ones given with argument f_n."""
# Custom occupations are used in calculation of response potential
# with GLLB-potential
if kpt.rho_MM is None:
rho_MM = self.calculate_density_matrix(f_n, kpt.C_nM)
if hasattr(kpt, 'c_on'):
assert self.bd.comm.size == 1
d_nn = np.zeros((self.bd.mynbands, self.bd.mynbands),
dtype=kpt.C_nM.dtype)
for ne, c_n in zip(kpt.ne_o, kpt.c_on):
assert abs(c_n.imag).max() < 1e-14
d_nn += ne * np.outer(c_n.conj(), c_n).real
rho_MM += self.calculate_density_matrix_delta(d_nn, kpt.C_nM)
else:
rho_MM = kpt.rho_MM
self.timer.start('Construct density')
self.basis_functions.construct_density(rho_MM, nt_sG[kpt.s], kpt.q)
self.timer.stop('Construct density')
def add_to_kinetic_density_from_k_point(self, taut_G, kpt):
raise NotImplementedError('Kinetic density calculation for LCAO '
'wavefunctions is not implemented.')
def calculate_forces(self, hamiltonian, F_av):
self.timer.start('LCAO forces')
spos_ac = self.tci.atoms.get_scaled_positions() % 1.0
ksl = self.ksl
nao = ksl.nao
mynao = ksl.mynao
nq = len(self.kd.ibzk_qc)
dtype = self.dtype
tci = self.tci
gd = self.gd
bfs = self.basis_functions
Mstart = ksl.Mstart
Mstop = ksl.Mstop
from gpaw.kohnsham_layouts import BlacsOrbitalLayouts
isblacs = isinstance(ksl, BlacsOrbitalLayouts) # XXX
if not isblacs:
self.timer.start('TCI derivative')
dThetadR_qvMM = np.empty((nq, 3, mynao, nao), dtype)
dTdR_qvMM = np.empty((nq, 3, mynao, nao), dtype)
dPdR_aqvMi = {}
for a in self.basis_functions.my_atom_indices:
ni = self.setups[a].ni
dPdR_aqvMi[a] = np.empty((nq, 3, nao, ni), dtype)
tci.calculate_derivative(spos_ac, dThetadR_qvMM, dTdR_qvMM,
dPdR_aqvMi)
gd.comm.sum(dThetadR_qvMM)
gd.comm.sum(dTdR_qvMM)
self.timer.stop('TCI derivative')
my_atom_indices = bfs.my_atom_indices
atom_indices = bfs.atom_indices
def _slices(indices):
for a in indices:
M1 = bfs.M_a[a] - Mstart
M2 = M1 + self.setups[a].nao
if M2 > 0:
yield a, max(0, M1), M2
def slices():
return _slices(atom_indices)
def my_slices():
return _slices(my_atom_indices)
#
# ----- -----
# \ -1 \ *
# E = ) S H rho = ) c eps f c
# mu nu / mu x x z z nu / n mu n n n nu
# ----- -----
# x z n
#
# We use the transpose of that matrix. The first form is used
# if rho is given, otherwise the coefficients are used.
self.timer.start('Initial')
rhoT_uMM = []
ET_uMM = []
if not isblacs:
if self.kpt_u[0].rho_MM is None:
self.timer.start('Get density matrix')
for kpt in self.kpt_u:
rhoT_MM = ksl.get_transposed_density_matrix(kpt.f_n,
kpt.C_nM)
rhoT_uMM.append(rhoT_MM)
ET_MM = ksl.get_transposed_density_matrix(kpt.f_n
* kpt.eps_n,
kpt.C_nM)
ET_uMM.append(ET_MM)
if hasattr(kpt, 'c_on'):
# XXX does this work with BLACS/non-BLACS/etc.?
assert self.bd.comm.size == 1
d_nn = np.zeros((self.bd.mynbands, self.bd.mynbands),
dtype=kpt.C_nM.dtype)
for ne, c_n in zip(kpt.ne_o, kpt.c_on):
d_nn += ne * np.outer(c_n.conj(), c_n)
rhoT_MM += ksl.get_transposed_density_matrix_delta(\
d_nn, kpt.C_nM)
ET_MM += ksl.get_transposed_density_matrix_delta(\
d_nn * kpt.eps_n, kpt.C_nM)
self.timer.stop('Get density matrix')
else:
rhoT_uMM = []
ET_uMM = []
for kpt in self.kpt_u:
H_MM = self.eigensolver.calculate_hamiltonian_matrix(\
hamiltonian, self, kpt)
tri2full(H_MM)
S_MM = kpt.S_MM.copy()
tri2full(S_MM)
ET_MM = np.linalg.solve(S_MM, gemmdot(H_MM,
kpt.rho_MM)).T.copy()
del S_MM, H_MM
rhoT_MM = kpt.rho_MM.T.copy()
rhoT_uMM.append(rhoT_MM)
ET_uMM.append(ET_MM)
self.timer.stop('Initial')
if isblacs: # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
from gpaw.blacs import BlacsGrid, Redistributor
def get_density_matrix(f_n, C_nM, redistributor):
rho1_mm = ksl.calculate_blocked_density_matrix(f_n,
C_nM).conj()
rho_mm = redistributor.redistribute(rho1_mm)
return rho_mm
pcutoff_a = [max([pt.get_cutoff() for pt in setup.pt_j])
for setup in self.setups]
phicutoff_a = [max([phit.get_cutoff() for phit in setup.phit_j])
for setup in self.setups]
# XXX should probably use bdsize x gdsize instead
# That would be consistent with some existing grids
grid = BlacsGrid(ksl.block_comm, self.gd.comm.size,
self.bd.comm.size)
blocksize1 = -(-nao // grid.nprow)
blocksize2 = -(-nao // grid.npcol)
# XXX what are rows and columns actually?
desc = grid.new_descriptor(nao, nao, blocksize1, blocksize2)
rhoT_umm = []
ET_umm = []
redistributor = Redistributor(grid.comm, ksl.mmdescriptor, desc)
Fpot_av = np.zeros_like(F_av)
for u, kpt in enumerate(self.kpt_u):
self.timer.start('Get density matrix')
rhoT_mm = get_density_matrix(kpt.f_n, kpt.C_nM, redistributor)
rhoT_umm.append(rhoT_mm)
self.timer.stop('Get density matrix')
self.timer.start('Potential')
rhoT_mM = ksl.distribute_to_columns(rhoT_mm, desc)
vt_G = hamiltonian.vt_sG[kpt.s]
Fpot_av += bfs.calculate_force_contribution(vt_G, rhoT_mM,
kpt.q)
del rhoT_mM
self.timer.stop('Potential')
self.timer.start('Get density matrix')
for kpt in self.kpt_u:
ET_mm = get_density_matrix(kpt.f_n * kpt.eps_n, kpt.C_nM,
redistributor)
ET_umm.append(ET_mm)
self.timer.stop('Get density matrix')
M1start = blocksize1 * grid.myrow
M2start = blocksize2 * grid.mycol
M1stop = min(M1start + blocksize1, nao)
M2stop = min(M2start + blocksize2, nao)
m1max = M1stop - M1start
m2max = M2stop - M2start
if not isblacs:
# Kinetic energy contribution
#
# ----- d T
# a \ mu nu
# F += 2 Re ) -------- rho
# / d R nu mu
# ----- mu nu
# mu in a; nu
#
Fkin_av = np.zeros_like(F_av)
for u, kpt in enumerate(self.kpt_u):
dEdTrhoT_vMM = (dTdR_qvMM[kpt.q]
* rhoT_uMM[u][np.newaxis]).real
for a, M1, M2 in my_slices():
Fkin_av[a, :] += \
2.0 * dEdTrhoT_vMM[:, M1:M2].sum(-1).sum(-1)
del dEdTrhoT_vMM
# Density matrix contribution due to basis overlap
#
# ----- d Theta
# a \ mu nu
# F += -2 Re ) ------------ E
# / d R nu mu
# ----- mu nu
# mu in a; nu
#
Ftheta_av = np.zeros_like(F_av)
for u, kpt in enumerate(self.kpt_u):
dThetadRE_vMM = (dThetadR_qvMM[kpt.q]
* ET_uMM[u][np.newaxis]).real
for a, M1, M2 in my_slices():
Ftheta_av[a, :] += \
-2.0 * dThetadRE_vMM[:, M1:M2].sum(-1).sum(-1)
del dThetadRE_vMM
if isblacs:
from gpaw.lcao.overlap import TwoCenterIntegralCalculator
self.timer.start('Prepare TCI loop')
M_a = bfs.M_a
Fkin2_av = np.zeros_like(F_av)
Ftheta2_av = np.zeros_like(F_av)
cell_cv = tci.atoms.cell
spos_ac = tci.atoms.get_scaled_positions() % 1.0
overlapcalc = TwoCenterIntegralCalculator(self.kd.ibzk_qc,
derivative=False)
# XXX this is not parallel *AT ALL*.
self.timer.start('Get neighbors')
nl = tci.atompairs.pairs.neighbors
r_and_offset_aao = get_r_and_offsets(nl, spos_ac, cell_cv)
atompairs = sorted(r_and_offset_aao.keys())
self.timer.stop('Get neighbors')
T_expansions = tci.T_expansions
Theta_expansions = tci.Theta_expansions
P_expansions = tci.P_expansions
nq = len(self.kd.ibzk_qc)
dH_asp = hamiltonian.dH_asp
self.timer.start('broadcast dH')
alldH_asp = {}
for a in range(len(self.setups)):
gdrank = bfs.sphere_a[a].rank
if gdrank == gd.rank:
dH_sp = dH_asp[a]
else:
ni = self.setups[a].ni
dH_sp = np.empty((self.nspins, ni * (ni + 1) // 2))
gd.comm.broadcast(dH_sp, gdrank)
# okay, now everyone gets copies of dH_sp
alldH_asp[a] = dH_sp
self.timer.stop('broadcast dH')
# This will get sort of hairy. We need to account for some
# three-center overlaps, such as:
#
# a1
# Phi ~a3 a3 ~a3 a2 a2,a1
# < ---- |p > dH rho
# dR
#
# To this end we will loop over all pairs of atoms (a1, a3),
# and then a sub-loop over (a3, a2).
from gpaw.lcao.overlap import DerivativeAtomicDisplacement
class Displacement(DerivativeAtomicDisplacement):
def __init__(self, a1, a2, R_c, offset):
phases = overlapcalc.phaseclass(overlapcalc.ibzk_qc,
offset)
DerivativeAtomicDisplacement.__init__(self, None, a1, a2,
R_c, offset, phases)
# Cache of Displacement objects with spherical harmonics with
# evaluated spherical harmonics.
disp_aao = {}
def get_displacements(a1, a2, maxdistance):
# XXX the way maxdistance is handled it can lead to
# bad caching when different maxdistances are passed
# to subsequent calls with same pair of atoms
disp_o = disp_aao.get((a1, a2))
if disp_o is None:
disp_o = []
for R_c, offset in r_and_offset_aao[(a1, a2)]:
if np.linalg.norm(R_c) > maxdistance:
continue
disp = Displacement(a1, a2, R_c, offset)
disp_o.append(disp)
disp_aao[(a1, a2)] = disp_o
return [disp for disp in disp_o if disp.r < maxdistance]
self.timer.stop('Prepare TCI loop')
self.timer.start('Not so complicated loop')
for (a1, a2) in atompairs:
if a1 >= a2:
# Actually this leads to bad load balance.
# We should take a1 > a2 or a1 < a2 equally many times.
# Maybe decide which of these choices
# depending on whether a2 % 1 == 0
continue
m1start = M_a[a1] - M1start
m2start = M_a[a2] - M2start
if m1start >= blocksize1 or m2start >= blocksize2:
continue # (we have only one block per CPU)
T_expansion = T_expansions.get(a1, a2)
Theta_expansion = Theta_expansions.get(a1, a2)
#P_expansion = P_expansions.get(a1, a2)
nm1, nm2 = T_expansion.shape
m1stop = min(m1start + nm1, m1max)
m2stop = min(m2start + nm2, m2max)
if m1stop <= 0 or m2stop <= 0:
continue
m1start = max(m1start, 0)
m2start = max(m2start, 0)
J1start = max(0, M1start - M_a[a1])
J2start = max(0, M2start - M_a[a2])
M1stop = J1start + m1stop - m1start
J2stop = J2start + m2stop - m2start
dTdR_qvmm = T_expansion.zeros((nq, 3), dtype=dtype)
dThetadR_qvmm = Theta_expansion.zeros((nq, 3), dtype=dtype)
disp_o = get_displacements(a1, a2,
phicutoff_a[a1] + phicutoff_a[a2])
for disp in disp_o:
disp.evaluate_overlap(T_expansion, dTdR_qvmm)
disp.evaluate_overlap(Theta_expansion, dThetadR_qvmm)
for u, kpt in enumerate(self.kpt_u):
rhoT_mm = rhoT_umm[u][m1start:m1stop, m2start:m2stop]
ET_mm = ET_umm[u][m1start:m1stop, m2start:m2stop]
Fkin_v = 2.0 * (dTdR_qvmm[kpt.q][:, J1start:M1stop,
J2start:J2stop]
* rhoT_mm[np.newaxis]).real.sum(-1).sum(-1)
Ftheta_v = 2.0 * (dThetadR_qvmm[kpt.q][:, J1start:M1stop,
J2start:J2stop]
* ET_mm[np.newaxis]).real.sum(-1).sum(-1)
Fkin2_av[a1] += Fkin_v
Fkin2_av[a2] -= Fkin_v
Ftheta2_av[a1] -= Ftheta_v
Ftheta2_av[a2] += Ftheta_v
Fkin_av = Fkin2_av
Ftheta_av = Ftheta2_av
self.timer.stop('Not so complicated loop')
dHP_and_dSP_aauim = {}
a2values = {}
for (a2, a3) in atompairs:
if not a3 in a2values:
a2values[a3] = []
a2values[a3].append(a2)
Fatom_av = np.zeros_like(F_av)
Frho_av = np.zeros_like(F_av)
self.timer.start('Complicated loop')
for a1, a3 in atompairs:
if a1 == a3:
# Functions reside on same atom, so their overlap
# does not change when atom is displaced
continue
m1start = M_a[a1] - M1start
if m1start >= blocksize1:
continue
P_expansion = P_expansions.get(a1, a3)
nm1 = P_expansion.shape[0]
m1stop = min(m1start + nm1, m1max)
if m1stop <= 0:
continue
m1start = max(m1start, 0)
J1start = max(0, M1start - M_a[a1])
J1stop = J1start + m1stop - m1start
disp_o = get_displacements(a1, a3,
phicutoff_a[a1] + pcutoff_a[a3])
if len(disp_o) == 0:
continue
dPdR_qvmi = P_expansion.zeros((nq, 3), dtype=dtype)
for disp in disp_o:
disp.evaluate_overlap(P_expansion, dPdR_qvmi)
dPdR_qvmi = dPdR_qvmi[:, :, J1start:J1stop, :].copy()
for a2 in a2values[a3]:
m2start = M_a[a2] - M2start
if m2start >= blocksize2:
continue
P_expansion2 = P_expansions.get(a2, a3)
nm2 = P_expansion2.shape[0]
m2stop = min(m2start + nm2, m2max)
if m2stop <= 0:
continue
disp_o = get_displacements(a2, a3,
phicutoff_a[a2] + pcutoff_a[a3])
if len(disp_o) == 0:
continue
m2start = max(m2start, 0)
J2start = max(0, M2start - M_a[a2])
J2stop = J2start + m2stop - m2start
if (a2, a3) in dHP_and_dSP_aauim:
dHP_uim, dSP_uim = dHP_and_dSP_aauim[(a2, a3)]
else:
P_qmi = P_expansion2.zeros((nq,), dtype=dtype)
for disp in disp_o:
disp.evaluate_direct(P_expansion2, P_qmi)
P_qmi = P_qmi[:, J2start:J2stop].copy()
dH_sp = alldH_asp[a3]
dS_ii = self.setups[a3].dO_ii
dHP_uim = []
dSP_uim = []
for u, kpt in enumerate(self.kpt_u):
dH_ii = unpack(dH_sp[kpt.s])
dHP_im = np.dot(P_qmi[kpt.q], dH_ii).T.conj()
# XXX only need nq of these
dSP_im = np.dot(P_qmi[kpt.q], dS_ii).T.conj()
dHP_uim.append(dHP_im)
dSP_uim.append(dSP_im)
dHP_and_dSP_aauim[(a2, a3)] = dHP_uim, dSP_uim
for u, kpt in enumerate(self.kpt_u):
rhoT_mm = rhoT_umm[u][m1start:m1stop, m2start:m2stop]
ET_mm = ET_umm[u][m1start:m1stop, m2start:m2stop]
dPdRdHP_vmm = np.dot(dPdR_qvmi[kpt.q], dHP_uim[u])
dPdRdSP_vmm = np.dot(dPdR_qvmi[kpt.q], dSP_uim[u])
Fatom_c = 2.0 * (dPdRdHP_vmm
* rhoT_mm).real.sum(-1).sum(-1)
Frho_c = 2.0 * (dPdRdSP_vmm
* ET_mm).real.sum(-1).sum(-1)
Fatom_av[a1] += Fatom_c
Fatom_av[a3] -= Fatom_c
Frho_av[a1] -= Frho_c
Frho_av[a3] += Frho_c
self.timer.stop('Complicated loop')
if not isblacs:
# Potential contribution
#
# ----- / d Phi (r)
# a \ | mu ~
# F += -2 Re ) | ---------- v (r) Phi (r) dr rho
# / | d R nu nu mu
# ----- / a
# mu in a; nu
#
self.timer.start('Potential')
Fpot_av = np.zeros_like(F_av)
for u, kpt in enumerate(self.kpt_u):
vt_G = hamiltonian.vt_sG[kpt.s]
Fpot_av += bfs.calculate_force_contribution(vt_G, rhoT_uMM[u],
kpt.q)
self.timer.stop('Potential')
# Density matrix contribution from PAW correction
#
# ----- -----
# a \ a \ b
# F += 2 Re ) Z E - 2 Re ) Z E
# / mu nu nu mu / mu nu nu mu
# ----- -----
# mu nu b; mu in a; nu
#
# with
# b*
# ----- dP
# b \ i mu b b
# Z = ) -------- dS P
# mu nu / dR ij j nu
# ----- b mu
# ij
#
self.timer.start('Paw correction')
Frho_av = np.zeros_like(F_av)
for u, kpt in enumerate(self.kpt_u):
work_MM = np.zeros((mynao, nao), dtype)
ZE_MM = None
for b in my_atom_indices:
setup = self.setups[b]
dO_ii = np.asarray(setup.dO_ii, dtype)
dOP_iM = np.zeros((setup.ni, nao), dtype)
gemm(1.0, self.P_aqMi[b][kpt.q], dO_ii, 0.0, dOP_iM, 'c')
for v in range(3):
gemm(1.0, dOP_iM,
dPdR_aqvMi[b][kpt.q][v][Mstart:Mstop],
0.0, work_MM, 'n')
ZE_MM = (work_MM * ET_uMM[u]).real
for a, M1, M2 in slices():
dE = 2 * ZE_MM[M1:M2].sum()
Frho_av[a, v] -= dE # the "b; mu in a; nu" term
Frho_av[b, v] += dE # the "mu nu" term
del work_MM, ZE_MM
self.timer.stop('Paw correction')
# Atomic density contribution
# ----- -----
# a \ a \ b
# F += -2 Re ) A rho + 2 Re ) A rho
# / mu nu nu mu / mu nu nu mu
# ----- -----
# mu nu b; mu in a; nu
#
# b*
# ----- d P
# b \ i mu b b
# A = ) ------- dH P
# mu nu / d R ij j nu
# ----- b mu
# ij
#
self.timer.start('Atomic Hamiltonian force')
Fatom_av = np.zeros_like(F_av)
for u, kpt in enumerate(self.kpt_u):
for b in my_atom_indices:
H_ii = np.asarray(unpack(hamiltonian.dH_asp[b][kpt.s]),
dtype)
HP_iM = gemmdot(H_ii,
np.ascontiguousarray(
self.P_aqMi[b][kpt.q].T.conj()))
for v in range(3):
dPdR_Mi = dPdR_aqvMi[b][kpt.q][v][Mstart:Mstop]
ArhoT_MM = (gemmdot(dPdR_Mi, HP_iM) * rhoT_uMM[u]).real
for a, M1, M2 in slices():
dE = 2 * ArhoT_MM[M1:M2].sum()
Fatom_av[a, v] += dE # the "b; mu in a; nu" term
Fatom_av[b, v] -= dE # the "mu nu" term
self.timer.stop('Atomic Hamiltonian force')
F_av += Fkin_av + Fpot_av + Ftheta_av + Frho_av + Fatom_av
self.timer.start('Wait for sum')
ksl.orbital_comm.sum(F_av)
if self.bd.comm.rank == 0:
self.kd.comm.sum(F_av, 0)
self.timer.stop('Wait for sum')
self.timer.stop('LCAO forces')
def _get_wave_function_array(self, u, n, realspace=True):
kpt = self.kpt_u[u]
if kpt.C_nM is None:
# Hack to make sure things are available after restart
self.lazyloader.load(self)
C_M = kpt.C_nM[n]
if realspace:
psit_G = self.gd.zeros(dtype=self.dtype)
self.basis_functions.lcao_to_grid(C_M, psit_G, kpt.q)
return psit_G
else:
return C_M
def load_lazily(self, hamiltonian, spos_ac):
"""Horrible hack to recalculate lcao coefficients after restart."""
self.basis_functions.set_positions(spos_ac)
class LazyLoader:
def __init__(self, hamiltonian, spos_ac):
self.spos_ac = spos_ac
def load(self, wfs):
wfs.set_positions(self.spos_ac) # this sets rank_a
# Now we need to pass atom_partition or things to work
# XXX WTF why does one have to fiddle with atom_partition???
hamiltonian.set_positions(self.spos_ac,
wfs.atom_partition)
wfs.eigensolver.iterate(hamiltonian, wfs)
del wfs.lazyloader
self.lazyloader = LazyLoader(hamiltonian, spos_ac)
def write(self, writer, write_wave_functions=False):
writer['Mode'] = 'lcao'
if not write_wave_functions:
return
writer.dimension('nbasis', self.setups.nao)
writer.add('WaveFunctionCoefficients',
('nspins', 'nibzkpts', 'nbands', 'nbasis'),
dtype=self.dtype)
for s in range(self.nspins):
for k in range(self.kd.nibzkpts):
C_nM = self.collect_array('C_nM', k, s)
writer.fill(C_nM, s, k)
def read_coefficients(self, reader):
for kpt in self.kpt_u:
kpt.C_nM = self.bd.empty(self.setups.nao, dtype=self.dtype)
for myn, C_M in enumerate(kpt.C_nM):
n = self.bd.global_index(myn)
C_M[:] = reader.get('WaveFunctionCoefficients',
kpt.s, kpt.k, n)
def estimate_memory(self, mem):
nq = len(self.kd.ibzk_qc)
nao = self.setups.nao
ni_total = sum([setup.ni for setup in self.setups])
itemsize = mem.itemsize[self.dtype]
mem.subnode('C [qnM]', nq * self.bd.mynbands * nao * itemsize)
nM1, nM2 = self.ksl.get_overlap_matrix_shape()
mem.subnode('S, T [2 x qmm]', 2 * nq * nM1 * nM2 * itemsize)
mem.subnode('P [aqMi]', nq * nao * ni_total // self.gd.comm.size)
self.tci.estimate_memory(mem.subnode('TCI'))
self.basis_functions.estimate_memory(mem.subnode('BasisFunctions'))
self.eigensolver.estimate_memory(mem.subnode('Eigensolver'),
self.dtype)
gpaw-0.11.0.13004/gpaw/wavefunctions/fdpw.py 0000664 0001750 0001750 00000021010 12553643470 020611 0 ustar jensj jensj 0000000 0000000 from __future__ import division
import numpy as np
from gpaw import extra_parameters
from gpaw.io import FileReference
from gpaw.lcao.eigensolver import DirectLCAO
from gpaw.lfc import BasisFunctions
from gpaw.overlap import Overlap
from gpaw.utilities import unpack
from gpaw.utilities.timing import nulltimer
from gpaw.wavefunctions.base import WaveFunctions
from gpaw.wavefunctions.lcao import LCAOWaveFunctions
class FDPWWaveFunctions(WaveFunctions):
"""Base class for finite-difference and planewave classes."""
def __init__(self, diagksl, orthoksl, initksl, *args, **kwargs):
WaveFunctions.__init__(self, *args, **kwargs)
self.diagksl = diagksl
self.orthoksl = orthoksl
self.initksl = initksl
self.set_orthonormalized(False)
self.overlap = self.make_overlap()
def set_setups(self, setups):
WaveFunctions.set_setups(self, setups)
def set_orthonormalized(self, flag):
self.orthonormalized = flag
def set_positions(self, spos_ac, atom_partition=None):
WaveFunctions.set_positions(self, spos_ac, atom_partition)
self.set_orthonormalized(False)
self.pt.set_positions(spos_ac)
self.allocate_arrays_for_projections(self.pt.my_atom_indices)
self.positions_set = True
def make_overlap(self):
return Overlap(self.orthoksl, self.timer)
def initialize(self, density, hamiltonian, spos_ac):
if self.kpt_u[0].psit_nG is None:
basis_functions = BasisFunctions(self.gd,
[setup.phit_j
for setup in self.setups],
self.kd, dtype=self.dtype,
cut=True)
basis_functions.set_positions(spos_ac)
elif isinstance(self.kpt_u[0].psit_nG, FileReference):
self.initialize_wave_functions_from_restart_file()
if self.kpt_u[0].psit_nG is not None:
density.initialize_from_wavefunctions(self)
elif density.nt_sG is None:
density.initialize_from_atomic_densities(basis_functions)
# Initialize GLLB-potential from basis function orbitals
if hamiltonian.xc.type == 'GLLB':
hamiltonian.xc.initialize_from_atomic_orbitals(
basis_functions)
else: # XXX???
# We didn't even touch density, but some combinations in paw.set()
# will make it necessary to do this for some reason.
density.calculate_normalized_charges_and_mix()
hamiltonian.update(density)
if self.kpt_u[0].psit_nG is None:
self.initialize_wave_functions_from_basis_functions(
basis_functions, density, hamiltonian, spos_ac)
def initialize_wave_functions_from_basis_functions(self,
basis_functions,
density, hamiltonian,
spos_ac):
if self.initksl is None:
raise RuntimeError('use fewer bands or more basis functions')
self.timer.start('LCAO initialization')
lcaoksl, lcaobd = self.initksl, self.initksl.bd
lcaowfs = LCAOWaveFunctions(lcaoksl, self.gd, self.nvalence,
self.setups, lcaobd, self.dtype,
self.world, self.kd, self.kptband_comm,
nulltimer)
lcaowfs.basis_functions = basis_functions
lcaowfs.timer = self.timer
self.timer.start('Set positions (LCAO WFS)')
lcaowfs.set_positions(spos_ac, self.atom_partition)
self.timer.stop('Set positions (LCAO WFS)')
eigensolver = DirectLCAO()
eigensolver.initialize(self.gd, self.dtype, self.setups.nao, lcaoksl)
# XXX when density matrix is properly distributed, be sure to
# update the density here also
eigensolver.iterate(hamiltonian, lcaowfs)
# Transfer coefficients ...
for kpt, lcaokpt in zip(self.kpt_u, lcaowfs.kpt_u):
kpt.C_nM = lcaokpt.C_nM
# and get rid of potentially big arrays early:
del eigensolver, lcaowfs
self.timer.start('LCAO to grid')
self.initialize_from_lcao_coefficients(basis_functions,
lcaobd.mynbands)
self.timer.stop('LCAO to grid')
if self.bd.mynbands > lcaobd.mynbands:
# Add extra states. If the number of atomic orbitals is
# less than the desired number of bands, then extra random
# wave functions are added.
self.random_wave_functions(lcaobd.mynbands)
self.timer.stop('LCAO initialization')
def initialize_wave_functions_from_restart_file(self):
if not isinstance(self.kpt_u[0].psit_nG, FileReference):
return
# Calculation started from a restart file. Copy data
# from the file to memory:
for kpt in self.kpt_u:
file_nG = kpt.psit_nG
kpt.psit_nG = self.empty(self.bd.mynbands, q=kpt.q)
if extra_parameters.get('sic'):
kpt.W_nn = np.zeros((self.bd.nbands, self.bd.nbands),
dtype=self.dtype)
# Read band by band to save memory
for n, psit_G in enumerate(kpt.psit_nG):
if self.gd.comm.rank == 0:
big_psit_G = file_nG[n][:].astype(psit_G.dtype)
else:
big_psit_G = None
self.gd.distribute(big_psit_G, psit_G)
def orthonormalize(self):
for kpt in self.kpt_u:
self.overlap.orthonormalize(self, kpt)
self.set_orthonormalized(True)
def calculate_forces(self, hamiltonian, F_av):
# Calculate force-contribution from k-points:
F_av.fill(0.0)
F_aniv = self.pt.dict(self.bd.mynbands, derivative=True)
for kpt in self.kpt_u:
self.pt.derivative(kpt.psit_nG, F_aniv, kpt.q)
for a, F_niv in F_aniv.items():
F_niv = F_niv.conj()
F_niv *= kpt.f_n[:, np.newaxis, np.newaxis]
dH_ii = unpack(hamiltonian.dH_asp[a][kpt.s])
P_ni = kpt.P_ani[a]
F_vii = np.dot(np.dot(F_niv.transpose(), P_ni), dH_ii)
F_niv *= kpt.eps_n[:, np.newaxis, np.newaxis]
dO_ii = hamiltonian.setups[a].dO_ii
F_vii -= np.dot(np.dot(F_niv.transpose(), P_ni), dO_ii)
F_av[a] += 2 * F_vii.real.trace(0, 1, 2)
# Hack used in delta-scf calculations:
if hasattr(kpt, 'c_on'):
assert self.bd.comm.size == 1
self.pt.derivative(kpt.psit_nG, F_aniv, kpt.q) # XXX again
d_nn = np.zeros((self.bd.mynbands, self.bd.mynbands),
dtype=complex)
for ne, c_n in zip(kpt.ne_o, kpt.c_on):
d_nn += ne * np.outer(c_n.conj(), c_n)
for a, F_niv in F_aniv.items():
F_niv = F_niv.conj()
dH_ii = unpack(hamiltonian.dH_asp[a][kpt.s])
Q_ni = np.dot(d_nn, kpt.P_ani[a])
F_vii = np.dot(np.dot(F_niv.transpose(), Q_ni), dH_ii)
F_niv *= kpt.eps_n[:, np.newaxis, np.newaxis]
dO_ii = hamiltonian.setups[a].dO_ii
F_vii -= np.dot(np.dot(F_niv.transpose(), Q_ni), dO_ii)
F_av[a] += 2 * F_vii.real.trace(0, 1, 2)
self.bd.comm.sum(F_av, 0)
if self.bd.comm.rank == 0:
self.kd.comm.sum(F_av, 0)
def _get_wave_function_array(self, u, n, realspace=True):
psit_nG = self.kpt_u[u].psit_nG
if psit_nG is None:
raise RuntimeError('This calculator has no wave functions!')
return psit_nG[n][:] # dereference possible tar-file content
def estimate_memory(self, mem):
gridbytes = self.bytes_per_wave_function()
n = len(self.kpt_u) * self.bd.mynbands
mem.subnode('Arrays psit_nG', n * gridbytes)
self.eigensolver.estimate_memory(mem.subnode('Eigensolver'), self)
ni = sum(dataset.ni for dataset in self.setups) / self.gd.comm.size
mem.subnode('Projections', n * ni * np.dtype(self.dtype).itemsize)
self.pt.estimate_memory(mem.subnode('Projectors'))
self.matrixoperator.estimate_memory(mem.subnode('Overlap op'),
self.dtype)
gpaw-0.11.0.13004/gpaw/wavefunctions/base.py 0000664 0001750 0001750 00000037206 12553643470 020601 0 ustar jensj jensj 0000000 0000000 import numpy as np
from gpaw.utilities import pack, unpack2
from gpaw.utilities.blas import gemm
from gpaw.utilities.partition import AtomPartition
from gpaw.utilities.timing import nulltimer
class EmptyWaveFunctions:
mode = 'undefined'
def __bool__(self):
return False
__nonzero__ = __bool__ # for Python 2
def set_eigensolver(self, eigensolver):
pass
def set_orthonormalized(self, flag):
pass
def estimate_memory(self, mem):
mem.set('Unknown WFs', 0)
class WaveFunctions(EmptyWaveFunctions):
"""...
setups:
List of setup objects.
symmetry:
Symmetry object.
kpt_u:
List of **k**-point 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 **k**-points used for sampling the whole
Brillouin zone - values scaled to [-0.5, 0.5).
ibzk_kc: ndarray
Scaled **k**-points in the irreducible part of the
Brillouin zone.
weight_k: ndarray
Weights of the **k**-points in the irreducible part
of the Brillouin zone (summing up to 1).
kpt_comm:
MPI-communicator for parallelization over **k**-points.
"""
collinear = True
# ncomp is a number of array components necessary to hold
# information about non-collinear spins. With collinear spin
# it is always 1; else it is 2.
ncomp = 1
def __init__(self, gd, nvalence, setups, bd, dtype,
world, kd, kptband_comm, timer=None):
self.gd = gd
self.nspins = kd.nspins
self.ns = self.nspins * self.ncomp**2
self.nvalence = nvalence
self.bd = bd
#self.nbands = self.bd.nbands #XXX
#self.mynbands = self.bd.mynbands #XXX
self.dtype = dtype
assert dtype == float or dtype == complex
self.world = world
self.kd = kd
self.kptband_comm = kptband_comm
self.band_comm = self.bd.comm # XXX
if timer is None:
timer = nulltimer
self.timer = timer
self.atom_partition = None
self.kpt_u = kd.create_k_points(self.gd)
self.eigensolver = None
self.positions_set = False
self.set_setups(setups)
def set_setups(self, setups):
self.setups = setups
def set_eigensolver(self, eigensolver):
self.eigensolver = eigensolver
def __bool__(self):
return True
__nonzero__ = __bool__ # for Python 2
def calculate_density_contribution(self, nt_sG):
"""Calculate contribution to pseudo density from wave functions."""
nt_sG.fill(0.0)
for kpt in self.kpt_u:
self.add_to_density_from_k_point(nt_sG, kpt)
self.kptband_comm.sum(nt_sG)
self.timer.start('Symmetrize density')
for nt_G in nt_sG:
self.kd.symmetry.symmetrize(nt_G, self.gd)
self.timer.stop('Symmetrize density')
def add_to_density_from_k_point(self, nt_sG, kpt):
self.add_to_density_from_k_point_with_occupation(nt_sG, kpt, kpt.f_n)
def get_orbital_density_matrix(self, a, kpt, n):
"""Add the nth band density from kpt to density matrix D_sp"""
ni = self.setups[a].ni
D_sii = np.zeros((self.nspins, ni, ni))
P_i = kpt.P_ani[a][n]
D_sii[kpt.s] += np.outer(P_i.conj(), P_i).real
D_sp = [pack(D_ii) for D_ii in D_sii]
return D_sp
def calculate_atomic_density_matrices_k_point(self, D_sii, kpt, a, f_n):
if kpt.rho_MM is not None:
P_Mi = self.P_aqMi[a][kpt.q]
#P_Mi = kpt.P_aMi_sparse[a]
#ind = get_matrix_index(kpt.P_aMi_index[a])
#D_sii[kpt.s] += np.dot(np.dot(P_Mi.T.conj(), kpt.rho_MM),
# P_Mi).real
rhoP_Mi = np.zeros_like(P_Mi)
D_ii = np.zeros(D_sii[kpt.s].shape, kpt.rho_MM.dtype)
#gemm(1.0, P_Mi, kpt.rho_MM[ind.T, ind], 0.0, tmp)
gemm(1.0, P_Mi, kpt.rho_MM, 0.0, rhoP_Mi)
gemm(1.0, rhoP_Mi, P_Mi.T.conj().copy(), 0.0, D_ii)
D_sii[kpt.s] += D_ii.real
#D_sii[kpt.s] += dot(dot(P_Mi.T.conj().copy(),
# kpt.rho_MM[ind.T, ind]), P_Mi).real
else:
P_ni = kpt.P_ani[a]
D_sii[kpt.s] += np.dot(P_ni.T.conj() * f_n, P_ni).real
if hasattr(kpt, 'c_on'):
for ne, c_n in zip(kpt.ne_o, kpt.c_on):
d_nn = ne * np.outer(c_n.conj(), c_n)
D_sii[kpt.s] += np.dot(P_ni.T.conj(), np.dot(d_nn, P_ni)).real
def calculate_atomic_density_matrices(self, D_asp):
"""Calculate atomic density matrices from projections."""
f_un = [kpt.f_n for kpt in self.kpt_u]
self.calculate_atomic_density_matrices_with_occupation(D_asp, f_un)
def calculate_atomic_density_matrices_with_occupation(self, D_asp, f_un):
"""Calculate atomic density matrices from projections with
custom occupation f_un."""
# Parameter check (if user accidentally passes f_n instead of f_un)
if f_un[0] is not None: # special case for transport calculations...
assert isinstance(f_un[0], np.ndarray)
# Varying f_n used in calculation of response part of GLLB-potential
for a, D_sp in D_asp.items():
ni = self.setups[a].ni
D_sii = np.zeros((len(D_sp), ni, ni))
for f_n, kpt in zip(f_un, self.kpt_u):
self.calculate_atomic_density_matrices_k_point(D_sii, kpt, a,
f_n)
D_sp[:] = [pack(D_ii) for D_ii in D_sii]
self.kptband_comm.sum(D_sp)
self.symmetrize_atomic_density_matrices(D_asp)
def symmetrize_atomic_density_matrices(self, D_asp):
if len(self.kd.symmetry.op_scc) == 0:
return
if hasattr(D_asp, 'redistribute'):
a_sa = self.kd.symmetry.a_sa
D_asp.redistribute(self.atom_partition.as_serial())
for s in range(self.nspins):
D_aii = [unpack2(D_asp[a][s])
for a in range(len(D_asp))]
for a, D_ii in enumerate(D_aii):
setup = self.setups[a]
D_asp[a][s] = pack(setup.symmetrize(a, D_aii, a_sa))
D_asp.redistribute(self.atom_partition)
else:
all_D_asp = []
for a, setup in enumerate(self.setups):
D_sp = D_asp.get(a)
if D_sp is None:
ni = setup.ni
D_sp = np.empty((self.ns, ni * (ni + 1) // 2))
self.gd.comm.broadcast(D_sp, self.atom_partition.rank_a[a])
all_D_asp.append(D_sp)
for s in range(self.nspins):
D_aii = [unpack2(D_sp[s]) for D_sp in all_D_asp]
for a, D_sp in D_asp.items():
setup = self.setups[a]
D_sp[s] = pack(setup.symmetrize(a, D_aii,
self.kd.symmetry.a_sa))
def set_positions(self, spos_ac, atom_partition=None):
self.positions_set = False
#rank_a = self.gd.get_ranks_from_positions(spos_ac)
#atom_partition = AtomPartition(self.gd.comm, rank_a)
# XXX pass AtomPartition around instead of spos_ac?
# All the classes passing around spos_ac end up needing the ranks
# anyway.
if atom_partition is None:
rank_a = self.gd.get_ranks_from_positions(spos_ac)
atom_partition = AtomPartition(self.gd.comm, rank_a)
if self.atom_partition is not None and self.kpt_u[0].P_ani is not None:
self.timer.start('Redistribute')
mynks = len(self.kpt_u)
def get_empty(a):
ni = self.setups[a].ni
return np.empty((mynks, self.bd.mynbands, ni), self.dtype)
self.atom_partition.redistribute(atom_partition,
[kpt.P_ani for kpt in self.kpt_u],
get_empty)
self.timer.stop('Redistribute')
self.atom_partition = atom_partition
self.kd.symmetry.check(spos_ac)
def allocate_arrays_for_projections(self, my_atom_indices):
if not self.positions_set and self.kpt_u[0].P_ani is not None:
# Projections have been read from file - don't delete them!
pass
else:
for kpt in self.kpt_u:
kpt.P_ani = {}
for a in my_atom_indices:
ni = self.setups[a].ni
for kpt in self.kpt_u:
kpt.P_ani[a] = np.empty((self.bd.mynbands, ni), self.dtype)
def collect_eigenvalues(self, k, s):
return self.collect_array('eps_n', k, s)
def collect_occupations(self, k, s):
return self.collect_array('f_n', k, s)
def collect_array(self, name, k, s, subset=None):
"""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."""
kpt_u = self.kpt_u
kpt_rank, u = self.kd.get_rank_and_index(s, k)
if self.kd.comm.rank == kpt_rank:
a_nx = getattr(kpt_u[u], name)
if subset is not None:
a_nx = a_nx[subset]
# Domain master send this to the global master
if self.gd.comm.rank == 0:
if self.band_comm.size == 1:
if kpt_rank == 0:
return a_nx
else:
self.kd.comm.ssend(a_nx, 0, 1301)
else:
b_nx = self.bd.collect(a_nx)
if self.band_comm.rank == 0:
if kpt_rank == 0:
return b_nx
else:
self.kd.comm.ssend(b_nx, 0, 1301)
elif self.world.rank == 0 and kpt_rank != 0:
# Only used to determine shape and dtype of receiving buffer:
a_nx = getattr(kpt_u[0], name)
if subset is not None:
a_nx = a_nx[subset]
b_nx = np.zeros((self.bd.nbands,) + a_nx.shape[1:],
dtype=a_nx.dtype)
self.kd.comm.receive(b_nx, kpt_rank, 1301)
return b_nx
def collect_auxiliary(self, value, k, s, shape=1, dtype=float):
"""Helper method for collecting band-independent 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."""
kpt_u = self.kpt_u
kpt_rank, u = self.kd.get_rank_and_index(s, k)
if self.kd.comm.rank == kpt_rank:
if isinstance(value, str):
a_o = getattr(kpt_u[u], value)
else:
a_o = value[u] # assumed list
# Make sure data is a mutable object
a_o = np.asarray(a_o)
if a_o.dtype is not dtype:
a_o = a_o.astype(dtype)
# Domain master send this to the global master
if self.gd.comm.rank == 0:
if kpt_rank == 0:
return a_o
else:
self.kd.comm.send(a_o, 0, 1302)
elif self.world.rank == 0 and kpt_rank != 0:
b_o = np.zeros(shape, dtype=dtype)
self.kd.comm.receive(b_o, kpt_rank, 1302)
return b_o
def collect_projections(self, k, s):
"""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."""
kpt_rank, u = self.kd.get_rank_and_index(s, k)
natoms = self.atom_partition.natoms
nproj = sum([setup.ni for setup in self.setups])
if self.world.rank == 0:
if kpt_rank == 0:
P_ani = self.kpt_u[u].P_ani
all_P_ni = np.empty((self.bd.nbands, nproj), self.dtype)
for band_rank in range(self.band_comm.size):
nslice = self.bd.get_slice(band_rank)
i = 0
for a in range(natoms):
ni = self.setups[a].ni
if kpt_rank == 0 and band_rank == 0 and a in P_ani:
P_ni = P_ani[a]
else:
P_ni = np.empty((self.bd.mynbands, ni), self.dtype)
# XXX will fail with nonstandard communicator nesting
world_rank = (self.atom_partition.rank_a[a] +
kpt_rank * self.gd.comm.size *
self.band_comm.size +
band_rank * self.gd.comm.size)
self.world.receive(P_ni, world_rank, 1303 + a)
all_P_ni[nslice, i:i + ni] = P_ni
i += ni
assert i == nproj
return all_P_ni
elif self.kd.comm.rank == kpt_rank: # plain else works too...
P_ani = self.kpt_u[u].P_ani
for a in range(natoms):
if a in P_ani:
self.world.ssend(P_ani[a], 0, 1303 + a)
def get_wave_function_array(self, n, k, s, realspace=True):
"""Return pseudo-wave-function array on master.
n: int
Global band index.
k: int
Global IBZ k-point index.
s: int
Spin index (0 or 1).
realspace: bool
Transform plane wave or LCAO expansion coefficients to real-space.
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_rank, u = self.kd.get_rank_and_index(s, k)
band_rank, myn = self.bd.who_has(n)
rank = self.world.rank
if (self.kd.comm.rank == kpt_rank and
self.band_comm.rank == band_rank):
psit_G = self._get_wave_function_array(u, myn, realspace)
if realspace:
psit_G = self.gd.collect(psit_G)
if rank == 0:
return psit_G
# Domain master send this to the global master
if self.gd.comm.rank == 0:
self.world.ssend(psit_G, 0, 1398)
if rank == 0:
# allocate full wave function and receive
psit_G = self.empty(global_array=True,
realspace=realspace)
# XXX this will fail when using non-standard nesting
# of communicators.
world_rank = (kpt_rank * self.gd.comm.size *
self.band_comm.size +
band_rank * self.gd.comm.size)
self.world.receive(psit_G, world_rank, 1398)
return psit_G
def read_projections(self, reader):
nslice = self.bd.get_slice()
for u, kpt in enumerate(self.kpt_u):
P_nI = reader.get('Projections', kpt.s, kpt.k)
I1 = 0
kpt.P_ani = {}
for a, setup in enumerate(self.setups):
I2 = I1 + setup.ni
if self.gd.comm.rank == 0:
kpt.P_ani[a] = np.array(P_nI[nslice, I1:I2], self.dtype)
I1 = I2
gpaw-0.11.0.13004/gpaw/wavefunctions/fd.py 0000664 0001750 0001750 00000031676 12553643470 020265 0 ustar jensj jensj 0000000 0000000 import numpy as np
from gpaw.kpoint import KPoint
from gpaw.mpi import serial_comm
from gpaw.io import FileReference
from gpaw.utilities.blas import axpy
from gpaw.transformers import Transformer
from gpaw.hs_operators import MatrixOperator
from gpaw.preconditioner import Preconditioner
from gpaw.fd_operators import Laplace, Gradient
from gpaw.kpt_descriptor import KPointDescriptor
from gpaw.wavefunctions.fdpw import FDPWWaveFunctions
from gpaw.lfc import LocalizedFunctionsCollection as LFC
class FD:
name = 'fd'
def __init__(self):
pass # Could hold parameters like FD stencils
def __call__(self, *args, **kwargs):
return FDWaveFunctions(*args, **kwargs)
class FDWaveFunctions(FDPWWaveFunctions):
mode = 'fd'
def __init__(self, stencil, diagksl, orthoksl, initksl,
gd, nvalence, setups, bd,
dtype, world, kd, kptband_comm, timer=None):
FDPWWaveFunctions.__init__(self, diagksl, orthoksl, initksl,
gd, nvalence, setups, bd,
dtype, world, kd, kptband_comm, timer)
# Kinetic energy operator:
self.kin = Laplace(self.gd, -0.5, stencil, self.dtype)
self.matrixoperator = MatrixOperator(self.orthoksl)
self.taugrad_v = None # initialized by MGGA functional
def empty(self, n=(), global_array=False, realspace=False, q=-1):
return self.gd.empty(n, self.dtype, global_array)
def integrate(self, a_xg, b_yg=None, global_integral=True):
return self.gd.integrate(a_xg, b_yg, global_integral)
def bytes_per_wave_function(self):
return self.gd.bytecount(self.dtype)
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 set_positions(self, spos_ac, atom_partition=None):
FDPWWaveFunctions.set_positions(self, spos_ac, atom_partition)
def summary(self, fd):
fd.write('Wave functions: Uniform real-space grid\n')
fd.write('Kinetic energy operator: %s\n' % self.kin.description)
def make_preconditioner(self, block=1):
return Preconditioner(self.gd, self.kin, self.dtype, block)
def apply_pseudo_hamiltonian(self, kpt, hamiltonian, psit_xG, Htpsit_xG):
self.timer.start('Apply hamiltonian')
self.kin.apply(psit_xG, Htpsit_xG, kpt.phase_cd)
hamiltonian.apply_local_potential(psit_xG, Htpsit_xG, kpt.s)
self.timer.stop('Apply hamiltonian')
def add_orbital_density(self, nt_G, kpt, n):
if self.dtype == float:
axpy(1.0, kpt.psit_nG[n]**2, nt_G)
else:
axpy(1.0, kpt.psit_nG[n].real**2, nt_G)
axpy(1.0, kpt.psit_nG[n].imag**2, nt_G)
def add_to_density_from_k_point_with_occupation(self, nt_sG, kpt, f_n):
# Used in calculation of response part of GLLB-potential
nt_G = nt_sG[kpt.s]
if self.dtype == float:
for f, psit_G in zip(f_n, kpt.psit_nG):
axpy(f, psit_G**2, nt_G)
else:
for f, psit_G in zip(f_n, kpt.psit_nG):
axpy(f, psit_G.real**2, nt_G)
axpy(f, psit_G.imag**2, nt_G)
# Hack used in delta-scf calculations:
if hasattr(kpt, 'c_on'):
assert self.bd.comm.size == 1
d_nn = np.zeros((self.bd.mynbands, self.bd.mynbands),
dtype=complex)
for ne, c_n in zip(kpt.ne_o, kpt.c_on):
d_nn += ne * np.outer(c_n.conj(), c_n)
for d_n, psi0_G in zip(d_nn, kpt.psit_nG):
for d, psi_G in zip(d_n, kpt.psit_nG):
if abs(d) > 1.e-12:
nt_G += (psi0_G.conj() * d * psi_G).real
def calculate_kinetic_energy_density(self):
if self.taugrad_v is None:
self.taugrad_v = [
Gradient(self.gd, v, n=3, dtype=self.dtype).apply
for v in range(3)]
assert not hasattr(self.kpt_u[0], 'c_on')
if self.kpt_u[0].psit_nG is None:
raise RuntimeError('No wavefunctions yet')
if isinstance(self.kpt_u[0].psit_nG, FileReference):
# XXX initialize
raise RuntimeError('Wavefunctions have not been initialized.')
taut_sG = self.gd.zeros(self.nspins)
dpsit_G = self.gd.empty(dtype=self.dtype)
for kpt in self.kpt_u:
for f, psit_G in zip(kpt.f_n, kpt.psit_nG):
for v in range(3):
self.taugrad_v[v](psit_G, dpsit_G, kpt.phase_cd)
axpy(0.5 * f, abs(dpsit_G)**2, taut_sG[kpt.s])
self.kd.comm.sum(taut_sG)
self.band_comm.sum(taut_sG)
return taut_sG
def apply_mgga_orbital_dependent_hamiltonian(self, kpt, psit_xG,
Htpsit_xG, dH_asp,
dedtaut_G):
a_G = self.gd.empty(dtype=psit_xG.dtype)
for psit_G, Htpsit_G in zip(psit_xG, Htpsit_xG):
for v in range(3):
self.taugrad_v[v](psit_G, a_G, kpt.phase_cd)
self.taugrad_v[v](dedtaut_G * a_G, a_G, kpt.phase_cd)
axpy(-0.5, a_G, Htpsit_G)
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_symmetry(atoms, self.setups, enabled=False)
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.kpt_u[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_nG = self.gd.empty(self.bd.nbands, dtype=self.dtype)
self.gd.distribute(Psit_nG, kpt2.psit_nG)
# Calculate PAW projections:
kpt2.P_ani = self.pt.dict(len(kpt.psit_nG))
self.pt.integrate(kpt2.psit_nG, kpt2.P_ani, k)
kpt_u.append(kpt2)
self.kd = kd
self.kpt_u = kpt_u
def write(self, writer, write_wave_functions=False):
writer['Mode'] = 'fd'
if not write_wave_functions:
return
writer.add('PseudoWaveFunctions',
('nspins', 'nibzkpts', 'nbands',
'ngptsx', 'ngptsy', 'ngptsz'),
dtype=self.dtype)
if hasattr(writer, 'hdf5'):
parallel = (self.world.size > 1)
for kpt in self.kpt_u:
indices = [kpt.s, kpt.k]
indices.append(self.bd.get_slice())
indices += self.gd.get_slice()
writer.fill(kpt.psit_nG, parallel=parallel, *indices)
else:
for s in range(self.nspins):
for k in range(self.kd.nibzkpts):
for n in range(self.bd.nbands):
psit_G = self.get_wave_function_array(n, k, s)
writer.fill(psit_G, s, k, n)
def read(self, reader, hdf5):
if ((not hdf5 and self.bd.comm.size == 1) or
(hdf5 and self.world.size == 1)):
# We may not be able to keep all the wave
# functions in memory - so psit_nG will be a special type of
# array that is really just a reference to a file:
for kpt in self.kpt_u:
kpt.psit_nG = reader.get_reference('PseudoWaveFunctions',
(kpt.s, kpt.k))
else:
for kpt in self.kpt_u:
kpt.psit_nG = self.empty(self.bd.mynbands)
if hdf5:
indices = [kpt.s, kpt.k]
indices.append(self.bd.get_slice())
indices += self.gd.get_slice()
reader.get('PseudoWaveFunctions', out=kpt.psit_nG,
parallel=(self.world.size > 1), *indices)
else:
# Read band by band to save memory
for myn, psit_G in enumerate(kpt.psit_nG):
n = self.bd.global_index(myn)
if self.gd.comm.rank == 0:
big_psit_G = np.array(
reader.get('PseudoWaveFunctions',
kpt.s, kpt.k, n),
self.dtype)
else:
big_psit_G = None
self.gd.distribute(big_psit_G, psit_G)
def initialize_from_lcao_coefficients(self, basis_functions, mynbands):
for kpt in self.kpt_u:
kpt.psit_nG = self.gd.zeros(self.bd.mynbands, self.dtype)
basis_functions.lcao_to_grid(kpt.C_nM,
kpt.psit_nG[:mynbands], kpt.q)
kpt.C_nM = None
def random_wave_functions(self, nao):
"""Generate random wave functions."""
gpts = self.gd.N_c[0] * self.gd.N_c[1] * self.gd.N_c[2]
if self.bd.nbands < gpts / 64:
gd1 = self.gd.coarsen()
gd2 = gd1.coarsen()
psit_G1 = gd1.empty(dtype=self.dtype)
psit_G2 = gd2.empty(dtype=self.dtype)
interpolate2 = Transformer(gd2, gd1, 1, self.dtype).apply
interpolate1 = Transformer(gd1, self.gd, 1, self.dtype).apply
shape = tuple(gd2.n_c)
scale = np.sqrt(12 / abs(np.linalg.det(gd2.cell_cv)))
old_state = np.random.get_state()
np.random.seed(4 + self.world.rank)
for kpt in self.kpt_u:
for psit_G in kpt.psit_nG[nao:]:
if self.dtype == float:
psit_G2[:] = (np.random.random(shape) - 0.5) * scale
else:
psit_G2.real = (np.random.random(shape) - 0.5) * scale
psit_G2.imag = (np.random.random(shape) - 0.5) * scale
interpolate2(psit_G2, psit_G1, kpt.phase_cd)
interpolate1(psit_G1, psit_G, kpt.phase_cd)
np.random.set_state(old_state)
elif gpts / 64 <= self.bd.nbands < gpts / 8:
gd1 = self.gd.coarsen()
psit_G1 = gd1.empty(dtype=self.dtype)
interpolate1 = Transformer(gd1, self.gd, 1, self.dtype).apply
shape = tuple(gd1.n_c)
scale = np.sqrt(12 / abs(np.linalg.det(gd1.cell_cv)))
old_state = np.random.get_state()
np.random.seed(4 + self.world.rank)
for kpt in self.kpt_u:
for psit_G in kpt.psit_nG[nao:]:
if self.dtype == float:
psit_G1[:] = (np.random.random(shape) - 0.5) * scale
else:
psit_G1.real = (np.random.random(shape) - 0.5) * scale
psit_G1.imag = (np.random.random(shape) - 0.5) * scale
interpolate1(psit_G1, psit_G, kpt.phase_cd)
np.random.set_state(old_state)
else:
shape = tuple(self.gd.n_c)
scale = np.sqrt(12 / abs(np.linalg.det(self.gd.cell_cv)))
old_state = np.random.get_state()
np.random.seed(4 + self.world.rank)
for kpt in self.kpt_u:
for psit_G in kpt.psit_nG[nao:]:
if self.dtype == float:
psit_G[:] = (np.random.random(shape) - 0.5) * scale
else:
psit_G.real = (np.random.random(shape) - 0.5) * scale
psit_G.imag = (np.random.random(shape) - 0.5) * scale
np.random.set_state(old_state)
def estimate_memory(self, mem):
FDPWWaveFunctions.estimate_memory(self, mem)
gpaw-0.11.0.13004/gpaw/wavefunctions/__init__.py 0000664 0001750 0001750 00000000000 12553643470 021404 0 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/rotation.py 0000664 0001750 0001750 00000003320 12553643470 016621 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
from math import sqrt, cos, sin
import numpy as np
from gpaw.spherical_harmonics import Y
s = sqrt(0.5)
t = sqrt(3) / 3
# Points on the unit sphere:
sphere_lm = [ \
np.array([(1, 0, 0)]), # s
np.array([(1, 0, 0), (0, 1, 0), (0, 0, 1)]), # p
np.array([(s, s, 0), (0, s, s), (s, 0, s), (1, 0, 0), (0, 0, 1)]), # d
np.array([(s, s, 0), (0, s, s), (s, 0, s),
(1, 0, 0), (s, -s, 0),
(t, -t, t), (t, t, -t)])] # f
def Y_matrix(l, U_vv):
"""YMatrix(l, symmetry) -> matrix.
For 2*l+1 points on the unit sphere (m1=0,...,2*l) calculate the
value of Y_lm2 for m2=0,...,2*l. The points are those from the
list sphere_lm[l] rotated as described by U_vv."""
Y_mm = np.zeros((2 * l + 1, 2 * l + 1))
for m1, point in enumerate(sphere_lm[l]):
x, y, z = np.dot(point, U_vv)
for m2 in range(2 * l + 1):
L = l**2 + m2
Y_mm[m1, m2] = Y(L, x, y, z)
return Y_mm
identity = np.eye(3)
iY_lmm = [np.linalg.inv(Y_matrix(l, identity)) for l in range(4)]
def rotation(l, U_vv):
"""Rotation(l, symmetry) -> transformation matrix.
Find the transformation from Y_lm1 to Y_lm2."""
return np.dot(iY_lmm[l], Y_matrix(l, U_vv))
def Y_rotation(l, angle):
Y_mm = np.zeros((2 * l + 1, 2 * l + 1))
sn = sin(angle)
cs = cos(angle)
for m1, point in enumerate(sphere_lm[l]):
x = point[0]
y = cs * point[1] - sn * point[2]
z = sn * point[1] + cs * point[2]
for m2 in range(2 * l + 1):
L = l**2 + m2
Y_mm[m1, m2] = Y(L, x, y, z)
return Y_mm
del s, identity
gpaw-0.11.0.13004/gpaw/poisson.py 0000664 0001750 0001750 00000056422 12553643472 016471 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
from math import pi
import warnings
import numpy as np
from numpy.fft import fftn, ifftn, fft2, ifft2
from gpaw.transformers import Transformer
from gpaw.fd_operators import Laplace, LaplaceA, LaplaceB
from gpaw import PoissonConvergenceError
from gpaw.utilities.blas import axpy
from gpaw.utilities.gauss import Gaussian
from gpaw.utilities.ewald import madelung
from gpaw.utilities.tools import construct_reciprocal
import _gpaw
POISSON_GRID_WARNING="""Grid unsuitable for Poisson solver!
The Poisson solver does not have sufficient multigrid levels for good
performance and will converge inefficiently if at all, or yield wrong
results.
You may need to manually specify a grid such that the number of points
along each direction is divisible by a high power of 2, such as 8, 16,
or 32 depending on system size; examples:
GPAW(gpts=(32, 32, 288))
or
from gpaw.tools import h2gpts
GPAW(gpts=h2gpts(0.2, atoms.get_cell(), idiv=16))
Parallelizing over very small domains can also undesirably limit the
number of multigrid levels even if the total number of grid points
is divisible by a high power of 2."""
class PoissonSolver:
def __init__(self, nn=3, relax='J', eps=2e-10, maxiter=1000,
remove_moment=None, use_charge_center=False):
self.relax = relax
self.nn = nn
self.eps = eps
self.charged_periodic_correction = None
self.maxiter = maxiter
self.remove_moment = remove_moment
self.use_charge_center = use_charge_center
# Relaxation method
if relax == 'GS':
# Gauss-Seidel
self.relax_method = 1
elif relax == 'J':
# Jacobi
self.relax_method = 2
else:
raise NotImplementedError('Relaxation method %s' % relax)
self.description = None
def get_stencil(self):
return self.nn
def set_grid_descriptor(self, gd):
# Should probably be renamed initialize
self.gd = gd
scale = -0.25 / pi
if self.nn == 'M':
if not gd.orthogonal:
raise RuntimeError('Cannot use Mehrstellen stencil with '
'non orthogonal cell.')
self.operators = [LaplaceA(gd, -scale)]
self.B = LaplaceB(gd)
else:
self.operators = [Laplace(gd, scale, self.nn)]
self.B = None
self.interpolators = []
self.restrictors = []
level = 0
self.presmooths = [2]
self.postsmooths = [1]
# Weights for the relaxation,
# only used if 'J' (Jacobi) is chosen as method
self.weights = [2.0 / 3.0]
while level < 8:
try:
gd2 = gd.coarsen()
except ValueError:
break
self.operators.append(Laplace(gd2, scale, 1))
self.interpolators.append(Transformer(gd2, gd))
self.restrictors.append(Transformer(gd, gd2))
self.presmooths.append(4)
self.postsmooths.append(4)
self.weights.append(1.0)
level += 1
gd = gd2
self.levels = level
if self.operators[-1].gd.N_c.max() > 36:
# Try to warn exactly once no matter how one uses the solver.
if gd.comm.parent is None:
warn = (gd.comm.rank == 0)
else:
warn = (gd.comm.parent.rank == 0)
if warn:
warntxt = '\n'.join([POISSON_GRID_WARNING, '',
self.get_description()])
else:
warntxt = ('Poisson warning from domain rank %d'
% self.gd.comm.rank)
# Warn from all ranks to avoid deadlocks.
warnings.warn(warntxt, stacklevel=2)
def get_description(self):
name = {1: 'Gauss-Seidel', 2: 'Jacobi'}[self.relax_method]
coarsest_grid = self.operators[-1].gd.N_c
coarsest_grid_string = ' x '.join([str(N) for N in coarsest_grid])
assert self.levels + 1 == len(self.operators)
lines = ['%s solver with %d multi-grid levels'
% (name, self.levels + 1),
' Coarsest grid: %s points' % coarsest_grid_string]
if coarsest_grid.max() > 24:
# This friendly warning has lower threshold than the big long
# one that we print when things are really bad.
lines.extend([' Warning: Coarse grid has more than 24 points.',
' More multi-grid levels recommended.'])
lines.extend([' Stencil: %s' % self.operators[0].description,
' Tolerance: %e' % self.eps,
' Max iterations: %d' % self.maxiter])
if self.remove_moment is not None:
lines.append(' Remove moments up to L=%d' % self.remove_moment)
if self.use_charge_center:
lines.append(' Compensate for charged system using center of '
'majority charge')
return '\n'.join(lines)
def initialize(self, load_gauss=False):
# Should probably be renamed allocate
gd = self.gd
self.rhos = [gd.empty()]
self.phis = [None]
self.residuals = [gd.empty()]
for level in range(self.levels):
gd2 = gd.coarsen()
self.phis.append(gd2.empty())
self.rhos.append(gd2.empty())
self.residuals.append(gd2.empty())
gd = gd2
assert len(self.phis) == len(self.rhos)
level += 1
assert level == self.levels
self.step = 0.66666666 / self.operators[0].get_diagonal_element()
self.presmooths[level] = 8
self.postsmooths[level] = 8
if load_gauss:
self.load_gauss()
def load_gauss(self, center=None):
if not hasattr(self, 'rho_gauss') or center is not None:
gauss = Gaussian(self.gd, center=center)
self.rho_gauss = gauss.get_gauss(0)
self.phi_gauss = gauss.get_gauss_pot(0)
def solve(self, phi, rho, charge=None, eps=None, maxcharge=1e-6,
zero_initial_phi=False):
if eps is None:
eps = self.eps
actual_charge = self.gd.integrate(rho)
background = (actual_charge / self.gd.dv /
self.gd.get_size_of_global_array().prod())
if self.remove_moment:
assert not self.gd.pbc_c.any()
if not hasattr(self, 'gauss'):
self.gauss = Gaussian(self.gd)
rho_neutral = rho.copy()
phi_cor_L = []
for L in range(self.remove_moment):
phi_cor_L.append(self.gauss.remove_moment(rho_neutral, L))
# Remove multipoles for better initial guess
for phi_cor in phi_cor_L:
phi -= phi_cor
niter = self.solve_neutral(phi, rho_neutral, eps=eps)
# correct error introduced by removing multipoles
for phi_cor in phi_cor_L:
phi += phi_cor
return niter
if charge is None:
charge = actual_charge
if abs(charge) <= maxcharge:
# System is charge neutral. Use standard solver
return self.solve_neutral(phi, rho - background, eps=eps)
elif abs(charge) > maxcharge and self.gd.pbc_c.all():
# System is charged and periodic. Subtract a homogeneous
# background charge
# Set initial guess for potential
if zero_initial_phi:
phi[:] = 0.0
iters = self.solve_neutral(phi, rho - background, eps=eps)
return iters
elif abs(charge) > maxcharge and not self.gd.pbc_c.any():
# The system is charged and in a non-periodic unit cell.
# Determine the potential by 1) subtract a gaussian from the
# density, 2) determine potential from the neutralized density
# and 3) add the potential from the gaussian density.
# Load necessary attributes
# use_charge_center: The monopole will be removed at the
# center of the majority charge, which prevents artificial
# dipoles.
# Due to the shape of the Gaussian and it's Fourier-Transform,
# the Gaussian representing the charge should stay at least
# 7 gpts from the borders - see:
# https://listserv.fysik.dtu.dk/pipermail/gpaw-developers/2015-July/005806.html
if self.use_charge_center:
charge_sign = actual_charge / abs(actual_charge)
rho_sign = rho * charge_sign
rho_sign[np.where(rho_sign < 0)] = 0
absolute_charge = self.gd.integrate(rho_sign)
center = - self.gd.calculate_dipole_moment(rho_sign) \
/ absolute_charge
border_offset = np.inner(self.gd.h_cv, np.array((7, 7, 7)))
borders = np.inner(self.gd.h_cv, self.gd.N_c)
borders -= border_offset
if np.any(center > borders) or np.any(center < border_offset):
raise RuntimeError(
'Poisson solver: center of charge outside' + \
' borders - please increase box')
center[np.where(center > borders)] = borders
self.load_gauss(center=center)
else:
self.load_gauss()
# Remove monopole moment
q = actual_charge / np.sqrt(4 * pi) # Monopole moment
rho_neutral = rho - q * self.rho_gauss # neutralized density
# Set initial guess for potential
if zero_initial_phi:
phi[:] = 0.0
else:
axpy(-q, self.phi_gauss, phi) # phi -= q * self.phi_gauss
# Determine potential from neutral density using standard solver
niter = self.solve_neutral(phi, rho_neutral, eps=eps)
# correct error introduced by removing monopole
axpy(q, self.phi_gauss, phi) # phi += q * self.phi_gauss
return niter
else:
# System is charged with mixed boundaryconditions
msg = ('Charged systems with mixed periodic/zero'
' boundary conditions')
raise NotImplementedError(msg)
def solve_neutral(self, phi, rho, eps=2e-10):
self.phis[0] = phi
if self.B is None:
self.rhos[0][:] = rho
else:
self.B.apply(rho, self.rhos[0])
niter = 1
maxiter = self.maxiter
while self.iterate2(self.step) > eps and niter < maxiter:
niter += 1
if niter == maxiter:
msg = 'Poisson solver did not converge in %d iterations!' % maxiter
raise PoissonConvergenceError(msg)
# Set the average potential to zero in periodic systems
if np.alltrue(self.gd.pbc_c):
phi_ave = self.gd.comm.sum(np.sum(phi.ravel()))
N_c = self.gd.get_size_of_global_array()
phi_ave /= np.product(N_c)
phi -= phi_ave
return niter
def iterate(self, step, level=0):
residual = self.residuals[level]
niter = 0
while True:
niter += 1
if level > 0 and niter == 1:
residual[:] = -self.rhos[level]
else:
self.operators[level].apply(self.phis[level], residual)
residual -= self.rhos[level]
error = self.gd.comm.sum(np.vdot(residual, residual))
if niter == 1 and level < self.levels:
self.restrictors[level].apply(residual, self.rhos[level + 1])
self.phis[level + 1][:] = 0.0
self.iterate(4.0 * step, level + 1)
self.interpolators[level].apply(self.phis[level + 1], residual)
self.phis[level] -= residual
continue
residual *= step
self.phis[level] -= residual
if niter == 2:
break
return error
def iterate2(self, step, level=0):
"""Smooths the solution in every multigrid level"""
residual = self.residuals[level]
if level < self.levels:
self.operators[level].relax(self.relax_method,
self.phis[level],
self.rhos[level],
self.presmooths[level],
self.weights[level])
self.operators[level].apply(self.phis[level], residual)
residual -= self.rhos[level]
self.restrictors[level].apply(residual,
self.rhos[level + 1])
self.phis[level + 1][:] = 0.0
self.iterate2(4.0 * step, level + 1)
self.interpolators[level].apply(self.phis[level + 1], residual)
self.phis[level] -= residual
self.operators[level].relax(self.relax_method,
self.phis[level],
self.rhos[level],
self.postsmooths[level],
self.weights[level])
if level == 0:
self.operators[level].apply(self.phis[level], residual)
residual -= self.rhos[level]
error = self.gd.comm.sum(np.dot(residual.ravel(),
residual.ravel())) * self.gd.dv
return error
def estimate_memory(self, mem):
# XXX Memory estimate works only for J and GS, not FFT solver
# Poisson solver appears to use same amount of memory regardless
# of whether it's J or GS, which is a bit strange
gdbytes = self.gd.bytecount()
nbytes = -gdbytes # No phi on finest grid, compensate ahead
for level in range(self.levels):
nbytes += 3 * gdbytes # Arrays: rho, phi, residual
gdbytes //= 8
mem.subnode('rho, phi, residual [%d levels]' % self.levels, nbytes)
def __repr__(self):
template = 'PoissonSolver(relax=\'%s\', nn=%s, eps=%e)'
representation = template % (self.relax, repr(self.nn), self.eps)
return representation
class NoInteractionPoissonSolver:
relax_method = 0
nn = 1
def get_description(self):
return 'No interaction'
def get_stencil(self):
return 1
def solve(self, phi, rho, charge):
return 0
def set_grid_descriptor(self, gd):
pass
def initialize(self):
pass
class FFTPoissonSolver(PoissonSolver):
"""FFT Poisson solver for general unit cells."""
relax_method = 0
nn = 999
def __init__(self, eps=2e-10):
self.charged_periodic_correction = None
self.remove_moment = None
self.eps = eps
def get_description(self):
return 'FFT'
def set_grid_descriptor(self, gd):
assert gd.pbc_c.all()
self.gd = gd
def initialize(self):
if self.gd.comm.rank == 0:
self.k2_Q, self.N3 = construct_reciprocal(self.gd)
def solve_neutral(self, phi_g, rho_g, eps=None):
if self.gd.comm.size == 1:
phi_g[:] = ifftn(fftn(rho_g) * 4.0 * pi / self.k2_Q).real
else:
rho_g = self.gd.collect(rho_g)
if self.gd.comm.rank == 0:
globalphi_g = ifftn(fftn(rho_g) * 4.0 * pi / self.k2_Q).real
else:
globalphi_g = None
self.gd.distribute(globalphi_g, phi_g)
return 1
class FixedBoundaryPoissonSolver(PoissonSolver):
"""Solve the Poisson equation with FFT in two directions,
and with central differential method in the third direction."""
def __init__(self, nn=1):
# XXX How can this work when it does not call __init___
# on PoissonSolver? -askhl
self.nn = nn
self.charged_periodic_correction = None
assert self.nn == 1
def set_grid_descriptor(self, gd):
assert gd.pbc_c.all()
assert gd.orthogonal
self.gd = gd
def initialize(self, b_phi1, b_phi2):
distribution = np.zeros([self.gd.comm.size], int)
if self.gd.comm.rank == 0:
gd = self.gd
N_c1 = gd.N_c[:2, np.newaxis]
i_cq = np.indices(gd.N_c[:2]).reshape((2, -1))
i_cq += N_c1 // 2
i_cq %= N_c1
i_cq -= N_c1 // 2
B_vc = 2.0 * np.pi * gd.icell_cv.T[:2, :2]
k_vq = np.dot(B_vc, i_cq)
k_vq *= k_vq
k_vq2 = np.sum(k_vq, axis=0)
k_vq2 = k_vq2.reshape(-1)
b_phi1 = fft2(b_phi1, None, (0, 1))
b_phi2 = fft2(b_phi2, None, (0, 1))
b_phi1 = b_phi1[:, :, -1].reshape(-1)
b_phi2 = b_phi2[:, :, 0].reshape(-1)
loc_b_phi1 = np.array_split(b_phi1, self.gd.comm.size)
loc_b_phi2 = np.array_split(b_phi2, self.gd.comm.size)
loc_k_vq2 = np.array_split(k_vq2, self.gd.comm.size)
self.loc_b_phi1 = loc_b_phi1[0]
self.loc_b_phi2 = loc_b_phi2[0]
self.k_vq2 = loc_k_vq2[0]
for i in range(self.gd.comm.size):
distribution[i] = len(loc_b_phi1[i])
self.gd.comm.broadcast(distribution, 0)
for i in range(1, self.gd.comm.size):
self.gd.comm.ssend(loc_b_phi1[i], i, 135)
self.gd.comm.ssend(loc_b_phi2[i], i, 246)
self.gd.comm.ssend(loc_k_vq2[i], i, 169)
else:
self.gd.comm.broadcast(distribution, 0)
self.loc_b_phi1 = np.zeros([distribution[self.gd.comm.rank]],
dtype=complex)
self.loc_b_phi2 = np.zeros([distribution[self.gd.comm.rank]],
dtype=complex)
self.k_vq2 = np.zeros([distribution[self.gd.comm.rank]])
self.gd.comm.receive(self.loc_b_phi1, 0, 135)
self.gd.comm.receive(self.loc_b_phi2, 0, 246)
self.gd.comm.receive(self.k_vq2, 0, 169)
k_distribution = np.arange(np.sum(distribution))
self.k_distribution = np.array_split(k_distribution,
self.gd.comm.size)
self.d1, self.d2, self.d3 = self.gd.N_c
self.r_distribution = np.array_split(np.arange(self.d3),
self.gd.comm.size)
self.comm_reshape = not (self.gd.parsize_c[0] == 1
and self.gd.parsize_c[1] == 1)
def solve(self, phi_g, rho_g, charge=None):
if charge is None:
actual_charge = self.gd.integrate(rho_g)
else:
actual_charge = charge
if self.charged_periodic_correction is None:
self.charged_periodic_correction = madelung(self.gd.cell_cv)
background = (actual_charge / self.gd.dv /
self.gd.get_size_of_global_array().prod())
self.solve_neutral(phi_g, rho_g - background)
phi_g += actual_charge * self.charged_periodic_correction
def scatter_r_distribution(self, global_rho_g, dtype=float):
d1 = self.d1
d2 = self.d2
comm = self.gd.comm
index = self.r_distribution[comm.rank]
if comm.rank == 0:
rho_g1 = global_rho_g[:, :, index]
for i in range(1, comm.size):
ind = self.r_distribution[i]
comm.ssend(global_rho_g[:, :, ind].copy(), i, 178)
else:
rho_g1 = np.zeros([d1, d2, len(index)], dtype=dtype)
comm.receive(rho_g1, 0, 178)
return rho_g1
def gather_r_distribution(self, rho_g, dtype=complex):
comm = self.gd.comm
index = self.r_distribution[comm.rank]
d1, d2, d3 = self.d1, self.d2, self.d3
if comm.rank == 0:
global_rho_g = np.zeros([d1, d2, d3], dtype)
global_rho_g[:, :, index] = rho_g
for i in range(1, comm.size):
ind = self.r_distribution[i]
rho_gi = np.zeros([d1, d2, len(ind)], dtype)
comm.receive(rho_gi, i, 368)
global_rho_g[:, :, ind] = rho_gi
else:
comm.ssend(rho_g, 0, 368)
global_rho_g = None
return global_rho_g
def scatter_k_distribution(self, global_rho_g):
comm = self.gd.comm
index = self.k_distribution[comm.rank]
if comm.rank == 0:
rho_g = global_rho_g[index]
for i in range(1, comm.size):
ind = self.k_distribution[i]
comm.ssend(global_rho_g[ind], i, 370)
else:
rho_g = np.zeros([len(index), self.d3], dtype=complex)
comm.receive(rho_g, 0, 370)
return rho_g
def gather_k_distribution(self, phi_g):
comm = self.gd.comm
index = self.k_distribution[comm.rank]
d12 = self.d1 * self.d2
if comm.rank == 0:
global_phi_g = np.zeros([d12, self.d3], dtype=complex)
global_phi_g[index] = phi_g
for i in range(1, comm.size):
ind = self.k_distribution[i]
phi_gi = np.zeros([len(ind), self.d3], dtype=complex)
comm.receive(phi_gi, i, 569)
global_phi_g[ind] = phi_gi
else:
comm.ssend(phi_g, 0, 569)
global_phi_g = None
return global_phi_g
def solve_neutral(self, phi_g, rho_g):
# b_phi1 and b_phi2 are the boundary Hartree potential values
# of left and right sides
if self.comm_reshape:
global_rho_g0 = self.gd.collect(rho_g)
rho_g1 = self.scatter_r_distribution(global_rho_g0)
else:
rho_g1 = rho_g
# use copy() to avoid the C_contiguous=False
rho_g2 = fft2(rho_g1, None, (0, 1)).copy()
global_rho_g = self.gather_r_distribution(rho_g2)
if self.gd.comm.rank == 0:
global_rho_g.shape = (self.d1 * self.d2, self.d3)
rho_g3 = self.scatter_k_distribution(global_rho_g)
du0 = np.zeros(self.d3 - 1, dtype=complex)
du20 = np.zeros(self.d3 - 2, dtype=complex)
h2 = self.gd.h_cv[2, 2] ** 2
phi_g1 = np.zeros(rho_g3.shape, dtype=complex)
index = self.k_distribution[self.gd.comm.rank]
for phi, rho, rv2, bp1, bp2, i in zip(phi_g1, rho_g3,
self.k_vq2,
self.loc_b_phi1,
self.loc_b_phi2,
range(len(index))):
A = np.zeros(self.d3, dtype=complex) + 2 + h2 * rv2
phi = rho * np.pi * 4 * h2
phi[0] += bp1
phi[-1] += bp2
du = du0 - 1
dl = du0 - 1
du2 = du20 - 1
_gpaw.linear_solve_tridiag(self.d3, A, du, dl, du2, phi)
phi_g1[i] = phi
global_phi_g = self.gather_k_distribution(phi_g1)
if self.gd.comm.rank == 0:
global_phi_g.shape = (self.d1, self.d2, self.d3)
phi_g2 = self.scatter_r_distribution(global_phi_g, dtype=complex)
# use copy() to avoid the C_contiguous=False
phi_g3 = ifft2(phi_g2, None, (0, 1)).real.copy()
if self.comm_reshape:
global_phi_g = self.gather_r_distribution(phi_g3, dtype=float)
self.gd.distribute(global_phi_g, phi_g)
else:
phi_g[:] = phi_g3
gpaw-0.11.0.13004/gpaw/sphere/ 0000775 0001750 0001750 00000000000 12553644063 015677 5 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/sphere/lebedev.py 0000664 0001750 0001750 00000066745 12553643472 017704 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
from __future__ import print_function
import numpy as np
def run():
from gpaw.spherical_harmonics import Y
weight_n = np.zeros(50)
Y_nL = np.zeros((50, 25))
R_nv = np.zeros((50, 3))
# We use 50 Lebedev quadrature points which will integrate
# spherical harmonics correctly for l < 12:
n = 0
for v in [0, 1, 2]:
for s in [-1, 1]:
R_nv[n, v] = s
n += 1
C = 2**-0.5
for v1 in [0, 1, 2]:
v2 = (v1 + 1) % 3
v3 = (v1 + 2) % 3
for s1 in [-1, 1]:
for s2 in [-1, 1]:
R_nv[n, v2] = s1 * C
R_nv[n, v3] = s2 * C
n += 1
C = 3**-0.5
for s1 in [-1, 1]:
for s2 in [-1, 1]:
for s3 in [-1, 1]:
R_nv[n] = (s1 * C, s2 * C, s3 * C)
n += 1
C1 = 0.30151134457776357
C2 = (1.0 - 2.0 * C1**2)**0.5
for v1 in [0, 1, 2]:
v2 = (v1 + 1) % 3
v3 = (v1 + 2) % 3
for s1 in [-1, 1]:
for s2 in [-1, 1]:
for s3 in [-1, 1]:
R_nv[n, v1] = s1 * C2
R_nv[n, v2] = s2 * C1
R_nv[n, v3] = s3 * C1
n += 1
assert n == 50
weight_n[0:6] = 0.01269841269841270
weight_n[6:18] = 0.02257495590828924
weight_n[18:26] = 0.02109375000000000
weight_n[26:50] = 0.02017333553791887
n = 0
for x, y, z in R_nv:
Y_nL[n] = [Y(L, x, y, z) for L in range(25)]
n += 1
# Write all 50 points to an xyz file as 50 hydrogen atoms:
f = open('50.xyz', 'w')
f.write('50\n\n')
for x, y, z in R_nv:
print('H', 4 * x, 4 * y, 4 * z, file=f)
#print np.dot(weights, Y_nL) * (4*pi)**.5
print('weight_n = np.array(%s)' % weight_n.tolist())
print('Y_nL = np.array(%s)' % Y_nL.tolist())
print('R_nv = np.array(%s)' % R_nv.tolist())
return weight_n, Y_nL, R_nv
if __name__ == '__main__':
run()
weight_n = np.array([0.0126984126984127, 0.0126984126984127, 0.0126984126984127, 0.0126984126984127, 0.0126984126984127, 0.0126984126984127, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.02257495590828924, 0.021093750000000001, 0.021093750000000001, 0.021093750000000001, 0.021093750000000001, 0.021093750000000001, 0.021093750000000001, 0.021093750000000001, 0.021093750000000001, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887, 0.02017333553791887])
Y_nL = np.array([[0.28209479177387814, 0.0, 0.0, -0.48860251190291992, 0.0, 0.0, -0.31539156525252005, 0.0, 0.54627421529603959, 0.0, 0.0, 0.0, 0.0, 0.45704579946446577, 0.0, -0.59004358992664352, 0.0, 0.0, 0.0, 0.0, 0.31735664074561293, 0.0, -0.47308734787878004, 0.0, 0.62583573544917614], [0.28209479177387814, 0.0, 0.0, 0.48860251190291992, 0.0, 0.0, -0.31539156525252005, 0.0, 0.54627421529603959, 0.0, 0.0, 0.0, 0.0, -0.45704579946446577, 0.0, 0.59004358992664352, 0.0, 0.0, 0.0, 0.0, 0.31735664074561293, 0.0, -0.47308734787878004, 0.0, 0.62583573544917614], [0.28209479177387814, -0.48860251190291992, 0.0, 0.0, 0.0, 0.0, -0.31539156525252005, 0.0, -0.54627421529603959, 0.59004358992664352, 0.0, 0.45704579946446577, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31735664074561293, 0.0, 0.47308734787878004, 0.0, 0.62583573544917614], [0.28209479177387814, 0.48860251190291992, 0.0, 0.0, 0.0, 0.0, -0.31539156525252005, 0.0, -0.54627421529603959, -0.59004358992664352, 0.0, -0.45704579946446577, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31735664074561293, 0.0, 0.47308734787878004, 0.0, 0.62583573544917614], [0.28209479177387814, 0.0, -0.48860251190291992, 0.0, 0.0, 0.0, 0.63078313050504009, 0.0, 0.0, 0.0, 0.0, 0.0, -0.7463526651802308, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.84628437532163447, 0.0, 0.0, 0.0, 0.0], [0.28209479177387814, 0.0, 0.48860251190291992, 0.0, 0.0, 0.0, 0.63078313050504009, 0.0, 0.0, 0.0, 0.0, 0.0, 0.7463526651802308, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.84628437532163447, 0.0, 0.0, 0.0, 0.0], [0.28209479177387814, -0.3454941494713355, -0.3454941494713355, 0.0, 0.0, 0.54627421529603959, 0.15769578262626005, 0.0, -0.27313710764801985, 0.2086119118163921, 0.0, -0.4847702761712262, 0.13193775767639854, 0.0, 0.51099273821664126, 0.0, 0.0, -0.44253269244498283, 0.0, 0.16726163588932241, -0.34380302747441421, 0.0, -0.59135918484847527, 0.0, 0.15645893386229406], [0.28209479177387814, -0.3454941494713355, 0.3454941494713355, 0.0, 0.0, -0.54627421529603959, 0.15769578262626005, 0.0, -0.27313710764801985, 0.2086119118163921, 0.0, -0.4847702761712262, -0.13193775767639854, 0.0, -0.51099273821664126, 0.0, 0.0, 0.44253269244498283, 0.0, -0.16726163588932241, -0.34380302747441421, 0.0, -0.59135918484847527, 0.0, 0.15645893386229406], [0.28209479177387814, 0.3454941494713355, -0.3454941494713355, 0.0, 0.0, -0.54627421529603959, 0.15769578262626005, 0.0, -0.27313710764801985, -0.2086119118163921, 0.0, 0.4847702761712262, 0.13193775767639854, 0.0, 0.51099273821664126, 0.0, 0.0, 0.44253269244498283, 0.0, -0.16726163588932241, -0.34380302747441421, 0.0, -0.59135918484847527, 0.0, 0.15645893386229406], [0.28209479177387814, 0.3454941494713355, 0.3454941494713355, 0.0, 0.0, 0.54627421529603959, 0.15769578262626005, 0.0, -0.27313710764801985, -0.2086119118163921, 0.0, 0.4847702761712262, -0.13193775767639854, 0.0, -0.51099273821664126, 0.0, 0.0, -0.44253269244498283, 0.0, 0.16726163588932241, -0.34380302747441421, 0.0, -0.59135918484847527, 0.0, 0.15645893386229406], [0.28209479177387814, 0.0, -0.3454941494713355, -0.3454941494713355, 0.0, 0.0, 0.15769578262626005, 0.54627421529603959, 0.27313710764801985, 0.0, 0.0, 0.0, 0.13193775767639854, -0.4847702761712262, -0.51099273821664126, -0.2086119118163921, 0.0, 0.0, 0.0, 0.0, -0.34380302747441421, 0.16726163588932241, 0.59135918484847527, 0.44253269244498283, 0.15645893386229406], [0.28209479177387814, 0.0, -0.3454941494713355, 0.3454941494713355, 0.0, 0.0, 0.15769578262626005, -0.54627421529603959, 0.27313710764801985, 0.0, 0.0, 0.0, 0.13193775767639854, 0.4847702761712262, -0.51099273821664126, 0.2086119118163921, 0.0, 0.0, 0.0, 0.0, -0.34380302747441421, -0.16726163588932241, 0.59135918484847527, -0.44253269244498283, 0.15645893386229406], [0.28209479177387814, 0.0, 0.3454941494713355, -0.3454941494713355, 0.0, 0.0, 0.15769578262626005, -0.54627421529603959, 0.27313710764801985, 0.0, 0.0, 0.0, -0.13193775767639854, -0.4847702761712262, 0.51099273821664126, -0.2086119118163921, 0.0, 0.0, 0.0, 0.0, -0.34380302747441421, -0.16726163588932241, 0.59135918484847527, -0.44253269244498283, 0.15645893386229406], [0.28209479177387814, 0.0, 0.3454941494713355, 0.3454941494713355, 0.0, 0.0, 0.15769578262626005, 0.54627421529603959, 0.27313710764801985, 0.0, 0.0, 0.0, -0.13193775767639854, 0.4847702761712262, 0.51099273821664126, 0.2086119118163921, 0.0, 0.0, 0.0, 0.0, -0.34380302747441421, 0.16726163588932241, 0.59135918484847527, 0.44253269244498283, 0.15645893386229406], [0.28209479177387814, -0.3454941494713355, 0.0, -0.3454941494713355, 0.54627421529603959, 0.0, -0.3153915652525201, 0.0, 0.0, -0.41722382363278415, 0.0, 0.32318018411415073, 0.0, 0.32318018411415073, 0.0, 0.41722382363278415, -1.1102230246251565e-16, 0.0, -0.47308734787878015, 0.0, 0.31735664074561298, 0.0, 0.0, 0.0, -0.62583573544917659], [0.28209479177387814, 0.3454941494713355, 0.0, -0.3454941494713355, -0.54627421529603959, 0.0, -0.3153915652525201, 0.0, 0.0, 0.41722382363278415, 0.0, -0.32318018411415073, 0.0, 0.32318018411415073, 0.0, 0.41722382363278415, 1.1102230246251565e-16, 0.0, 0.47308734787878015, 0.0, 0.31735664074561298, 0.0, 0.0, 0.0, -0.62583573544917659], [0.28209479177387814, -0.3454941494713355, 0.0, 0.3454941494713355, -0.54627421529603959, 0.0, -0.3153915652525201, 0.0, 0.0, -0.41722382363278415, 0.0, 0.32318018411415073, 0.0, -0.32318018411415073, 0.0, -0.41722382363278415, 1.1102230246251565e-16, 0.0, 0.47308734787878015, 0.0, 0.31735664074561298, 0.0, 0.0, 0.0, -0.62583573544917659], [0.28209479177387814, 0.3454941494713355, 0.0, 0.3454941494713355, 0.54627421529603959, 0.0, -0.3153915652525201, 0.0, 0.0, 0.41722382363278415, 0.0, -0.32318018411415073, 0.0, -0.32318018411415073, 0.0, -0.41722382363278415, -1.1102230246251565e-16, 0.0, -0.47308734787878015, 0.0, 0.31735664074561298, 0.0, 0.0, 0.0, -0.62583573544917659], [0.28209479177387814, -0.28209479177387814, -0.28209479177387814, -0.28209479177387814, 0.36418281019735971, 0.36418281019735971, 0.0, 0.36418281019735971, 0.0, -0.22710788365184043, -0.55629843151037861, -0.17591701023519801, 0.28727127476813386, -0.17591701023519801, 0.0, 0.22710788365184048, 0.0, 0.3933623932844289, 0.42052208700336002, -0.14867700967939762, -0.32911059040285784, -0.14867700967939762, 0.0, -0.3933623932844289, -0.27814921575518947], [0.28209479177387814, -0.28209479177387814, 0.28209479177387814, -0.28209479177387814, 0.36418281019735971, -0.36418281019735971, 0.0, -0.36418281019735971, 0.0, -0.22710788365184043, 0.55629843151037861, -0.17591701023519801, -0.28727127476813386, -0.17591701023519801, 0.0, 0.22710788365184048, 0.0, -0.3933623932844289, 0.42052208700336002, 0.14867700967939762, -0.32911059040285784, 0.14867700967939762, 0.0, 0.3933623932844289, -0.27814921575518947], [0.28209479177387814, 0.28209479177387814, -0.28209479177387814, -0.28209479177387814, -0.36418281019735971, -0.36418281019735971, 0.0, 0.36418281019735971, 0.0, 0.22710788365184043, 0.55629843151037861, 0.17591701023519801, 0.28727127476813386, -0.17591701023519801, 0.0, 0.22710788365184048, 0.0, -0.3933623932844289, -0.42052208700336002, 0.14867700967939762, -0.32911059040285784, -0.14867700967939762, 0.0, -0.3933623932844289, -0.27814921575518947], [0.28209479177387814, 0.28209479177387814, 0.28209479177387814, -0.28209479177387814, -0.36418281019735971, 0.36418281019735971, 0.0, -0.36418281019735971, 0.0, 0.22710788365184043, -0.55629843151037861, 0.17591701023519801, -0.28727127476813386, -0.17591701023519801, 0.0, 0.22710788365184048, 0.0, 0.3933623932844289, -0.42052208700336002, -0.14867700967939762, -0.32911059040285784, 0.14867700967939762, 0.0, 0.3933623932844289, -0.27814921575518947], [0.28209479177387814, -0.28209479177387814, -0.28209479177387814, 0.28209479177387814, -0.36418281019735971, 0.36418281019735971, 0.0, -0.36418281019735971, 0.0, -0.22710788365184043, 0.55629843151037861, -0.17591701023519801, 0.28727127476813386, 0.17591701023519801, 0.0, -0.22710788365184048, 0.0, 0.3933623932844289, -0.42052208700336002, -0.14867700967939762, -0.32911059040285784, 0.14867700967939762, 0.0, 0.3933623932844289, -0.27814921575518947], [0.28209479177387814, -0.28209479177387814, 0.28209479177387814, 0.28209479177387814, -0.36418281019735971, -0.36418281019735971, 0.0, 0.36418281019735971, 0.0, -0.22710788365184043, -0.55629843151037861, -0.17591701023519801, -0.28727127476813386, 0.17591701023519801, 0.0, -0.22710788365184048, 0.0, -0.3933623932844289, -0.42052208700336002, 0.14867700967939762, -0.32911059040285784, -0.14867700967939762, 0.0, -0.3933623932844289, -0.27814921575518947], [0.28209479177387814, 0.28209479177387814, -0.28209479177387814, 0.28209479177387814, 0.36418281019735971, -0.36418281019735971, 0.0, -0.36418281019735971, 0.0, 0.22710788365184043, -0.55629843151037861, 0.17591701023519801, 0.28727127476813386, 0.17591701023519801, 0.0, -0.22710788365184048, 0.0, -0.3933623932844289, 0.42052208700336002, 0.14867700967939762, -0.32911059040285784, 0.14867700967939762, 0.0, 0.3933623932844289, -0.27814921575518947], [0.28209479177387814, 0.28209479177387814, 0.28209479177387814, 0.28209479177387814, 0.36418281019735971, 0.36418281019735971, 0.0, 0.36418281019735971, 0.0, 0.22710788365184043, 0.55629843151037861, 0.17591701023519801, -0.28727127476813386, 0.17591701023519801, 0.0, -0.22710788365184048, 0.0, 0.3933623932844289, 0.42052208700336002, -0.14867700967939762, -0.32911059040285784, -0.14867700967939762, 0.0, -0.3933623932844289, -0.27814921575518947], [0.28209479177387814, -0.14731920032792212, -0.14731920032792212, -0.44195760098376641, 0.29796775379783974, 0.099322584599279895, -0.22937568382001461, 0.29796775379783974, 0.39729033839711975, -0.42050234001046305, -0.23769603892429697, 0.07516608738008182, 0.28640664895524026, 0.22549826214024549, -0.31692805189906265, -0.29111700462262841, 0.49653083143075138, 0.38035867780395194, -0.093835507017278719, -0.14376206721065715, 0.05944972884490831, -0.43128620163197151, -0.12511400935637168, 0.26332523847965916, 0.14482149250063592], [0.28209479177387814, -0.14731920032792212, 0.14731920032792212, -0.44195760098376641, 0.29796775379783974, -0.099322584599279895, -0.22937568382001461, -0.29796775379783974, 0.39729033839711975, -0.42050234001046305, 0.23769603892429697, 0.07516608738008182, -0.28640664895524026, 0.22549826214024549, 0.31692805189906265, -0.29111700462262841, 0.49653083143075138, -0.38035867780395194, -0.093835507017278719, 0.14376206721065715, 0.05944972884490831, 0.43128620163197151, -0.12511400935637168, -0.26332523847965916, 0.14482149250063592], [0.28209479177387814, 0.14731920032792212, -0.14731920032792212, -0.44195760098376641, -0.29796775379783974, -0.099322584599279895, -0.22937568382001461, 0.29796775379783974, 0.39729033839711975, 0.42050234001046305, 0.23769603892429697, -0.07516608738008182, 0.28640664895524026, 0.22549826214024549, -0.31692805189906265, -0.29111700462262841, -0.49653083143075138, -0.38035867780395194, 0.093835507017278719, 0.14376206721065715, 0.05944972884490831, -0.43128620163197151, -0.12511400935637168, 0.26332523847965916, 0.14482149250063592], [0.28209479177387814, 0.14731920032792212, 0.14731920032792212, -0.44195760098376641, -0.29796775379783974, 0.099322584599279895, -0.22937568382001461, -0.29796775379783974, 0.39729033839711975, 0.42050234001046305, -0.23769603892429697, -0.07516608738008182, -0.28640664895524026, 0.22549826214024549, 0.31692805189906265, -0.29111700462262841, -0.49653083143075138, 0.38035867780395194, 0.093835507017278719, -0.14376206721065715, 0.05944972884490831, 0.43128620163197151, -0.12511400935637168, -0.26332523847965916, 0.14482149250063592], [0.28209479177387814, -0.14731920032792212, -0.14731920032792212, 0.44195760098376641, -0.29796775379783974, 0.099322584599279895, -0.22937568382001461, -0.29796775379783974, 0.39729033839711975, -0.42050234001046305, 0.23769603892429697, 0.07516608738008182, 0.28640664895524026, -0.22549826214024549, -0.31692805189906265, 0.29111700462262841, -0.49653083143075138, 0.38035867780395194, 0.093835507017278719, -0.14376206721065715, 0.05944972884490831, 0.43128620163197151, -0.12511400935637168, -0.26332523847965916, 0.14482149250063592], [0.28209479177387814, -0.14731920032792212, 0.14731920032792212, 0.44195760098376641, -0.29796775379783974, -0.099322584599279895, -0.22937568382001461, 0.29796775379783974, 0.39729033839711975, -0.42050234001046305, -0.23769603892429697, 0.07516608738008182, -0.28640664895524026, -0.22549826214024549, 0.31692805189906265, 0.29111700462262841, -0.49653083143075138, -0.38035867780395194, 0.093835507017278719, 0.14376206721065715, 0.05944972884490831, -0.43128620163197151, -0.12511400935637168, 0.26332523847965916, 0.14482149250063592], [0.28209479177387814, 0.14731920032792212, -0.14731920032792212, 0.44195760098376641, 0.29796775379783974, -0.099322584599279895, -0.22937568382001461, -0.29796775379783974, 0.39729033839711975, 0.42050234001046305, -0.23769603892429697, -0.07516608738008182, 0.28640664895524026, -0.22549826214024549, -0.31692805189906265, 0.29111700462262841, 0.49653083143075138, -0.38035867780395194, -0.093835507017278719, 0.14376206721065715, 0.05944972884490831, 0.43128620163197151, -0.12511400935637168, -0.26332523847965916, 0.14482149250063592], [0.28209479177387814, 0.14731920032792212, 0.14731920032792212, 0.44195760098376641, 0.29796775379783974, 0.099322584599279895, -0.22937568382001461, 0.29796775379783974, 0.39729033839711975, 0.42050234001046305, 0.23769603892429697, -0.07516608738008182, -0.28640664895524026, -0.22549826214024549, 0.31692805189906265, 0.29111700462262841, 0.49653083143075138, 0.38035867780395194, -0.093835507017278719, -0.14376206721065715, 0.05944972884490831, -0.43128620163197151, -0.12511400935637168, 0.26332523847965916, 0.14482149250063592], [0.28209479177387814, -0.44195760098376641, -0.14731920032792212, -0.14731920032792212, 0.29796775379783974, 0.29796775379783974, -0.22937568382001461, 0.099322584599279895, -0.39729033839711975, 0.29111700462262841, -0.23769603892429697, 0.22549826214024549, 0.28640664895524026, 0.07516608738008182, 0.31692805189906265, 0.42050234001046305, -0.49653083143075133, -0.26332523847965916, -0.093835507017278746, -0.43128620163197157, 0.059449728844908303, -0.14376206721065715, 0.12511400935637171, -0.38035867780395199, 0.14482149250063592], [0.28209479177387814, -0.44195760098376641, -0.14731920032792212, 0.14731920032792212, -0.29796775379783974, 0.29796775379783974, -0.22937568382001461, -0.099322584599279895, -0.39729033839711975, 0.29111700462262841, 0.23769603892429697, 0.22549826214024549, 0.28640664895524026, -0.07516608738008182, 0.31692805189906265, -0.42050234001046305, 0.49653083143075133, -0.26332523847965916, 0.093835507017278746, -0.43128620163197157, 0.059449728844908303, 0.14376206721065715, 0.12511400935637171, 0.38035867780395199, 0.14482149250063592], [0.28209479177387814, -0.44195760098376641, 0.14731920032792212, -0.14731920032792212, 0.29796775379783974, -0.29796775379783974, -0.22937568382001461, -0.099322584599279895, -0.39729033839711975, 0.29111700462262841, 0.23769603892429697, 0.22549826214024549, -0.28640664895524026, 0.07516608738008182, -0.31692805189906265, 0.42050234001046305, -0.49653083143075133, 0.26332523847965916, -0.093835507017278746, 0.43128620163197157, 0.059449728844908303, 0.14376206721065715, 0.12511400935637171, 0.38035867780395199, 0.14482149250063592], [0.28209479177387814, -0.44195760098376641, 0.14731920032792212, 0.14731920032792212, -0.29796775379783974, -0.29796775379783974, -0.22937568382001461, 0.099322584599279895, -0.39729033839711975, 0.29111700462262841, -0.23769603892429697, 0.22549826214024549, -0.28640664895524026, -0.07516608738008182, -0.31692805189906265, -0.42050234001046305, 0.49653083143075133, 0.26332523847965916, 0.093835507017278746, 0.43128620163197157, 0.059449728844908303, -0.14376206721065715, 0.12511400935637171, -0.38035867780395199, 0.14482149250063592], [0.28209479177387814, 0.44195760098376641, -0.14731920032792212, -0.14731920032792212, -0.29796775379783974, -0.29796775379783974, -0.22937568382001461, 0.099322584599279895, -0.39729033839711975, -0.29111700462262841, 0.23769603892429697, -0.22549826214024549, 0.28640664895524026, 0.07516608738008182, 0.31692805189906265, 0.42050234001046305, 0.49653083143075133, 0.26332523847965916, 0.093835507017278746, 0.43128620163197157, 0.059449728844908303, -0.14376206721065715, 0.12511400935637171, -0.38035867780395199, 0.14482149250063592], [0.28209479177387814, 0.44195760098376641, -0.14731920032792212, 0.14731920032792212, 0.29796775379783974, -0.29796775379783974, -0.22937568382001461, -0.099322584599279895, -0.39729033839711975, -0.29111700462262841, -0.23769603892429697, -0.22549826214024549, 0.28640664895524026, -0.07516608738008182, 0.31692805189906265, -0.42050234001046305, -0.49653083143075133, 0.26332523847965916, -0.093835507017278746, 0.43128620163197157, 0.059449728844908303, 0.14376206721065715, 0.12511400935637171, 0.38035867780395199, 0.14482149250063592], [0.28209479177387814, 0.44195760098376641, 0.14731920032792212, -0.14731920032792212, -0.29796775379783974, 0.29796775379783974, -0.22937568382001461, -0.099322584599279895, -0.39729033839711975, -0.29111700462262841, -0.23769603892429697, -0.22549826214024549, -0.28640664895524026, 0.07516608738008182, -0.31692805189906265, 0.42050234001046305, 0.49653083143075133, -0.26332523847965916, 0.093835507017278746, -0.43128620163197157, 0.059449728844908303, 0.14376206721065715, 0.12511400935637171, 0.38035867780395199, 0.14482149250063592], [0.28209479177387814, 0.44195760098376641, 0.14731920032792212, 0.14731920032792212, 0.29796775379783974, 0.29796775379783974, -0.22937568382001461, 0.099322584599279895, -0.39729033839711975, -0.29111700462262841, 0.23769603892429697, -0.22549826214024549, -0.28640664895524026, -0.07516608738008182, -0.31692805189906265, -0.42050234001046305, -0.49653083143075133, -0.26332523847965916, -0.093835507017278746, -0.43128620163197157, 0.059449728844908303, -0.14376206721065715, 0.12511400935637171, -0.38035867780395199, 0.14482149250063592], [0.28209479177387814, -0.14731920032792212, -0.44195760098376641, -0.14731920032792212, 0.099322584599279895, 0.29796775379783974, 0.45875136764002922, 0.29796775379783974, 0.0, -0.032346333846958689, -0.23769603892429694, -0.4259411618204636, -0.36823712008530907, -0.4259411618204636, 0.0, 0.032346333846958689, 3.4694469519536142e-18, 0.087775079493219665, 0.40662053040820756, 0.49763792495996717, 0.19933144377410417, 0.49763792495996717, 0.0, -0.087775079493219665, -0.020688784642947957], [0.28209479177387814, 0.14731920032792212, -0.44195760098376641, -0.14731920032792212, -0.099322584599279895, -0.29796775379783974, 0.45875136764002922, 0.29796775379783974, 0.0, 0.032346333846958689, 0.23769603892429694, 0.4259411618204636, -0.36823712008530907, -0.4259411618204636, 0.0, 0.032346333846958689, -3.4694469519536142e-18, -0.087775079493219665, -0.40662053040820756, -0.49763792495996717, 0.19933144377410417, 0.49763792495996717, 0.0, -0.087775079493219665, -0.020688784642947957], [0.28209479177387814, -0.14731920032792212, -0.44195760098376641, 0.14731920032792212, -0.099322584599279895, 0.29796775379783974, 0.45875136764002922, -0.29796775379783974, 0.0, -0.032346333846958689, 0.23769603892429694, -0.4259411618204636, -0.36823712008530907, 0.4259411618204636, 0.0, -0.032346333846958689, -3.4694469519536142e-18, 0.087775079493219665, -0.40662053040820756, 0.49763792495996717, 0.19933144377410417, -0.49763792495996717, 0.0, 0.087775079493219665, -0.020688784642947957], [0.28209479177387814, 0.14731920032792212, -0.44195760098376641, 0.14731920032792212, 0.099322584599279895, -0.29796775379783974, 0.45875136764002922, -0.29796775379783974, 0.0, 0.032346333846958689, -0.23769603892429694, 0.4259411618204636, -0.36823712008530907, 0.4259411618204636, 0.0, -0.032346333846958689, 3.4694469519536142e-18, -0.087775079493219665, 0.40662053040820756, -0.49763792495996717, 0.19933144377410417, -0.49763792495996717, 0.0, 0.087775079493219665, -0.020688784642947957], [0.28209479177387814, -0.14731920032792212, 0.44195760098376641, -0.14731920032792212, 0.099322584599279895, -0.29796775379783974, 0.45875136764002922, -0.29796775379783974, 0.0, -0.032346333846958689, 0.23769603892429694, -0.4259411618204636, 0.36823712008530907, -0.4259411618204636, 0.0, 0.032346333846958689, 3.4694469519536142e-18, -0.087775079493219665, 0.40662053040820756, -0.49763792495996717, 0.19933144377410417, -0.49763792495996717, 0.0, 0.087775079493219665, -0.020688784642947957], [0.28209479177387814, 0.14731920032792212, 0.44195760098376641, -0.14731920032792212, -0.099322584599279895, 0.29796775379783974, 0.45875136764002922, -0.29796775379783974, 0.0, 0.032346333846958689, -0.23769603892429694, 0.4259411618204636, 0.36823712008530907, -0.4259411618204636, 0.0, 0.032346333846958689, -3.4694469519536142e-18, 0.087775079493219665, -0.40662053040820756, 0.49763792495996717, 0.19933144377410417, -0.49763792495996717, 0.0, 0.087775079493219665, -0.020688784642947957], [0.28209479177387814, -0.14731920032792212, 0.44195760098376641, 0.14731920032792212, -0.099322584599279895, -0.29796775379783974, 0.45875136764002922, 0.29796775379783974, 0.0, -0.032346333846958689, -0.23769603892429694, -0.4259411618204636, 0.36823712008530907, 0.4259411618204636, 0.0, -0.032346333846958689, -3.4694469519536142e-18, -0.087775079493219665, -0.40662053040820756, -0.49763792495996717, 0.19933144377410417, 0.49763792495996717, 0.0, -0.087775079493219665, -0.020688784642947957], [0.28209479177387814, 0.14731920032792212, 0.44195760098376641, 0.14731920032792212, 0.099322584599279895, 0.29796775379783974, 0.45875136764002922, 0.29796775379783974, 0.0, 0.032346333846958689, 0.23769603892429694, 0.4259411618204636, 0.36823712008530907, 0.4259411618204636, 0.0, -0.032346333846958689, 3.4694469519536142e-18, 0.087775079493219665, 0.40662053040820756, 0.49763792495996717, 0.19933144377410417, 0.49763792495996717, 0.0, -0.087775079493219665, -0.020688784642947957]])
R_nv = np.array([[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0], [0.0, 0.0, 1.0], [0.0, -0.70710678118654757, -0.70710678118654757], [0.0, -0.70710678118654757, 0.70710678118654757], [0.0, 0.70710678118654757, -0.70710678118654757], [0.0, 0.70710678118654757, 0.70710678118654757], [-0.70710678118654757, 0.0, -0.70710678118654757], [0.70710678118654757, 0.0, -0.70710678118654757], [-0.70710678118654757, 0.0, 0.70710678118654757], [0.70710678118654757, 0.0, 0.70710678118654757], [-0.70710678118654757, -0.70710678118654757, 0.0], [-0.70710678118654757, 0.70710678118654757, 0.0], [0.70710678118654757, -0.70710678118654757, 0.0], [0.70710678118654757, 0.70710678118654757, 0.0], [-0.57735026918962573, -0.57735026918962573, -0.57735026918962573], [-0.57735026918962573, -0.57735026918962573, 0.57735026918962573], [-0.57735026918962573, 0.57735026918962573, -0.57735026918962573], [-0.57735026918962573, 0.57735026918962573, 0.57735026918962573], [0.57735026918962573, -0.57735026918962573, -0.57735026918962573], [0.57735026918962573, -0.57735026918962573, 0.57735026918962573], [0.57735026918962573, 0.57735026918962573, -0.57735026918962573], [0.57735026918962573, 0.57735026918962573, 0.57735026918962573], [-0.90453403373329089, -0.30151134457776357, -0.30151134457776357], [-0.90453403373329089, -0.30151134457776357, 0.30151134457776357], [-0.90453403373329089, 0.30151134457776357, -0.30151134457776357], [-0.90453403373329089, 0.30151134457776357, 0.30151134457776357], [0.90453403373329089, -0.30151134457776357, -0.30151134457776357], [0.90453403373329089, -0.30151134457776357, 0.30151134457776357], [0.90453403373329089, 0.30151134457776357, -0.30151134457776357], [0.90453403373329089, 0.30151134457776357, 0.30151134457776357], [-0.30151134457776357, -0.90453403373329089, -0.30151134457776357], [0.30151134457776357, -0.90453403373329089, -0.30151134457776357], [-0.30151134457776357, -0.90453403373329089, 0.30151134457776357], [0.30151134457776357, -0.90453403373329089, 0.30151134457776357], [-0.30151134457776357, 0.90453403373329089, -0.30151134457776357], [0.30151134457776357, 0.90453403373329089, -0.30151134457776357], [-0.30151134457776357, 0.90453403373329089, 0.30151134457776357], [0.30151134457776357, 0.90453403373329089, 0.30151134457776357], [-0.30151134457776357, -0.30151134457776357, -0.90453403373329089], [-0.30151134457776357, 0.30151134457776357, -0.90453403373329089], [0.30151134457776357, -0.30151134457776357, -0.90453403373329089], [0.30151134457776357, 0.30151134457776357, -0.90453403373329089], [-0.30151134457776357, -0.30151134457776357, 0.90453403373329089], [-0.30151134457776357, 0.30151134457776357, 0.90453403373329089], [0.30151134457776357, -0.30151134457776357, 0.90453403373329089], [0.30151134457776357, 0.30151134457776357, 0.90453403373329089]])
gpaw-0.11.0.13004/gpaw/sphere/csh.py 0000664 0001750 0001750 00000021733 12553643472 017037 0 ustar jensj jensj 0000000 0000000 from math import factorial as fact
import numpy as np
from gpaw.sphere import lmfact
from gpaw.sphere.legendre import ilegendre, legendre, dlegendre
# Define the Heaviside function
heaviside = lambda x: (1.0+np.sign(x))/2.0
# Define spherical harmoncics and normalization coefficient
C = lambda l,m: (-1)**((m+abs(m))//2)*((2.*l+1.)/(4*np.pi*lmfact(l,m)))**0.5
Y = lambda l,m,theta,phi: C(l,m)*legendre(l,abs(m),np.cos(theta))*np.exp(1j*m*phi)
# Define theta-derivative of spherical harmoncics
dYdtheta = lambda l,m,theta,phi: C(l,m)*dlegendre(l,abs(m),np.cos(theta))*np.exp(1j*m*phi)
# Define phi-derivative of spherical harmoncics
dYdphi = lambda l,m,theta,phi: 1j*m*C(l,m)*legendre(l,abs(m),np.cos(theta))*np.exp(1j*m*phi)
# -------------------------------------------------------------------
def intYY(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / *
A = | | Y (u,v) Y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if l1 = l2 and m1 = m2.
"""
if (l1,m1) == (l2,m2):
return C(l1,m1)**2*2*np.pi*ilegendre(l1,m1) # == 1 always, XXX right?
else:
return 0.0
# -------------------------------------------------------------------
def intYY_ex(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / *
A = | | Y (u,v) sin(u)*cos(v) Y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and `|m1-m2|` = 1.
"""
if abs(l1-l2) != 1 or abs(m1-m2) != 1:
return 0.0
scale = C(l1,m1)*C(l2,m2)*np.pi
if abs(m1) == abs(m2)+1:
return scale*np.sign(l1-l2)/(2.*l2+1.)*ilegendre(l1,m1)
else:
assert abs(m1) == abs(m2)-1
return scale*np.sign(l2-l1)/(2.*l1+1.)*ilegendre(l2,m2)
def intYY_ey(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / *
A = | | Y (u,v) sin(u)*sin(v) Y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and `|m1-m2|` = 1.
"""
if abs(l1-l2) != 1 or abs(m1-m2) != 1:
return 0.0
scale = C(l1,m1)*C(l2,m2)*np.sign(m1-m2)*np.pi/1j
if abs(m1) == abs(m2)+1:
return scale*np.sign(l1-l2)/(2.*l2+1.)*ilegendre(l1,m1)
else:
assert abs(m1) == abs(m2)-1
return scale*np.sign(l2-l1)/(2.*l1+1.)*ilegendre(l2,m2)
def intYY_ez(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / *
A = | | Y (u,v) cos(u) Y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and m1 = m2.
"""
if abs(l1-l2) != 1 or m1 != m2:
return 0.0
scale = C(l1,m1)*C(l2,m2)*2*np.pi
return scale*(l2-np.sign(l1-l2)*abs(m1)+heaviside(l1-l2))/(2.*l2+1.)*ilegendre(l1,m1)
# -------------------------------------------------------------------
def intYdYdtheta_ex(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / * d Y(u,v)
A = | | Y (u,v) cos(u)*cos(v) --- l'm' sin(u) dv du
LL' / / lm du
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
return 0.0
scale = -C(l1,m1)*C(l2,m2)*np.pi
if abs(m1) == abs(m2)+1:
if l1+1 == l2:
return scale*2/(2.0*l2+1)*(l2+1)/(2.0*l2-1.0)*fact(l2+abs(m2))/fact(l2-abs(m2)-1)*(l2-abs(m2)-1)
elif l1-1 == l2:
return scale*2/(2.0*l2+1)*((l2+1)*fact(l2+abs(m2))/fact(l2-abs(m2))*(l2-abs(m2))-l2/(2.0*l2+3.0)*fact(l2+abs(m2)+1)/fact(l2-abs(m2))*(l2-abs(m2)+1))
elif l1-l2 > 2: # and (l1-l2)%2 == 1 which is always true
return -scale*2*abs(m2)*fact(l2+abs(m2))/fact(l2-abs(m2))
else:
return 0.0
else:
assert abs(m1) == abs(m2)-1
if l1 == l2+1:
return -scale*2/(2.0*l1+1.0)*(l1-1)/(2.0*l1-1.0)*fact(l1+abs(m1))/fact(l1-abs(m1)-1)*(l1-abs(m1)-1)
elif l1 == l2-1:
return -scale*2/(2.0*l1+1.0)*((l1+1)/(2.0*l1+3.0)*fact(l1+abs(m1)+1)/fact(l1-abs(m1))*(l1-abs(m1)+1)-(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))*(l1-abs(m1)))
elif l2-l1 > 2: # and (l2-l1)%2 == 1 which is always true
return scale*2*(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))
else:
return 0.0
def intYdYdtheta_ey(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / * d Y(u,v)
A = | | Y (u,v) cos(u)*sin(v) --- l'm' sin(u) dv du
LL' / / lm du
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
return 0.0
scale = -C(l1,m1)*C(l2,m2)*np.sign(m1-m2)*np.pi/1j
if abs(m1) == abs(m2)+1:
if l1+1 == l2:
return scale*2/(2.0*l2+1)*(l2+1)/(2.0*l2-1.0)*fact(l2+abs(m2))/fact(l2-abs(m2)-1)*(l2-abs(m2)-1)
elif l1-1 == l2:
return scale*2/(2.0*l2+1)*((l2+1)*fact(l2+abs(m2))/fact(l2-abs(m2))*(l2-abs(m2))-l2/(2.0*l2+3.0)*fact(l2+abs(m2)+1)/fact(l2-abs(m2))*(l2-abs(m2)+1))
elif l1-l2 > 2: # and (l1-l2)%2 == 1 which is always true
return -scale*2*abs(m2)*fact(l2+abs(m2))/fact(l2-abs(m2))
else:
return 0.0
else:
assert abs(m1) == abs(m2)-1
if l1 == l2+1:
return -scale*2/(2.0*l1+1.0)*(l1-1)/(2.0*l1-1.0)*fact(l1+abs(m1))/fact(l1-abs(m1)-1)*(l1-abs(m1)-1)
elif l1 == l2-1:
return -scale*2/(2.0*l1+1.0)*((l1+1)/(2.0*l1+3.0)*fact(l1+abs(m1)+1)/fact(l1-abs(m1))*(l1-abs(m1)+1)-(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))*(l1-abs(m1)))
elif l2-l1 > 2: # and (l2-l1)%2 == 1 which is always true
return scale*2*(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))
else:
return 0.0
def intYdYdtheta_ez(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / * d Y(u,v)
A = - | | Y (u,v) sin(u) --- l'm' sin(u) dv du
LL' / / lm du
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and m1 = m2.
"""
if abs(l1-l2) != 1 or m1 != m2:
return 0.0
scale = -C(l1,m1)*C(l2,m2)*2*np.pi
return scale*np.sign(l1-l2)*(l2+1-heaviside(l1-l2))*(l2-np.sign(l1-l2)*abs(m1)+heaviside(l1-l2))/(2*l2+1)*ilegendre(l1,m1)
# -------------------------------------------------------------------
def intYdYdphi_ex(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / * -1 d Y(u,v)
A = - | | Y (u,v) sin(u)*sin(v) --- l'm' sin(u) dv du
LL' / / lm dv
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
return 0.0
scale = -C(l1,m1)*C(l2,m2)*np.sign(m1-m2)*np.pi/1j*1j*m2
if abs(m1) == abs(m2)+1 and l1 > l2: # and (l1-l2)%2 == 1 which is always true
return scale*2*lmfact(l2,m2)
elif abs(m1) == abs(m2)-1 and l1 < l2: # and (l2-l1)%2 == 1 which is always true
return scale*2*lmfact(l1,m1)
else:
return 0.0
def intYdYdphi_ey(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / * -1 d Y(u,v)
A = | | Y (u,v) sin(u)*cos(v) --- l'm' sin(u) dv du
LL' / / lm dv
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
return 0.0
scale = C(l1,m1)*C(l2,m2)*np.pi*1j*m2
if abs(m1) == abs(m2)+1 and l1 > l2: # and (l1-l2)%2 == 1 which is always true
return scale*2*lmfact(l2,m2)
elif abs(m1) == abs(m2)-1 and l1 < l2: # and (l2-l1)%2 == 1 which is always true
return scale*2*lmfact(l1,m1)
else:
return 0.0
def intYdYdphi_ez(l1, m1, l2, m2): #XXX this is silly
return 0.0
gpaw-0.11.0.13004/gpaw/sphere/rsh.py 0000664 0001750 0001750 00000032642 12553643472 017057 0 ustar jensj jensj 0000000 0000000 from math import factorial as fact
import numpy as np
from gpaw.sphere import lmfact
from gpaw.sphere.legendre import ilegendre, legendre, dlegendre
# Define the Heaviside function
heaviside = lambda x: (1.0+np.sign(x))/2.0
# Define spherical harmoncics and normalization coefficient
C = lambda l,m: ((2.*l+1.)/(4*np.pi*lmfact(l,m)))**0.5
def Y(l,m,theta,phi):
if m == 0:
return C(l,m)*legendre(l,abs(m),np.cos(theta))
elif m > 0:
return C(l,m)*legendre(l,abs(m),np.cos(theta))*np.cos(m*phi)*2**0.5
else:
return C(l,m)*legendre(l,abs(m),np.cos(theta))*np.sin(abs(m)*phi)*2**0.5
# Define theta-derivative of spherical harmoncics
def dYdtheta(l,m,theta,phi):
if m == 0:
return C(l,m)*dlegendre(l,abs(m),np.cos(theta))
elif m > 0:
return C(l,m)*dlegendre(l,abs(m),np.cos(theta))*np.cos(m*phi)*2**0.5
else:
return C(l,m)*dlegendre(l,abs(m),np.cos(theta))*np.sin(abs(m)*phi)*2**0.5
# Define phi-derivative of spherical harmoncics
def dYdphi(l,m,theta,phi):
if m == 0:
return np.zeros_like(theta)
elif m > 0:
return -m*C(l,m)*legendre(l,abs(m),np.cos(theta))*np.sin(m*phi)*2**0.5
else:
return -m*C(l,m)*legendre(l,abs(m),np.cos(theta))*np.cos(m*phi)*2**0.5
# -------------------------------------------------------------------
def intYY(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ /
A = | | y (u,v) y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if l1 = l2 and m1 = m2.
"""
if (l1,m1) == (l2,m2):
return C(l1,m1)**2*2*np.pi*ilegendre(l1,m1) # == 1 always, XXX right?
else:
return 0.0
# -------------------------------------------------------------------
from gpaw.sphere.csh import intYY_ex as _intYY_ex, intYY_ey as _intYY_ey, intYY_ez as _intYY_ez #TODO make independent
def mix(l1, m1, l2, m2, func):
# m1 == 0
if m1 == 0 and m2 == 0:
return func(l1,abs(m1),l2,abs(m2))
elif m1 == 0 and m2 > 0:
return 1/2**0.5*((-1)**m2*func(l1,abs(m1),l2,abs(m2)) \
+func(l1,abs(m1),l2,-abs(m2)))
elif m1 == 0 and m2 < 0:
return 1/(2**0.5*1j)*((-1)**m2*func(l1,abs(m1),l2,abs(m2)) \
-func(l1,abs(m1),l2,-abs(m2)))
# m1 > 0
elif m1 > 0 and m2 == 0:
return 1/2**0.5*((-1)**m1*func(l1,abs(m1),l2,abs(m2)) \
+func(l1,-abs(m1),l2,abs(m2)))
elif m1 > 0 and m2 > 0:
return 0.5*((-1)**(m1+m2)*func(l1,abs(m1),l2,abs(m2)) \
+(-1)**m1*func(l1,abs(m1),l2,-abs(m2)) \
+(-1)**m2*func(l1,-abs(m1),l2,abs(m2)) \
+func(l1,-abs(m1),l2,-abs(m2)))
elif m1 > 0 and m2 < 0:
return 1/2j*((-1)**(m1+m2)*func(l1,abs(m1),l2,abs(m2)) \
-(-1)**m1*func(l1,abs(m1),l2,-abs(m2)) \
+(-1)**m2*func(l1,-abs(m1),l2,abs(m2)) \
-func(l1,-abs(m1),l2,-abs(m2)))
# m1 < 0
elif m1 < 0 and m2 == 0:
return -1/(2**0.5*1j)*((-1)**m1*func(l1,abs(m1),l2,abs(m2)) \
-func(l1,-abs(m1),l2,abs(m2)))
elif m1 < 0 and m2 > 0:
return -1/2j*((-1)**(m1+m2)*func(l1,abs(m1),l2,abs(m2)) \
+(-1)**m1*func(l1,abs(m1),l2,-abs(m2)) \
-(-1)**m2*func(l1,-abs(m1),l2,abs(m2)) \
-func(l1,-abs(m1),l2,-abs(m2)))
elif m1 < 0 and m2 < 0:
return 0.5*((-1)**(m1+m2)*func(l1,abs(m1),l2,abs(m2)) \
-(-1)**m1*func(l1,abs(m1),l2,-abs(m2)) \
-(-1)**m2*func(l1,-abs(m1),l2,abs(m2)) \
+func(l1,-abs(m1),l2,-abs(m2)))
else:
raise ValueError('Invalid arguments (l1=%s, m1=%s, l2=%s, m2=%s)' \
% (l1,m1,l2,m2))
def intYY_ex(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ /
A = | | y (u,v) sin(u)*cos(v) y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and `|m1-m2|` = 1.
"""
#if abs(l1-l2) != 1 or abs(m1-m2) != 1:
# return 0.0
#scale = C(l1,m1)*C(l2,m2)*np.pi
#if abs(m1) == abs(m2)+1:
# return scale*np.sign(l1-l2)/(2.*l2+1.)*ilegendre(l1,m1)
#else:
# assert abs(m1) == abs(m2)-1
# return scale*np.sign(l2-l1)/(2.*l1+1.)*ilegendre(l2,m2)
return mix(l1,m1,l2,m2,_intYY_ex)
def intYY_ey(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ /
A = | | y (u,v) sin(u)*sin(v) y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and `|m1-m2|` = 1.
"""
#if abs(l1-l2) != 1 or abs(m1-m2) != 1:
# return 0.0
#scale = C(l1,m1)*C(l2,m2)*np.sign(m1-m2)*np.pi/1j
#if abs(m1) == abs(m2)+1:
# return scale*np.sign(l1-l2)/(2.*l2+1.)*ilegendre(l1,m1)
#else:
# assert abs(m1) == abs(m2)-1
# return scale*np.sign(l2-l1)/(2.*l1+1.)*ilegendre(l2,m2)
return mix(l1,m1,l2,m2,_intYY_ey)
def intYY_ez(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ /
A = | | y (u,v) cos(u) y (u,v) sin(u) dv du
LL' / / lm l'm'
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and m1 = m2.
"""
return mix(l1,m1,l2,m2,_intYY_ez)
# -------------------------------------------------------------------
from gpaw.sphere.csh import intYdYdtheta_ex as _intYdYdtheta_ex, intYdYdtheta_ey as _intYdYdtheta_ey, intYdYdtheta_ez as _intYdYdtheta_ez #TODO make independent
def intYdYdtheta_ex(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / d y(u,v)
A = | | y (u,v) cos(u)*cos(v) --- l'm' sin(u) dv du
LL' / / lm du
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
#if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
# return 0.0
#scale = -C(l1,m1)*C(l2,m2)*np.pi
#if abs(m1) == abs(m2)+1:
# if l1+1 == l2:
# return scale*2/(2.0*l2+1)*(l2+1)/(2.0*l2-1.0)*fact(l2+abs(m2))/fact(l2-abs(m2)-1)*(l2-abs(m2)-1)
# elif l1-1 == l2:
# return scale*2/(2.0*l2+1)*((l2+1)*fact(l2+abs(m2))/fact(l2-abs(m2))*(l2-abs(m2))-l2/(2.0*l2+3.0)*fact(l2+abs(m2)+1)/fact(l2-abs(m2))*(l2-abs(m2)+1))
# elif l1-l2 > 2: # and (l1-l2)%2 == 1 which is always true
# return -scale*2*abs(m2)*fact(l2+abs(m2))/fact(l2-abs(m2))
# else:
# return 0.0
#else:
# assert abs(m1) == abs(m2)-1
# if l1 == l2+1:
# return -scale*2/(2.0*l1+1.0)*(l1-1)/(2.0*l1-1.0)*fact(l1+abs(m1))/fact(l1-abs(m1)-1)*(l1-abs(m1)-1)
# elif l1 == l2-1:
# return -scale*2/(2.0*l1+1.0)*((l1+1)/(2.0*l1+3.0)*fact(l1+abs(m1)+1)/fact(l1-abs(m1))*(l1-abs(m1)+1)-(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))*(l1-abs(m1)))
# elif l2-l1 > 2: # and (l2-l1)%2 == 1 which is always true
# return scale*2*(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))
# else:
# return 0.0
return mix(l1,m1,l2,m2,_intYdYdtheta_ex)
def intYdYdtheta_ey(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / d y(u,v)
A = | | y (u,v) cos(u)*sin(v) --- l'm' sin(u) dv du
LL' / / lm du
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
#if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
# return 0.0
#scale = -C(l1,m1)*C(l2,m2)*np.sign(m1-m2)*np.pi/1j
#if abs(m1) == abs(m2)+1:
# if l1+1 == l2:
# return scale*2/(2.0*l2+1)*(l2+1)/(2.0*l2-1.0)*fact(l2+abs(m2))/fact(l2-abs(m2)-1)*(l2-abs(m2)-1)
# elif l1-1 == l2:
# return scale*2/(2.0*l2+1)*((l2+1)*fact(l2+abs(m2))/fact(l2-abs(m2))*(l2-abs(m2))-l2/(2.0*l2+3.0)*fact(l2+abs(m2)+1)/fact(l2-abs(m2))*(l2-abs(m2)+1))
# elif l1-l2 > 2: # and (l1-l2)%2 == 1 which is always true
# return -scale*2*abs(m2)*fact(l2+abs(m2))/fact(l2-abs(m2))
# else:
# return 0.0
#else:
# assert abs(m1) == abs(m2)-1
# if l1 == l2+1:
# return -scale*2/(2.0*l1+1.0)*(l1-1)/(2.0*l1-1.0)*fact(l1+abs(m1))/fact(l1-abs(m1)-1)*(l1-abs(m1)-1)
# elif l1 == l2-1:
# return -scale*2/(2.0*l1+1.0)*((l1+1)/(2.0*l1+3.0)*fact(l1+abs(m1)+1)/fact(l1-abs(m1))*(l1-abs(m1)+1)-(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))*(l1-abs(m1)))
# elif l2-l1 > 2: # and (l2-l1)%2 == 1 which is always true
# return scale*2*(abs(m1)+1)*fact(l1+abs(m1))/fact(l1-abs(m1))
# else:
# return 0.0
return mix(l1,m1,l2,m2,_intYdYdtheta_ey)
def intYdYdtheta_ez(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / d y(u,v)
A = - | | y (u,v) sin(u) --- l'm' sin(u) dv du
LL' / / lm du
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` = 1 and m1 = m2.
"""
#if abs(l1-l2) != 1 or m1 != m2:
# return 0.0
#scale = -C(l1,m1)*C(l2,m2)*2*np.pi
#return scale*np.sign(l1-l2)*(l2+1-heaviside(l1-l2))*(l2-np.sign(l1-l2)*abs(m1)+heaviside(l1-l2))/(2*l2+1)*ilegendre(l1,m1)
return mix(l1,m1,l2,m2,_intYdYdtheta_ez)
# -------------------------------------------------------------------
from gpaw.sphere.csh import intYdYdphi_ex as _intYdYdphi_ex, intYdYdphi_ey as _intYdYdphi_ey #TODO make independent
def intYdYdphi_ex(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / -1 d y(u,v)
A = - | | y (u,v) sin(u)*sin(v) --- l'm' sin(u) dv du
LL' / / lm dv
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
#if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
# return 0.0
#scale = -C(l1,m1)*C(l2,m2)*np.sign(m1-m2)*np.pi/1j*1j*m2
#if abs(m1) == abs(m2)+1 and l1 > l2: # and (l1-l2)%2 == 1 which is always true
# return scale*2*lmfact(l2,m2)
#elif abs(m1) == abs(m2)-1 and l1 < l2: # and (l2-l1)%2 == 1 which is always true
# return scale*2*lmfact(l1,m1)
#else:
# return 0.0
return mix(l1,m1,l2,m2,_intYdYdphi_ex)
def intYdYdphi_ey(l1, m1, l2, m2):
"""Calculates::
pi 2pi
/ / -1 d y(u,v)
A = | | y (u,v) sin(u)*cos(v) --- l'm' sin(u) dv du
LL' / / lm dv
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` = 1 (stricter rule applies).
"""
#if abs(l1-l2) % 2 != 1 or abs(m1-m2) != 1:
# return 0.0
#scale = C(l1,m1)*C(l2,m2)*np.pi*1j*m2
#if abs(m1) == abs(m2)+1 and l1 > l2: # and (l1-l2)%2 == 1 which is always true
# return scale*2*lmfact(l2,m2)
#elif abs(m1) == abs(m2)-1 and l1 < l2: # and (l2-l1)%2 == 1 which is always true
# return scale*2*lmfact(l1,m1)
#else:
# return 0.0
return mix(l1,m1,l2,m2,_intYdYdphi_ey)
def intYdYdphi_ez(l1, m1, l2, m2): #XXX this is silly
return 0.0
# -------------------------------------------------------------------
def intYgradY(l1, m1, l2, m2, r_g, dr_g, A_g, B_g, dBdr_g, v=None):
"""Calculates::
pi 2pi
/ / * / __ \ 2
A = | | A(r) y (u,v) | \/ B(r) y (u,v) | r sin(u) dv du dr
vLL' / / lm \ v l'm' /
0 0
where u = theta and v = phi in the usual notation. Note that the result
is only non-zero if `|l1-l2|` is odd and `|m1-m2|` <= 1 (stricter rule applies).
"""
if v is None:
D = [intYY_ex(l1,m1,l2,m2), \
intYY_ey(l1,m1,l2,m2), \
intYY_ez(l1,m1,l2,m2)]
G = [intYdYdtheta_ex(l1,m1,l2,m2) + intYdYdphi_ex(l1,m1,l2,m2), \
intYdYdtheta_ey(l1,m1,l2,m2) + intYdYdphi_ey(l1,m1,l2,m2), \
intYdYdtheta_ez(l1,m1,l2,m2) + intYdYdphi_ez(l1,m1,l2,m2)]
D, G = np.array(D), np.array(G)
elif v == 0:
D = intYY_ex(l1,m1,l2,m2)
G = intYdYdtheta_ex(l1,m1,l2,m2) + intYdYdphi_ex(l1,m1,l2,m2)
elif v == 1:
D = intYY_ey(l1,m1,l2,m2)
G = intYdYdtheta_ey(l1,m1,l2,m2) + intYdYdphi_ey(l1,m1,l2,m2)
elif v == 2:
D = intYY_ez(l1,m1,l2,m2)
G = intYdYdtheta_ez(l1,m1,l2,m2) + intYdYdphi_ez(l1,m1,l2,m2)
else:
raise ValueError
return D * np.vdot(A_g, dBdr_g * r_g**2 * dr_g) \
+ G * np.vdot(A_g, B_g * r_g * dr_g)
gpaw-0.11.0.13004/gpaw/sphere/legendre.py 0000664 0001750 0001750 00000033306 12553643472 020046 0 ustar jensj jensj 0000000 0000000
import numpy as np
from gpaw.sphere import lmfact
# Highest l for which associated Legendre polynomials are implemented
lmax = 9
# Integral norm of the associated Legendre polynomials
ilegendre = lambda l,m: 2./(2.*l+1.)*lmfact(l,m)
def legendre(l, m, w):
if m < 0 or l < m:
return np.zeros_like(w)
if (l,m) == (0,0):
return np.ones_like(w)
elif (l,m) == (1,0):
return w.copy()
elif (l,m) == (1,1):
return (1-w**2)**0.5
elif (l,m) == (2,0):
return 1.5*w**2-0.5
elif (l,m) == (2,1):
return 3*(1-w**2)**0.5*w
elif (l,m) == (2,2):
return 3*(1-w**2)
elif (l,m) == (3,0):
return 2.5*w**3-1.5*w
elif (l,m) == (3,1):
return (1-w**2)**0.5*(7.5*w**2-1.5)
elif (l,m) == (3,2):
return 15*w-15*w**3
elif (l,m) == (3,3):
return 15*(1-w**2)**1.5
elif (l,m) == (4,0):
return 4.375*w**4-3.75*w**2+0.375
elif (l,m) == (4,1):
return (1-w**2)**0.5*(17.5*w**3-7.5*w)
elif (l,m) == (4,2):
return (1-w**2)*(52.5*w**2-7.5)
elif (l,m) == (4,3):
return 105*(1-w**2)**1.5*w
elif (l,m) == (4,4):
return 105*(1-w**2)**2
elif (l,m) == (5,0):
return 7.875*w**5-8.75*w**3+1.875*w
elif (l,m) == (5,1):
return (1-w**2)**0.5*(39.375*w**4-26.25*w**2+1.875)
elif (l,m) == (5,2):
return (1-w**2)*(157.5*w**3-52.5*w)
elif (l,m) == (5,3):
return (1-w**2)**1.5*(472.5*w**2-52.5)
elif (l,m) == (5,4):
return 945*(1-w**2)**2*w
elif (l,m) == (5,5):
return 945*(1-w**2)**2.5
elif (l,m) == (6,0):
return 14.4375*w**6-19.6875*w**4+6.5625*w**2-0.3125
elif (l,m) == (6,1):
return (1-w**2)**0.5*(86.625*w**5-78.75*w**3+13.125*w)
elif (l,m) == (6,2):
return (1-w**2)*(433.125*w**4-236.25*w**2+13.125)
elif (l,m) == (6,3):
return (1-w**2)**1.5*(1732.5*w**3-472.5*w)
elif (l,m) == (6,4):
return (1-w**2)**2*(5197.5*w**2-472.5)
elif (l,m) == (6,5):
return 10395*(1-w**2)**2.5*w
elif (l,m) == (6,6):
return 10395*(1-w**2)**3
elif (l,m) == (7,0):
return 26.8125*w**7-43.3125*w**5+19.6875*w**3-2.1875*w
elif (l,m) == (7,1):
return (1-w**2)**0.5*(187.6875*w**6-216.5625*w**4+59.0625*w**2-2.1875)
elif (l,m) == (7,2):
return (1-w**2)*(1126.125*w**5-866.25*w**3+118.125*w)
elif (l,m) == (7,3):
return (1-w**2)**1.5*(5630.625*w**4-2598.75*w**2+118.125)
elif (l,m) == (7,4):
return (1-w**2)**2*(22522.5*w**3-5197.5*w)
elif (l,m) == (7,5):
return (1-w**2)**2.5*(67567.5*w**2-5197.5)
elif (l,m) == (7,6):
return 135135*(1-w**2)**3*w
elif (l,m) == (7,7):
return 135135.*(1-w**2)**3.5
elif (l,m) == (8,0):
return 50.2734375*w**8-93.84375*w**6+54.140625*w**4-9.84375*w**2+0.2734375
elif (l,m) == (8,1):
return (1-w**2)**0.5*(402.1875*w**7-563.0625*w**5+216.5625*w**3-19.6875*w)
elif (l,m) == (8,2):
return (1-w**2)*(2815.3125*w**6-2815.3125*w**4+649.6875*w**2-19.6875)
elif (l,m) == (8,3):
return (1-w**2)**1.5*(16891.875*w**5-11261.25*w**3+1299.375*w)
elif (l,m) == (8,4):
return (1-w**2)**2*(84459.375*w**4-33783.75*w**2+1299.375)
elif (l,m) == (8,5):
return (1-w**2)**2.5*(337837.5*w**3-67567.5*w)
elif (l,m) == (8,6):
return (1-w**2)**3*(1013512.5*w**2-67567.5)
elif (l,m) == (8,7):
return 2027025*(1-w**2)**3.5*w
elif (l,m) == (8,8):
return 2027025*(1-w**2)**4
elif (l,m) == (9,0):
return 94.9609375*w**9-201.09375*w**7+140.765625*w**5-36.09375*w**3+2.4609375*w
elif (l,m) == (9,1):
return (1-w**2)**0.5*(854.6484375*w**8-1407.65625*w**6+703.828125*w**4-108.28125*w**2+2.4609375)
elif (l,m) == (9,2):
return (1-w**2)*(6837.1875*w**7-8445.9375*w**5+2815.3125*w**3-216.5625*w)
elif (l,m) == (9,3):
return (1-w**2)**1.5*(47860.3125*w**6-42229.6875*w**4+8445.9375*w**2-216.5625)
elif (l,m) == (9,4):
return (1-w**2)**2*(287161.875*w**5-168918.75*w**3+16891.875*w)
elif (l,m) == (9,5):
return (1-w**2)**2.5*(1435809.375*w**4-506756.25*w**2+16891.875)
elif (l,m) == (9,6):
return (1-w**2)**3*(5743237.5*w**3-1013512.5*w)
elif (l,m) == (9,7):
return (1-w**2)**3.5*(17229712.5*w**2-1013512.5)
elif (l,m) == (9,8):
return 34459425*(1-w**2)**4*w
elif (l,m) == (9,9):
return 34459425*(1-w**2)**4.5
else:
raise ValueError('Unsupported arguments (l,m)=(%d,%d)' % (l,m))
def dlegendre(l, m, w): # XXX not d/dw but rather -sin(theta)*d/dw
if m < 0 or l < m:
return np.zeros_like(w)
if (l,m) == (0,0):
return np.zeros_like(w)
elif (l,m) == (1,0):
return -(1-w**2)**0.5
elif (l,m) == (1,1):
return w.copy()
elif (l,m) == (2,0):
return -3*w*(1-w**2)**0.5
elif (l,m) == (2,1):
return 6*w**2-3
elif (l,m) == (2,2):
return 6*(1-w**2)**0.5*w
elif (l,m) == (3,0):
return (1-w**2)**0.5*(-7.5*w**2+1.5)
elif (l,m) == (3,1):
return 22.5*w**3-16.5*w
elif (l,m) == (3,2):
return (1-w**2)**0.5*(45*w**2-15)
elif (l,m) == (3,3):
return 45*(1-w**2)*w
elif (l,m) == (4,0):
return (1-w**2)**0.5*(-17.5*w**3+7.5*w)
elif (l,m) == (4,1):
return 70*w**4-67.5*w**2+7.5
elif (l,m) == (4,2):
return (1-w**2)**0.5*(210*w**3-120*w)
elif (l,m) == (4,3):
return (1-w**2)*(420*w**2-105)
elif (l,m) == (4,4):
return 420*(1-w**2)**1.5*w
elif (l,m) == (5,0):
return (1-w**2)**0.5*(-39.375*w**4+26.25*w**2-1.875)
elif (l,m) == (5,1):
return (196.875*w**5-236.25*w**3+54.375*w)
elif (l,m) == (5,2):
return (1-w**2)**0.5*(787.5*w**4-630*w**2+52.5)
elif (l,m) == (5,3):
return (1-w**2)*(2362.5*w**3-1102.5*w)
elif (l,m) == (5,4):
return (1-w**2)**1.5*(4725*w**2-945)
elif (l,m) == (5,5):
return 4725*(1-w**2)**2*w
elif (l,m) == (6,0):
return (1-w**2)**0.5*(-86.625*w**5+78.75*w**3-13.125*w)
elif (l,m) == (6,1):
return 519.75*w**6-748.125*w**4+262.5*w**2-13.125
elif (l,m) == (6,2):
return (1-w**2)**0.5*(2598.75*w**5-2677.5*w**3+498.75*w)
elif (l,m) == (6,3):
return (1-w**2)*(10395.0*w**4-7087.5*w**2+472.5)
elif (l,m) == (6,4):
return (1-w**2)**1.5*(31185*w**3-12285*w)
elif (l,m) == (6,5):
return (1-w**2)**2*(62370*w**2-10395)
elif (l,m) == (6,6):
return 62370*(1-w**2)**2.5*w
elif (l,m) == (7,0):
return (1-w**2)**0.5*(-187.6875*w**6+216.5625*w**4-59.0625*w**2+2.1875)
elif (l,m) == (7,1):
return 1313.8125*w**7-2208.9375*w**5+1043.4375*w**3-120.3125*w
elif (l,m) == (7,2):
return (1-w**2)**0.5*(7882.875*w**6-9961.875*w**4+2953.125*w**2-118.125)
elif (l,m) == (7,3):
return (1-w**2)*(39414.375*w**5-35516.25*w**3+5551.875*w)
elif (l,m) == (7,4):
return (1-w**2)**1.5*(157657.5*w**4-93555*w**2+5197.5)
elif (l,m) == (7,5):
return (1-w**2)**2*(472972.5*w**3-161122.5*w)
elif (l,m) == (7,6):
return (1-w**2)**2.5*(945945*w**2-135135)
elif (l,m) == (7,7):
return 945945*(1-w**2)**3*w
elif (l,m) == (8,0):
return (1-w**2)**0.5*(-402.1875*w**7+563.0625*w**5-216.5625*w**3+19.6875*w)
elif (l,m) == (8,1):
return 3217.5*w**8-6193.6875*w**6+3681.5625*w**4-689.0625*w**2+19.6875
elif (l,m) == (8,2):
return (1-w**2)**0.5*(22522.5*w**7-33783.75*w**5+13860.0*w**3-1338.75*w)
elif (l,m) == (8,3):
return (1-w**2)*(135135.0*w**6-152026.875*w**4+38981.25*w**2-1299.375)
elif (l,m) == (8,4):
return (1-w**2)**1.5*(675675.0*w**5-540540.0*w**3+72765.0*w)
elif (l,m) == (8,5):
return (1-w**2)**2*(2702700.0*w**4-1418917.5*w**2+67567.5)
elif (l,m) == (8,6):
return (1-w**2)**2.5*(8108100*w**3-2432430*w)
elif (l,m) == (8,7):
return (1-w**2)**3*(16216200*w**2-2027025)
elif (l,m) == (8,8):
return 16216200*(1-w**2)**3.5*w
elif (l,m) == (9,0):
return (1-w**2)**0.5*(-854.6484375*w**8+1407.65625*w**6-703.828125*w**4+108.28125*w**2-2.4609375)
elif (l,m) == (9,1):
return 7691.8359375*w**9-16690.78125*w**7+11965.078125*w**5-3140.15625*w**3+219.0234375*w
elif (l,m) == (9,2):
return (1-w**2)**0.5*(61534.6875*w**8-106981.875*w**6+56306.25*w**4-9095.625*w**2+216.5625)
elif (l,m) == (9,3):
return (1-w**2)*(430742.8125*w**7-582769.6875*w**5+211148.4375*w**3-17541.5625*w)
elif (l,m) == (9,4):
return (1-w**2)**1.5*(2584456.875*w**6-2618240.625*w**4+591215.625*w**2-16891.875)
elif (l,m) == (9,5):
return (1-w**2)**2*(12922284.375*w**5-9290531.25*w**3+1097971.875*w)
elif (l,m) == (9,6):
return (1-w**2)**2.5*(51689137.5*w**4-24324300*w**2+1013512.5)
elif (l,m) == (9,7):
return (1-w**2)**3*(155067412.5*w**3-41554012.5*w)
elif (l,m) == (9,8):
return (1-w**2)**3.5*(310134825*w**2-34459425)
elif (l,m) == (9,9):
return 310134825*(1-w**2)**4*w
else:
raise ValueError('Unsupported arguments (l,m)=(%d,%d)' % (l,m))
# -------------------------------------------------------------------
if __name__ == '__main__':
from gpaw.mpi import world
from gpaw.sphere import lmiter
def equal(x, y, tol=0, msg=''):
if abs(x-y) > tol:
msg = (msg + '(%.9g,%.9g) != (%.9g,%.9g) (error: |%.9g| > %.9g)' %
(np.real(x),np.imag(x),np.real(y),np.imag(y),abs(x-y),tol))
raise AssertionError(msg)
nw = 10000
dw = 2.0/nw
w = np.linspace(-1+dw/2,1-dw/2,nw)
equal(w[1]-w[0], dw, 1e-12)
tol = 1e-5
# Test orthogonality of the associated Legendre polynomials
if world.rank == 0:
print('\n%s\nAssociated Legendre orthogonality\n%s' % ('-'*40,'-'*40))
for l1,m1 in lmiter(lmax, False, comm=world):
p1 = legendre(l1, m1, w)
for l2,m2 in lmiter(lmax, False):
p2 = legendre(l2, m2, w)
scale = (ilegendre(l1,m1)*ilegendre(l2,m2))**0.5
v = np.dot(p1,p2)*dw / scale
if (l1,m1) == (l2,m2):
v0 = ilegendre(l1,m1) / scale
print('l1=%2d, m1=%2d, l2=%2d, m2=%2d, v=%12.9f, err=%12.9f' % (l1,m1,l2,m2,v,abs(v-v0)))
equal(v, v0, tol, 'l1=%2d, m1=%2d, l2=%2d, m=%2d: ' % (l1,m1,l2,m2))
elif m1 == m2:
print('l1=%2d, m1=%2d, l2=%2d, m2=%2d, v=%12.9f, err=%12.9f' % (l1,m1,l2,m2,v,abs(v)))
equal(v, 0, tol, 'l1=%2d, m1=%2d, l2=%2d, m=%2d: ' % (l1,m1,l2,m2))
del nw, dw, w, tol, p1, p2, v, v0
world.barrier()
# =======================
nw = 50000
dw = 1.9/nw
w = np.linspace(-0.95+dw/2,0.95-dw/2,nw)
tol = 1e-5
# Test theta-derivative of the associated Legendre polynomials
if world.rank == 0:
print('\n%s\nAssociated Legendre theta-derivative\n%s' % ('-'*40,'-'*40))
for l,m in lmiter(lmax, False, comm=world):
scale = l**(-abs(m))*lmfact(l,abs(m)) # scale to fit ~ [-1; 1]
p = legendre(l, m, w) / scale
dpdtheta = -(1-w[1:-1]**2)**0.5*(p[2:]-p[:-2])/(2.0*dw)
dpdtheta0 = dlegendre(l, m, w[1:-1]) / scale
e = np.sum((dpdtheta-dpdtheta0)**2)**0.5/(nw-2.0)**0.5
print('l=%2d, m=%2d, err=%12.9f, max=%12.9f' % (l,m,e,np.abs(dpdtheta-dpdtheta0).max()))
#if e > tol:
# import pylab as pl
# w, p = w[1:-1], p[1:-1]
# fig = pl.figure(lm_to_L(l,m))
# ax = pl.axes()
# ax.plot(w, p,'-r', w, dpdtheta, '-b', w, dpdtheta0, '-g')
# fig = pl.figure((lmax+1)**2+lm_to_L(l,m))
# ax = pl.axes()
# ax.plot(w, dpdtheta-dpdtheta0, '-k')
# pl.show()
equal(e, 0, tol, 'l=%2d, m=%2d: ' % (l,m))
del nw, dw, w, tol, p, dpdtheta, dpdtheta0, e
world.barrier()
# =======================
R = 1.0
npts = 1000
tol = 1e-9
# ((R-dR)/(R+dR))**(lmax+1) = tol
# (lmax+1)*np.log((R-dR)/(R+dR)) = np.log(tol)
# (R-dR)/(R+dR) = np.exp(np.log(tol)/(lmax+1))
# R-dR = (R+dR) * tol**(1/(lmax+1))
# R * (1-tol**(1/(lmax+1))) = dR * (1+tol**(1/(lmax+1)))
dR = R * (1-tol**(1./(lmax+1))) / (1+tol**(1./(lmax+1)))
assert abs(((R-dR)/(R+dR))**(lmax+1) - tol) < 1e-12
r_g = np.random.uniform(R+dR, 10*R, size=npts)
world.broadcast(r_g, 0)
theta_g = np.random.uniform(0, np.pi, size=npts)
world.broadcast(theta_g, 0)
phi_g = np.random.uniform(0, np.pi, size=npts)
world.broadcast(phi_g, 0)
r_vg = np.empty((3, npts), dtype=float)
r_vg[0] = r_g*np.cos(phi_g)*np.sin(theta_g)
r_vg[1] = r_g*np.sin(phi_g)*np.sin(theta_g)
r_vg[2] = r_g*np.cos(theta_g)
rm_g = np.random.uniform(0, R-dR, size=npts)
world.broadcast(rm_g, 0)
thetam_g = np.random.uniform(0, np.pi, size=npts)
world.broadcast(thetam_g, 0)
phim_g = np.random.uniform(0, np.pi, size=npts)
world.broadcast(phim_g, 0)
rm_vg = np.empty((3, npts), dtype=float)
rm_vg[0] = rm_g*np.cos(phim_g)*np.sin(thetam_g)
rm_vg[1] = rm_g*np.sin(phim_g)*np.sin(thetam_g)
rm_vg[2] = rm_g*np.cos(thetam_g)
# Cosine of the angle between r and r' using 1st spherical law of cosines
w_g = np.cos(theta_g)*np.cos(thetam_g) \
+ np.sin(theta_g)*np.sin(thetam_g)*np.cos(phi_g-phim_g)
f0_g = np.sum((r_vg-rm_vg)**2, axis=0)**(-0.5)
f_g = np.zeros_like(f0_g)
# Test truncated multi-pole expansion using Legendre polynomials
if world.rank == 0:
print('\n%s\nLegendre multi-pole expansion\n%s' % ('-'*40,'-'*40))
for l in range(lmax+1):
f_g += 1/r_g * (rm_g/r_g)**l * legendre(l, 0, w_g)
e = np.abs(f_g-f0_g).max()
equal(e, 0, tol, 'lmax=%02d, dR=%g: ' % (lmax, dR))
del R, dR, npts, tol, r_g, theta_g, phi_g, r_vg, rm_g, thetam_g, phim_g, rm_vg, w_g, f0_g, f_g, e
gpaw-0.11.0.13004/gpaw/sphere/__init__.py 0000664 0001750 0001750 00000002573 12553643472 020022 0 ustar jensj jensj 0000000 0000000
import numpy as np
#from gpaw.utilities import ffact
# Define (l+|m|)!/(l-|m|)!
#lmfact = lambda l,m: ffact(l-abs(m), l+abs(m))
def _lmiter(lmax, full=True):
for l in range(lmax+1):
for m in range(full and -l or 0,l+1):
yield (l,m)
raise StopIteration
def lmiter(lmax, full=True, comm=None, cost=None):
"""Utility function to parallelize over (l,m) with load balancing."""
if comm is None or comm.size == 1:
return _lmiter(lmax ,full)
lm_j = tuple(_lmiter(lmax, full))
if cost is None:
cost_j = np.ones(len(lm_j), dtype=float)
else:
cost_j = np.fromiter((cost(lmax, *lm) for lm in lm_j), dtype=float)
assert np.isfinite(cost_j).all() and np.all(cost_j>0) #XXX and np.isreal?
a,b = np.array([comm.rank,comm.rank+1], dtype=float) / comm.size
if 0: #XXX which one is best?
rel_j = np.cumsum(np.hstack((0,cost_j)))/np.sum(cost_j)
ja,jb = np.argmin(np.abs(rel_j-a)), np.argmin(np.abs(rel_j-b))
else:
rel_j = np.cumsum(cost_j)/np.sum(cost_j)
ja,jb = np.take(np.argwhere(np.bitwise_and(a 0:
self.A_wgm.append(A_gm)
self.G_wb.append(G_b)
self.M_w.append(M)
self.sdisp_wc.append(sdisp_c)
ng += A_gm.shape[0]
assert A_gm.shape[0] > 0
M += 2 * l + 1
self.Mmax = M
self.rank = gd.get_rank_from_position(spos_c)
if ng == 0:
self.ranks = None # What about making empty lists instead?
self.A_wgm = None
self.G_wb = None
self.M_w = None
self.sdisp_wc = None
self.spos_c = spos_c.copy()
self.normalized = False
return True
def spline_to_grid(spline, gd, start_c, end_c, spos_c):
dom = gd
pos_v = np.dot(spos_c, dom.cell_cv)
return _gpaw.spline_to_grid(spline.spline, start_c, end_c, pos_v,
np.ascontiguousarray(gd.h_cv),
gd.n_c, gd.beg_c)
# TODO This belongs in Spline!
spline_to_grid = staticmethod(spline_to_grid)
def get_function_count(self):
return sum([2 * spline.get_angular_momentum_number() + 1
for spline in self.spline_j])
def normalize(self, integral, a, dv, comm):
"""Normalize localized functions."""
if self.normalized or integral < 1e-15:
self.normalized = True
yield None
yield None
yield None
return
I_M = np.zeros(self.Mmax)
nw = len(self.A_wgm) // len(self.spline_j)
assert nw * len(self.spline_j) == len(self.A_wgm)
for M, A_gm in zip(self.M_w, self.A_wgm):
I_m = A_gm.sum(axis=0)
I_M[M:M + len(I_m)] += I_m * dv
requests = []
if len(self.ranks) > 0:
I_rM = np.empty((len(self.ranks), self.Mmax))
for r, J_M in zip(self.ranks, I_rM):
requests.append(comm.receive(J_M, r, a, False))
if self.rank != comm.rank:
requests.append(comm.send(I_M, self.rank, a, False))
yield None
for request in requests:
comm.wait(request)
requests = []
if len(self.ranks) > 0:
I_M += I_rM.sum(axis=0)
for r in self.ranks:
requests.append(comm.send(I_M, r, a, False))
if self.rank != comm.rank:
requests.append(comm.receive(I_M, self.rank, a, False))
yield None
for request in requests:
comm.wait(request)
w = 0
for M, A_gm in zip(self.M_w, self.A_wgm):
if M == 0:
A_gm *= integral / I_M[0]
else:
A_gm -= (I_M[M:M + A_gm.shape[1]] / integral *
self.A_wgm[w % nw])
w += 1
self.normalized = True
self.I_M = I_M
yield None
def estimate_gridpointcount(self, gd):
points = 0.0
for spline in self.spline_j:
l = spline.get_angular_momentum_number()
rc = spline.get_cutoff()
points += 4.0 * np.pi / 3.0 * rc**3 / gd.dv * (2 * l + 1)
return points
# Quick hack: base class to share basic functionality across LFC classes
class BaseLFC:
def dict(self, shape=(), derivative=False, zero=False):
if isinstance(shape, int):
shape = (shape,)
if derivative:
assert not zero
c_axiv = {}
for a in self.my_atom_indices:
ni = self.get_function_count(a)
c_axiv[a] = np.empty(shape + (ni, 3), self.dtype)
return c_axiv
else:
c_axi = {}
for a in self.my_atom_indices:
ni = self.get_function_count(a)
c_axi[a] = np.empty(shape + (ni,), self.dtype)
if zero:
c_axi[a].fill(0.0)
return c_axi
def estimate_memory(self, mem):
points = 0
for sphere in self.sphere_a:
points += sphere.estimate_gridpointcount(self.gd)
nbytes = points * mem.floatsize
mem.setsize(nbytes / self.gd.comm.size) # Assume equal distribution
class NewLocalizedFunctionsCollection(BaseLFC):
"""New LocalizedFunctionsCollection
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.
"""
def __init__(self, gd, spline_aj, kd=None, cut=False, dtype=float,
integral=None, forces=None):
self.gd = gd
self.sphere_a = [Sphere(spline_j) for spline_j in spline_aj]
self.cut = cut
self.dtype = dtype
self.Mmax = None
if kd is None:
self.ibzk_qc = np.zeros((1, 3))
self.gamma = True
else:
self.ibzk_qc = kd.ibzk_qc
self.gamma = kd.gamma
# Global or local M-indices?
self.use_global_indices = False
if integral is not None:
if isinstance(integral, (float, int)):
self.integral_a = np.empty(len(spline_aj))
self.integral_a[:] = integral
else:
self.integral_a = np.array(integral)
else:
self.integral_a = None
self.my_atom_indices = None
def set_positions(self, spos_ac):
assert len(spos_ac) == len(self.sphere_a)
spos_ac = np.asarray(spos_ac)
movement = False
for a, (spos_c, sphere) in enumerate(zip(spos_ac, self.sphere_a)):
try:
movement |= sphere.set_position(spos_c, self.gd, self.cut)
except GridBoundsError as e:
e.args = ['Atom %d too close to edge: %s' % (a, str(e))]
raise
if movement or self.my_atom_indices is None:
self._update(spos_ac)
def _update(self, spos_ac):
nB = 0
nW = 0
self.my_atom_indices = []
self.atom_indices = []
M = 0
self.M_a = []
for a, sphere in enumerate(self.sphere_a):
self.M_a.append(M)
if sphere.rank == self.gd.comm.rank:
self.my_atom_indices.append(a)
G_wb = sphere.G_wb
if G_wb:
nB += sum([len(G_b) for G_b in G_wb])
nW += len(G_wb)
self.atom_indices.append(a)
if not self.use_global_indices:
M += sphere.Mmax
if self.use_global_indices:
M += sphere.Mmax
self.Mmax = M
natoms = len(spos_ac)
# Holm-Nielsen check:
if ((self.gd.comm.sum(float(sum(self.my_atom_indices))) !=
natoms * (natoms - 1) // 2)):
raise ValueError('Holm-Nielsen check failed. Grid might be '
'too coarse. Use h < %.3f'
% (smallest_safe_grid_spacing * Bohr))
self.M_W = np.empty(nW, np.intc)
self.G_B = np.empty(nB, np.intc)
self.W_B = np.empty(nB, np.intc)
self.A_Wgm = []
sdisp_Wc = np.empty((nW, 3), int)
self.pos_Wv = np.empty((nW, 3))
B1 = 0
W = 0
for a in self.atom_indices:
sphere = self.sphere_a[a]
self.A_Wgm.extend(sphere.A_wgm)
nw = len(sphere.M_w)
self.M_W[W:W + nw] = self.M_a[a] + np.array(sphere.M_w)
sdisp_Wc[W:W + nw] = sphere.sdisp_wc
self.pos_Wv[W:W + nw] = np.dot(spos_ac[a] -
np.array(sphere.sdisp_wc),
self.gd.cell_cv)
for G_b in sphere.G_wb:
B2 = B1 + len(G_b)
self.G_B[B1:B2] = G_b
self.W_B[B1:B2:2] = W
self.W_B[B1 + 1:B2 + 1:2] = -W - 1
B1 = B2
W += 1
assert B1 == nB
if self.gamma:
if self.dtype == float:
self.phase_qW = np.empty((0, nW), complex)
else:
# TDDFT calculation:
self.phase_qW = np.ones((1, nW), complex)
else:
self.phase_qW = np.exp(2j * pi * np.inner(self.ibzk_qc, sdisp_Wc))
indices = np.argsort(self.G_B, kind='mergesort')
self.G_B = self.G_B[indices]
self.W_B = self.W_B[indices]
self.lfc = _gpaw.LFC(self.A_Wgm, self.M_W, self.G_B, self.W_B,
self.gd.dv, self.phase_qW)
# Find out which ranks have a piece of the
# localized functions:
x_a = np.zeros(natoms, bool)
x_a[self.atom_indices] = True
x_a[self.my_atom_indices] = False
x_ra = np.empty((self.gd.comm.size, natoms), bool)
self.gd.comm.all_gather(x_a, x_ra)
for a in self.atom_indices:
sphere = self.sphere_a[a]
if sphere.rank == self.gd.comm.rank:
sphere.ranks = x_ra[:, a].nonzero()[0]
else:
sphere.ranks = []
if self.integral_a is not None:
iterators = []
for a in self.atom_indices:
iterator = self.sphere_a[a].normalize(self.integral_a[a], a,
self.gd.dv,
self.gd.comm)
iterators.append(iterator)
for i in range(3):
for iterator in iterators:
next(iterator)
return sdisp_Wc
def M_to_ai(self, src_xM, dst_axi):
xshape = src_xM.shape[:-1]
src_xM = src_xM.reshape(np.prod(xshape), self.Mmax)
for a in self.my_atom_indices:
M1 = self.M_a[a]
M2 = M1 + self.sphere_a[a].Mmax
dst_axi[a] = src_xM[:, M1:M2].copy()
def ai_to_M(self, src_axi, dst_xM):
xshape = dst_xM.shape[:-1]
dst_xM = dst_xM.reshape(np.prod(xshape), self.Mmax)
for a in self.my_atom_indices:
M1 = self.M_a[a]
M2 = M1 + self.sphere_a[a].Mmax
dst_xM[:, M1:M2] = src_axi[a]
def add(self, a_xG, c_axi=1.0, q=-1):
"""Add localized functions to extended arrays.
::
-- a a
a (G) += > c Phi (G)
x -- xi i
a,i
"""
assert not self.use_global_indices
if q == -1:
assert self.dtype == float
if isinstance(c_axi, float):
assert q == -1 and a_xG.ndim == 3
c_xM = np.empty(self.Mmax)
c_xM.fill(c_axi)
self.lfc.add(c_xM, a_xG, q)
return
dtype = a_xG.dtype
if debug:
assert a_xG.ndim >= 3
assert sorted(c_axi.keys()) == self.my_atom_indices
for c_xi in c_axi.values():
assert c_xi.dtype == dtype
comm = self.gd.comm
xshape = a_xG.shape[:-3]
requests = []
M1 = 0
b_axi = {}
for a in self.atom_indices:
c_xi = c_axi.get(a)
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if c_xi is None:
c_xi = np.empty(xshape + (sphere.Mmax,), dtype)
b_axi[a] = c_xi
requests.append(comm.receive(c_xi, sphere.rank, a, False))
else:
for r in sphere.ranks:
requests.append(comm.send(c_xi, r, a, False))
M1 = M2
for request in requests:
comm.wait(request)
c_xM = np.empty(xshape + (self.Mmax,), dtype)
M1 = 0
for a in self.atom_indices:
c_xi = c_axi.get(a)
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if c_xi is None:
c_xi = b_axi[a]
c_xM[..., M1:M2] = c_xi
M1 = M2
self.lfc.add(c_xM, a_xG, q)
def add_derivative(self, a, v, a_xG, c_axi=1.0, q=-1):
"""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.
"""
assert v in [0, 1, 2]
assert not self.use_global_indices
if q == -1:
assert self.dtype == float
if isinstance(c_axi, float):
assert q == -1
c_xM = np.empty(self.Mmax)
c_xM.fill(c_axi)
self.lfc.add(c_xM, a_xG, q)
return
dtype = a_xG.dtype
if debug:
assert a_xG.ndim >= 3
assert dtype == self.dtype
if isinstance(c_axi, dict):
assert sorted(c_axi.keys()) == self.my_atom_indices
for c_xi in c_axi.values():
assert c_xi.dtype == dtype
cspline_M = []
for a_ in self.atom_indices:
for spline in self.sphere_a[a_].spline_j:
nm = 2 * spline.get_angular_momentum_number() + 1
cspline_M.extend([spline.spline] * nm)
# Temp solution - set all coefficient to zero except for those at
# atom a
# Coefficient indices for atom a
M1 = self.M_a[a]
M2 = M1 + self.sphere_a[a].Mmax
if isinstance(c_axi, float):
assert q == -1
c_xM = np.zeros(self.Mmax)
c_xM[..., M1:M2] = c_axi
else:
xshape = a_xG.shape[:-3]
c_xM = np.zeros(xshape + (self.Mmax,), dtype)
c_xM[..., M1:M2] = c_axi[a]
gd = self.gd
self.lfc.add_derivative(c_xM, a_xG, np.ascontiguousarray(gd.h_cv),
gd.n_c, cspline_M,
gd.beg_c, self.pos_Wv, a, v, q)
def integrate(self, a_xG, c_axi, q=-1):
"""Calculate integrals of arrays times localized functions.
::
/ a*
c_axi = | dG a (G) Phi (G)
/ x i
"""
assert not self.use_global_indices
if q == -1:
assert self.dtype == float
xshape = a_xG.shape[:-3]
if debug:
assert a_xG.ndim >= 3
assert sorted(c_axi.keys()) == self.my_atom_indices
for c_xi in c_axi.values():
assert c_xi.shape[:-1] == xshape
dtype = a_xG.dtype
c_xM = np.zeros(xshape + (self.Mmax,), dtype)
self.lfc.integrate(a_xG, c_xM, q)
comm = self.gd.comm
rank = comm.rank
srequests = []
rrequests = []
c_arxi = {}
b_axi = {}
M1 = 0
for a in self.atom_indices:
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if sphere.rank != rank:
c_xi = c_xM[..., M1:M2].copy()
b_axi[a] = c_xi
srequests.append(comm.send(c_xi,
sphere.rank, a, False))
else:
if len(sphere.ranks) > 0:
c_rxi = np.empty(sphere.ranks.shape + xshape + (M2 - M1,),
dtype)
c_arxi[a] = c_rxi
for r, b_xi in zip(sphere.ranks, c_rxi):
rrequests.append(comm.receive(b_xi, r, a, False))
M1 = M2
for request in rrequests:
comm.wait(request)
M1 = 0
for a in self.atom_indices:
c_xi = c_axi.get(a)
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if c_xi is not None:
if len(sphere.ranks) > 0:
c_xi[:] = c_xM[..., M1:M2] + c_arxi[a].sum(axis=0)
else:
c_xi[:] = c_xM[..., M1:M2]
M1 = M2
for request in srequests:
comm.wait(request)
def derivative(self, a_xG, c_axiv, q=-1):
"""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.
"""
assert not self.use_global_indices
if debug:
assert a_xG.ndim >= 3
assert sorted(c_axiv.keys()) == self.my_atom_indices
if self.integral_a is not None:
assert q == -1
assert a_xG.ndim == 3
assert a_xG.dtype == float
self._normalized_derivative(a_xG, c_axiv)
return
dtype = a_xG.dtype
xshape = a_xG.shape[:-3]
c_xMv = np.zeros(xshape + (self.Mmax, 3), dtype)
cspline_M = []
for a in self.atom_indices:
for spline in self.sphere_a[a].spline_j:
nm = 2 * spline.get_angular_momentum_number() + 1
cspline_M.extend([spline.spline] * nm)
gd = self.gd
self.lfc.derivative(a_xG, c_xMv, np.ascontiguousarray(gd.h_cv),
gd.n_c, cspline_M,
gd.beg_c, self.pos_Wv, q)
comm = self.gd.comm
rank = comm.rank
srequests = []
rrequests = []
c_arxiv = {} # see also http://arXiv.org
b_axiv = {}
M1 = 0
for a in self.atom_indices:
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if sphere.rank != rank:
c_xiv = c_xMv[..., M1:M2, :].copy()
b_axiv[a] = c_xiv
srequests.append(comm.send(c_xiv,
sphere.rank, a, False))
else:
if len(sphere.ranks) > 0:
c_rxiv = np.empty(sphere.ranks.shape + xshape +
(M2 - M1, 3), dtype)
c_arxiv[a] = c_rxiv
for r, b_xiv in zip(sphere.ranks, c_rxiv):
rrequests.append(comm.receive(b_xiv, r, a, False))
M1 = M2
for request in rrequests:
comm.wait(request)
M1 = 0
for a in self.atom_indices:
c_xiv = c_axiv.get(a)
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if c_xiv is not None:
if len(sphere.ranks) > 0:
c_xiv[:] = c_xMv[..., M1:M2, :] + c_arxiv[a].sum(axis=0)
else:
c_xiv[:] = c_xMv[..., M1:M2, :]
M1 = M2
for request in srequests:
comm.wait(request)
def _normalized_derivative(self, a_G, c_aiv):
"""Calculate x-, y-, and z-derivatives of localized function integrals.
Calculates the derivatives of this integral::
a / _ _ a - _a
A = | dr a(r) f (r - R ),
lm / lm
a
dA
lm
c_aiv = ----,
a
R
v
where v is either x, y, or z and i=l**2+m. Note that the
actual integrals used are normalized::
a
~a a I
f = f ---,
00 00 a
I
00
and for l > 0::
a
I
~a a a lm
f = f - f ---,
lm lm 00 a
I
00
where
::
a / _ -a _ _a
I = | dr f (r - R ),
lm / lm
so the derivative look pretty ugly!
"""
c_Mv = np.zeros((self.Mmax, 7))
cspline_M = []
for a in self.atom_indices:
for spline in self.sphere_a[a].spline_j:
nm = 2 * spline.get_angular_momentum_number() + 1
cspline_M.extend([spline.spline] * nm)
gd = self.gd
self.lfc.normalized_derivative(a_G, c_Mv,
np.ascontiguousarray(gd.h_cv), gd.n_c,
cspline_M,
gd.beg_c, self.pos_Wv)
comm = self.gd.comm
rank = comm.rank
srequests = []
rrequests = []
c_ariv = {}
b_aiv = {}
M1 = 0
for a in self.atom_indices:
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if sphere.rank != rank:
c_iv = c_Mv[M1:M2].copy()
b_aiv[a] = c_iv
srequests.append(comm.send(c_iv, sphere.rank, a, False))
else:
if len(sphere.ranks) > 0:
c_riv = np.empty((len(sphere.ranks), M2 - M1, 7))
c_ariv[a] = c_riv
for r, b_iv in zip(sphere.ranks, c_riv):
rrequests.append(comm.receive(b_iv, r, a, False))
M1 = M2
for request in rrequests:
comm.wait(request)
M1 = 0
for a in self.atom_indices:
c_iv = c_aiv.get(a)
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if c_iv is not None:
I = self.integral_a[a]
if I > 1e-15:
if len(sphere.ranks) > 0:
c_Mv[M1:M2] += c_ariv[a].sum(axis=0)
I_L = sphere.I_M
I0 = I_L[0]
c_Lv = c_Mv[M1:M2, :3]
b_Lv = c_Mv[M1:M2, 3:6]
A0 = c_Mv[M1, 6]
c_iv[0, :] = (I / I0 * c_Lv[0] -
I / I0**2 * b_Lv[0] * A0)
c_iv[1:, :] = (c_Lv[1:] -
np.outer(I_L[1:] / I0, c_Lv[0]) -
A0 / I0 * b_Lv[1:] +
A0 / I0**2 * np.outer(I_L[1:], b_Lv[0]))
else:
c_iv[:] = 0.0
M1 = M2
for request in srequests:
comm.wait(request)
def second_derivative(self, a_xG, c_axivv, q=-1):
"""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
"""
assert not self.use_global_indices
if debug:
assert a_xG.ndim == 3
assert a_xG.dtype == self.dtype
assert sorted(c_axivv.keys()) == self.my_atom_indices
dtype = a_xG.dtype
c_Mvv = np.zeros((self.Mmax, 3, 3), dtype)
cspline_M = []
for a in self.atom_indices:
# Works only for atoms with a single function
assert len(self.sphere_a[a].spline_j) == 1
spline = self.sphere_a[a].spline_j[0]
# that is spherical symmetric
assert spline.get_angular_momentum_number() == 0
cspline_M.append(spline.spline)
gd = self.gd
self.lfc.second_derivative(a_xG, c_Mvv, np.ascontiguousarray(gd.h_cv),
gd.n_c, cspline_M,
gd.beg_c, self.pos_Wv, q)
comm = self.gd.comm
rank = comm.rank
srequests = []
rrequests = []
c_arvv = {}
b_avv = {}
M1 = 0
for a in self.atom_indices:
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if sphere.rank != rank:
c_vv = c_Mvv[M1:M2].copy()
b_avv[a] = c_vv
srequests.append(comm.send(c_vv, sphere.rank, a, False))
else:
if len(sphere.ranks) > 0:
c_rvv = np.empty(sphere.ranks.shape + (3, 3), dtype)
c_arvv[a] = c_rvv
for r, b_vv in zip(sphere.ranks, c_rvv):
rrequests.append(comm.receive(b_vv, r, a, False))
M1 = M2
for request in rrequests:
comm.wait(request)
M1 = 0
for a in self.atom_indices:
c_vv = c_axivv.get(a)
sphere = self.sphere_a[a]
M2 = M1 + sphere.Mmax
if c_vv is not None:
if len(sphere.ranks) > 0:
c_vv[:] = c_Mvv[M1] + c_arvv[a].sum(axis=0)
else:
c_vv[:] = c_Mvv[M1]
M1 = M2
for request in srequests:
comm.wait(request)
def griditer(self):
"""Iterate over grid points."""
self.g_W = np.zeros(len(self.M_W), np.intc)
self.current_lfindices = []
G1 = 0
for W, G in zip(self.W_B, self.G_B):
G2 = G
yield G1, G2
self.g_W[self.current_lfindices] += G2 - G1
if W >= 0:
self.current_lfindices.append(W)
else:
self.current_lfindices.remove(-1 - W)
G1 = G2
def get_function_count(self, a):
return self.sphere_a[a].get_function_count()
class BasisFunctions(NewLocalizedFunctionsCollection):
def __init__(self, gd, spline_aj, kd=None, cut=False, dtype=float,
integral=None, forces=None):
NewLocalizedFunctionsCollection.__init__(self, gd, spline_aj,
kd, cut,
dtype, integral,
forces)
self.use_global_indices = True
self.Mstart = None
self.Mstop = None
def set_positions(self, spos_ac):
NewLocalizedFunctionsCollection.set_positions(self, spos_ac)
self.Mstart = 0
self.Mstop = self.Mmax
def _update(self, spos_ac):
sdisp_Wc = NewLocalizedFunctionsCollection._update(self, spos_ac)
if not self.gamma or self.dtype == complex:
self.x_W, self.sdisp_xc = self.create_displacement_arrays(sdisp_Wc)
return sdisp_Wc
def create_displacement_arrays(self, sdisp_Wc=None):
if sdisp_Wc is None:
sdisp_Wc = np.empty((len(self.M_W), 3), int)
W = 0
for a in self.atom_indices:
sphere = self.sphere_a[a]
nw = len(sphere.M_w)
sdisp_Wc[W:W + nw] = sphere.sdisp_wc
W += nw
if len(sdisp_Wc) > 0:
n_c = sdisp_Wc.max(0) - sdisp_Wc.min(0)
else:
n_c = np.zeros(3, int)
N_c = 2 * n_c + 1
stride_c = np.array([N_c[1] * N_c[2], N_c[2], 1])
x_W = np.dot(sdisp_Wc, stride_c).astype(np.intc)
# use a neighbor list instead?
x1 = np.dot(n_c, stride_c)
sdisp_xc = np.zeros((x1 + 1, 3), int)
r_x, sdisp_xc[:, 2] = divmod(np.arange(x1, 2 * x1 + 1), N_c[2])
sdisp_xc.T[:2] = divmod(r_x, N_c[1])
sdisp_xc -= n_c
return x_W, sdisp_xc
def set_matrix_distribution(self, Mstart, Mstop):
assert self.Mmax is not None
self.Mstart = Mstart
self.Mstop = Mstop
def add_to_density(self, nt_sG, f_asi):
"""Add linear combination of squared localized functions to density.
::
~ -- a / a \2
n (r) += > f | Phi (r) |
s -- si \ i /
a,i
"""
nspins = len(nt_sG)
f_sM = np.empty((nspins, self.Mmax))
for a in self.atom_indices:
sphere = self.sphere_a[a]
M1 = self.M_a[a]
M2 = M1 + sphere.Mmax
f_sM[:, M1:M2] = f_asi[a]
for nt_G, f_M in zip(nt_sG, f_sM):
self.lfc.construct_density1(f_M, nt_G)
def construct_density(self, rho_MM, nt_G, q):
"""Calculate electron density from density matrix.
rho_MM: ndarray
Density matrix.
nt_G: ndarray
Pseudo electron density.
::
~ -- *
n(r) += > Phi (r) rho Phi (r)
-- M1 M1M2 M2
M1,M2
"""
self.lfc.construct_density(rho_MM, nt_G, q, self.Mstart, self.Mstop)
def integrate2(self, a_xG, c_xM, q=-1):
"""Calculate integrals of arrays times localized functions.
::
/ *
c_xM += = | dG Phi (G) a (G)
M x / M x
"""
xshape, Gshape = a_xG.shape[:-3], a_xG.shape[-3:]
Nx = int(np.prod(xshape))
a_xG = a_xG.reshape((Nx,) + Gshape)
c_xM = c_xM.reshape(Nx, -1)
for a_G, c_M in zip(a_xG, c_xM):
self.lfc.integrate(a_G, c_M, q)
def calculate_potential_matrices(self, vt_G):
"""Calculate lower part of potential matrix.
::
/
~ | * _ ~ _ _ _
V = | Phi (r) v(r) Phi (r) dr for mu >= nu
mu nu | mu nu
/
Overwrites the elements of the target matrix Vt_MM. """
if self.gamma and self.dtype == float:
Vt_xMM = np.zeros((1, self.Mstop - self.Mstart, self.Mmax))
self.lfc.calculate_potential_matrix(vt_G, Vt_xMM[0], -1,
self.Mstart, self.Mstop)
else:
Vt_xMM = np.zeros((len(self.sdisp_xc),
self.Mstop - self.Mstart,
self.Mmax))
self.lfc.calculate_potential_matrices(vt_G, Vt_xMM, self.x_W,
self.Mstart, self.Mstop)
return Vt_xMM
def calculate_potential_matrix(self, vt_G, Vt_MM, q):
"""Calculate lower part of potential matrix.
::
/
~ | * _ ~ _ _ _
V = | Phi (r) v(r) Phi (r) dr for mu >= nu
mu nu | mu nu
/
Overwrites the elements of the target matrix Vt_MM. """
Vt_MM[:] = 0.0
self.lfc.calculate_potential_matrix(vt_G, Vt_MM, q,
self.Mstart, self.Mstop)
def lcao_to_grid(self, C_xM, psit_xG, q):
"""Deploy basis functions onto grids according to coefficients.
::
----
~ _ \ _
psi (r) += ) C Phi (r)
n / n mu mu
----
mu
"""
if C_xM.size == 0:
return
C_xM = C_xM.reshape((-1,) + C_xM.shape[-1:])
psit_xG = psit_xG.reshape((-1,) + psit_xG.shape[-3:])
if self.gamma or len(C_xM) == 1:
for C_M, psit_G in zip(C_xM, psit_xG):
self.lfc.lcao_to_grid(C_M, psit_G, q)
else:
# Do sum over unit cells first followed by sum over bands
# in blocks of 10 orbitals at the time:
assert C_xM.flags.contiguous
assert psit_xG.flags.contiguous
self.lfc.lcao_to_grid_k(C_xM, psit_xG, q, 10)
def calculate_potential_matrix_derivative(self, vt_G, DVt_vMM, q):
"""Calculate derivatives of potential matrix elements.
::
/ * _
| Phi (r)
~c | mu ~ _ _ _
DV += | -------- v(r) Phi (r) dr
mu nu | dr nu
/ c
Results are added to DVt_vMM.
"""
cspline_M = []
for a, sphere in enumerate(self.sphere_a):
for j, spline in enumerate(sphere.spline_j):
nm = 2 * spline.get_angular_momentum_number() + 1
cspline_M.extend([spline.spline] * nm)
gd = self.gd
for v in range(3):
self.lfc.calculate_potential_matrix_derivative(
vt_G, DVt_vMM[v],
np.ascontiguousarray(gd.h_cv),
gd.n_c, q, v,
np.array(cspline_M),
gd.beg_c,
self.pos_Wv,
self.Mstart,
self.Mstop)
def calculate_force_contribution(self, vt_G, rhoT_MM, q):
"""Calculate derivatives of potential matrix elements.
::
/ * _
| Phi (r)
~c | mu ~ _ _ _
DV += | -------- v(r) Phi (r) dr
mu nu | dr nu
/ c
Results are added to DVt_vMM.
"""
cspline_M = []
for a, sphere in enumerate(self.sphere_a):
for j, spline in enumerate(sphere.spline_j):
nm = 2 * spline.get_angular_momentum_number() + 1
cspline_M.extend([spline.spline] * nm)
gd = self.gd
Mstart = self.Mstart
Mstop = self.Mstop
F_vM = np.zeros((3, Mstop - Mstart))
assert self.Mmax == rhoT_MM.shape[1]
assert Mstop - Mstart == rhoT_MM.shape[0]
for v in range(3):
self.lfc.calculate_potential_matrix_force_contribution(
vt_G, rhoT_MM, F_vM[v],
np.ascontiguousarray(gd.h_cv),
gd.n_c, q, v,
np.array(cspline_M),
gd.beg_c,
self.pos_Wv,
Mstart,
Mstop)
F_av = np.zeros((len(self.M_a), 3))
a = 0
for a, M1 in enumerate(self.M_a):
M1 -= Mstart
M2 = M1 + self.sphere_a[a].Mmax
if M2 < 0:
continue
M1 = max(0, M1)
F_av[a, :] = 2.0 * F_vM[:, M1:M2].sum(axis=1)
return F_av
from gpaw.localized_functions import LocFuncs, LocFuncBroadcaster
from gpaw.mpi import run
class LocalizedFunctionsCollection(BaseLFC):
def __init__(self, gd, spline_aj, kpt_comm=None,
cut=False, dtype=float,
integral=None, forces=False):
self.gd = gd
self.spline_aj = spline_aj
self.cut = cut
self.forces = forces
self.dtype = dtype
self.integral_a = integral
self.spos_ac = None
self.lfs_a = {}
self.ibzk_qc = None
self.gamma = True
self.kpt_comm = kpt_comm
self.my_atom_indices = None
def set_positions(self, spos_ac):
if self.kpt_comm:
lfbc = LocFuncBroadcaster(self.kpt_comm)
else:
lfbc = None
for a, spline_j in enumerate(self.spline_aj):
if self.spos_ac is None or (self.spos_ac[a] != spos_ac[a]).any():
lfs = LocFuncs(spline_j, self.gd, spos_ac[a],
self.dtype, self.cut, self.forces, lfbc)
if len(lfs.box_b) > 0:
if not self.gamma:
lfs.set_phase_factors(self.ibzk_qc)
self.lfs_a[a] = lfs
elif a in self.lfs_a:
del self.lfs_a[a]
if lfbc:
lfbc.broadcast()
rank = self.gd.comm.rank
self.my_atom_indices = [a for a, lfs in self.lfs_a.items()
if lfs.root == rank]
self.my_atom_indices.sort()
self.atom_indices = [a for a, lfs in self.lfs_a.items()]
self.atom_indices.sort()
if debug:
# Holm-Nielsen check:
natoms = len(spos_ac)
assert (self.gd.comm.sum(float(sum(self.my_atom_indices))) ==
natoms * (natoms - 1) // 2)
if self.integral_a is not None:
if isinstance(self.integral_a, (float, int)):
integral = self.integral_a
for a in self.atom_indices:
self.lfs_a[a].normalize(integral)
else:
for a in self.atom_indices:
lfs = self.lfs_a[a]
integral = self.integral_a[a]
if abs(integral) > 1e-15:
lfs.normalize(integral)
self.spos_ac = spos_ac
def get_dtype(self): # old LFC uses the dtype attribute for dicts
return self.dtype
def add(self, a_xG, c_axi=1.0, q=-1):
if isinstance(c_axi, float):
assert q == -1
c_xi = np.array([c_axi])
run([lfs.iadd(a_xG, c_xi) for lfs in self.lfs_a.values()])
else:
run([self.lfs_a[a].iadd(a_xG, c_axi.get(a), q, True)
for a in self.atom_indices])
def integrate(self, a_xG, c_axi, q=-1):
for c_xi in c_axi.values():
c_xi.fill(0.0)
run([self.lfs_a[a].iintegrate(a_xG, c_axi.get(a), q)
for a in self.atom_indices])
def derivative(self, a_xG, c_axiv, q=-1):
for c_xiv in c_axiv.values():
c_xiv.fill(0.0)
run([self.lfs_a[a].iderivative(a_xG, c_axiv.get(a), q)
for a in self.atom_indices])
def add1(self, n_g, scale, I_a):
scale_i = np.array([scale], float)
for lfs in self.lfs_a.values():
lfs.add(n_g, scale_i)
for a, lfs in self.lfs_a.items():
I_ic = np.zeros((1, 4))
for box in lfs.box_b:
box.norm(I_ic)
I_a[a] += I_ic[0, 0] * scale
def add2(self, n_g, D_asp, s, scale, I_a):
for a, lfs in self.lfs_a.items():
I_a[a] += lfs.add_density2(n_g, scale * D_asp[a][s])
def get_function_count(self, a):
return self.lfs_a[a].ni
def estimate_memory(self, mem):
count = 0
for spline_j in self.spline_aj:
for spline in spline_j:
l = spline.get_angular_momentum_number()
sidelength = 2 * spline.get_cutoff()
count += (2 * l + 1) * sidelength**3 / self.gd.dv
bytes = count * mem.floatsize / self.gd.comm.size
mem.subnode('Boxes', bytes)
if self.forces:
mem.subnode('Derivatives', 3 * bytes)
mem.subnode('Work', bytes)
if extra_parameters.get('usenewlfc', True):
LocalizedFunctionsCollection = NewLocalizedFunctionsCollection
def LFC(gd, spline_aj, kd=None,
cut=False, dtype=float,
integral=None, forces=False):
if isinstance(gd, GridDescriptor):
return LocalizedFunctionsCollection(gd, spline_aj, kd,
cut, dtype, integral, forces)
else:
return gd.get_lfc(gd, spline_aj)
def test():
from gpaw.grid_descriptor import GridDescriptor
ngpts = 40
h = 1.0 / ngpts
N_c = (ngpts, ngpts, ngpts)
a = h * ngpts
gd = GridDescriptor(N_c, (a, a, a))
from gpaw.spline import Spline
a = np.array([1, 0.9, 0.8, 0.0])
s = Spline(0, 0.2, a)
x = LocalizedFunctionsCollection(gd, [[s], [s]])
x.set_positions([(0.5, 0.45, 0.5), (0.5, 0.55, 0.5)])
n_G = gd.zeros()
x.add(n_G)
import pylab as plt
plt.contourf(n_G[20, :, :])
plt.axis('equal')
plt.show()
if __name__ == '__main__':
test()
gpaw-0.11.0.13004/gpaw/helmholtz.py 0000664 0001750 0001750 00000014433 12553643470 016777 0 ustar jensj jensj 0000000 0000000 from math import pi, sqrt
import numpy as np
from numpy import exp
from gpaw.poisson import PoissonSolver
from gpaw.utilities import cerf, erf
from gpaw.utilities.gauss import Gaussian
from gpaw.fd_operators import FDOperator, laplace
from gpaw.transformers import Transformer
class HelmholtzGaussian(Gaussian):
def get_phi(self, k2):
"""Get the solution of the Helmholtz equation for a Gaussian."""
# This should lead to very big errors
r = np.sqrt(self.r2)
k = sqrt(k2)
sigma = 1. / sqrt(2 * self.a)
p = sigma * k / sqrt(2)
i = 1j
rhop = r / sqrt(2) / sigma + i * p
rhom = r / sqrt(2) / sigma - i * p
# h = np.sin(k * r)
# the gpaw-Gaussian is sqrt(4 * pi) times a 3D normalized Gaussian
return sqrt(4 * pi) * exp(-p**2) / r / 2 * (
np.cos(k * r) * (cerf(rhop) + cerf(rhom)) +
i * np.sin(k * r) * (2 + cerf(rhop) - cerf(rhom)))
class ScreenedPoissonGaussian(Gaussian):
def get_phi(self, mu2):
"""Get the solution of the screened Poisson equation for a Gaussian.
The Gaussian is centered to middle of grid-descriptor."""
r = np.sqrt(self.r2)
mu = sqrt(mu2)
sigma = 1. / sqrt(2 * self.a)
sig2 = sigma**2
mrho = (sig2 * mu - r) / (sqrt(2) * sigma)
prho = (sig2 * mu + r) / (sqrt(2) * sigma)
def erfc(values):
return 1. - erf(values)
# the gpaw-Gaussian is sqrt(4 * pi) times a 3D normalized Gaussian
return sqrt(4 * pi) * exp(sig2 * mu2 / 2.0) / (2 * r) * (
exp(-mu * r) * erfc(mrho) - exp(mu * r) * erfc(prho))
class HelmholtzOperator(FDOperator):
def __init__(self, gd, scale=1.0, n=1, dtype=float, k2=0.0):
"""Helmholtz for general non orthorhombic grid.
gd: GridDescriptor
Descriptor for grid.
scale: float
Scaling factor. Use scale=-0.5 for a kinetic energy operator.
n: int
Range of stencil. Stencil has O(h^(2n)) error.
dtype: float or complex
Datatype to work on.
"""
# Order the 13 neighbor grid points:
M_ic = np.indices((3, 3, 3)).reshape((3, -3)).T[-13:] - 1
u_cv = gd.h_cv / (gd.h_cv**2).sum(1)[:, np.newaxis]**0.5
u2_i = (np.dot(M_ic, u_cv)**2).sum(1)
i_d = u2_i.argsort()
m_mv = np.array([(2, 0, 0), (0, 2, 0), (0, 0, 2),
(0, 1, 1), (1, 0, 1), (1, 1, 0)])
# Try 3, 4, 5 and 6 directions:
for D in range(3, 7):
h_dv = np.dot(M_ic[i_d[:D]], gd.h_cv)
A_md = (h_dv**m_mv[:, np.newaxis, :]).prod(2)
a_d, residual, rank, s = np.linalg.lstsq(A_md, [1, 1, 1, 0, 0, 0])
if residual.sum() < 1e-14:
assert rank == D, 'You have a weird unit cell!'
# D directions was OK
break
a_d *= scale
offsets = [(0, 0, 0)]
coefs = [laplace[n][0] * a_d.sum()]
coefs[0] += k2 * scale
for d in range(D):
M_c = M_ic[i_d[d]]
offsets.extend(np.arange(1, n + 1)[:, np.newaxis] * M_c)
coefs.extend(a_d[d] * np.array(laplace[n][1:]))
offsets.extend(np.arange(-1, -n - 1, -1)[:, np.newaxis] * M_c)
coefs.extend(a_d[d] * np.array(laplace[n][1:]))
FDOperator.__init__(self, coefs, offsets, gd, dtype)
self.description = (
'%d*%d+1=%d point O(h^%d) finite-difference Helmholtz' %
((self.npoints - 1) // n, n, self.npoints, 2 * n))
class HelmholtzSolver(PoissonSolver):
"""Solve the Helmholtz or screened Poisson equations.
The difference between the Helmholtz equation:
(Laplace + k^2) phi = n
and the screened Poisson equation:
(Laplace - mu^2) phi = n
is only the sign of the added inhomogenity. Because of
this we can use one class to solve both. So if k2 is
greater zero we'll try to solve the Helmhlotz equation,
otherwise we'll try to solve the screened Poisson equation.
"""
def __init__(self, k2=0.0, nn='M', relax='GS', eps=2e-10,
use_charge_center=True):
assert k2 <= 0, 'Currently only defined for k^2<=0'
PoissonSolver.__init__(self, nn, relax, eps,
use_charge_center=use_charge_center)
self.k2 = k2
def set_grid_descriptor(self, gd):
# Should probably be renamed initialize
self.gd = gd
self.dv = gd.dv
gd = self.gd
scale = -0.25 / pi
if self.nn == 'M':
raise ValueError(
'Helmholtz not defined for Mehrstellen stencil')
self.operators = [HelmholtzOperator(gd, scale, self.nn, k2=self.k2)]
self.B = None
self.interpolators = []
self.restrictors = []
level = 0
self.presmooths = [2]
self.postsmooths = [1]
# Weights for the relaxation,
# only used if 'J' (Jacobi) is chosen as method
self.weights = [2.0 / 3.0]
while level < 4:
try:
gd2 = gd.coarsen()
except ValueError:
break
self.operators.append(HelmholtzOperator(gd2, scale, 1,
k2=self.k2))
self.interpolators.append(Transformer(gd2, gd))
self.restrictors.append(Transformer(gd, gd2))
self.presmooths.append(4)
self.postsmooths.append(4)
self.weights.append(1.0)
level += 1
gd = gd2
self.levels = level
if self.relax_method == 1:
self.description = 'Gauss-Seidel'
else:
self.description = 'Jacobi'
self.description += ' solver with %d multi-grid levels' % (level + 1)
self.description += '\nStencil: ' + self.operators[0].description
def load_gauss(self, center=None):
"""Load the gaussians."""
if not hasattr(self, 'rho_gauss') or center is not None:
if self.k2 > 0:
gauss = HelmholtzGaussian(self.gd, center=center)
else:
gauss = ScreenedPoissonGaussian(self.gd, center=center)
self.rho_gauss = gauss.get_gauss(0)
self.phi_gauss = gauss.get_phi(abs(self.k2))
gpaw-0.11.0.13004/gpaw/coulomb.py 0000664 0001750 0001750 00000030325 12553643472 016431 0 ustar jensj jensj 0000000 0000000 from math import pi, sqrt
from ase.units import Hartree
import numpy as np
from numpy.fft import fftn
from gpaw.lfc import LocalizedFunctionsCollection as LFC
from gpaw.pair_density import PairDensity2 as PairDensity
from gpaw.poisson import PoissonSolver, FFTPoissonSolver
from gpaw.utilities import unpack, packed_index, unpack2
from gpaw.utilities.ewald import madelung
from gpaw.utilities.tools import construct_reciprocal, tri2full, symmetrize
from gpaw.utilities.gauss import Gaussian
from gpaw.utilities.blas import r2k
def get_vxc(paw, spin=0, U=None):
"""Calculate matrix elements of the xc-potential."""
assert not paw.hamiltonian.xc.xcfunc.orbital_dependent, "LDA/GGA's only"
assert paw.wfs.dtype == float, 'Complex waves not implemented'
if U is not None: # Rotate xc matrix
return np.dot(U.T.conj(), np.dot(get_vxc(paw, spin), U))
gd = paw.hamiltonian.gd
psit_nG = paw.wfs.kpt_u[spin].psit_nG[:]
if paw.density.nt_sg is None:
paw.density.interpolate_pseudo_density()
nt_g = paw.density.nt_sg[spin]
vxct_g = paw.density.finegd.zeros()
paw.hamiltonian.xc.get_energy_and_potential(nt_g, vxct_g)
vxct_G = gd.empty()
paw.hamiltonian.restrict(vxct_g, vxct_G)
Vxc_nn = np.zeros((paw.wfs.bd.nbands, paw.wfs.bd.nbands))
# Apply pseudo part
r2k(.5 * gd.dv, psit_nG, vxct_G * psit_nG, .0, Vxc_nn) # lower triangle
tri2full(Vxc_nn, 'L') # Fill in upper triangle from lower
gd.comm.sum(Vxc_nn)
# Add atomic PAW corrections
for a, P_ni in paw.wfs.kpt_u[spin].P_ani.items():
D_sp = paw.density.D_asp[a][:]
H_sp = np.zeros_like(D_sp)
paw.wfs.setups[a].xc_correction.calculate_energy_and_derivatives(
D_sp, H_sp)
H_ii = unpack(H_sp[spin])
Vxc_nn += np.dot(P_ni, np.dot(H_ii, P_ni.T))
return Vxc_nn * Hartree
class Coulomb:
"""Class used to evaluate two index coulomb integrals."""
def __init__(self, gd, poisson=None):
"""Class should be initialized with a grid_descriptor 'gd' from
the gpaw module.
"""
self.gd = gd
self.poisson = poisson
def load(self, method):
"""Make sure all necessary attributes have been initialized"""
assert method in ('real', 'recip_gauss', 'recip_ewald'),\
str(method) + ' is an invalid method name,\n' +\
'use either real, recip_gauss, or recip_ewald'
if method.startswith('recip'):
if self.gd.comm.size > 1:
raise RuntimeError("Cannot do parallel FFT, use method='real'")
if not hasattr(self, 'k2'):
self.k2, self.N3 = construct_reciprocal(self.gd)
if method.endswith('ewald') and not hasattr(self, 'ewald'):
# cutoff radius
assert self.gd.orthogonal
rc = 0.5 * np.average(self.gd.cell_cv.diagonal())
# ewald potential: 1 - cos(k rc)
self.ewald = (np.ones(self.gd.n_c) -
np.cos(np.sqrt(self.k2) * rc))
# lim k -> 0 ewald / k2
self.ewald[0, 0, 0] = 0.5 * rc**2
elif method.endswith('gauss') and not hasattr(self, 'ng'):
gauss = Gaussian(self.gd)
self.ng = gauss.get_gauss(0) / sqrt(4 * pi)
self.vg = gauss.get_gauss_pot(0) / sqrt(4 * pi)
else: # method == 'real'
if not hasattr(self, 'solve'):
if self.poisson is not None:
self.solve = self.poisson.solve
else:
solver = PoissonSolver(nn=2)
solver.set_grid_descriptor(self.gd)
solver.initialize(load_gauss=True)
self.solve = solver.solve
def coulomb(self, n1, n2=None, Z1=None, Z2=None, method='recip_gauss'):
"""Evaluates the coulomb integral of n1 and n2
The coulomb integral is defined by::
*
/ / n1(r) n2(r')
(n1 | n2) = | dr | dr' -------------,
/ / |r - r'|
where n1 and n2 could be complex.
real:
Evaluate directly in real space using gaussians to neutralize
density n2, such that the potential can be generated by standard
procedures
recip_ewald:
Evaluate by Fourier transform.
Divergence at division by k^2 is avoided by utilizing the Ewald /
Tuckermann trick, which formaly requires the densities to be
localized within half of the unit cell.
recip_gauss:
Evaluate by Fourier transform.
Divergence at division by k^2 is avoided by removing total charge
of n1 and n2 with gaussian density ng::
* * *
(n1|n2) = (n1 - Z1 ng|n2 - Z2 ng) + (Z2 n1 + Z1 n2 - Z1 Z2 ng | ng)
The evaluation of the integral (n1 - Z1 ng|n2 - Z2 ng) is done in
k-space using FFT techniques.
"""
self.load(method)
# determine integrand using specified method
if method == 'real':
I = self.gd.zeros()
if n2 is None:
n2 = n1
Z2 = Z1
self.solve(I, n2, charge=Z2, eps=1e-12, zero_initial_phi=True)
I += madelung(self.gd.cell_cv) * self.gd.integrate(n2)
I *= n1.conj()
elif method == 'recip_ewald':
n1k = fftn(n1)
if n2 is None:
n2k = n1k
else:
n2k = fftn(n2)
I = n1k.conj() * n2k * self.ewald * 4 * pi / (self.k2 * self.N3)
else: # method == 'recip_gauss':
# Determine total charges
if Z1 is None:
Z1 = self.gd.integrate(n1)
if Z2 is None and n2 is not None:
Z2 = self.gd.integrate(n2)
# Determine the integrand of the neutral system
# (n1 - Z1 ng)* int dr' (n2 - Z2 ng) / |r - r'|
nk1 = fftn(n1 - Z1 * self.ng)
if n2 is None:
I = abs(nk1)**2 * 4 * pi / (self.k2 * self.N3)
else:
nk2 = fftn(n2 - Z2 * self.ng)
I = nk1.conj() * nk2 * 4 * pi / (self.k2 * self.N3)
# add the corrections to the integrand due to neutralization
if n2 is None:
I += (2 * np.real(np.conj(Z1) * n1) -
abs(Z1)**2 * self.ng) * self.vg
else:
I += (np.conj(Z1) * n2 + Z2 * n1.conj() -
np.conj(Z1) * Z2 * self.ng) * self.vg
if n1.dtype == float and (n2 is None or n2.dtype == float):
return np.real(self.gd.integrate(I))
else:
return self.gd.integrate(I)
class CoulombNEW:
def __init__(self, gd, setups, spos_ac, fft=False):
assert gd.comm.size == 1
self.rhot1_G = gd.empty()
self.rhot2_G = gd.empty()
self.pot_G = gd.empty()
self.dv = gd.dv
if fft:
self.poisson = FFTPoissonSolver()
else:
self.poisson = PoissonSolver(nn=3)
self.poisson.set_grid_descriptor(gd)
self.poisson.initialize()
self.setups = setups
# Set coarse ghat
self.Ghat = LFC(gd, [setup.ghat_l for setup in setups],
integral=sqrt(4 * pi))
self.Ghat.set_positions(spos_ac)
def calculate(self, nt1_G, nt2_G, P1_ap, P2_ap):
I = 0.0
self.rhot1_G[:] = nt1_G
self.rhot2_G[:] = nt2_G
Q1_aL = {}
Q2_aL = {}
for a, P1_p in P1_ap.items():
P2_p = P2_ap[a]
setup = self.setups[a]
# Add atomic corrections to integral
I += 2 * np.dot(P1_p, np.dot(setup.M_pp, P2_p))
# Add compensation charges to pseudo densities
Q1_aL[a] = np.dot(P1_p, setup.Delta_pL)
Q2_aL[a] = np.dot(P2_p, setup.Delta_pL)
self.Ghat.add(self.rhot1_G, Q1_aL)
self.Ghat.add(self.rhot2_G, Q2_aL)
# Add coulomb energy of compensated pseudo densities to integral
self.poisson.solve(self.pot_G, self.rhot2_G, charge=None,
eps=1e-12, zero_initial_phi=True)
I += np.vdot(self.rhot1_G, self.pot_G) * self.dv
return I * Hartree
class HF:
def __init__(self, paw):
paw.initialize_positions()
self.nspins = paw.wfs.nspins
self.nbands = paw.wfs.bd.nbands
self.restrict = paw.hamiltonian.restrict
self.pair_density = PairDensity(paw.density, paw.atoms, finegrid=True)
self.dv = paw.wfs.gd.dv
self.dtype = paw.wfs.dtype
self.setups = paw.wfs.setups
# Allocate space for matrices
self.nt_G = paw.wfs.gd.empty()
self.rhot_g = paw.density.finegd.empty()
self.vt_G = paw.wfs.gd.empty()
self.vt_g = paw.density.finegd.empty()
self.poisson_solve = paw.hamiltonian.poisson.solve
def apply(self, paw, u=0):
H_nn = np.zeros((self.nbands, self.nbands), self.dtype)
self.soft_pseudo(paw, H_nn, u=u)
self.atomic_val_val(paw, H_nn, u=u)
self.atomic_val_core(paw, H_nn, u=u)
return H_nn * Hartree
def soft_pseudo(self, paw, H_nn, h_nn=None, u=0):
if h_nn is None:
h_nn = H_nn
kpt = paw.wfs.kpt_u[u]
pd = self.pair_density
deg = 2 / self.nspins
fmin = 1e-9
Htpsit_nG = np.zeros(kpt.psit_nG.shape, self.dtype)
for n1 in range(self.nbands):
psit1_G = kpt.psit_nG[n1]
f1 = kpt.f_n[n1] / deg
for n2 in range(n1, self.nbands):
psit2_G = kpt.psit_nG[n2]
f2 = kpt.f_n[n2] / deg
if f1 < fmin and f2 < fmin:
continue
pd.initialize(kpt, n1, n2)
pd.get_coarse(self.nt_G)
pd.add_compensation_charges(self.nt_G, self.rhot_g)
self.poisson_solve(self.vt_g, -self.rhot_g,
charge=-float(n1 == n2), eps=1e-12,
zero_initial_phi=True)
self.restrict(self.vt_g, self.vt_G)
Htpsit_nG[n1] += f2 * self.vt_G * psit2_G
if n1 != n2:
Htpsit_nG[n2] += f1 * self.vt_G * psit1_G
v_aL = paw.density.ghat.dict()
paw.density.ghat.integrate(self.vt_g, v_aL)
for a, v_L in v_aL.items():
v_ii = unpack(np.dot(paw.wfs.setups[a].Delta_pL, v_L))
P_ni = kpt.P_ani[a]
h_nn[:, n1] += f2 * np.dot(P_ni, np.dot(v_ii, P_ni[n2]))
if n1 != n2:
h_nn[:, n2] += f1 * np.dot(P_ni,
np.dot(v_ii, P_ni[n1]))
symmetrize(h_nn) # Grrrr why!!! XXX
# Fill in lower triangle
r2k(0.5 * self.dv, kpt.psit_nG[:], Htpsit_nG, 1.0, H_nn)
# Fill in upper triangle from lower
tri2full(H_nn, 'L')
def atomic_val_val(self, paw, H_nn, u=0):
deg = 2 / self.nspins
kpt = paw.wfs.kpt_u[u]
for a, P_ni in kpt.P_ani.items():
# Add atomic corrections to the valence-valence exchange energy
# --
# > D C D
# -- ii iiii ii
setup = paw.wfs.setups[a]
D_p = paw.density.D_asp[a][kpt.s]
H_p = np.zeros_like(D_p)
D_ii = unpack2(D_p)
ni = len(D_ii)
for i1 in range(ni):
for i2 in range(ni):
A = 0.0
for i3 in range(ni):
p13 = packed_index(i1, i3, ni)
for i4 in range(ni):
p24 = packed_index(i2, i4, ni)
A += setup.M_pp[p13, p24] * D_ii[i3, i4]
p12 = packed_index(i1, i2, ni)
H_p[p12] -= 2 / deg * A / ((i1 != i2) + 1)
H_nn += np.dot(P_ni, np.inner(unpack(H_p), P_ni.conj()))
def atomic_val_core(self, paw, H_nn, u=0):
kpt = paw.wfs.kpt_u[u]
for a, P_ni in kpt.P_ani.items():
dH_ii = unpack(-paw.wfs.setups[a].X_p)
H_nn += np.dot(P_ni, np.inner(dH_ii, P_ni.conj()))
gpaw-0.11.0.13004/gpaw/svnversion_io.py 0000664 0001750 0001750 00000002474 12553643472 017700 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
from os import path
try:
from subprocess import Popen, PIPE
except ImportError:
from os import popen3
else:
def popen3(cmd):
p = Popen(cmd, shell=True, close_fds=True,
stdin=PIPE, stdout=PIPE, stderr=PIPE)
return p.stdin, p.stdout, p.stderr
def write_svnversion(svnversion, dir):
svnversionfile = path.join(dir, 'svnversion.py')
f = open(svnversionfile,'w')
f.write('svnversion = "%s"\n' % svnversion)
f.close()
print('svnversion = ' +svnversion+' written to '+svnversionfile)
# assert svn:ignore property if the installation is under svn control
# because svnversion.py has to be ignored by svn!
cmd = popen3('svn propset svn:ignore svnversion.py '+dir)[1]
output = cmd.read()
cmd.close()
def get_svnversion_from_svn(dir):
# try to get the last svn version number from svnversion
cmd = popen3('svnversion -n '+dir)[1] # assert we are in the project dir
output = cmd.read().strip()
cmd.close()
if not (output + ' ')[0].isdigit():
# we build from exported source (e.g. rpmbuild)
output = None
return output
svnversion = get_svnversion_from_svn(dir='gpaw')
if svnversion:
write_svnversion(svnversion, dir='gpaw')
gpaw-0.11.0.13004/gpaw/kpt_descriptor.py 0000664 0001750 0001750 00000046456 12553643470 020037 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
"""K-point/spin combination-descriptors
This module contains classes for defining combinations of two indices:
* Index k for irreducible kpoints in the 1st Brillouin zone.
* Index s for spin up/down if spin-polarized (otherwise ignored).
"""
import numpy as np
from ase.dft.kpoints import monkhorst_pack, get_monkhorst_pack_size_and_offset
from gpaw.kpoint import KPoint
import gpaw.mpi as mpi
import _gpaw
def to1bz(bzk_kc, cell_cv):
"""Wrap k-points to 1. BZ.
Return k-points wrapped to the 1. BZ.
bzk_kc: (n,3) ndarray
Array of k-points in units of the reciprocal lattice vectors.
cell_cv: (3,3) ndarray
Unit cell.
"""
B_cv = 2.0 * np.pi * np.linalg.inv(cell_cv).T
K_kv = np.dot(bzk_kc, B_cv)
N_xc = np.indices((3, 3, 3)).reshape((3, 27)).T - 1
G_xv = np.dot(N_xc, B_cv)
bz1k_kc = bzk_kc.copy()
# Find the closest reciprocal lattice vector:
for k, K_v in enumerate(K_kv):
# If a k-point has the same distance to several reciprocal
# lattice vectors, we don't want to pick a random one on the
# basis of numerical noise, so we round off the differences
# between the shortest distances to 6 decimals and chose the
# one with the lowest index.
d = ((G_xv - K_v)**2).sum(1)
x = (d - d.min()).round(6).argmin()
bz1k_kc[k] -= N_xc[x]
return bz1k_kc
class KPointDescriptor:
"""Descriptor-class for k-points."""
def __init__(self, kpts, nspins=1, collinear=True):
"""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.
``nks`` Number of k-point/spin combinations in total.
``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
=================== =================================================
"""
if kpts is None:
self.bzk_kc = np.zeros((1, 3))
self.N_c = np.array((1, 1, 1), dtype=int)
self.offset_c = np.zeros(3)
else:
kpts = np.asarray(kpts)
if kpts.ndim == 1:
self.N_c = np.array(kpts, dtype=int)
self.bzk_kc = monkhorst_pack(self.N_c)
self.offset_c = np.zeros(3)
else:
self.bzk_kc = np.array(kpts, dtype=float)
try:
self.N_c, self.offset_c = \
get_monkhorst_pack_size_and_offset(self.bzk_kc)
except ValueError:
self.N_c = None
self.offset_c = None
self.collinear = collinear
self.nspins = nspins
self.nbzkpts = len(self.bzk_kc)
# Gamma-point calculation?
self.gamma = self.nbzkpts == 1 and np.allclose(self.bzk_kc, 0)
# Point group and time-reversal symmetry neglected:
self.weight_k = np.ones(self.nbzkpts) / self.nbzkpts
self.ibzk_kc = self.bzk_kc.copy()
self.sym_k = np.zeros(self.nbzkpts, int)
self.time_reversal_k = np.zeros(self.nbzkpts, bool)
self.bz2ibz_k = np.arange(self.nbzkpts)
self.ibz2bz_k = np.arange(self.nbzkpts)
self.bz2bz_ks = np.arange(self.nbzkpts)[:, np.newaxis]
self.nibzkpts = self.nbzkpts
self.nks = self.nibzkpts * self.nspins
self.set_communicator(mpi.serial_comm)
if self.gamma:
self.description = '1 k-point (Gamma)'
else:
self.description = '%d k-points' % self.nbzkpts
if self.N_c is not None:
self.description += (': %d x %d x %d Monkhorst-Pack grid' %
tuple(self.N_c))
if self.offset_c.any():
self.description += ' + ['
for x in self.offset_c:
if x != 0 and abs(round(1 / x) - 1 / x) < 1e-12:
self.description += '1/%d,' % round(1 / x)
else:
self.description += '%f,' % x
self.description = self.description[:-1] + ']'
def __len__(self):
"""Return number of k-point/spin combinations of local CPU."""
return self.mynks
def set_symmetry(self, atoms, symmetry, comm=None):
"""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.
"""
self.symmetry = symmetry
for c, periodic in enumerate(atoms.pbc):
if not periodic and not np.allclose(self.bzk_kc[:, c], 0.0):
raise ValueError('K-points can only be used with PBCs!')
# Find symmetry operations of atoms:
symmetry.analyze(atoms.get_scaled_positions())
if symmetry.time_reversal or symmetry.point_group:
(self.ibzk_kc, self.weight_k,
self.sym_k,
self.time_reversal_k,
self.bz2ibz_k,
self.ibz2bz_k,
self.bz2bz_ks) = symmetry.reduce(self.bzk_kc, comm)
# Number of irreducible k-points and k-point/spin combinations.
self.nibzkpts = len(self.ibzk_kc)
if self.collinear:
self.nks = self.nibzkpts * self.nspins
else:
self.nks = self.nibzkpts
def set_communicator(self, comm):
"""Set k-point communicator."""
# Ranks < self.rank0 have mynks0 k-point/spin combinations and
# ranks >= self.rank0 have mynks0+1 k-point/spin combinations.
mynks0, x = divmod(self.nks, comm.size)
self.rank0 = comm.size - x
self.comm = comm
# My number and offset of k-point/spin combinations
self.mynks = self.get_count()
self.ks0 = self.get_offset()
if self.nspins == 2 and comm.size == 1: # NCXXXXXXXX
# Avoid duplicating k-points in local list of k-points.
self.ibzk_qc = self.ibzk_kc.copy()
self.weight_q = self.weight_k
else:
self.ibzk_qc = np.vstack((self.ibzk_kc,
self.ibzk_kc))[self.get_slice()]
self.weight_q = np.hstack((self.weight_k,
self.weight_k))[self.get_slice()]
def copy(self, comm=mpi.serial_comm):
"""Create a copy with shared symmetry object."""
kd = KPointDescriptor(self.bzk_kc, self.nspins)
kd.weight_k = self.weight_k
kd.ibzk_kc = self.ibzk_kc
kd.sym_k = self.sym_k
kd.time_reversal_k = self.time_reversal_k
kd.bz2ibz_k = self.bz2ibz_k
kd.ibz2bz_k = self.ibz2bz_k
kd.bz2bz_ks = self.bz2bz_ks
kd.symmetry = self.symmetry
kd.nibzkpts = self.nibzkpts
kd.nks = self.nks
kd.set_communicator(comm)
return kd
def create_k_points(self, gd):
"""Return a list of KPoints."""
sdisp_cd = gd.sdisp_cd
kpt_u = []
for ks in range(self.ks0, self.ks0 + self.mynks):
s, k = divmod(ks, self.nibzkpts)
q = (ks - self.ks0) % self.nibzkpts
if self.collinear:
weight = self.weight_k[k] * 2 / self.nspins
else:
weight = self.weight_k[k]
if self.gamma:
phase_cd = np.ones((3, 2), complex)
else:
phase_cd = np.exp(2j * np.pi *
sdisp_cd * self.ibzk_kc[k, :, np.newaxis])
kpt_u.append(KPoint(weight, s, k, q, phase_cd))
return kpt_u
def collect(self, a_ux, broadcast=True):
"""Collect distributed data to all."""
if self.comm.rank == 0 or broadcast:
xshape = a_ux.shape[1:]
a_skx = np.empty((self.nspins, self.nibzkpts) + xshape, a_ux.dtype)
a_Ux = a_skx.reshape((-1,) + xshape)
else:
a_skx = None
if self.comm.rank > 0:
self.comm.send(a_ux, 0)
else:
u1 = self.get_count(0)
a_Ux[0:u1] = a_ux
requests = []
for rank in range(1, self.comm.size):
u2 = u1 + self.get_count(rank)
requests.append(self.comm.receive(a_Ux[u1:u2], rank,
block=False))
u1 = u2
assert u1 == len(a_Ux)
self.comm.waitall(requests)
if broadcast:
self.comm.broadcast(a_Ux, 0)
return a_skx
def transform_wave_function(self, psit_G, k, index_G=None, phase_G=None):
"""Transform wave function from IBZ to BZ.
k is the index of the desired k-point in the full BZ.
"""
s = self.sym_k[k]
time_reversal = self.time_reversal_k[k]
op_cc = np.linalg.inv(self.symmetry.op_scc[s]).round().astype(int)
# Identity
if (np.abs(op_cc - np.eye(3, dtype=int)) < 1e-10).all():
if time_reversal:
return psit_G.conj()
else:
return psit_G
# General point group symmetry
else:
ik = self.bz2ibz_k[k]
kibz_c = self.ibzk_kc[ik]
b_g = np.zeros_like(psit_G)
kbz_c = np.dot(self.symmetry.op_scc[s], kibz_c)
if index_G is not None:
assert index_G.shape == psit_G.shape == phase_G.shape,\
'Shape mismatch %s vs %s vs %s' % (index_G.shape,
psit_G.shape,
phase_G.shape)
_gpaw.symmetrize_with_index(psit_G, b_g, index_G, phase_G)
else:
_gpaw.symmetrize_wavefunction(psit_G, b_g, op_cc.copy(),
np.ascontiguousarray(kibz_c),
kbz_c)
if time_reversal:
return b_g.conj()
else:
return b_g
def get_transform_wavefunction_index(self, nG, k):
"""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."""
s = self.sym_k[k]
op_cc = np.linalg.inv(self.symmetry.op_scc[s]).round().astype(int)
# General point group symmetry
if (np.abs(op_cc - np.eye(3, dtype=int)) < 1e-10).all():
nG0 = np.prod(nG)
index_G = np.arange(nG0).reshape(nG)
phase_G = np.ones(nG)
else:
ik = self.bz2ibz_k[k]
kibz_c = self.ibzk_kc[ik]
index_G = np.zeros(nG, dtype=int)
phase_G = np.zeros(nG, dtype=complex)
kbz_c = np.dot(self.symmetry.op_scc[s], kibz_c)
_gpaw.symmetrize_return_index(index_G, phase_G, op_cc.copy(),
np.ascontiguousarray(kibz_c),
kbz_c)
return index_G, phase_G
def find_k_plus_q(self, q_c, kpts_k=None):
"""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.
"""
k_x = kpts_k
if k_x is None:
return self.find_k_plus_q(q_c, range(self.nbzkpts))
i_x = []
for k in k_x:
kpt_c = self.bzk_kc[k] + q_c
d_kc = kpt_c - self.bzk_kc
d_k = abs(d_kc - d_kc.round()).sum(1)
i = d_k.argmin()
if d_k[i] > 1e-8:
raise RuntimeError('Could not find k+q!')
i_x.append(i)
return i_x
def get_bz_q_points(self, first=False):
"""Return the q=k1-k2. q-mesh is always Gamma-centered."""
shift_c = 0.5 * ((self.N_c + 1) % 2) / self.N_c
bzq_qc = monkhorst_pack(self.N_c) + shift_c
if first:
return to1bz(bzq_qc, self.symmetry.cell_cv)
else:
return bzq_qc
def get_ibz_q_points(self, bzq_qc, op_scc):
"""Return ibz q points and the corresponding symmetry operations that
work for k-mesh as well."""
ibzq_qc_tmp = []
ibzq_qc_tmp.append(bzq_qc[-1])
weight_tmp = [0]
for i, op_cc in enumerate(op_scc):
if np.abs(op_cc - np.eye(3)).sum() < 1e-8:
identity_iop = i
break
ibzq_q_tmp = {}
iop_q = {}
timerev_q = {}
diff_qc = {}
for i in range(len(bzq_qc) - 1, -1, -1): # loop opposite to kpoint
try:
ibzk, iop, timerev, diff_c = self.find_ibzkpt(
op_scc, ibzq_qc_tmp, bzq_qc[i])
find = False
for ii, iop1 in enumerate(self.sym_k):
if iop1 == iop and self.time_reversal_k[ii] == timerev:
find = True
break
if find is False:
raise ValueError('cant find k!')
ibzq_q_tmp[i] = ibzk
weight_tmp[ibzk] += 1.
iop_q[i] = iop
timerev_q[i] = timerev
diff_qc[i] = diff_c
except ValueError:
ibzq_qc_tmp.append(bzq_qc[i])
weight_tmp.append(1.)
ibzq_q_tmp[i] = len(ibzq_qc_tmp) - 1
iop_q[i] = identity_iop
timerev_q[i] = False
diff_qc[i] = np.zeros(3)
# reverse the order.
nq = len(ibzq_qc_tmp)
ibzq_qc = np.zeros((nq, 3))
ibzq_q = np.zeros(len(bzq_qc), dtype=int)
for i in range(nq):
ibzq_qc[i] = ibzq_qc_tmp[nq - i - 1]
for i in range(len(bzq_qc)):
ibzq_q[i] = nq - ibzq_q_tmp[i] - 1
self.q_weights = np.array(weight_tmp[::-1]) / len(bzq_qc)
return ibzq_qc, ibzq_q, iop_q, timerev_q, diff_qc
def find_ibzkpt(self, symrel, ibzk_kc, bzk_c):
"""Find index in IBZ and related symmetry operations."""
find = False
ibzkpt = 0
iop = 0
timerev = False
for sign in (1, -1):
for ioptmp, op in enumerate(symrel):
for i, ibzk in enumerate(ibzk_kc):
diff_c = bzk_c - sign * np.dot(op, ibzk)
if (np.abs(diff_c - diff_c.round()) < 1e-8).all():
ibzkpt = i
iop = ioptmp
find = True
if sign == -1:
timerev = True
break
if find:
break
if find:
break
if not find:
raise ValueError('Cant find corresponding IBZ kpoint!')
return ibzkpt, iop, timerev, diff_c.round()
def where_is_q(self, q_c, bzq_qc):
"""Find the index of q points in BZ."""
d_qc = q_c - bzq_qc
d_q = abs(d_qc - d_qc.round()).sum(1)
q = d_q.argmin()
if d_q[q] > 1e-8:
raise RuntimeError('Could not find q!')
return q
def get_count(self, rank=None):
"""Return the number of ks-pairs which belong to a given rank."""
if rank is None:
rank = self.comm.rank
assert rank in range(self.comm.size)
mynks0 = self.nks // self.comm.size
mynks = mynks0
if rank >= self.rank0:
mynks += 1
return mynks
def get_offset(self, rank=None):
"""Return the offset of the first ks-pair on a given rank."""
if rank is None:
rank = self.comm.rank
assert rank in range(self.comm.size)
mynks0 = self.nks // self.comm.size
ks0 = rank * mynks0
if rank >= self.rank0:
ks0 += rank - self.rank0
return ks0
def get_rank_and_index(self, s, k):
"""Find rank and local index of k-point/spin combination."""
u = self.where_is(s, k)
rank, myu = self.who_has(u)
return rank, myu
def get_slice(self, rank=None):
"""Return the slice of global ks-pairs which belong to a given rank."""
if rank is None:
rank = self.comm.rank
assert rank in range(self.comm.size)
mynks, ks0 = self.get_count(rank), self.get_offset(rank)
uslice = slice(ks0, ks0 + mynks)
return uslice
def get_indices(self, rank=None):
"""Return the global ks-pair indices which belong to a given rank."""
uslice = self.get_slice(rank)
return np.arange(*uslice.indices(self.nks))
def get_ranks(self):
"""Return array of ranks as a function of global ks-pair indices."""
ranks = np.empty(self.nks, dtype=int)
for rank in range(self.comm.size):
uslice = self.get_slice(rank)
ranks[uslice] = rank
assert (ranks >= 0).all() and (ranks < self.comm.size).all()
return ranks
def who_has(self, u):
"""Convert global index to rank information and local index."""
mynks0 = self.nks // self.comm.size
if u < mynks0 * self.rank0:
rank, myu = divmod(u, mynks0)
else:
rank, myu = divmod(u - mynks0 * self.rank0, mynks0 + 1)
rank += self.rank0
return rank, myu
def global_index(self, myu, rank=None):
"""Convert rank information and local index to global index."""
if rank is None:
rank = self.comm.rank
assert rank in range(self.comm.size)
ks0 = self.get_offset(rank)
u = ks0 + myu
return u
def what_is(self, u):
"""Convert global index to corresponding kpoint/spin combination."""
s, k = divmod(u, self.nibzkpts)
return s, k
def where_is(self, s, k):
"""Convert kpoint/spin combination to the global index thereof."""
u = k + self.nibzkpts * s
return u
gpaw-0.11.0.13004/gpaw/density.py 0000664 0001750 0001750 00000053060 12553643470 016447 0 ustar jensj jensj 0000000 0000000 # -*- coding: utf-8 -*-
# Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
"""This module defines a density class."""
from math import pi, sqrt
import numpy as np
from gpaw import debug
from gpaw.mixer import BaseMixer, Mixer, MixerSum
from gpaw.transformers import Transformer
from gpaw.lfc import LFC, BasisFunctions
from gpaw.wavefunctions.lcao import LCAOWaveFunctions
from gpaw.utilities import unpack2
from gpaw.utilities.partition import AtomPartition
from gpaw.utilities.timing import nulltimer
from gpaw.io import read_atomic_matrices
from gpaw.mpi import SerialCommunicator
from gpaw.arraydict import ArrayDict
class Density(object):
"""Density object.
Attributes:
=============== =====================================================
``gd`` Grid descriptor for coarse grids.
``finegd`` Grid descriptor for fine grids.
``interpolate`` Function for interpolating the electron density.
``mixer`` ``DensityMixer`` object.
=============== =====================================================
Soft and smooth pseudo functions on uniform 3D grids:
========== =========================================
``nt_sG`` Electron density on the coarse grid.
``nt_sg`` Electron density on the fine grid.
``nt_g`` Electron density on the fine grid.
``rhot_g`` Charge density on the fine grid.
``nct_G`` Core electron-density on the coarse grid.
========== =========================================
"""
def __init__(self, gd, finegd, nspins, charge, collinear=True):
"""Create the Density object."""
self.gd = gd
self.finegd = finegd
self.nspins = nspins
self.charge = float(charge)
self.collinear = collinear
self.ncomp = 1 if collinear else 2
self.ns = self.nspins * self.ncomp**2
self.charge_eps = 1e-7
self.D_asp = None
self.Q_aL = None
self.nct_G = None
self.nt_sG = None
self.rhot_g = None
self.nt_sg = None
self.nt_g = None
self.atom_partition = None
self.mixer = BaseMixer()
self.timer = nulltimer
def initialize(self, setups, timer, magmom_av, hund):
self.timer = timer
self.setups = setups
self.hund = hund
self.magmom_av = magmom_av
def reset(self):
# TODO: reset other parameters?
self.nt_sG = None
def set_positions(self, spos_ac, atom_partition):
rank_a = atom_partition.rank_a
self.nct.set_positions(spos_ac)
self.ghat.set_positions(spos_ac)
self.mixer.reset()
#self.nt_sG = None
self.nt_sg = None
self.nt_g = None
self.rhot_g = None
self.Q_aL = None
# If both old and new atomic ranks are present, start a blank dict if
# it previously didn't exist but it will needed for the new atoms.
if (self.atom_partition is not None and
self.D_asp is None and (rank_a == self.gd.comm.rank).any()):
self.D_asp = self.setups.empty_atomic_matrix(self.ns,
self.atom_partition)
if (self.atom_partition is not None and self.D_asp is not None
and not isinstance(self.gd.comm, SerialCommunicator)):
self.timer.start('Redistribute')
self.D_asp.redistribute(atom_partition)
self.timer.stop('Redistribute')
self.atom_partition = atom_partition
def calculate_pseudo_density(self, wfs):
"""Calculate nt_sG from scratch.
nt_sG will be equal to nct_G plus the contribution from
wfs.add_to_density().
"""
wfs.calculate_density_contribution(self.nt_sG)
self.nt_sG[:self.nspins] += self.nct_G
@property
def D_asp(self):
if self._D_asp is not None:
assert isinstance(self._D_asp, ArrayDict), type(self._D_asp)
self._D_asp.check_consistency()
return self._D_asp
@D_asp.setter
def D_asp(self, value):
if isinstance(value, dict):
tmp = self.setups.empty_atomic_matrix(self.ns, self.atom_partition)
tmp.update(value)
value = tmp
assert isinstance(value, ArrayDict) or value is None, type(value)
if value is not None:
value.check_consistency()
self._D_asp = value
def update(self, wfs):
self.timer.start('Density')
self.timer.start('Pseudo density')
self.calculate_pseudo_density(wfs)
self.timer.stop('Pseudo density')
self.timer.start('Atomic density matrices')
wfs.calculate_atomic_density_matrices(self.D_asp)
self.timer.stop('Atomic density matrices')
self.timer.start('Multipole moments')
comp_charge = self.calculate_multipole_moments()
self.timer.stop('Multipole moments')
if isinstance(wfs, LCAOWaveFunctions):
self.timer.start('Normalize')
self.normalize(comp_charge)
self.timer.stop('Normalize')
self.timer.start('Mix')
self.mix(comp_charge)
self.timer.stop('Mix')
self.timer.stop('Density')
def normalize(self, comp_charge=None):
"""Normalize pseudo density."""
if comp_charge is None:
comp_charge = self.calculate_multipole_moments()
pseudo_charge = self.gd.integrate(self.nt_sG[:self.nspins]).sum()
if pseudo_charge + self.charge + comp_charge != 0:
if pseudo_charge != 0:
x = -(self.charge + comp_charge) / pseudo_charge
self.nt_sG *= x
else:
# Use homogeneous background:
volume = self.gd.get_size_of_global_array().prod() * self.gd.dv
self.nt_sG[:self.nspins] = -(self.charge +
comp_charge) / volume
def mix(self, comp_charge):
if not self.mixer.mix_rho:
self.mixer.mix(self)
comp_charge = None
self.interpolate_pseudo_density(comp_charge)
self.calculate_pseudo_charge()
if self.mixer.mix_rho:
self.mixer.mix(self)
def calculate_multipole_moments(self):
"""Calculate multipole moments of compensation charges.
Returns the total compensation charge in units of electron
charge, so the number will be negative because of the
dominating contribution from the nuclear charge."""
comp_charge = 0.0
self.Q_aL = {}
for a, D_sp in self.D_asp.items():
Q_L = self.Q_aL[a] = np.dot(D_sp[:self.nspins].sum(0),
self.setups[a].Delta_pL)
Q_L[0] += self.setups[a].Delta0
comp_charge += Q_L[0]
return self.gd.comm.sum(comp_charge) * sqrt(4 * pi)
def initialize_from_atomic_densities(self, basis_functions):
"""Initialize D_asp, nt_sG and Q_aL from atomic densities.
nt_sG is initialized from atomic orbitals, and will
be constructed with the specified magnetic moments and
obeying Hund's rules if ``hund`` is true."""
# XXX does this work with blacs? What should be distributed?
# Apparently this doesn't use blacs at all, so it's serial
# with respect to the blacs distribution. That means it works
# but is not particularly efficient (not that this is a time
# consuming step)
self.D_asp = self.setups.empty_atomic_matrix(self.ns,
self.atom_partition)
f_asi = {}
for a in basis_functions.atom_indices:
c = self.charge / len(self.setups) # distribute on all atoms
M_v = self.magmom_av[a]
M = (M_v**2).sum()**0.5
f_si = self.setups[a].calculate_initial_occupation_numbers(
M, self.hund, charge=c, nspins=self.nspins * self.ncomp)
if self.collinear:
if M_v[2] < 0:
f_si = f_si[::-1].copy()
else:
f_i = f_si.sum(axis=0)
fm_i = f_si[0] - f_si[1]
f_si = np.zeros((4, len(f_i)))
f_si[0] = f_i
if M > 0:
f_si[1:4] = np.outer(M_v / M, fm_i)
if a in basis_functions.my_atom_indices:
self.D_asp[a] = self.setups[a].initialize_density_matrix(f_si)
f_asi[a] = f_si
self.nt_sG = self.gd.zeros(self.ns)
basis_functions.add_to_density(self.nt_sG, f_asi)
self.nt_sG[:self.nspins] += self.nct_G
self.calculate_normalized_charges_and_mix()
def initialize_from_wavefunctions(self, wfs):
"""Initialize D_asp, nt_sG and Q_aL from wave functions."""
self.timer.start("Density initialize from wavefunctions")
self.nt_sG = self.gd.empty(self.ns)
self.calculate_pseudo_density(wfs)
self.D_asp = self.setups.empty_atomic_matrix(self.ns,
self.atom_partition)
wfs.calculate_atomic_density_matrices(self.D_asp)
self.calculate_normalized_charges_and_mix()
self.timer.stop("Density initialize from wavefunctions")
def initialize_directly_from_arrays(self, nt_sG, D_asp):
"""Set D_asp and nt_sG directly."""
self.nt_sG = nt_sG
self.D_asp = D_asp
D_asp.check_consistency()
#self.calculate_normalized_charges_and_mix()
# No calculate multipole moments? Tests will fail because of
# improperly initialized mixer
def calculate_normalized_charges_and_mix(self):
comp_charge = self.calculate_multipole_moments()
self.normalize(comp_charge)
self.mix(comp_charge)
def set_mixer(self, mixer):
if mixer is not None:
if self.nspins == 1 and isinstance(mixer, MixerSum):
raise RuntimeError('Cannot use MixerSum with nspins==1')
self.mixer = mixer
else:
if self.gd.pbc_c.any():
beta = 0.05
history = 5
weight = 50.0
else:
beta = 0.25
history = 3
weight = 1.0
if self.nspins == 2:
self.mixer = MixerSum(beta, history, weight)
else:
self.mixer = Mixer(beta, history, weight)
self.mixer.initialize(self)
def estimate_magnetic_moments(self):
magmom_av = np.zeros_like(self.magmom_av)
if self.nspins == 2 or not self.collinear:
for a, D_sp in self.D_asp.items():
if self.collinear:
magmom_av[a, 2] = np.dot(D_sp[0] - D_sp[1],
self.setups[a].N0_p)
else:
magmom_av[a] = np.dot(D_sp[1:4], self.setups[a].N0_p)
self.gd.comm.sum(magmom_av)
return magmom_av
def get_correction(self, a, spin):
"""Integrated atomic density correction.
Get the integrated correction to the pseuso density relative to
the all-electron density.
"""
setup = self.setups[a]
return sqrt(4 * pi) * (
np.dot(self.D_asp[a][spin], setup.Delta_pL[:, 0])
+ setup.Delta0 / self.nspins)
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.atom_partition.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 estimate_memory(self, mem):
nspins = self.nspins
nbytes = self.gd.bytecount()
nfinebytes = self.finegd.bytecount()
arrays = mem.subnode('Arrays')
for name, size in [('nt_sG', nbytes * nspins),
('nt_sg', nfinebytes * nspins),
('nt_g', nfinebytes),
('rhot_g', nfinebytes),
('nct_G', nbytes)]:
arrays.subnode(name, size)
lfs = mem.subnode('Localized functions')
for name, obj in [('nct', self.nct),
('ghat', self.ghat)]:
obj.estimate_memory(lfs.subnode(name))
self.mixer.estimate_memory(mem.subnode('Mixer'), self.gd)
# TODO
# The implementation of interpolator memory use is not very
# accurate; 20 MiB vs 13 MiB estimated in one example, probably
# worse for parallel calculations.
def get_spin_contamination(self, atoms, majority_spin=0):
"""Calculate the spin contamination.
Spin contamination is defined as the integral over the
spin density difference, where it is negative (i.e. the
minority spin density is larger than the majority spin density.
"""
if majority_spin == 0:
smaj = 0
smin = 1
else:
smaj = 1
smin = 0
nt_sg, gd = self.get_all_electron_density(atoms)
dt_sg = nt_sg[smin] - nt_sg[smaj]
dt_sg = np.where(dt_sg > 0, dt_sg, 0.0)
return gd.integrate(dt_sg)
def read(self, reader, parallel, kptband_comm):
if reader['version'] > 0.3:
density_error = reader['DensityError']
if density_error is not None:
self.mixer.set_charge_sloshing(density_error)
if not reader.has_array('PseudoElectronDensity'):
return
hdf5 = hasattr(reader, 'hdf5')
nt_sG = self.gd.empty(self.nspins)
if hdf5:
# Read pseudoelectron density on the coarse grid
# and broadcast on kpt_comm and band_comm:
indices = [slice(0, self.nspins)] + self.gd.get_slice()
do_read = (kptband_comm.rank == 0)
reader.get('PseudoElectronDensity', out=nt_sG, parallel=parallel,
read=do_read, *indices) # XXX read=?
kptband_comm.broadcast(nt_sG, 0)
else:
for s in range(self.nspins):
self.gd.distribute(reader.get('PseudoElectronDensity', s),
nt_sG[s])
# Read atomic density matrices
natoms = len(self.setups)
atom_partition = AtomPartition(self.gd.comm, np.zeros(natoms, int))
D_asp = self.setups.empty_atomic_matrix(self.ns, atom_partition)
self.atom_partition = atom_partition # XXXXXX
all_D_sp = reader.get('AtomicDensityMatrices', broadcast=True)
if self.gd.comm.rank == 0:
D_asp.update(read_atomic_matrices(all_D_sp, self.setups))
D_asp.check_consistency()
self.initialize_directly_from_arrays(nt_sG, D_asp)
class RealSpaceDensity(Density):
def __init__(self, gd, finegd, nspins, charge, collinear=True,
stencil=3):
Density.__init__(self, gd, finegd, nspins, charge, collinear)
self.stencil = stencil
def initialize(self, setups, timer, magmom_av, hund):
Density.initialize(self, setups, timer, magmom_av, hund)
# Interpolation function for the density:
self.interpolator = Transformer(self.gd, self.finegd, self.stencil)
spline_aj = []
for setup in setups:
if setup.nct is None:
spline_aj.append([])
else:
spline_aj.append([setup.nct])
self.nct = LFC(self.gd, spline_aj,
integral=[setup.Nct for setup in setups],
forces=True, cut=True)
self.ghat = LFC(self.finegd, [setup.ghat_l for setup in setups],
integral=sqrt(4 * pi), forces=True)
def set_positions(self, spos_ac, rank_a=None):
Density.set_positions(self, spos_ac, rank_a)
self.nct_G = self.gd.zeros()
self.nct.add(self.nct_G, 1.0 / self.nspins)
def interpolate_pseudo_density(self, comp_charge=None):
"""Interpolate pseudo density to fine grid."""
if comp_charge is None:
comp_charge = self.calculate_multipole_moments()
self.nt_sg = self.interpolate(self.nt_sG, self.nt_sg)
# With periodic boundary conditions, the interpolation will
# conserve the number of electrons.
if not self.gd.pbc_c.all():
# With zero-boundary conditions in one or more directions,
# this is not the case.
pseudo_charge = -(self.charge + comp_charge)
if abs(pseudo_charge) > 1.0e-14:
x = (pseudo_charge /
self.finegd.integrate(self.nt_sg[:self.nspins]).sum())
self.nt_sg *= x
def interpolate(self, in_xR, out_xR=None):
"""Interpolate array(s)."""
# ndim will be 3 in finite-difference mode and 1 when working
# with the AtomPAW class (spherical atoms and 1d grids)
ndim = self.gd.ndim
if out_xR is None:
out_xR = self.finegd.empty(in_xR.shape[:-ndim])
a_xR = in_xR.reshape((-1,) + in_xR.shape[-ndim:])
b_xR = out_xR.reshape((-1,) + out_xR.shape[-ndim:])
for in_R, out_R in zip(a_xR, b_xR):
self.interpolator.apply(in_R, out_R)
return out_xR
def calculate_pseudo_charge(self):
self.nt_g = self.nt_sg[:self.nspins].sum(axis=0)
self.rhot_g = self.nt_g.copy()
self.ghat.add(self.rhot_g, self.Q_aL)
if debug:
charge = self.finegd.integrate(self.rhot_g) + self.charge
if abs(charge) > self.charge_eps:
raise RuntimeError('Charge not conserved: excess=%.9f' %
charge)
def get_pseudo_core_kinetic_energy_density_lfc(self):
return LFC(self.gd,
[[setup.tauct] for setup in self.setups],
forces=True, cut=True)
def calculate_dipole_moment(self):
return self.finegd.calculate_dipole_moment(self.rhot_g)
gpaw-0.11.0.13004/gpaw/scf.py 0000664 0001750 0001750 00000006547 12553643472 015555 0 ustar jensj jensj 0000000 0000000 import numpy as np
class SCFLoop:
"""Self-consistent field loop.
converged: Do we have a self-consistent solution?
"""
def __init__(self, eigenstates=0.1, energy=0.1, density=0.1, maxiter=100,
fixdensity=False, niter_fixdensity=None, force=None):
self.max_eigenstates_error = max(eigenstates, 1e-20)
self.max_energy_error = energy
self.max_force_error = force
self.max_density_error = max(density, 1e-20)
self.maxiter = maxiter
self.fixdensity = fixdensity
if niter_fixdensity is None:
niter_fixdensity = 2
self.niter_fixdensity = niter_fixdensity
if fixdensity:
self.fix_density()
self.reset()
def fix_density(self):
self.fixdensity = True
self.niter_fixdensity = 10000000
self.max_density_error = np.inf
def reset(self):
self.energies = []
self.eigenstates_error = None
self.energy_error = None
self.density_error = None
self.force_error = None
self.force_last = None
self.converged = False
def run(self, wfs, hamiltonian, density, occupations, forces):
if self.converged:
return
for iter in range(1, self.maxiter + 1):
wfs.eigensolver.iterate(hamiltonian, wfs)
occupations.calculate(wfs)
# XXX ortho, dens, wfs?
energy = hamiltonian.get_energy(occupations)
self.energies.append(energy)
self.check_convergence(density, wfs.eigensolver,
wfs, hamiltonian, forces)
yield iter
if self.converged:
break
if iter > self.niter_fixdensity:
density.update(wfs)
hamiltonian.update(density)
else:
hamiltonian.npoisson = 0
# Don't fix the density in the next step:
self.niter_fixdensity = 0
def check_convergence(self, density, eigensolver,
wfs=None, hamiltonian=None, forces=None):
"""Check convergence of eigenstates, energy and density."""
if self.converged:
return True
self.eigenstates_error = eigensolver.error
if len(self.energies) < 3:
self.energy_error = self.max_energy_error
else:
self.energy_error = np.ptp(self.energies[-3:])
self.density_error = density.mixer.get_charge_sloshing()
if self.density_error is None:
self.density_error = 1000000.0
if self.max_force_error is not None:
forces.reset()
F_av = forces.calculate(wfs, density, hamiltonian)
if self.force_last is None:
self.force_last = F_av
else:
F_av_diff = ((F_av - self.force_last)**2).sum(axis=1)
self.force_error = abs(F_av_diff).max()
self.force_last = F_av
self.converged = (
(self.eigenstates_error or 0.0) < self.max_eigenstates_error and
self.energy_error < self.max_energy_error and
self.density_error < self.max_density_error and
(self.force_error or 0) < ((self.max_force_error)
or float('Inf')))
return self.converged
gpaw-0.11.0.13004/gpaw/output.py 0000664 0001750 0001750 00000052025 12553643470 016330 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import os
import sys
import time
import platform
from math import log
import numpy as np
import ase
from ase.units import Bohr, Hartree
from ase.data import chemical_symbols
from ase.version import version as ase_version
from ase.utils import devnull
from ase.parallel import get_txt
import gpaw
import _gpaw
from gpaw.version import version
from gpaw.utilities.memory import maxrss
from gpaw import dry_run, extra_parameters
class PAWTextOutput:
"""Class for handling all text output."""
def __init__(self):
self.txt = devnull
def set_txt(self, txt):
"""Set the stream for text output.
If `txt` is not a stream-object, then it must be one of:
* None: Throw output away.
* '-': Use stdout (``sys.stdout``) on master, elsewhere throw away.
* A filename: Open a new file on master, elsewhere throw away.
"""
self.txt = get_txt(txt, self.wfs.world.rank)
self.print_header()
def text(self, *args, **kwargs):
print(*args, file=self.txt, **kwargs)
def print_header(self):
self.text()
self.text(' ___ ___ ___ _ _ _ ')
self.text(' | | |_ | | | | ')
self.text(' | | | | | . | | | | ')
self.text(' |__ | _|___|_____| ', version)
self.text(' |___|_| ')
self.text()
uname = platform.uname()
self.text('User: ', os.getenv('USER', '???') + '@' + uname[1])
self.text('Date: ', time.asctime())
self.text('Arch: ', uname[4])
self.text('Pid: ', os.getpid())
self.text('gpaw: ', os.path.dirname(gpaw.__file__))
# Find C-code:
c = getattr(_gpaw, '__file__', None)
if not c:
c = sys.executable
self.text('_gpaw:', os.path.normpath(c))
self.text('ase: %s (version %s)' %
(os.path.dirname(ase.__file__), ase_version))
self.text('numpy: %s (version %s)' %
(os.path.dirname(np.__file__), np.version.version))
try:
import scipy as sp
self.text('scipy: %s (version %s)' %
(os.path.dirname(sp.__file__), sp.version.version))
# Explicitly deleting SciPy seems to remove garbage collection
# problem of unknown cause
del sp
except ImportError:
self.text('scipy: Not available')
self.text('units: Angstrom and eV')
self.text('cores:', self.wfs.world.size)
if gpaw.debug:
self.text('DEBUG MODE')
if extra_parameters:
self.text('Extra parameters:', extra_parameters)
def print_cell_and_parameters(self):
self.plot_atoms(self.atoms)
self.print_unit_cell(self.atoms.get_positions() / Bohr)
self.print_parameters()
def print_unit_cell(self, pos_ac):
self.text()
self.text('Unit Cell:')
self.text(' Periodic X Y Z' +
' Points Spacing')
self.text(' -----------------------------------------------' +
'---------------------')
gd = self.wfs.gd
h_c = gd.get_grid_spacings()
pbc_c = self.atoms.pbc
for c in range(3):
self.text(' %d. axis: %s %10.6f %10.6f %10.6f %3d %8.4f'
% ((c + 1, ['no ', 'yes'][int(pbc_c[c])]) +
tuple(Bohr * gd.cell_cv[c]) +
(gd.N_c[c], Bohr * h_c[c])))
self.text()
def print_positions(self):
t = self.text
t()
t('Positions:')
symbols = self.atoms.get_chemical_symbols()
for a, pos_c in enumerate(self.atoms.get_positions()):
symbol = symbols[a]
t('%3d %-2s %9.4f %9.4f %9.4f' % ((a, symbol) + tuple(pos_c)))
t()
def print_parameters(self):
t = self.text
p = self.input_parameters
# Write PAW setup information in order of appearance:
ids = set()
for id in self.wfs.setups.id_a:
if id in ids:
continue
ids.add(id)
setup = self.wfs.setups.setups[id]
setup.print_info(self.text)
basis_descr = setup.get_basis_description()
t(basis_descr)
t()
t('Using the %s Exchange-Correlation Functional.'
% self.hamiltonian.xc.name)
if self.wfs.nspins == 2:
t('Spin-Polarized Calculation.')
t('Magnetic Moment: (%.6f, %.6f, %.6f)' %
tuple(self.density.magmom_av.sum(0)), end='')
if self.occupations.fixmagmom:
t('(fixed)')
else:
t()
else:
t('Spin-Paired Calculation')
t('Total Charge: %.6f' % p['charge'])
t('Fermi Temperature: %.6f' % (self.occupations.width * Hartree))
self.wfs.summary(self.txt)
t('Eigensolver: %s' % self.wfs.eigensolver)
self.hamiltonian.summary(self.txt)
t('Reference Energy: %.6f' % (self.wfs.setups.Eref * Hartree))
t()
nibzkpts = self.wfs.kd.nibzkpts
# Print parallelization details
t('Total number of cores used: %d' % self.wfs.world.size)
if self.wfs.kd.comm.size > 1: # kpt/spin parallization
if self.wfs.nspins == 2 and nibzkpts == 1:
t('Parallelization over spin')
elif self.wfs.nspins == 2:
t('Parallelization over k-points and spin: %d' %
self.wfs.kd.comm.size)
else:
t('Parallelization over k-points: %d' %
self.wfs.kd.comm.size)
if self.wfs.gd.comm.size > 1: # domain parallelization
t('Domain Decomposition: %d x %d x %d' %
tuple(self.wfs.gd.parsize_c))
if self.wfs.bd.comm.size > 1: # band parallelization
t('Parallelization over states: %d'
% self.wfs.bd.comm.size)
if self.wfs.mode == 'fd':
# XXX Why is this not in wfs summary? -askhl
# Also, why wouldn't PW mode use the diagonalizer?
if self.wfs.diagksl.buffer_size is not None:
t('MatrixOperator buffer_size (KiB): %d'
% self.wfs.diagksl.buffer_size)
else:
t('MatrixOperator buffer_size: default value or \n' +
' %s see value of nblock in input file' % (26 * ' '))
diagonalizer_layout = self.wfs.diagksl.get_description()
t('Diagonalizer layout: ' + diagonalizer_layout)
orthonormalizer_layout = self.wfs.orthoksl.get_description()
t('Orthonormalizer layout: ' + orthonormalizer_layout)
t()
self.wfs.kd.symmetry.print_symmetries(self.txt)
t(self.wfs.kd.description)
t(('%d k-point%s in the Irreducible Part of the Brillouin Zone') %
(nibzkpts, ' s'[1:nibzkpts]))
kd = self.wfs.kd
w_k = kd.weight_k * kd.nbzkpts
assert np.allclose(w_k, w_k.round())
w_k = w_k.round()
t()
t(' k-points in crystal coordinates weights')
for k in range(nibzkpts):
if k < 10 or k == nibzkpts - 1:
t('%4d: %12.8f %12.8f %12.8f %6d/%d' %
((k,) + tuple(kd.ibzk_kc[k]) + (w_k[k], kd.nbzkpts)))
elif k == 10:
t(' ...')
t()
if self.scf.fixdensity > self.scf.maxiter:
t('Fixing the initial density')
else:
mixer = self.density.mixer
t('Mixer Type:', mixer.__class__.__name__)
t('Linear Mixing Parameter: %g' % mixer.beta)
t('Mixing with %d Old Densities' % mixer.nmaxold)
if mixer.weight == 1:
t('No Damping of Long Wave Oscillations')
else:
t('Damping of Long Wave Oscillations: %g' % mixer.weight)
cc = p['convergence']
t()
t('Convergence Criteria:')
t(' Total Energy Change: %g eV / electron' %
(cc['energy']))
t(' Integral of Absolute Density Change: %g electrons' %
cc['density'])
t(' Integral of Absolute Eigenstate Change: %g eV^2' %
cc['eigenstates'])
t('Number of Atoms: %d' % len(self.wfs.setups))
t('Number of Atomic Orbitals: %d' % self.wfs.setups.nao)
if self.nbands_parallelization_adjustment != 0:
t('Adjusting Number of Bands by %+d to Match Parallelization'
% self.nbands_parallelization_adjustment)
t('Number of Bands in Calculation: %d' % self.wfs.bd.nbands)
t('Bands to Converge: ', end='')
if cc['bands'] == 'occupied':
t('Occupied States Only')
elif cc['bands'] == 'all':
t('All')
else:
t('%d Lowest Bands' % cc['bands'])
t('Number of Valence Electrons: %g'
% (self.wfs.setups.nvalence - p.charge))
def print_converged(self, iter):
t = self.text
t('------------------------------------')
t('Converged After %d Iterations.' % iter)
t()
self.print_all_information()
def print_all_information(self):
t = self.text
if len(self.atoms) == 1:
t('Energy Contributions Relative to Reference Atom:', end='')
else:
t('Energy Contributions Relative to Reference Atoms:', end='')
t('(reference = %.6f)' % (self.wfs.setups.Eref * Hartree))
t('-------------------------')
energies = [('Kinetic: ', self.hamiltonian.Ekin),
('Potential: ', self.hamiltonian.Epot),
('External: ', self.hamiltonian.Eext),
('XC: ', self.hamiltonian.Exc),
('Entropy (-ST):', -self.hamiltonian.S),
('Local: ', self.hamiltonian.Ebar)]
for name, e in energies:
t('%-14s %+11.6f' % (name, Hartree * e))
t('-------------------------')
t('Free Energy: %+11.6f' % (Hartree * self.hamiltonian.Etot))
t('Zero Kelvin: %+11.6f' % (Hartree * (self.hamiltonian.Etot +
0.5 * self.hamiltonian.S)))
t()
self.occupations.print_fermi_level(self.txt)
self.print_eigenvalues()
self.hamiltonian.xc.summary(self.txt)
t()
try:
dipole = self.get_dipole_moment()
except NotImplementedError:
pass
else:
if self.density.charge == 0:
t('Dipole Moment: %s' % dipole)
else:
t('Center of Charge: %s' % (dipole / self.density.charge))
try:
correction = self.hamiltonian.poisson.corrector.correction
epsF = self.occupations.fermilevel
except AttributeError:
pass
else:
wf1 = (-epsF + correction) * Hartree
wf2 = (-epsF - correction) * Hartree
t('Dipole-corrected work function: %f, %f' % (wf1, wf2))
if self.wfs.nspins == 2:
t()
magmom = self.occupations.magmom
t('Total Magnetic Moment: %f' % magmom)
try:
# XXX This doesn't always work, HGH, SIC, ...
sc = self.density.get_spin_contamination(self.atoms,
int(magmom < 0))
t('Spin contamination: %f electrons' % sc)
except (TypeError, AttributeError):
pass
t('Local Magnetic Moments:')
for a, mom in enumerate(self.get_magnetic_moments()):
t(a, mom)
t()
elif not self.wfs.collinear:
self.txt.write('Local Magnetic Moments:\n')
for a, mom_v in enumerate(self.get_magnetic_moments()):
self.txt.write('%4d (%.3f, %.3f, %.3f)\n' %
(a, mom_v[0], mom_v[1], mom_v[2]))
def print_iteration(self, iter):
# Output from each iteration:
t = self.text
nvalence = self.wfs.setups.nvalence - self.input_parameters.charge
if nvalence > 0:
eigerr = self.scf.eigenstates_error * Hartree**2 / nvalence
else:
eigerr = 0.0
if self.verbose != 0:
T = time.localtime()
t()
t('------------------------------------')
t('iter: %d %d:%02d:%02d' % (iter, T[3], T[4], T[5]))
t()
t('Poisson Solver Converged in %d Iterations' %
self.hamiltonian.npoisson)
t('Fermi Level Found in %d Iterations' % self.occupations.niter)
t('Error in Wave Functions: %.13f' % eigerr)
t()
self.print_all_information()
else:
if iter == 1:
header = """\
log10-error: Total Iterations:
Time WFS Density Energy Fermi Poisson"""
if self.wfs.nspins == 2:
header += ' MagMom'
if self.scf.max_force_error is not None:
l1 = header.find('Total')
header = header[:l1] + ' ' + header[l1:]
l2 = header.find('Energy')
header = header[:l2] + 'Force ' + header[l2:]
t(header)
T = time.localtime()
if eigerr == 0.0:
eigerr = ''
else:
eigerr = '%+.2f' % (log(eigerr) / log(10))
denserr = self.density.mixer.get_charge_sloshing()
if denserr is None or denserr == 0 or nvalence == 0:
denserr = ''
else:
denserr = '%+.2f' % (log(denserr / nvalence) / log(10))
niterocc = self.occupations.niter
if niterocc == -1:
niterocc = ''
else:
niterocc = '%d' % niterocc
if self.hamiltonian.npoisson == 0:
niterpoisson = ''
else:
niterpoisson = str(self.hamiltonian.npoisson)
t('iter: %3d %02d:%02d:%02d %6s %6s ' %
(iter,
T[3], T[4], T[5],
eigerr,
denserr), end='')
if self.scf.max_force_error is not None:
if self.scf.force_error is not None:
t(' %+.2f' %
(log(self.scf.force_error) / log(10)), end='')
else:
t(' ', end='')
t('%11.6f %-5s %-7s' %
(Hartree * (self.hamiltonian.Etot + 0.5 * self.hamiltonian.S),
niterocc,
niterpoisson), end='')
if self.wfs.nspins == 2:
t(' %+.4f' % self.occupations.magmom, end='')
t()
self.txt.flush()
def print_forces(self):
if self.forces.F_av is None:
return
t = self.text
t()
t('Forces in eV/Ang:')
c = Hartree / Bohr
symbols = self.atoms.get_chemical_symbols()
for a, symbol in enumerate(symbols):
t('%3d %-2s %10.5f %10.5f %10.5f' %
((a, symbol) + tuple(self.forces.F_av[a] * c)))
def print_eigenvalues(self):
"""Print eigenvalues and occupation numbers."""
self.text(eigenvalue_string(self))
def plot_atoms(self, atoms):
self.text(plot(atoms))
def __del__(self):
"""Destructor: Write timing output before closing."""
if not dry_run:
mr = maxrss()
if mr > 0:
if mr < 1024.0**3:
self.text('Memory usage: %.2f MiB' % (mr / 1024.0**2))
else:
self.text('Memory usage: %.2f GiB' % (mr / 1024.0**3))
self.timer.write(self.txt)
def eigenvalue_string(paw, comment=' '):
"""
Write eigenvalues and occupation numbers into a string.
The parameter comment can be used to comment out non-numers,
for example to escape it for gnuplot.
"""
tokens = []
def add(*line):
for token in line:
tokens.append(token)
tokens.append('\n')
if len(paw.wfs.kd.ibzk_kc) == 1:
if paw.wfs.nspins == 1:
add(comment, 'Band Eigenvalues Occupancy')
eps_n = paw.get_eigenvalues(kpt=0, spin=0)
f_n = paw.get_occupation_numbers(kpt=0, spin=0)
if paw.wfs.world.rank == 0:
for n in range(paw.wfs.bd.nbands):
add('%5d %11.5f %9.5f' % (n, eps_n[n], f_n[n]))
else:
add(comment, ' Up Down')
add(comment, 'Band Eigenvalues Occupancy Eigenvalues '
'Occupancy')
epsa_n = paw.get_eigenvalues(kpt=0, spin=0, broadcast=False)
epsb_n = paw.get_eigenvalues(kpt=0, spin=1, broadcast=False)
fa_n = paw.get_occupation_numbers(kpt=0, spin=0, broadcast=False)
fb_n = paw.get_occupation_numbers(kpt=0, spin=1, broadcast=False)
if paw.wfs.world.rank == 0:
for n in range(paw.wfs.bd.nbands):
add('%5d %11.5f %9.5f %11.5f %9.5f' %
(n, epsa_n[n], fa_n[n], epsb_n[n], fb_n[n]))
return ''.join(tokens)
if len(paw.wfs.kd.ibzk_kc) > 10:
add('Warning: Showing only first 10 kpts')
print_range = 10
else:
add('Showing all kpts')
print_range = len(paw.wfs.kd.ibzk_kc)
if paw.wfs.nvalence / 2. > 10:
m = int(paw.wfs.nvalence / 2. - 10)
else:
m = 0
if paw.wfs.bd.nbands - paw.wfs.nvalence / 2. > 10:
j = int(paw.wfs.nvalence / 2. + 10)
else:
j = int(paw.wfs.bd.nbands)
if paw.wfs.nspins == 1:
add(comment, 'Kpt Band Eigenvalues Occupancy')
for i in range(print_range):
eps_n = paw.get_eigenvalues(kpt=i, spin=0)
f_n = paw.get_occupation_numbers(kpt=i, spin=0)
if paw.wfs.world.rank == 0:
for n in range(m, j):
add('%3i %5d %11.5f %9.5f' % (i, n, eps_n[n], f_n[n]))
add()
else:
add(comment, ' Up Down')
add(comment, 'Kpt Band Eigenvalues Occupancy Eigenvalues '
'Occupancy')
for i in range(print_range):
epsa_n = paw.get_eigenvalues(kpt=i, spin=0, broadcast=False)
epsb_n = paw.get_eigenvalues(kpt=i, spin=1, broadcast=False)
fa_n = paw.get_occupation_numbers(kpt=i, spin=0, broadcast=False)
fb_n = paw.get_occupation_numbers(kpt=i, spin=1, broadcast=False)
if paw.wfs.world.rank == 0:
for n in range(m, j):
add('%3i %5d %11.5f %9.5f %11.5f %9.5f' %
(i, n, epsa_n[n], fa_n[n], epsb_n[n], fb_n[n]))
add()
return ''.join(tokens)
def plot(atoms):
"""Ascii-art plot of the atoms."""
# y
# |
# .-- x
# /
# z
cell_cv = atoms.get_cell()
if (cell_cv - np.diag(cell_cv.diagonal())).any():
atoms = atoms.copy()
atoms.cell = [1, 1, 1]
atoms.center(vacuum=2.0)
cell_cv = atoms.get_cell()
plot_box = False
else:
plot_box = True
cell = np.diagonal(cell_cv) / Bohr
positions = atoms.get_positions() / Bohr
numbers = atoms.get_atomic_numbers()
s = 1.3
nx, ny, nz = n = (s * cell * (1.0, 0.25, 0.5) + 0.5).astype(int)
sx, sy, sz = n / cell
grid = Grid(nx + ny + 4, nz + ny + 1)
positions = (positions % cell + cell) % cell
ij = np.dot(positions, [(sx, 0), (sy, sy), (0, sz)])
ij = np.around(ij).astype(int)
for a, Z in enumerate(numbers):
symbol = chemical_symbols[Z]
i, j = ij[a]
depth = positions[a, 1]
for n, c in enumerate(symbol):
grid.put(c, i + n + 1, j, depth)
if plot_box:
k = 0
for i, j in [(1, 0), (1 + nx, 0)]:
grid.put('*', i, j)
grid.put('.', i + ny, j + ny)
if k == 0:
grid.put('*', i, j + nz)
grid.put('.', i + ny, j + nz + ny)
for y in range(1, ny):
grid.put('/', i + y, j + y, y / sy)
if k == 0:
grid.put('/', i + y, j + y + nz, y / sy)
for z in range(1, nz):
if k == 0:
grid.put('|', i, j + z)
grid.put('|', i + ny, j + z + ny)
k = 1
for i, j in [(1, 0), (1, nz)]:
for x in range(1, nx):
if k == 1:
grid.put('-', i + x, j)
grid.put('-', i + x + ny, j + ny)
k = 0
return '\n'.join([''.join([chr(x) for x in line])
for line in np.transpose(grid.grid)[::-1]])
class Grid:
def __init__(self, i, j):
self.grid = np.zeros((i, j), np.int8)
self.grid[:] = ord(' ')
self.depth = np.zeros((i, j))
self.depth[:] = 1e10
def put(self, c, i, j, depth=1e9):
if depth < self.depth[i, j]:
self.grid[i, j] = ord(c)
self.depth[i, j] = depth
gpaw-0.11.0.13004/gpaw/elph/ 0000775 0001750 0001750 00000000000 12553644063 015341 5 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/elph/electronphonon.py 0000664 0001750 0001750 00000104517 12553643470 020761 0 ustar jensj jensj 0000000 0000000 """Module for calculating electron-phonon couplings.
Electron-phonon interaction::
__
\ l + +
H = ) g c c ( a + a ),
el-ph /_ ij i j l l
l,ij
where the electron phonon coupling is given by::
______
l / hbar ___
g = /------- < i | \ / V * e | j > .
ij \/ 2 M w 'u eff l
l
Here, l denotes the vibrational mode, w_l and e_l is the frequency and
mass-scaled polarization vector, respectively, M is an effective mass, i, j are
electronic state indices and nabla_u denotes the gradient wrt atomic
displacements. The implementation supports calculations of the el-ph coupling
in both finite and periodic systems, i.e. expressed in a basis of molecular
orbitals or Bloch states.
The implementation is based on finite-difference calculations of the the atomic
gradients of the effective potential expressed on a real-space grid. The el-ph
couplings are obtained from LCAO representations of the atomic gradients of the
effective potential and the electronic states.
In PAW the matrix elements of the derivative of the effective potential is
given by the sum of the following contributions::
d d
< i | -- V | j > = < i | -- V | j>
du eff du
_
\ ~a d . ~a
+ ) < i | p > -- /_\H < p | j >
/_ i du ij j
a,ij
_
\ d ~a . ~a
+ ) < i | -- p > /_\H < p | j >
/_ du i ij j
a,ij
_
\ ~a . d ~a
+ ) < i | p > /_\H < -- p | j >
/_ i ij du j
a,ij
where the first term is the derivative of the potential (Hartree + XC) and the
last three terms originate from the PAW (pseudopotential) part of the effective
DFT Hamiltonian.
"""
import pickle
from math import pi
import numpy as np
import numpy.fft as fft
import numpy.linalg as la
import ase.units as units
from ase.phonons import Displacement
from gpaw.utilities import unpack2
from gpaw.utilities.tools import tri2full
from gpaw.utilities.timing import StepTimer, nulltimer
from gpaw.lcao.overlap import ManySiteDictionaryWrapper, \
TwoCenterIntegralCalculator
from gpaw.lcao.tightbinding import TightBinding
from gpaw.kpt_descriptor import KPointDescriptor
class ElectronPhononCoupling(Displacement):
"""Class for calculating the electron-phonon coupling in an LCAO basis.
The derivative of the effective potential wrt atomic displacements is
obtained from a finite difference approximation to the derivative by doing
a self-consistent calculation for atomic displacements in the +/-
directions. These calculations are carried out in the ``run`` member
function.
The subsequent calculation of the coupling matrix in the basis of atomic
orbitals (or Bloch-sums hereof for periodic systems) is handled by the
``calculate_matrix`` member function.
"""
def __init__(self, atoms, calc=None, supercell=(1, 1, 1), name='elph',
delta=0.01, phonons=None):
"""Initialize with base class args and kwargs.
Parameters
----------
atoms: Atoms object
The atoms to work on.
calc: Calculator
Calculator for the supercell calculation.
supercell: tuple
Size of supercell given by the number of repetitions (l, m, n) of
the small unit cell in each direction.
name: str
Name to use for files (default: 'elph').
delta: float
Magnitude of displacements.
phonons: Phonons object
If provided, the ``__call__`` member function of the ``Phonons``
class in ASE will be called in the ``__call__`` member function of
this class.
"""
# Init base class and make the center cell in the supercell the
# reference cell
Displacement.__init__(self, atoms, calc=calc, supercell=supercell,
name=name, delta=delta, refcell='center')
# Store ``Phonons`` object in attribute
self.phonons = phonons
# Log
self.set_log()
# LCAO calculator
self.calc_lcao = None
# Supercell matrix
self.g_xNNMM = None
def __call__(self, atoms_N):
"""Extract effective potential and projector coefficients."""
# Do calculation
atoms_N.get_potential_energy()
# Call phonons class if provided
if self.phonons is not None:
forces = self.phonons.__call__(atoms_N)
# Get calculator
calc = atoms_N.get_calculator()
# Effective potential (in Hartree) and projector coefficients
Vt_G = calc.hamiltonian.vt_sG[0]
Vt_G = calc.wfs.gd.collect(Vt_G, broadcast=True)
dH_asp = calc.hamiltonian.dH_asp
setups = calc.wfs.setups
nspins = calc.wfs.nspins
gd_comm = calc.wfs.gd.comm
dH_all_asp = {}
for a, setup in enumerate(setups):
ni = setup.ni
nii = ni * (ni + 1) // 2
dH_tmp_sp = np.zeros((nspins, nii))
if a in dH_asp:
dH_tmp_sp[:] = dH_asp[a]
gd_comm.sum(dH_tmp_sp)
dH_all_asp[a] = dH_tmp_sp
return Vt_G, dH_all_asp
def set_lcao_calculator(self, calc):
"""Set LCAO calculator for the calculation of the supercell matrix."""
# Add parameter checks here
# - check that gamma
# - check that no symmetries are used
# - ...
assert calc.input_parameters['mode'] == 'lcao', 'LCAO mode required.'
symmetry = calc.input_parameters['symmetry']
assert not symmetry['point_group'], 'Symmetries not supported.'
self.calc_lcao = calc
def set_basis_info(self, *args):
"""Store lcao basis info for atoms in reference cell in attribute.
Parameters
----------
args: tuple
If the LCAO calculator is not available (e.g. if the supercell is
loaded from file), the ``load_supercell_matrix`` member function
provides the required info as arguments.
"""
if len(args) == 0:
calc = self.calc_lcao
setups = calc.wfs.setups
bfs = calc.wfs.basis_functions
nao_a = [setups[a].nao for a in range(len(self.atoms))]
M_a = [bfs.M_a[a] for a in range(len(self.atoms))]
else:
M_a = args[0]
nao_a = args[1]
self.basis_info = {'M_a': M_a,
'nao_a': nao_a}
def set_log(self, log=None):
"""Set output log."""
if log is None:
self.timer = nulltimer
elif log == '-':
self.timer = StepTimer(name='elph')
else:
self.timer = StepTimer(name='elph', out=open(log, 'w'))
def calculate_supercell_matrix(self, dump=0, name=None, filter=None,
include_pseudo=True, atoms=None):
"""Calculate matrix elements of the el-ph coupling in the LCAO basis.
This function calculates the matrix elements between LCAOs and local
atomic gradients of the effective potential. The matrix elements are
calculated for the supercell used to obtain finite-difference
approximations to the derivatives of the effective potential wrt to
atomic displacements.
Parameters
----------
dump: int
Dump supercell matrix to pickle file (default: 0).
0: Supercell matrix not saved
1: Supercell matrix saved in a single pickle file.
2: Dump matrix for different gradients in separate files. Useful
for large systems where the total array gets too large for a
single pickle file.
name: string
User specified name of the generated pickle file(s). If not
provided, the string in the ``name`` attribute is used.
filter: str
Fourier filter atomic gradients of the effective potential. The
specified components (``normal`` or ``umklapp``) are removed
(default: None).
include_pseudo: bool
Include the contribution from the psedupotential in the atomic
gradients. If ``False``, only the gradient of the effective
potential is included (default: True).
atoms: Atoms object
Calculate supercell for an ``Atoms`` object different from the one
provided in the ``__init__`` method (WARNING, NOT working!).
"""
assert self.calc_lcao is not None, "Set LCAO calculator"
# Supercell atoms
if atoms is None:
atoms_N = self.atoms * self.N_c
else:
atoms_N = atoms
# Initialize calculator if required and extract useful quantities
calc = self.calc_lcao
if not hasattr(calc.wfs, 'S_qMM'):
calc.initialize(atoms_N)
calc.initialize_positions(atoms_N)
self.set_basis_info()
basis = calc.input_parameters['basis']
# Extract useful objects from the calculator
wfs = calc.wfs
gd = calc.wfs.gd
kd = calc.wfs.kd
kpt_u = wfs.kpt_u
setups = wfs.setups
nao = setups.nao
bfs = wfs.basis_functions
dtype = wfs.dtype
spin = 0 # XXX
# If gamma calculation, overlap with neighboring cell cannot be removed
if kd.gamma:
print("WARNING: Gamma-point calculation.")
else:
# Bloch to real-space converter
tb = TightBinding(atoms_N, calc)
self.timer.write_now("Calculating supercell matrix")
self.timer.write_now("Calculating real-space gradients")
# Calculate finite-difference gradients (in Hartree / Bohr)
V1t_xG, dH1_xasp = self.calculate_gradient()
self.timer.write_now("Finished real-space gradients")
# Fourier filter the atomic gradients of the effective potential
if filter is not None:
self.timer.write_now("Fourier filtering gradients")
V1_xG = V1t_xG.copy()
self.fourier_filter(V1t_xG, components=filter)
self.timer.write_now("Finished Fourier filtering")
# For the contribution from the derivative of the projectors
dP_aqvMi = self.calculate_dP_aqvMi(wfs)
# Equilibrium atomic Hamiltonian matrix (projector coefficients)
dH_asp = pickle.load(open(self.name + '.eq.pckl'))[1]
# Check that the grid is the same as in the calculator
assert np.all(V1t_xG.shape[-3:] == (gd.N_c + gd.pbc_c - 1)), \
"Mismatch in grids."
# Calculate < i k | grad H | j k >, i.e. matrix elements in Bloch basis
# List for supercell matrices;
g_xNNMM = []
self.timer.write_now("Calculating gradient of PAW Hamiltonian")
# Do each cartesian component separately
for i, a in enumerate(self.indices):
for v in range(3):
# Corresponding array index
x = 3 * i + v
V1t_G = V1t_xG[x]
self.timer.write_now("%s-gradient of atom %u" %
(['x','y','z'][v], a))
# Array for different k-point components
g_qMM = np.zeros((len(kpt_u), nao, nao), dtype)
# 1) Gradient of effective potential
self.timer.write_now("Starting gradient of effective potential")
for kpt in kpt_u:
# Matrix elements
geff_MM = np.zeros((nao, nao), dtype)
bfs.calculate_potential_matrix(V1t_G, geff_MM, q=kpt.q)
tri2full(geff_MM, 'L')
# Insert in array
g_qMM[kpt.q] += geff_MM
self.timer.write_now("Finished gradient of effective potential")
if include_pseudo:
self.timer.write_now("Starting gradient of pseudo part")
# 2) Gradient of non-local part (projectors)
self.timer.write_now("Starting gradient of dH^a")
P_aqMi = calc.wfs.P_aqMi
# 2a) dH^a part has contributions from all other atoms
for kpt in kpt_u:
# Matrix elements
gp_MM = np.zeros((nao, nao), dtype)
dH1_asp = dH1_xasp[x]
for a_, dH1_sp in dH1_asp.items():
dH1_ii = unpack2(dH1_sp[spin])
gp_MM += np.dot(P_aqMi[a_][kpt.q], np.dot(dH1_ii,
P_aqMi[a_][kpt.q].T.conjugate()))
g_qMM[kpt.q] += gp_MM
self.timer.write_now("Finished gradient of dH^a")
self.timer.write_now("Starting gradient of projectors")
# 2b) dP^a part has only contributions from the same atoms
dP_qvMi = dP_aqvMi[a]
dH_ii = unpack2(dH_asp[a][spin])
for kpt in kpt_u:
#XXX Sort out the sign here; conclusion -> sign = +1 !
P1HP_MM = +1 * np.dot(dP_qvMi[kpt.q][v], np.dot(dH_ii,
P_aqMi[a][kpt.q].T.conjugate()))
# Matrix elements
gp_MM = P1HP_MM + P1HP_MM.T.conjugate()
g_qMM[kpt.q] += gp_MM
self.timer.write_now("Finished gradient of projectors")
self.timer.write_now("Finished gradient of pseudo part")
# Extract R_c=(0, 0, 0) block by Fourier transforming
if kd.gamma or kd.N_c is None:
g_MM = g_qMM[0]
else:
# Convert to array
g_MM = tb.bloch_to_real_space(g_qMM, R_c=(0, 0, 0))[0]
# Reshape to global unit cell indices
N = np.prod(self.N_c)
# Number of basis function in the primitive cell
assert (nao % N) == 0, "Alarm ...!"
nao_cell = nao / N
g_NMNM = g_MM.reshape((N, nao_cell, N, nao_cell))
g_NNMM = g_NMNM.swapaxes(1, 2).copy()
self.timer.write_now("Finished supercell matrix")
if dump != 2:
g_xNNMM.append(g_NNMM)
else:
if name is not None:
fname = '%s.supercell_matrix_x_%2.2u.%s.pckl' % (name, x, basis)
else:
fname = self.name + \
'.supercell_matrix_x_%2.2u.%s.pckl' % (x, basis)
if kd.comm.rank == 0:
fd = open(fname, 'w')
M_a = self.basis_info['M_a']
nao_a = self.basis_info['nao_a']
pickle.dump((g_NNMM, M_a, nao_a), fd, 2)
fd.close()
self.timer.write_now("Finished gradient of PAW Hamiltonian")
if dump != 2:
# Collect gradients in one array
self.g_xNNMM = np.array(g_xNNMM)
# Dump to pickle file using binary mode together with basis info
if dump and kd.comm.rank == 0:
if name is not None:
fname = '%s.supercell_matrix.%s.pckl' % (name, basis)
else:
fname = self.name + '.supercell_matrix.%s.pckl' % basis
fd = open(fname, 'w')
M_a = self.basis_info['M_a']
nao_a = self.basis_info['nao_a']
pickle.dump((self.g_xNNMM, M_a, nao_a), fd, 2)
fd.close()
def load_supercell_matrix(self, basis=None, name=None, multiple=False):
"""Load supercell matrix from pickle file.
Parameters
----------
basis: string
String specifying the LCAO basis used to calculate the supercell
matrix, e.g. 'dz(dzp)'.
name: string
User specified name of the pickle file.
multiple: bool
Load each derivative from individual files.
"""
assert (basis is not None) or (name is not None), \
"Provide basis or name."
if self.g_xNNMM is not None:
self.g_xNNMM = None
if not multiple:
# File name
if name is not None:
fname = name
else:
fname = self.name + '.supercell_matrix.%s.pckl' % basis
fd = open(fname)
self.g_xNNMM, M_a, nao_a = pickle.load(fd)
fd.close()
else:
g_xNNMM = []
for x in range(len(self.indices)*3):
if name is not None:
fname = name
else:
fname = self.name + \
'.supercell_matrix_x_%2.2u.%s.pckl' % (x, basis)
fd = open(fname, 'r')
g_NNMM, M_a, nao_a = pickle.load(fd)
fd.close()
g_xNNMM.append(g_NNMM)
self.g_xNNMM = np.array(g_xNNMM)
self.set_basis_info(M_a, nao_a)
def apply_cutoff(self, cutmax=None, cutmin=None):
"""Zero matrix element inside/beyond the specified cutoffs.
Parameters
----------
cutmax: float
Zero matrix elements for basis functions with a distance to the
atomic gradient that is larger than the cutoff.
cutmin: float
Zero matrix elements where both basis functions have distances to
the atomic gradient that is smaller than the cutoff.
"""
if cutmax is not None:
cutmax = float(cutmax)
if cutmin is not None:
cutmin = float(cutmin)
# Reference to supercell matrix attribute
g_xNNMM = self.g_xNNMM
# Number of atoms and primitive cells
N_atoms = len(self.indices)
N = np.prod(self.N_c)
nao = g_xNNMM.shape[-1]
# Reshape array
g_avNNMM = g_xNNMM.reshape(N_atoms, 3, N, N, nao, nao)
# Make slices for orbitals on atoms
M_a = self.basis_info['M_a']
nao_a = self.basis_info['nao_a']
slice_a = []
for a in range(len(self.atoms)):
start = M_a[a] ;
stop = start + nao_a[a]
s = slice(start, stop)
slice_a.append(s)
# Lattice vectors
R_cN = self.lattice_vectors()
# Unit cell vectors
cell_vc = self.atoms.cell.transpose()
# Atomic positions in reference cell
pos_av = self.atoms.get_positions()
# Create a mask array to zero the relevant matrix elements
if cutmin is not None:
mask_avNNMM = np.zeros(g_avNNMM.shape, dtype=bool)
# Zero elements where one of the basis orbitals has a distance to atoms
# (atomic gradients) in the reference cell larger than the cutoff
for n in range(N):
# Lattice vector to cell
R_v = np.dot(cell_vc, R_cN[:, n])
# Atomic positions in cell
posn_av = pos_av + R_v
for i, a in enumerate(self.indices):
# Atomic distances wrt to the position of the gradient
dist_a = np.sqrt(np.sum((pos_av[a] - posn_av)**2, axis=-1))
if cutmax is not None:
# Atoms indices where the distance is larger than the max
# cufoff
j_a = np.where(dist_a > cutmax)[0]
# Zero elements
for j in j_a:
g_avNNMM[a, :, n, :, slice_a[j], :] = 0.0
g_avNNMM[a, :, :, n, :, slice_a[j]] = 0.0
if cutmin is not None:
# Atoms indices where the distance is larger than the min
# cufoff
j_a = np.where(dist_a > cutmin)[0]
# Update mask to keep elements where one LCAO is outside
# the min cutoff
for j in j_a:
mask_avNNMM[a, :, n, :, slice_a[j], :] = True
mask_avNNMM[a, :, :, n, :, slice_a[j]] = True
# Zero elements where both LCAOs are located within the min cutoff
if cutmin is not None:
g_avNNMM[~mask_avNNMM] = 0.0
def lcao_matrix(self, u_l, omega_l):
"""Calculate the el-ph coupling in the electronic LCAO basis.
For now, only works for Gamma-point phonons.
Parameters
----------
u_l: ndarray
Mass-scaled polarization vectors (in units of 1 / sqrt(amu)) of the
phonons.
omega_l: ndarray
Vibrational frequencies in eV.
"""
# Supercell matrix (Hartree / Bohr)
assert self.g_xNNMM is not None, "Load supercell matrix."
assert self.g_xNNMM.shape[1:3] == (1, 1)
g_xMM = self.g_xNNMM[:, 0, 0, :, :]
# Number of atomic orbitals
nao = g_xMM.shape[-1]
# Number of phonon modes
nmodes = u_l.shape[0]
#
u_lx = u_l.reshape(nmodes, 3 * len(self.atoms))
g_lMM = np.dot(u_lx, g_xMM.transpose(1, 0, 2))
# Multiply prefactor sqrt(hbar / 2 * M * omega) in units of Bohr
amu = units._amu # atomic mass unit
me = units._me # electron mass
g_lMM /= np.sqrt(2 * amu / me / units.Hartree * \
omega_l[:, np.newaxis, np.newaxis])
# Convert to eV
g_lMM *= units.Hartree
return g_lMM
def bloch_matrix(self, kpts, qpts, c_kn, u_ql, omega_ql=None, kpts_from=None):
"""Calculate el-ph coupling in the Bloch basis for the electrons.
This function calculates the electron-phonon coupling between the
specified Bloch states, i.e.::
______
mnl / hbar ^
g = /------- < m k + q | e . grad V | n k >
kq \/ 2 M w ql q
ql
In case the ``omega_ql`` keyword argument is not given, the bare matrix
element (in units of eV / Ang) without the sqrt prefactor is returned.
Parameters
----------
kpts: ndarray or tuple.
k-vectors of the Bloch states. When a tuple of integers is given, a
Monkhorst-Pack grid with the specified number of k-points along the
directions of the reciprocal lattice vectors is generated.
qpts: ndarray or tuple.
q-vectors of the phonons.
c_kn: ndarray
Expansion coefficients for the Bloch states. The ordering must be
the same as in the ``kpts`` argument.
u_ql: ndarray
Mass-scaled polarization vectors (in units of 1 / sqrt(amu)) of the
phonons. Again, the ordering must be the same as in the
corresponding ``qpts`` argument.
omega_ql: ndarray
Vibrational frequencies in eV.
kpts_from: list of ints or int
Calculate only the matrix element for the k-vectors specified by
their index in the ``kpts`` argument (default: all).
In short, phonon frequencies and mode vectors must be given in ase units.
"""
assert self.g_xNNMM is not None, "Load supercell matrix."
assert len(c_kn.shape) == 3
assert len(u_ql.shape) == 4
if omega_ql is not None:
assert np.all(u_ql.shape[:2] == omega_ql.shape[:2])
# Translate k-points into 1. BZ (required by ``find_k_plus_q``` member
# function of the ```KPointDescriptor``).
if isinstance(kpts, np.ndarray):
assert kpts.shape[1] == 3, "kpts_kc array must be given"
# XXX This does not seem to cause problems!
kpts -= kpts.round()
# Use the KPointDescriptor to keep track of the k and q-vectors
kd_kpts = KPointDescriptor(kpts)
kd_qpts = KPointDescriptor(qpts)
# Check that number of k- and q-points agree with the number of Bloch
# functions and polarization vectors
assert kd_kpts.nbzkpts == len(c_kn)
assert kd_qpts.nbzkpts == len(u_ql)
# Include all k-point per default
if kpts_from is None:
kpts_kc = kd_kpts.bzk_kc
kpts_k = range(kd_kpts.nbzkpts)
else:
kpts_kc = kd_kpts.bzk_kc[kpts_from]
if isinstance(kpts_from, int):
kpts_k = list([kpts_from])
else:
kpts_k = list(kpts_from)
# Supercell matrix (real matrix in Hartree / Bohr)
g_xNNMM = self.g_xNNMM
# Number of phonon modes and electronic bands
nmodes = u_ql.shape[1]
nbands = c_kn.shape[1]
# Number of atoms displacements and basis functions
ndisp = np.prod(u_ql.shape[2:])
assert ndisp == (3 * len(self.indices))
nao = c_kn.shape[2]
assert ndisp == g_xNNMM.shape[0]
assert nao == g_xNNMM.shape[-1]
# Lattice vectors
R_cN = self.lattice_vectors()
# Number of unit cell in supercell
N = np.prod(self.N_c)
# Allocate array for couplings
g_qklnn = np.zeros((kd_qpts.nbzkpts, len(kpts_kc), nmodes,
nbands, nbands), dtype=complex)
self.timer.write_now("Calculating coupling matrix elements")
for q, q_c in enumerate(kd_qpts.bzk_kc):
# Find indices of k+q for the k-points
kplusq_k = kd_kpts.find_k_plus_q(q_c, kpts_k=kpts_k)
# Here, ``i`` is counting from 0 and ``k`` is the global index of
# the k-point
for i, (k, k_c) in enumerate(zip(kpts_k, kpts_kc)):
# Check the wave vectors (adapted to the ``KPointDescriptor`` class)
kplusq_c = k_c + q_c
kplusq_c -= kplusq_c.round()
assert np.allclose(kplusq_c, kd_kpts.bzk_kc[kplusq_k[i]] ), \
(i, k, k_c, q_c, kd_kpts.bzk_kc[kplusq_k[i]])
# Allocate array
g_xMM = np.zeros((ndisp, nao, nao), dtype=complex)
# Multiply phase factors
for m in range(N):
for n in range(N):
Rm_c = R_cN[:, m]
Rn_c = R_cN[:, n]
phase = np.exp(2.j * pi * (np.dot(k_c, Rm_c - Rn_c)
+ np.dot(q_c, Rm_c)))
# Sum contributions from different cells
g_xMM += g_xNNMM[:, m, n, :, :] * phase
# LCAO coefficient for Bloch states
ck_nM = c_kn[k]
ckplusq_nM = c_kn[kplusq_k[i]]
# Mass scaled polarization vectors
u_lx = u_ql[q].reshape(nmodes, 3 * len(self.atoms))
g_nxn = np.dot(ckplusq_nM.conj(), np.dot(g_xMM, ck_nM.T))
g_lnn = np.dot(u_lx, g_nxn)
# Insert value
g_qklnn[q, i] = g_lnn
# XXX Temp
if np.all(q_c == 0.0):
# These should be real
print(g_qklnn[q].imag.min(), g_qklnn[q].imag.max())
self.timer.write_now("Finished calculation of coupling matrix elements")
# Return the bare matrix element if frequencies are not given
if omega_ql is None:
# Convert to eV / Ang
g_qklnn *= units.Hartree / units.Bohr
else:
# Multiply prefactor sqrt(hbar / 2 * M * omega) in units of Bohr
amu = units._amu # atomic mass unit
me = units._me # electron mass
g_qklnn /= np.sqrt(2 * amu / me / units.Hartree * \
omega_ql[:, np.newaxis, :, np.newaxis, np.newaxis])
# Convert to eV
g_qklnn *= units.Hartree
# Return couplings in eV (or eV / Ang)
return g_qklnn
def fourier_filter(self, V1t_xG, components='normal', criteria=1):
"""Fourier filter atomic gradients of the effective potential.
Parameters
----------
V1t_xG: ndarray
Array representation of atomic gradients of the effective potential
in the supercell grid.
components: str
Fourier components to filter out (``normal`` or ``umklapp``).
"""
assert components in ['normal', 'umklapp']
# Grid shape
shape = V1t_xG.shape[-3:]
# Primitive unit cells in Bohr/Bohr^-1
cell_cv = self.atoms.get_cell() / units.Bohr
reci_vc = 2 * pi * la.inv(cell_cv)
norm_c = np.sqrt(np.sum(reci_vc**2, axis=0))
# Periodic BC array
pbc_c = np.array(self.atoms.get_pbc(), dtype=bool)
# Supercell atoms and cell
atoms_N = self.atoms * self.N_c
supercell_cv = atoms_N.get_cell() / units.Bohr
# q-grid in units of the grid spacing (FFT ordering)
q_cG = np.indices(shape).reshape(3, -1)
q_c = np.array(shape)[:, np.newaxis]
q_cG += q_c // 2
q_cG %= q_c
q_cG -= q_c // 2
# Locate q-points inside the Brillouin zone
if criteria == 0:
# Works for all cases
# Grid spacing in direction of reciprocal lattice vectors
h_c = np.sqrt(np.sum((2 * pi * la.inv(supercell_cv))**2, axis=0))
# XXX Why does a "*=" operation on q_cG not work here ??
q1_cG = q_cG * h_c[:, np.newaxis] / (norm_c[:, np.newaxis] / 2)
mask_G = np.ones(np.prod(shape), dtype=bool)
for i, pbc in enumerate(pbc_c):
if not pbc:
continue
mask_G &= (-1. < q1_cG[i]) & (q1_cG[i] <= 1.)
else:
# 2D hexagonal lattice
# Projection of q points onto the periodic directions. Only in
# these directions do normal and umklapp processees make sense.
q_vG = np.dot(q_cG[pbc_c].T,
2 * pi * la.inv(supercell_cv).T[pbc_c]).T.copy()
# Parametrize the BZ boundary in terms of the angle theta
theta_G = np.arctan2(q_vG[1], q_vG[0]) % (pi / 3)
phi_G = pi / 6 - np.abs(theta_G)
qmax_G = norm_c[0] / 2 / np.cos(phi_G)
norm_G = np.sqrt(np.sum(q_vG**2, axis=0))
# Includes point on BZ boundary with +1e-2
mask_G = (norm_G <= qmax_G + 1e-2) # & (q_vG[1] < (norm_c[0] / 2 - 1e-3))
if components != 'normal':
mask_G = ~mask_G
# Reshape to grid shape
mask_G.shape = shape
for V1t_G in V1t_xG:
# Fourier transform atomic gradient
V1tq_G = fft.fftn(V1t_G)
# Zero normal/umklapp components
V1tq_G[mask_G] = 0.0
# Fourier transform back
V1t_G[:] = fft.ifftn(V1tq_G).real
def calculate_gradient(self):
"""Calculate gradient of effective potential and projector coefs.
This function loads the generated pickle files and calculates
finite-difference derivatives.
"""
# Array and dict for finite difference derivatives
V1t_xG = []
dH1_xasp = []
x = 0
for a in self.indices:
for v in range(3):
name = '%s.%d%s' % (self.name, a, 'xyz'[v])
# Potential and atomic density matrix for atomic displacement
try:
Vtm_G, dHm_asp = pickle.load(open(name + '-.pckl'))
Vtp_G, dHp_asp = pickle.load(open(name + '+.pckl'))
except (IOError, EOFError):
raise IOError('%s(-/+).pckl' % name)
# FD derivatives in Hartree / Bohr
V1t_G = (Vtp_G - Vtm_G) / (2 * self.delta / units.Bohr)
V1t_xG.append(V1t_G)
dH1_asp = {}
for atom in dHm_asp.keys():
dH1_asp[atom] = (dHp_asp[atom] - dHm_asp[atom]) / \
(2 * self.delta / units.Bohr)
dH1_xasp.append(dH1_asp)
x += 1
return np.array(V1t_xG), dH1_xasp
def calculate_dP_aqvMi(self, wfs):
"""Overlap between LCAO basis functions and gradient of projectors.
Only the gradient wrt the atomic positions in the reference cell is
computed.
"""
nao = wfs.setups.nao
nq = len(wfs.ibzk_qc)
atoms = [self.atoms[i] for i in self.indices]
# Derivatives in reference cell
dP_aqvMi = {}
for atom, setup in zip(atoms, wfs.setups):
a = atom.index
dP_aqvMi[a] = np.zeros((nq, 3, nao, setup.ni), wfs.dtype)
# Calculate overlap between basis function and gradient of projectors
# NOTE: the derivative is calculated wrt the atomic position and not
# the real-space coordinate
calc = TwoCenterIntegralCalculator(wfs.ibzk_qc, derivative=True)
expansions = ManySiteDictionaryWrapper(wfs.tci.P_expansions, dP_aqvMi)
calc.calculate(wfs.tci.atompairs, [expansions], [dP_aqvMi])
# Extract derivatives in the reference unit cell
# dP_aqvMi = {}
# for atom in self.atoms:
# dP_aqvMi[atom.index] = dPall_aqvMi[atom.index]
return dP_aqvMi
gpaw-0.11.0.13004/gpaw/elph/__init__.py 0000664 0001750 0001750 00000000000 12553643470 017441 0 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/grid_descriptor.py 0000664 0001750 0001750 00000055772 12553643470 020167 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
"""Grid-descriptors
This module contains a classes defining uniform 3D grids.
For radial grid descriptors, look atom/radialgd.py.
"""
import numbers
from math import pi
import numpy as np
import _gpaw
import gpaw.mpi as mpi
from gpaw.domain import Domain
from gpaw.utilities import mlsqr
from gpaw.utilities.blas import rk, r2k, gemv, gemm
# Remove this: XXX
assert (-1) % 3 == 2
assert (np.array([-1]) % 3)[0] == 2
NONBLOCKING = False
class GridBoundsError(ValueError):
pass
class GridDescriptor(Domain):
"""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]]])
"""
ndim = 3 # dimension of ndarrays
def __init__(self, N_c, cell_cv=(1, 1, 1), pbc_c=True,
comm=None, parsize=None):
"""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: tuple of 3 ints, a single int or None
Number of domains.
Note that if pbc_c[c] is True, 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.
"""
if isinstance(pbc_c, int):
pbc_c = (pbc_c,) * 3
if comm is None:
comm = mpi.world
self.N_c = np.array(N_c, int)
if (self.N_c != N_c).any():
raise ValueError('Non-int number of grid points %s' % N_c)
Domain.__init__(self, cell_cv, pbc_c, comm, parsize, self.N_c)
self.rank = self.comm.rank
parsize_c = self.parsize_c
n_c, remainder_c = divmod(self.N_c, parsize_c)
self.beg_c = np.empty(3, int)
self.end_c = np.empty(3, int)
self.n_cp = []
for c in range(3):
n_p = (np.arange(parsize_c[c] + 1) * float(self.N_c[c]) /
parsize_c[c])
n_p = np.around(n_p + 0.4999).astype(int)
if not self.pbc_c[c]:
n_p[0] = 1
if not np.alltrue(n_p[1:] - n_p[:-1]):
raise ValueError('Grid too small!')
self.beg_c[c] = n_p[self.parpos_c[c]]
self.end_c[c] = n_p[self.parpos_c[c] + 1]
self.n_cp.append(n_p)
self.n_c = self.end_c - self.beg_c
self.h_cv = self.cell_cv / self.N_c[:, np.newaxis]
self.volume = abs(np.linalg.det(self.cell_cv))
self.dv = self.volume / self.N_c.prod()
self.orthogonal = not (self.cell_cv -
np.diag(self.cell_cv.diagonal())).any()
# Sanity check for grid spacings:
h_c = self.get_grid_spacings()
if max(h_c) / min(h_c) > 1.3:
raise ValueError('Very anisotropic grid spacings: %s' % h_c)
def new_descriptor(self, N_c=None, cell_cv=None, pbc_c=None,
comm=None, parsize=None):
"""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."""
if N_c is None:
N_c = self.N_c
if cell_cv is None:
cell_cv = self.cell_cv
if pbc_c is None:
pbc_c = self.pbc_c
if comm is None:
comm = self.comm
if parsize is None:
parsize = self.parsize_c
return self.__class__(N_c, cell_cv, pbc_c, comm, parsize)
def get_grid_spacings(self):
L_c = (np.linalg.inv(self.cell_cv)**2).sum(0)**-0.5
return L_c / self.N_c
def get_size_of_global_array(self, pad=False):
if pad:
return self.N_c
else:
return self.N_c - 1 + self.pbc_c
def flat_index(self, G_c):
g1, g2, g3 = G_c - self.beg_c
return g3 + self.n_c[2] * (g2 + g1 * self.n_c[1])
def get_slice(self):
return [slice(b - 1 + p, e - 1 + p) for b, e, p in
zip(self.beg_c, self.end_c, self.pbc_c)]
def zeros(self, n=(), dtype=float, global_array=False, pad=False):
"""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``."""
return self._new_array(n, dtype, True, global_array, pad)
def empty(self, n=(), dtype=float, global_array=False, pad=False):
"""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 self._new_array(n, dtype, False, global_array, pad)
def _new_array(self, n=(), dtype=float, zero=True,
global_array=False, pad=False):
if global_array:
shape = self.get_size_of_global_array(pad)
else:
shape = self.n_c
if isinstance(n, numbers.Integral):
n = (n,)
shape = n + tuple(shape)
if zero:
return np.zeros(shape, dtype)
else:
return np.empty(shape, dtype)
def integrate(self, a_xg, b_yg=None,
global_integral=True, hermitian=False,
_transposed_result=None):
"""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 ..."""
xshape = a_xg.shape[:-3]
if b_yg is None:
# Only one array:
result = a_xg.reshape(xshape + (-1,)).sum(axis=-1) * self.dv
if global_integral:
if result.ndim == 0:
result = self.comm.sum(result)
else:
self.comm.sum(result)
return result
A_xg = np.ascontiguousarray(a_xg.reshape((-1,) + a_xg.shape[-3:]))
B_yg = np.ascontiguousarray(b_yg.reshape((-1,) + b_yg.shape[-3:]))
if _transposed_result is None:
result_yx = np.zeros((len(B_yg), len(A_xg)), A_xg.dtype)
else:
result_yx = _transposed_result
global_integral = False
if a_xg is b_yg:
rk(self.dv, A_xg, 0.0, result_yx)
elif hermitian:
r2k(0.5 * self.dv, A_xg, B_yg, 0.0, result_yx)
else:
gemm(self.dv, A_xg, B_yg, 0.0, result_yx, 'c')
if global_integral:
self.comm.sum(result_yx)
yshape = b_yg.shape[:-3]
result = result_yx.T.reshape(xshape + yshape)
if result.ndim == 0:
return result.item()
else:
return result
def gemm(self, alpha, psit_nG, C_mn, beta, newpsit_mG):
"""Helper function for MatrixOperator class."""
gemm(alpha, psit_nG, C_mn, beta, newpsit_mG)
def gemv(self, alpha, psit_nG, C_n, beta, newpsit_G, trans='t'):
"""Helper function for CG eigensolver."""
gemv(alpha, psit_nG, C_n, beta, newpsit_G, trans)
def coarsen(self):
"""Return coarsened `GridDescriptor` object.
Reurned descriptor has 2x2x2 fewer grid points."""
if np.sometrue(self.N_c % 2):
raise ValueError('Grid %s not divisible by 2!' % self.N_c)
return self.new_descriptor(self.N_c // 2)
def refine(self):
"""Return refined `GridDescriptor` object.
Returned descriptor has 2x2x2 more grid points."""
return self.new_descriptor(self.N_c * 2)
def get_boxes(self, spos_c, rcut, cut=True):
"""Find boxes enclosing sphere."""
N_c = self.N_c
ncut = rcut * (self.icell_cv**2).sum(axis=1)**0.5 * self.N_c
npos_c = spos_c * N_c
beg_c = np.ceil(npos_c - ncut).astype(int)
end_c = np.ceil(npos_c + ncut).astype(int)
if cut:
for c in range(3):
if not self.pbc_c[c]:
if beg_c[c] < 0:
beg_c[c] = 0
if end_c[c] > N_c[c]:
end_c[c] = N_c[c]
else:
for c in range(3):
if (not self.pbc_c[c] and
(beg_c[c] < 0 or end_c[c] > N_c[c])):
msg = ('Box at %.3f %.3f %.3f crosses boundary. '
'Beg. of box %s, end of box %s, max box size %s' %
(tuple(spos_c) + (beg_c, end_c, self.N_c)))
raise GridBoundsError(msg)
range_c = ([], [], [])
for c in range(3):
b = beg_c[c]
e = b
while e < end_c[c]:
b0 = b % N_c[c]
e = min(end_c[c], b + N_c[c] - b0)
if b0 < self.beg_c[c]:
b1 = b + self.beg_c[c] - b0
else:
b1 = b
e0 = b0 - b + e
if e0 > self.end_c[c]:
e1 = e - (e0 - self.end_c[c])
else:
e1 = e
if e1 > b1:
range_c[c].append((b1, e1))
b = e
boxes = []
for b0, e0 in range_c[0]:
for b1, e1 in range_c[1]:
for b2, e2 in range_c[2]:
b = np.array((b0, b1, b2))
e = np.array((e0, e1, e2))
beg_c = np.array((b0 % N_c[0], b1 % N_c[1], b2 % N_c[2]))
end_c = beg_c + e - b
disp = (b - beg_c) / N_c
beg_c = np.maximum(beg_c, self.beg_c)
end_c = np.minimum(end_c, self.end_c)
if (beg_c[0] < end_c[0] and
beg_c[1] < end_c[1] and
beg_c[2] < end_c[2]):
boxes.append((beg_c, end_c, disp))
return boxes
def get_nearest_grid_point(self, spos_c, force_to_this_domain=False):
"""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).
"""
g_c = np.around(self.N_c * spos_c).astype(int)
if force_to_this_domain:
for c in range(3):
g_c[c] = max(g_c[c], self.beg_c[c])
g_c[c] = min(g_c[c], self.end_c[c] - 1)
return g_c - self.beg_c
def plane_wave(self, k_c):
"""Evaluate plane wave on grid.
Returns::
_ _
ik.r
e ,
where the wave vector is given by k_c (in units of reciprocal
lattice vectors)."""
N_c = self.N_c
return np.exp(2j * pi * np.dot(np.indices(N_c).T, k_c / N_c).T)
def symmetrize(self, a_g, op_scc, ft_sc=None):
if len(op_scc) == 1:
return
if ft_sc is not None and not ft_sc.any():
ft_sc = None
A_g = self.collect(a_g)
if self.comm.rank == 0:
B_g = np.zeros_like(A_g)
for s, op_cc in enumerate(op_scc):
if ft_sc is None:
_gpaw.symmetrize(A_g, B_g, op_cc)
else:
_gpaw.symmetrize_ft(A_g, B_g, op_cc, ft_sc[s])
else:
B_g = None
self.distribute(B_g, a_g)
a_g /= len(op_scc)
def collect(self, a_xg, broadcast=False):
"""Collect distributed array to master-CPU or all CPU's."""
if self.comm.size == 1:
return a_xg
xshape = a_xg.shape[:-3]
# Collect all arrays on the master:
if self.rank != 0:
# There can be several sends before the corresponding receives
# are posted, so use syncronous send here
self.comm.ssend(a_xg, 0, 301)
if broadcast:
A_xg = self.empty(xshape, a_xg.dtype, global_array=True)
self.comm.broadcast(A_xg, 0)
return A_xg
else:
return None
# Put the subdomains from the slaves into the big array
# for the whole domain:
A_xg = self.empty(xshape, a_xg.dtype, global_array=True)
parsize_c = self.parsize_c
r = 0
for n0 in range(parsize_c[0]):
b0, e0 = self.n_cp[0][n0:n0 + 2] - self.beg_c[0]
for n1 in range(parsize_c[1]):
b1, e1 = self.n_cp[1][n1:n1 + 2] - self.beg_c[1]
for n2 in range(parsize_c[2]):
b2, e2 = self.n_cp[2][n2:n2 + 2] - self.beg_c[2]
if r != 0:
a_xg = np.empty(xshape +
((e0 - b0), (e1 - b1), (e2 - b2)),
a_xg.dtype.char)
self.comm.receive(a_xg, r, 301)
A_xg[..., b0:e0, b1:e1, b2:e2] = a_xg
r += 1
if broadcast:
self.comm.broadcast(A_xg, 0)
return A_xg
def distribute(self, B_xg, b_xg):
"""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.
"""
if self.comm.size == 1:
b_xg[:] = B_xg
return
if self.rank != 0:
self.comm.receive(b_xg, 0, 42)
return
else:
parsize_c = self.parsize_c
requests = []
r = 0
for n0 in range(parsize_c[0]):
b0, e0 = self.n_cp[0][n0:n0 + 2] - self.beg_c[0]
for n1 in range(parsize_c[1]):
b1, e1 = self.n_cp[1][n1:n1 + 2] - self.beg_c[1]
for n2 in range(parsize_c[2]):
b2, e2 = self.n_cp[2][n2:n2 + 2] - self.beg_c[2]
if r != 0:
a_xg = B_xg[..., b0:e0, b1:e1, b2:e2].copy()
request = self.comm.send(a_xg, r, 42, NONBLOCKING)
# Remember to store a reference to the
# send buffer (a_xg) so that is isn't
# deallocated:
requests.append((request, a_xg))
else:
b_xg[:] = B_xg[..., b0:e0, b1:e1, b2:e2]
r += 1
for request, a_xg in requests:
self.comm.wait(request)
def zero_pad(self, a_xg):
"""Pad array with zeros as first element along non-periodic directions.
Should only be invoked on global arrays.
"""
assert np.all(a_xg.shape[-3:] == (self.N_c + self.pbc_c - 1))
if self.pbc_c.all():
return a_xg
npbx, npby, npbz = 1 - self.pbc_c
b_xg = np.zeros(a_xg.shape[:-3] + tuple(self.N_c), dtype=a_xg.dtype)
b_xg[..., npbx:, npby:, npbz:] = a_xg
return b_xg
def calculate_dipole_moment(self, rho_g):
"""Calculate dipole moment of density."""
rho_01 = rho_g.sum(axis=2)
rho_02 = rho_g.sum(axis=1)
rho_cg = [rho_01.sum(axis=1), rho_01.sum(axis=0), rho_02.sum(axis=0)]
rhog_c = [np.dot(np.arange(self.beg_c[c], self.end_c[c]), rho_cg[c])
for c in range(3)]
d_c = -np.dot(rhog_c, self.h_cv) * self.dv
self.comm.sum(d_c)
return d_c
def wannier_matrix(self, psit_nG, psit_nG1, G_c, nbands=None):
"""Wannier localization integrals
The soft part of Z is given by (Eq. 27 ref1)::
~ ~ -i G.r ~
Z =
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)
"""
if nbands is None:
nbands = len(psit_nG)
if nbands == 0:
return np.zeros((0, 0), complex)
e_G = np.exp(-2j * pi * np.dot(np.indices(self.n_c).T +
self.beg_c, G_c / self.N_c).T)
a_nG = (e_G * psit_nG[:nbands].conj()).reshape((nbands, -1))
return np.inner(a_nG,
psit_nG1[:nbands].reshape((nbands, -1))) * self.dv
def find_center(self, a_R):
"""Calculate center of positive function."""
assert self.orthogonal
r_vR = self.get_grid_point_coordinates()
a_R = a_R.astype(complex)
center = []
for L, r_R in zip(self.cell_cv.diagonal(), r_vR):
z = self.integrate(a_R, np.exp(2j * pi / L * r_R))
center.append(np.angle(z) / (2 * pi) * L % L)
return np.array(center)
def bytecount(self, dtype=float):
"""Get the number of bytes used by a grid of specified dtype."""
return int(np.prod(self.n_c)) * np.array(1, dtype).itemsize
def get_grid_point_coordinates(self, dtype=float, global_array=False):
"""Construct cartesian coordinates of grid points in the domain."""
r_vG = np.dot(np.indices(self.n_c, dtype).T + self.beg_c,
self.h_cv).T.copy()
if global_array:
return self.collect(r_vG, broadcast=True) # XXX waste!
else:
return r_vG
def get_grid_point_distance_vectors(self, r_v, mic=True, dtype=float):
"""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
"""
s_Gc = (np.indices(self.n_c, dtype).T + self.beg_c) / self.N_c
cell_cv = self.N_c * self.h_cv
s_Gc -= np.linalg.solve(cell_cv.T, r_v)
if mic:
# XXX do the correction twice works better
s_Gc -= self.pbc_c * (2 * s_Gc).astype(int)
s_Gc -= self.pbc_c * (2 * s_Gc).astype(int)
# sanity check
assert((s_Gc * self.pbc_c >= -0.5).all())
assert((s_Gc * self.pbc_c <= 0.5).all())
return np.dot(s_Gc, cell_cv).T.copy()
def interpolate_grid_points(self, spos_nc, vt_g, target_n, use_mlsqr=True):
"""Return interpolated values.
Calculate interpolated values from array vt_g based on the
scaled coordinates on spos_c.
Uses moving least squares algorithm by default, or otherwise
trilinear interpolation.
This doesn't work in parallel, since it would require
communication between neighbouring grid. """
assert mpi.world.size == 1
if use_mlsqr:
mlsqr(3, 2.3, spos_nc, self.N_c, self.beg_c, vt_g, target_n)
else:
for n, spos_c in enumerate(spos_nc):
g_c = self.N_c * spos_c - self.beg_c
# The begin and end of the array slice
bg_c = np.floor(g_c).astype(int)
Bg_c = np.ceil(g_c).astype(int)
# The coordinate within the box (bottom left = 0,
# top right = h_c)
dg_c = g_c - bg_c
Bg_c %= self.N_c
target_n[n] = (
vt_g[bg_c[0], bg_c[1], bg_c[2]] *
(1.0 - dg_c[0]) * (1.0 - dg_c[1]) * (1.0 - dg_c[2]) +
vt_g[Bg_c[0], bg_c[1], bg_c[2]] *
(0.0 + dg_c[0]) * (1.0 - dg_c[1]) * (1.0 - dg_c[2]) +
vt_g[bg_c[0], Bg_c[1], bg_c[2]] *
(1.0 - dg_c[0]) * (0.0 + dg_c[1]) * (1.0 - dg_c[2]) +
vt_g[Bg_c[0], Bg_c[1], bg_c[2]] *
(0.0 + dg_c[0]) * (0.0 + dg_c[1]) * (1.0 - dg_c[2]) +
vt_g[bg_c[0], bg_c[1], Bg_c[2]] *
(1.0 - dg_c[0]) * (1.0 - dg_c[1]) * (0.0 + dg_c[2]) +
vt_g[Bg_c[0], bg_c[1], Bg_c[2]] *
(0.0 + dg_c[0]) * (1.0 - dg_c[1]) * (0.0 + dg_c[2]) +
vt_g[bg_c[0], Bg_c[1], Bg_c[2]] *
(1.0 - dg_c[0]) * (0.0 + dg_c[1]) * (0.0 + dg_c[2]) +
vt_g[Bg_c[0], Bg_c[1], Bg_c[2]] *
(0.0 + dg_c[0]) * (0.0 + dg_c[1]) * (0.0 + dg_c[2]))
def __eq__(self, other):
return (self.dv == other.dv and
(self.h_cv == other.h_cv).all() and
(self.N_c == other.N_c).all() and
(self.n_c == other.n_c).all() and
(self.beg_c == other.beg_c).all() and
(self.end_c == other.end_c).all())
gpaw-0.11.0.13004/gpaw/response/ 0000775 0001750 0001750 00000000000 12553644063 016247 5 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/response/df.py 0000664 0001750 0001750 00000067046 12553643470 017230 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import os
import sys
import pickle
from math import pi
import numpy as np
from ase.units import Hartree, Bohr
import gpaw.mpi as mpi
from gpaw.response.chi0 import Chi0
from gpaw.response.kernel2 import calculate_Kxc, truncated_coulomb
from gpaw.response.wstc import WignerSeitzTruncatedCoulomb
class DielectricFunction:
"""This class defines dielectric function related physical quantities."""
def __init__(self, calc, name=None, frequencies=None, domega0=0.1,
omega2=10.0, omegamax=None, ecut=50, hilbert=True,
nbands=None, eta=0.2, ftol=1e-6, threshold=1,
intraband=True, nblocks=1, world=mpi.world, txt=sys.stdout,
gate_voltage=None, truncation=None, disable_point_group=False,
disable_time_reversal=False, use_more_memory=1,
unsymmetrized=True):
"""Creates a DielectricFunction object.
calc: str
The groundstate calculation file that the linear response
calculation is based on.
name: str
If defined, save the density-density response function to::
name + '%+d%+d%+d.pckl' % tuple((q_c * kd.N_c).round())
where q_c is the reduced momentum and N_c is the number of
kpoints along each direction.
frequencies: np.ndarray
Specification of frequency grid. If not set the non-linear
frequency grid is used.
domega0: float
Frequency grid spacing for non-linear frequency grid at omega = 0.
omega2: float
Frequency at which the non-linear frequency grid has doubled
the spacing.
omegamax: float
The upper frequency bound for the non-linear frequency grid.
ecut: float
Plane-wave cut-off.
hilbert: bool
Use hilbert transform.
nbands: int
Number of bands from calc.
eta: float
Broadening parameter.
ftol: float
Threshold for including close to equally occupied orbitals,
f_ik - f_jk > ftol.
threshold: float
Threshold for matrix elements in optical response perturbation
theory.
intraband: bool
Include intraband transitions.
world: comm
mpi communicator.
nblocks: int
Split matrices in nblocks blocks and distribute them G-vectors or
frequencies over processes.
txt: str
Output file.
gate_voltage: float
Shift Fermi level of ground state calculation by the
specified amount.
truncation: str
'wigner-seitz' for Wigner Seitz truncated Coulomb
'2D' for regular truncation in the z-direction
"""
self.chi0 = Chi0(calc, frequencies, domega0=domega0,
omega2=omega2, omegamax=omegamax,
ecut=ecut, hilbert=hilbert, nbands=nbands,
eta=eta, ftol=ftol, threshold=threshold,
intraband=intraband, world=world, nblocks=nblocks,
txt=txt, gate_voltage=gate_voltage,
disable_point_group=disable_point_group,
disable_time_reversal=disable_time_reversal,
use_more_memory=use_more_memory,
unsymmetrized=unsymmetrized)
self.name = name
self.omega_w = self.chi0.omega_w
nw = len(self.omega_w)
world = self.chi0.world
self.mynw = (nw + world.size - 1) // world.size
self.w1 = min(self.mynw * world.rank, nw)
self.w2 = min(self.w1 + self.mynw, nw)
self.truncation = truncation
def calculate_chi0(self, q_c):
"""Calculates the density response function.
Calculate the density response function for a specific momentum.
q_c: [float, float, float]
The momentum wavevector.
"""
if self.name:
kd = self.chi0.calc.wfs.kd
name = self.name + '%+d%+d%+d.pckl' % tuple((q_c * kd.N_c).round())
if os.path.isfile(name):
return self.read(name)
pd, chi0_wGG, chi0_wxvG, chi0_wvv = self.chi0.calculate(q_c)
chi0_wGG = self.chi0.distribute_frequencies(chi0_wGG)
self.chi0.timer.write(self.chi0.fd)
if self.name:
self.write(name, pd, chi0_wGG, chi0_wxvG, chi0_wvv)
return pd, chi0_wGG, chi0_wxvG, chi0_wvv
def write(self, name, pd, chi0_wGG, chi0_wxvG, chi0_wvv):
nw = len(self.omega_w)
nG = pd.ngmax
world = self.chi0.world
if world.rank == 0:
fd = open(name, 'wb')
pickle.dump((self.omega_w, pd, None, chi0_wxvG, chi0_wvv),
fd, pickle.HIGHEST_PROTOCOL)
for chi0_GG in chi0_wGG:
pickle.dump(chi0_GG, fd, pickle.HIGHEST_PROTOCOL)
tmp_wGG = np.empty((self.mynw, nG, nG), complex)
w1 = self.mynw
for rank in range(1, world.size):
w2 = min(w1 + self.mynw, nw)
world.receive(tmp_wGG[:w2 - w1], rank)
for w in range(w2 - w1):
pickle.dump(tmp_wGG[w], fd, pickle.HIGHEST_PROTOCOL)
w1 = w2
fd.close()
else:
world.send(chi0_wGG, 0)
def read(self, name):
print('Reading from', name, file=self.chi0.fd)
fd = open(name, 'rb')
omega_w, pd, chi0_wGG, chi0_wxvG, chi0_wvv = pickle.load(fd)
assert np.allclose(omega_w, self.omega_w)
world = self.chi0.world
nw = len(omega_w)
nG = pd.ngmax
if chi0_wGG is not None:
# Old file format:
chi0_wGG = chi0_wGG[self.w1:self.w2].copy()
else:
if world.rank == 0:
chi0_wGG = np.empty((self.mynw, nG, nG), complex)
for chi0_GG in chi0_wGG:
chi0_GG[:] = pickle.load(fd)
tmp_wGG = np.empty((self.mynw, nG, nG), complex)
w1 = self.mynw
for rank in range(1, world.size):
w2 = min(w1 + self.mynw, nw)
for w in range(w2 - w1):
tmp_wGG[w] = pickle.load(fd)
world.send(tmp_wGG[:w2 - w1], rank)
w1 = w2
else:
chi0_wGG = np.empty((self.w2 - self.w1, nG, nG), complex)
world.receive(chi0_wGG, 0)
return pd, chi0_wGG, chi0_wxvG, chi0_wvv
def collect(self, a_w):
world = self.chi0.world
b_w = np.zeros(self.mynw, a_w.dtype)
b_w[:self.w2 - self.w1] = a_w
nw = len(self.omega_w)
A_w = np.empty(world.size * self.mynw, a_w.dtype)
world.all_gather(b_w, A_w)
return A_w[:nw]
def get_frequencies(self):
"""Return frequencies that Chi is evaluated on"""
return self.omega_w * Hartree
def get_chi(self, xc='RPA', q_c=[0, 0, 0], direction='x'):
""" Returns v^1/2 chi V^1/2"""
pd, chi0_wGG, chi0_wxvG, chi0_wvv = self.calculate_chi0(q_c)
G_G = pd.G2_qG[0]**0.5
nG = len(G_G)
if pd.kd.gamma:
G_G[0] = 1.0
if isinstance(direction, str):
d_v = {'x': [1, 0, 0],
'y': [0, 1, 0],
'z': [0, 0, 1]}[direction]
else:
d_v = direction
d_v = np.asarray(d_v) / np.linalg.norm(d_v)
W = slice(self.w1, self.w2)
chi0_wGG[:, 0] = np.dot(d_v, chi0_wxvG[W, 0])
chi0_wGG[:, :, 0] = np.dot(d_v, chi0_wxvG[W, 1])
chi0_wGG[:, 0, 0] = np.dot(d_v, np.dot(chi0_wvv[W], d_v).T)
G_G /= (4 * pi)**0.5
if self.truncation == 'wigner-seitz':
kernel = WignerSeitzTruncatedCoulomb(pd.gd.cell_cv,
self.chi0.calc.wfs.kd.N_c)
K_G = kernel.get_potential(pd)
K_G *= G_G**2
if pd.kd.gamma:
K_G[0] = 0.0
elif self.truncation == '2D':
K_G = truncated_coulomb(pd)
K_G *= G_G**2
if pd.kd.gamma:
K_G[0] = 0.0
else:
K_G = np.ones(nG)
K_GG = np.zeros((nG, nG), dtype=complex)
for i in range(nG):
K_GG[i, i] = K_G[i]
if xc != 'RPA':
R_av = self.chi0.calc.atoms.positions / Bohr
nt_sG = self.chi0.calc.density.nt_sG
Kxc_sGG = calculate_Kxc(pd, nt_sG, R_av, self.chi0.calc.wfs.setups,
self.chi0.calc.density.D_asp,
functional=xc)
K_GG += Kxc_sGG[0] * G_G * G_G[:, np.newaxis]
chi_wGG = []
for chi0_GG in chi0_wGG:
chi0_GG[:] = chi0_GG / G_G / G_G[:, np.newaxis]
chi_wGG.append(np.dot(np.linalg.inv(np.eye(nG) -
np.dot(chi0_GG, K_GG)),
chi0_GG))
return chi0_wGG, np.array(chi_wGG)
def get_dielectric_matrix(self, xc='RPA', q_c=[0, 0, 0],
direction='x', symmetric=True,
calculate_chi=False, q0=None,
add_intraband=True):
"""Returns the symmetrized dielectric matrix.
::
\tilde\epsilon_GG' = v^{-1/2}_G \epsilon_GG' v^{1/2}_G',
where::
epsilon_GG' = 1 - v_G * P_GG' and P_GG'
is the polarization.
::
In RPA: P = chi^0
In TDDFT: P = (1 - chi^0 * f_xc)^{-1} chi^0
The head of the inverse symmetrized dielectric matrix is equal
to the head of the inverse dielectric matrix (inverse dielectric
function)
"""
pd, chi0_wGG, chi0_wxvG, chi0_wvv = self.calculate_chi0(q_c)
G_G = pd.G2_qG[0]**0.5
nG = len(G_G)
if pd.kd.gamma:
G_G[0] = 1.0
if isinstance(direction, str):
d_v = {'x': [1, 0, 0],
'y': [0, 1, 0],
'z': [0, 0, 1]}[direction]
else:
d_v = direction
d_v = np.asarray(d_v) / np.linalg.norm(d_v)
W = slice(self.w1, self.w2)
if add_intraband:
chi0_wGG[:, 0] = np.dot(d_v, chi0_wxvG[W, 0])
chi0_wGG[:, :, 0] = np.dot(d_v, chi0_wxvG[W, 1])
chi0_wGG[:, 0, 0] = np.dot(d_v, np.dot(chi0_wvv[W], d_v).T)
if q0 is not None:
print('Restoring q dependence of head and wings of chi0')
chi0_wGG[:, 1:, 0] *= q0
chi0_wGG[:, 0, 1:] *= q0
chi0_wGG[:, 0, 0] *= q0**2
G_G[0] = q0
if self.truncation == 'wigner-seitz':
kernel = WignerSeitzTruncatedCoulomb(pd.gd.cell_cv,
self.chi0.calc.wfs.kd.N_c)
K_G = kernel.get_potential(pd)**0.5
if pd.kd.gamma:
K_G[0] = 0.0
elif self.truncation == '2D':
K_G = truncated_coulomb(pd, q0=q0)
if pd.kd.gamma and q0 is None:
K_G[0] = 0.0
else:
K_G = (4 * pi)**0.5 / G_G
if xc != 'RPA':
R_av = self.chi0.calc.atoms.positions / Bohr
nt_sG = self.chi0.calc.density.nt_sG
Kxc_sGG = calculate_Kxc(pd, nt_sG, R_av,
self.chi0.calc.wfs.setups,
self.chi0.calc.density.D_asp,
functional=xc)
if calculate_chi:
chi_wGG = []
for chi0_GG in chi0_wGG:
if xc == 'RPA':
P_GG = chi0_GG
else:
P_GG = np.dot(np.linalg.inv(np.eye(nG) -
np.dot(chi0_GG, Kxc_sGG[0])),
chi0_GG)
if symmetric:
e_GG = np.eye(nG) - P_GG * K_G * K_G[:, np.newaxis]
else:
K_GG = (K_G**2 * np.ones([nG, nG])).T
e_GG = np.eye(nG) - P_GG * K_GG
if calculate_chi:
K_GG = np.diag(K_G**2)
if xc != 'RPA':
K_GG += Kxc_sGG[0]
chi_wGG.append(np.dot(np.linalg.inv(np.eye(nG) -
np.dot(chi0_GG, K_GG)),
chi0_GG))
chi0_GG[:] = e_GG
# chi0_wGG is now the dielectric matrix
if not calculate_chi:
return chi0_wGG
else:
# chi_wGG is the full density response function..
return pd, chi0_wGG, np.array(chi_wGG)
def get_dielectric_function(self, xc='RPA', q_c=[0, 0, 0],
direction='x', filename='df.csv'):
"""Calculate the dielectric function.
Returns dielectric function without and with local field correction:
df_NLFC_w, df_LFC_w = DielectricFunction.get_dielectric_function()
"""
e_wGG = self.get_dielectric_matrix(xc, q_c, direction)
df_NLFC_w = np.zeros(len(e_wGG), dtype=complex)
df_LFC_w = np.zeros(len(e_wGG), dtype=complex)
for w, e_GG in enumerate(e_wGG):
df_NLFC_w[w] = e_GG[0, 0]
df_LFC_w[w] = 1 / np.linalg.inv(e_GG)[0, 0]
df_NLFC_w = self.collect(df_NLFC_w)
df_LFC_w = self.collect(df_LFC_w)
if filename is not None and mpi.rank == 0:
with open(filename, 'w') as fd:
for omega, nlfc, lfc in zip(self.omega_w * Hartree,
df_NLFC_w,
df_LFC_w):
print('%.6f, %.6f, %.6f, %.6f, %.6f' %
(omega, nlfc.real, nlfc.imag, lfc.real, lfc.imag),
file=fd)
return df_NLFC_w, df_LFC_w
def get_macroscopic_dielectric_constant(self, xc='RPA', direction='x'):
"""Calculate macroscopic dielectric constant.
Returns eM_NLFC and eM_LFC.
Macroscopic dielectric constant is defined as the real part
of dielectric function at w=0.
Parameters:
eM_LFC: float
Dielectric constant without local field correction. (RPA, ALDA)
eM2_NLFC: float
Dielectric constant with local field correction.
"""
fd = self.chi0.fd
print('', file=fd)
print('%s Macroscopic Dielectric Constant:' % xc, file=fd)
df_NLFC_w, df_LFC_w = self.get_dielectric_function(
xc=xc,
filename=None,
direction=direction)
eps0 = np.real(df_NLFC_w[0])
eps = np.real(df_LFC_w[0])
print(' %s direction' % direction, file=fd)
print(' Without local field: %f' % eps0, file=fd)
print(' Include local field: %f' % eps, file=fd)
return eps0, eps
def get_eels_spectrum(self, xc='RPA', q_c=[0, 0, 0],
direction='x', filename='eels.csv'):
"""Calculate EELS spectrum. By default, generate a file 'eels.csv'.
EELS spectrum is obtained from the imaginary part of the inverse
of dielectric function. Returns EELS spectrum without and with
local field corrections:
df_NLFC_w, df_LFC_w = DielectricFunction.get_eels_spectrum()
"""
# Calculate dielectric function
df_NLFC_w, df_LFC_w = self.get_dielectric_function(
xc=xc, q_c=q_c,
direction=direction,
filename=None)
Nw = df_NLFC_w.shape[0]
# Calculate eels
eels_NLFC_w = -(1 / df_NLFC_w).imag
eels_LFC_w = -(1 / df_LFC_w).imag
# Write to file
if filename is not None and mpi.rank == 0:
fd = open(filename, 'w')
print('# energy, eels_NLFC_w, eels_LFC_w', file=fd)
for iw in range(Nw):
print('%.6f, %.6f, %.6f' %
(self.chi0.omega_w[iw] * Hartree,
eels_NLFC_w[iw], eels_LFC_w[iw]), file=fd)
fd.close()
return eels_NLFC_w, eels_LFC_w
def get_polarizability(self, xc='RPA', direction='x',
filename='polarizability.csv', pbc=None):
"""Calculate the polarizability alpha.
In 3D the imaginary part of the polarizability is related to the
dielectric function by Im(eps_M) = 4 pi * Im(alpha). In systems
with reduced dimensionality the converged value of alpha is
independent of the cell volume. This is not the case for eps_M,
which is ill defined. A truncated Coulomb kernel will always give
eps_M = 1.0, whereas the polarizability maintains its structure.
By default, generate a file 'polarizability.csv'. The five colomns are:
frequency (eV), Real(alpha0), Imag(alpha0), Real(alpha), Imag(alpha)
alpha0 is the result without local field effects and the
dimension of alpha is \AA to the power of non-periodic directions
"""
cell_cv = self.chi0.calc.wfs.gd.cell_cv
if not pbc:
pbc_c = self.chi0.calc.atoms.pbc
else:
pbc_c = np.array(pbc)
if pbc_c.all():
V = 1.0
else:
V = np.abs(np.linalg.det(cell_cv[~pbc_c][:, ~pbc_c]))
if not self.truncation:
# Without truncation alpha is simply related to eps_M
df0_w, df_w = self.get_dielectric_function(xc=xc, q_c=[0, 0, 0],
filename=None,
direction=direction)
alpha_w = V * (df_w - 1.0) / (4 * pi)
alpha0_w = V * (df0_w - 1.0) / (4 * pi)
else:
# With truncation we need to calculate \chit = v^0.5*chi*v^0.5
print('Using truncated Coulomb interaction',
file=self.chi0.fd)
chi0_wGG, chi_wGG = self.get_chi(xc=xc, direction=direction)
alpha_w = -V * (chi_wGG[:, 0, 0]) / (4 * pi)
alpha0_w = -V * (chi0_wGG[:, 0, 0]) / (4 * pi)
alpha_w = self.collect(alpha_w)
alpha0_w = self.collect(alpha0_w)
Nw = len(alpha_w)
if filename is not None and mpi.rank == 0:
fd = open(filename, 'w')
for iw in range(Nw):
print('%.6f, %.6f, %.6f, %.6f, %.6f' %
(self.chi0.omega_w[iw] * Hartree,
alpha0_w[iw].real * Bohr**(sum(~pbc_c)),
alpha0_w[iw].imag * Bohr**(sum(~pbc_c)),
alpha_w[iw].real * Bohr**(sum(~pbc_c)),
alpha_w[iw].imag * Bohr**(sum(~pbc_c))), file=fd)
fd.close()
return alpha0_w * Bohr**(sum(~pbc_c)), alpha_w * Bohr**(sum(~pbc_c))
def check_sum_rule(self, spectrum=None):
"""Check f-sum rule.
It takes the y of a spectrum as an entry and it check its integral.
spectrum: np.ndarray
Input spectrum
"""
assert (self.omega_w[1:] - self.omega_w[:-1]).ptp() < 1e-10
fd = self.chi0.fd
if spectrum is None:
raise ValueError('No spectrum input ')
dw = self.chi0.omega_w[1] - self.chi0.omega_w[0]
N1 = 0
for iw in range(len(spectrum)):
w = iw * dw
N1 += spectrum[iw] * w
N1 *= dw * self.chi0.vol / (2 * pi**2)
print('', file=fd)
print('Sum rule:', file=fd)
nv = self.chi0.calc.wfs.nvalence
print('N1 = %f, %f %% error' % (N1, (N1 - nv) / nv * 100), file=fd)
def get_eigenmodes(self, q_c=[0, 0, 0], w_max=None, name=None,
eigenvalue_only=False, direction='x',
checkphase=True):
"""Plasmon eigenmodes as eigenvectors of the dielectric matrix."""
assert self.chi0.world.size == 1
pd, chi0_wGG, chi0_wxvG, chi0_wvv = self.calculate_chi0(q_c)
e_wGG = self.get_dielectric_matrix(xc='RPA', q_c=q_c,
direction=direction,
symmetric=False)
kd = pd.kd
# Get real space grid for plasmon modes:
r = pd.gd.get_grid_point_coordinates()
w_w = self.omega_w * Hartree
if w_max:
w_w = w_w[np.where(w_w < w_max)]
Nw = len(w_w)
nG = e_wGG.shape[1]
eig = np.zeros([Nw, nG], dtype=complex)
eig_all = np.zeros([Nw, nG], dtype=complex)
# Find eigenvalues and eigenvectors:
e_GG = e_wGG[0]
eig_all[0], vec = np.linalg.eig(e_GG)
eig[0] = eig_all[0]
vec_dual = np.linalg.inv(vec)
omega0 = np.array([])
eigen0 = np.array([], dtype=complex)
v_ind = np.zeros([0, r.shape[1], r.shape[2], r.shape[3]],
dtype=complex)
n_ind = np.zeros([0, r.shape[1], r.shape[2], r.shape[3]],
dtype=complex)
# Loop to find the eigenvalues that crosses zero
# from negative to positive values:
for i in np.array(range(1, Nw)):
e_GG = e_wGG[i] # epsilon_GG'(omega + d-omega)
eig_all[i], vec_p = np.linalg.eig(e_GG)
if eigenvalue_only:
continue
vec_dual_p = np.linalg.inv(vec_p)
overlap = np.abs(np.dot(vec_dual, vec_p))
index = list(np.argsort(overlap)[:, -1])
if len(np.unique(index)) < nG: # add missing indices
addlist = []
removelist = []
for j in range(nG):
if index.count(j) < 1:
addlist.append(j)
if index.count(j) > 1:
for l in range(1, index.count(j)):
removelist.append(
np.argwhere(np.array(index) == j)[l])
for j in range(len(addlist)):
index[removelist[j]] = addlist[j]
vec = vec_p[:, index]
vec_dual = vec_dual_p[index, :]
eig[i] = eig_all[i, index]
for k in [k for k in range(nG)
# Eigenvalue crossing:
if (eig[i - 1, k] < 0 and eig[i, k] > 0)]:
a = np.real((eig[i, k] - eig[i - 1, k]) /
(w_w[i] - w_w[i - 1]))
# linear interp for crossing point
w0 = np.real(-eig[i - 1, k]) / a + w_w[i - 1]
eig0 = a * (w0 - w_w[i - 1]) + eig[i - 1, k]
print('crossing found at w = %1.2f eV' % w0)
omega0 = np.append(omega0, w0)
eigen0 = np.append(eigen0, eig0)
# Fourier Transform:
qG = pd.get_reciprocal_vectors(add_q=True)
coef_G = np.diagonal(np.inner(qG, qG)) / (4 * pi)
qGr_R = np.inner(qG, r.T).T
factor = np.exp(1j * qGr_R)
v_temp = np.dot(factor, vec[:, k])
n_temp = np.dot(factor, vec[:, k] * coef_G)
if checkphase: # rotate eigenvectors in complex plane
integral = np.zeros([81])
phases = np.linspace(0, 2, 81)
for ip in range(81):
v_int = v_temp * np.exp(1j * pi * phases[ip])
integral[ip] = abs(np.imag(v_int)).sum()
phase = phases[np.argsort(integral)][0]
v_temp *= np.exp(1j * pi * phase)
n_temp *= np.exp(1j * pi * phase)
v_ind = np.append(v_ind, v_temp[np.newaxis, :], axis=0)
n_ind = np.append(n_ind, n_temp[np.newaxis, :], axis=0)
kd = self.chi0.calc.wfs.kd
if name is None and self.name:
name = (self.name + '%+d%+d%+d-eigenmodes.pckl' %
tuple((q_c * kd.N_c).round()))
elif name:
name = (name + '%+d%+d%+d-eigenmodes.pckl' %
tuple((q_c * kd.N_c).round()))
else:
name = '%+d%+d%+d-eigenmodes.pckl' % tuple((q_c * kd.N_c).round())
# Returns: real space grid, frequency grid,
# sorted eigenvalues, zero-crossing frequencies + eigenvalues,
# induced potential + density in real space.
if eigenvalue_only:
pickle.dump((r * Bohr, w_w, eig),
open(name, 'wb'), pickle.HIGHEST_PROTOCOL)
return r * Bohr, w_w, eig
else:
pickle.dump((r * Bohr, w_w, eig, omega0, eigen0,
v_ind, n_ind), open(name, 'wb'),
pickle.HIGHEST_PROTOCOL)
return r * Bohr, w_w, eig, omega0, eigen0, v_ind, n_ind
def get_spatial_eels(self, q_c=[0, 0, 0], direction='x',
w_max=None, filename='eels'):
"""Spatially resolved loss spectrum.
The spatially resolved loss spectrum is calculated as the inverse
fourier transform of ``VChiV = (eps^{-1}-I)V``::
EELS(w,r) = - Im [sum_{G,G'} e^{iGr} Vchi_{GG'}(w) V_G'e^{-iG'r}]
\delta(w-G\dot v_e )
Input parameters:
direction: 'x', 'y', or 'z'
The direction for scanning acroos the structure
(perpendicular to the electron beam) .
w_max: float
maximum frequency
filename: str
name of output
Returns: real space grid, frequency points, EELS(w,r)
"""
assert self.chi0.world.size == 1
pd, chi0_wGG, chi0_wxvG, chi0_wvv = self.calculate_chi0(q_c)
e_wGG = self.get_dielectric_matrix(xc='RPA', q_c=q_c,
symmetric=False)
r = pd.gd.get_grid_point_coordinates()
ix = r.shape[1] / 2
iy = r.shape[2] / 2
iz = r.shape[3] / 2
if direction == 'x':
r = r[:, :, iy, iz]
perpdir = [1, 2]
if direction == 'y':
r = r[:, ix, :, iz]
perpdir = [0, 2]
if direction == 'z':
r = r[:, ix, iy, :]
perpdir = [0, 1]
nG = e_wGG.shape[1]
Gvec = pd.G_Qv[pd.Q_qG[0]]
Glist = []
# Only use G-vectors that are zero along electron beam
# due to \delta(w-G\dot v_e )
for iG in range(nG):
if Gvec[iG, perpdir[0]] == 0 and Gvec[iG, perpdir[1]] == 0:
Glist.append(iG)
qG = Gvec[Glist] + pd.K_qv
w_w = self.omega_w * Hartree
if w_max:
w_w = w_w[np.where(w_w < w_max)]
Nw = len(w_w)
qGr = np.inner(qG, r.T).T
phase = np.exp(1j * qGr)
V_G = (4 * pi) / np.diagonal(np.inner(qG, qG))
phase2 = np.exp(-1j * qGr) * V_G
E_wrr = np.zeros([Nw, r.shape[1], r.shape[1]])
E_wr = np.zeros([Nw, r.shape[1]])
for i in range(Nw):
Vchi_GG = (np.linalg.inv(e_wGG[i, Glist, :][:, Glist]) -
np.eye(len(Glist)))
# Fourier transform:
E_wrr[i] = -np.imag(np.dot(np.dot(phase, Vchi_GG), phase2.T))
E_wr[i] = np.diagonal(E_wrr[i])
pickle.dump((r * Bohr, w_w, E_wr), open('%s.pickle' % filename, 'wb'),
pickle.HIGHEST_PROTOCOL)
return r * Bohr, w_w, E_wr
gpaw-0.11.0.13004/gpaw/response/kernel.py 0000664 0001750 0001750 00000047673 12553643470 020123 0 ustar jensj jensj 0000000 0000000 # -*- coding: utf-8
# In an attempt to appease epydoc and still have readable docstrings,
# the vertical bar | is represented by u'\u2758' in this module.
"""This module defines Coulomb and XC kernels for the response model.
"""
import numpy as np
#from math import sqrt, pi, sin, cos, exp
from gpaw.utilities.blas import gemmdot
from gpaw.xc import XC
from gpaw.sphere.lebedev import weight_n, R_nv
from gpaw.mpi import world, rank, size
from ase.dft.kpoints import monkhorst_pack
def v3D_Coulomb(qG):
"""Coulomb Potential in the 3D Periodic Case.
Periodic calculation, no cutoff.
::
v3D = 4 pi / |q+G|^2
"""
v_q = 1. / (qG**2).sum(axis=1)
return v_q
def v2D_Coulomb(qG, N_p, N_np, R):
"""Coulomb Potential in the 2D Periodic Case.
Slab/Surface/Layer calculation.
Cutoff in non-periodic N_np direction.
No cutoff in periodic N_p directions.
::
v2D = 4 pi/|q+G|^2 * [1 + exp(-|G_p|R)*[(G_n/|G_p|)*sin(G_n R)
- cos(G_n R)]
"""
G_nR = qG[:, N_np[0]] * R
G_pR = (qG[:, N_p[0]]**2 + qG[:, N_p[1]]**2)**0.5 * R
v_q = 1. / (qG**2).sum(axis=1)
v_q *= 1. + np.exp(-G_pR) * ((G_nR / G_pR) * np.sin(G_nR)
- np.cos(G_nR))
return v_q.astype(complex)
def v1D_Coulomb(qG, N_p, N_np, R):
"""Coulomb Potential in the 1D Periodic Case.
Nanotube/Nanowire/Atomic Chain calculation.
Cutoff in non-periodic N_np directions.
No cutoff in periodic N_p direction.
::
v1D = 4 pi/|q+G|^2 * [1 + |G_n|R J_1(|G_n|R) K_0(G_p R)
- G_p R J_0(|G_n| R) K_1(G_p R)]
"""
from scipy.special import j1, k0, j0, k1
G_nR = (qG[:, N_np[0]]**2 + qG[:, N_np[1]]**2)**0.5 * R
G_pR = abs(qG[:, N_p[0]]) * R
v_q = 1. / (qG**2).sum(axis=1)
v_q *= (1. + G_nR * j1(G_nR) * k0(G_pR)
- G_pR * j0(G_nR) * k1(G_pR))
return v_q
def v0D_Coulomb(qG, R):
"""Coulomb Potential in the 0D Non-Periodic Case
Isolated System/Molecule calculation.
Spherical cutoff in all directions.
::
v0D = 4 pi/|G|^2 * [1 - cos(|G|R)]
"""
qGR = ((qG.sum(axis=1))**2)**0.5 * R
v_q = 1. / (qG**2).sum(axis=1)
v_q *= 1. - np.cos(qGR)
return v_q
class BaseCoulombKernel:
"""This is an abstract class for calculating the Coulomb kernel.
"""
def __init__(self, vcut):
self.vcut = vcut
def v_Coulomb(self, qG):
"""Returns the Coulomb potential in k-space.
"""
pass
def calculate_Kc(self,
q_c,
Gvec_Gc,
bcell_cv,
integrate_gamma=False,
N_k=None,
symmetric=True):
"""Symmetric Coulomb kernel.
"""
pass
def calculate_Kc_q(self,
bcell_cv,
N_k,
q_qc=None,
Gvec_c=None,
N=100):
"""What does this do? XXX
"""
pass
class CoulombKernel3D(BaseCoulombKernel):
"""Class for calculating the Coulomb kernel for a 3D calculation.
vcut = [False, False, False].
"""
def v_Coulomb(self, qG):
"""Coulomb Potential in the 3D Periodic Case.
Periodic calculation, no cutoff.
"""
return v3D_Coulomb(qG)
class CoulombKernel2D(BaseCoulombKernel):
"""Class for calculating the Coulomb kernel for a 2D calculation.
Slab/Surface/Layer calculation.
vcut = [False, False, True].
Cutoff in non-periodic N_np direction.
No cutoff in periodic N_p directions.
R = 1/2 max cell[N_np].
"""
def __init__(self, vcut, cell):
# Periodic Directions
self.N_p = vcut.argsort()[:2]
# Non-Periodic Direction
self.N_np = vcut.argsort()[-1:]
# 2D Radial Cutoff is one half the cell dimension in Bohr
self.R = cell[self.N_np, self.N_np] / 2.
BaseCoulombKernel.__init__(self, vcut)
def v_Coulomb(self, qG):
"""Coulomb Potential in the 2D Periodic Case.
Slab/Surface/Layer calculation.
Cutoff in non-periodic N_np direction.
No cutoff in periodic N_p directions.
"""
return v2D_Coulomb(qG, self.N_p, self.N_np, self.R)
class CoulombKernel1D(BaseCoulombKernel):
"""Class for calculating the Coulomb kernel for a 1D calculation.
Nanotube/Nanowire/Atomic Chain calculation.
vcut = [False, True, True].
Cutoff in non-periodic N_np directions.
No cutoff in periodic N_p direction.
R = 1/2 max cell[N_np].
"""
def __init__(self, vcut, cell):
from scipy.special import j1, k0, j0, k1
# Periodic Direction
self.N_p = vcut.argsort()[:1]
# Non-Periodic Directions
self.N_np = vcut.argsort()[-2:]
# 2D Radial Cutoff is one half the cell dimension in Bohr
self.R = max(cell[self.N_np[0], self.N_np[0]],
cell[self.N_np[1], self.N_np[1]]) / 2.
self.j1 = j1
self.k0 = k0
self.j0 = j0
self.k1 = k1
BaseCoulombKernel.__init__(self, vcut)
def v_Coulomb(self, qG):
"""Coulomb Potential in the 1D Periodic Case.
Nanotube/Nanowire/Atomic Chain calculation.
Cutoff in non-periodic N_np directions.
No cutoff in periodic N_p direction.
"""
return v1D_Coulomb(qG, self.N_p, self.N_np, self.R)
class CoulombKernel0D(BaseCoulombKernel):
"""Class for calculating the Coulomb kernel for a 0D calculation.
Isolated System/Molecule calculation.
vcut = [True, True, True].
Spherical cutoff in all directions.
R = 1/2 max cell.
"""
def __init__(self, vcut, cell):
self.R = max(np.diag(cell)) / 2.
BaseCoulombKernel.__init__(self, vcut)
def v_Coulomb(self, qG):
"""Coulomb Potential in the 0D Non-Periodic Case
Isolated System/Molecule calculation.
Spherical cutoff in all directions.
"""
return v0D_Coulomb(qG, self.R)
class CoulombKernel(BaseCoulombKernel):
"""Class for calculating the Coulomb kernel.
vcut = None (Default).
Applies Coulomb cutoff in non-periodic directions.
vcut = '3D' => [False, False, False].
vcut = '2D' => [False, False, True].
vcut = '1D' => [False, True, True].
vcut = '0D' => [True, True, True].
vcut is a numpy arry of type bool of length 3.
"""
def __init__(self, vcut, pbc, cell):
if vcut is None:
vcut = pbc - True
elif isinstance(vcut, str):
# Assume vcut = 'nD', where n is number of periodic directions
# Should be deprecated
n_p = int(vcut[0])
vcut = np.ones(3, bool)
vcut[:n_p] = False
# 3D periodic case
if vcut.sum() == 0:
self.impl = CoulombKernel3D(vcut)
# 2D periodic case
elif vcut.sum() == 1:
self.impl = CoulombKernel2D(vcut, cell)
# 1D periodic case
elif vcut.sum() == 2:
self.impl = CoulombKernel1D(vcut, cell)
# 0D periodic case
elif vcut.sum() == 3:
self.impl = CoulombKernel0D(vcut, cell)
BaseCoulombKernel.__init__(self, vcut)
def v_Coulomb(self, qG):
"""Returns vcut dependent Coulomb potential.
Uses v_Coulomb as implemented in self.impl
"""
return self.impl.v_Coulomb(qG)
def calculate_Kc(self,
q_c,
Gvec_Gc,
bcell_cv,
integrate_gamma=False,
N_k=None,
symmetric=True):
"""Symmetric Coulomb kernel"""
if integrate_gamma:
assert N_k is not None
if (q_c == 0).all():
# Only to avoid dividing by zero below!
# The term is handled separately later
q_c = [1.e-12, 0., 0.]
qG_c = np.zeros((len(Gvec_Gc), 3))
qG_c[:, 0] = Gvec_Gc[:, 0] + q_c[0]
qG_c[:, 1] = Gvec_Gc[:, 1] + q_c[1]
qG_c[:, 2] = Gvec_Gc[:, 2] + q_c[2]
qG = np.dot(qG_c, bcell_cv)
# Calculate coulomb kernel
Kc_G = self.v_Coulomb(qG)
if integrate_gamma and np.abs(q_c).sum() < 1e-8:
bvol = np.abs(np.linalg.det(bcell_cv)) / (N_k[0] * N_k[1] * N_k[2])
R_q0 = (3. * bvol / (4. * np.pi))**(1. / 3.)
Kc_G[0] = 4. * np.pi * R_q0 / bvol
if symmetric:
Kc_G = np.array(Kc_G, np.complex)**0.5
Kc_G = np.outer(Kc_G.conj(), Kc_G)
return 4. * np.pi * Kc_G
else:
return 4. * np.pi * (Kc_G * np.ones([len(Kc_G), len(Kc_G)])).T
def calculate_Kc_q(self,
bcell_cv,
N_k,
q_qc=None,
Gvec_c=None,
N=100):
if q_qc is None:
q_qc = np.array([[1.e-12, 0., 0.]])
if Gvec_c is None:
Gvec_c = np.array([0, 0, 0])
bcell = bcell_cv.copy()
bcell[0] /= N_k[0]
bcell[1] /= N_k[1]
bcell[2] /= N_k[2]
bvol = np.abs(np.linalg.det(bcell))
gamma = np.where(np.sum(abs(q_qc), axis=1) < 1e-5)[0][0]
if (Gvec_c == 0).all():
q_qc = q_qc.copy()
# Just to avoid zero division
q_qc[gamma] = [0.001, 0., 0.]
q_qc[:, 0] += Gvec_c[0]
q_qc[:, 1] += Gvec_c[1]
q_qc[:, 2] += Gvec_c[2]
qG = np.dot(q_qc, bcell_cv)
K0_q = self.v_Coulomb(qG)
if (Gvec_c == 0).all():
R_q0 = (3. * bvol / (4. * np.pi))**(1. / 3.)
K0_q[gamma] = 4. * np.pi * R_q0 / bvol
bvol = np.abs(np.linalg.det(bcell))
# Integrated Coulomb kernel
qt_qc = monkhorst_pack((N, N, N))
qt_qcv = np.dot(qt_qc, bcell)
dv = bvol / len(qt_qcv)
K_q = np.zeros(len(q_qc), complex)
for i in range(len(q_qc)):
q = qt_qcv.copy() + qG[i]
v_q = v3D_Coulomb(q)
K_q[i] = np.sum(v_q) * dv / bvol
return 4. * np.pi * K_q, 4. * np.pi * K0_q
def calculate_Kc(q_c,
Gvec_Gc,
acell_cv,
bcell_cv,
pbc,
vcut=None,
integrate_gamma=False,
N_k=None,
symmetric=True):
"""Symmetric Coulomb kernel"""
if integrate_gamma:
assert N_k is not None
if (q_c == 0).all():
# Only to avoid dividing by zero below!
# The term is handled separately later
q_c = [1.e-12, 0., 0.]
#G_p = np.array(pbc, float)
#G_n = np.array([1,1,1]) - G_p
if vcut is None:
vcut = '3D'
G_p = np.array(pbc, bool).argsort()[-int(vcut[0]):]
G_n = np.array(pbc, bool).argsort()[:int(vcut[0])]
if vcut is None or vcut == '3D':
pass
elif vcut == '2D':
# R is half the length of cell in non-periodic direction
if pbc.all(): # G_n.sum() < 1e-8: # default dir is z
G_n = np.array([2]) # np.array([0,0,1])
G_p = np.array([0, 1]) # np.array([1,1,0])
acell_n = acell_cv[G_n, G_n]
R = max(acell_n) / 2.
elif vcut == '1D':
# R is the radius of the cylinder containing the cell.
if pbc.all(): # G_n.sum() < 1e-8:
raise ValueError('Check boundary condition ! ')
acell_n = acell_cv
R = max(acell_n[G_n[0], G_n[0]],
acell_n[G_n[1], G_n[1]]) / 2.
elif vcut == '0D':
# R is the minimum radius of a sphere containing the cell.
acell_n = acell_cv
R = min(acell_n[0, 0],
acell_n[1, 1],
acell_n[2, 2]) / 2.
else:
NotImplemented
qG_c = np.zeros((len(Gvec_Gc), 3))
qG_c[:, 0] = Gvec_Gc[:, 0] + q_c[0]
qG_c[:, 1] = Gvec_Gc[:, 1] + q_c[1]
qG_c[:, 2] = Gvec_Gc[:, 2] + q_c[2]
qG = np.dot(qG_c, bcell_cv)
# Calculate Coulomb kernel
if vcut is None or vcut == '3D':
Kc_G = v3D_Coulomb(qG)
elif vcut == '2D':
Kc_G = v2D_Coulomb(qG, G_p, G_n, R)
elif vcut == '1D':
Kc_G = v1D_Coulomb(qG, G_p, G_n, R)
elif vcut == '0D':
Kc_G = v0D_Coulomb(qG, R)
else:
NotImplemented
if integrate_gamma and np.abs(q_c).sum() < 1e-8:
bvol = np.abs(np.linalg.det(bcell_cv)) / (N_k[0] * N_k[1] * N_k[2])
R_q0 = (3. * bvol / (4. * np.pi))**(1. / 3.)
Kc_G[0] = 4. * np.pi * R_q0 / bvol
if symmetric:
#print "Kc_G"
#print Kc_G
Kc_G = np.array(Kc_G, np.complex)**0.5
#print "Kc_G^0.5"
#print Kc_GC
#print "Outer Product"
Kc_G = np.outer(Kc_G.conj(), Kc_G)
#print Kc_G
return 4. * np.pi * Kc_G # np.outer(Kc_G.conj(), Kc_G)
else:
return 4. * np.pi * (Kc_G * np.ones([len(Kc_G), len(Kc_G)])).T
def calculate_Kxc(gd,
nt_sG,
npw,
Gvec_Gc,
nG,
vol,
bcell_cv,
R_av,
setups,
D_asp,
functional='ALDA',
density_cut=None):
"""ALDA kernel"""
# The soft part
#assert np.abs(nt_sG[0].shape - nG).sum() == 0
if functional == 'ALDA_X':
x_only = True
A_x = -3. / 4. * (3. / np.pi)**(1. / 3.)
nspins = len(nt_sG)
assert nspins in [1, 2]
fxc_sg = nspins**(1. / 3.) * 4. / 9. * A_x * nt_sG**(-2. / 3.)
else:
assert len(nt_sG) == 1
x_only = False
fxc_sg = np.zeros_like(nt_sG)
xc = XC(functional[1:])
xc.calculate_fxc(gd, nt_sG, fxc_sg)
if density_cut is not None:
fxc_sg[np.where(nt_sG * len(nt_sG) < density_cut)] = 0.0
# FFT fxc(r)
nG0 = nG[0] * nG[1] * nG[2]
tmp_sg = [np.fft.fftn(fxc_sg[s]) * vol / nG0 for s in range(len(nt_sG))]
r_vg = gd.get_grid_point_coordinates()
Kxc_sGG = np.zeros((len(fxc_sg), npw, npw), dtype=complex)
for s in range(len(fxc_sg)):
for iG in range(npw):
for jG in range(npw):
dG_c = Gvec_Gc[iG] - Gvec_Gc[jG]
if (nG / 2 - np.abs(dG_c) > 0).all():
index = (dG_c + nG) % nG
Kxc_sGG[s, iG, jG] = tmp_sg[s][index[0],
index[1],
index[2]]
else: # not in the fft index
dG_v = np.dot(dG_c, bcell_cv)
dGr_g = gemmdot(dG_v, r_vg, beta=0.0)
Kxc_sGG[s, iG, jG] = gd.integrate(np.exp(-1j * dGr_g)
* fxc_sg[s])
# The PAW part
KxcPAW_sGG = np.zeros_like(Kxc_sGG)
dG_GGv = np.zeros((npw, npw, 3))
for iG in range(npw):
for jG in range(npw):
dG_c = Gvec_Gc[iG] - Gvec_Gc[jG]
dG_GGv[iG, jG] = np.dot(dG_c, bcell_cv)
for a, setup in enumerate(setups):
if rank == a % size:
rgd = setup.xc_correction.rgd
n_qg = setup.xc_correction.n_qg
nt_qg = setup.xc_correction.nt_qg
nc_g = setup.xc_correction.nc_g
nct_g = setup.xc_correction.nct_g
Y_nL = setup.xc_correction.Y_nL
dv_g = rgd.dv_g
D_sp = D_asp[a]
B_pqL = setup.xc_correction.B_pqL
D_sLq = np.inner(D_sp, B_pqL.T)
nspins = len(D_sp)
f_sg = rgd.empty(nspins)
ft_sg = rgd.empty(nspins)
n_sLg = np.dot(D_sLq, n_qg)
nt_sLg = np.dot(D_sLq, nt_qg)
# Add core density
n_sLg[:, 0] += np.sqrt(4. * np.pi) / nspins * nc_g
nt_sLg[:, 0] += np.sqrt(4. * np.pi) / nspins * nct_g
coefatoms_GG = np.exp(-1j * np.inner(dG_GGv, R_av[a]))
for n, Y_L in enumerate(Y_nL):
w = weight_n[n]
f_sg[:] = 0.0
n_sg = np.dot(Y_L, n_sLg)
if x_only:
f_sg = nspins * (4 / 9.) * A_x * (nspins * n_sg)**(-2 / 3.)
else:
xc.calculate_fxc(rgd, n_sg, f_sg)
ft_sg[:] = 0.0
nt_sg = np.dot(Y_L, nt_sLg)
if x_only:
ft_sg = nspins * (4 / 9.) * (A_x
* (nspins * nt_sg)**(-2 / 3.))
else:
xc.calculate_fxc(rgd, nt_sg, ft_sg)
for i in range(len(rgd.r_g)):
coef_GG = np.exp(-1j * np.inner(dG_GGv, R_nv[n])
* rgd.r_g[i])
for s in range(len(f_sg)):
KxcPAW_sGG[s] += w * np.dot(coef_GG,
(f_sg[s, i] -
ft_sg[s, i])
* dv_g[i]) * coefatoms_GG
world.sum(KxcPAW_sGG)
Kxc_sGG += KxcPAW_sGG
return Kxc_sGG / vol
def calculate_Kc_q(acell_cv,
bcell_cv,
pbc,
N_k,
vcut=None,
integrated=True,
q_qc=np.array([[1.e-12, 0., 0.]]),
Gvec_c=np.array([0, 0, 0]),
N=100):
# get cutoff parameters
#G_p = np.array(pbc, int)
# Normal Direction
#G_n = np.array([1,1,1]) - G_p
if vcut is None:
vcut = '3D'
G_p = np.array(pbc, bool).argsort()[-int(vcut[0]):]
G_n = np.array(pbc, bool).argsort()[:int(vcut[0])]
if vcut is None or vcut == '3D':
pass
elif vcut == '2D':
if pbc.all(): # G_n.sum() < 1e-8: # default dir is z
G_n = np.array([2])
G_p = np.array([0, 1])
acell_n = acell_cv[G_n, G_n]
R = max(acell_n) / 2.
elif vcut == '1D':
# R is the radius of the cylinder containing the cell.
if pbc.all(): # G_n.sum() < 1e-8:
raise ValueError('Check boundary condition ! ')
acell_n = acell_cv
R = max(acell_n[G_n[0], G_n[0]], acell_n[G_n[1], G_n[1]]) / 2.
elif vcut == '0D':
# R is the minimum radius of a sphere containing the cell.
acell_n = acell_cv
R = min(acell_n[0, 0], acell_n[1, 1], acell_n[2, 2]) / 2.
else:
NotImplemented
bcell = bcell_cv.copy()
bcell[0] /= N_k[0]
bcell[1] /= N_k[1]
bcell[2] /= N_k[2]
bvol = np.abs(np.linalg.det(bcell))
gamma = np.where(np.sum(abs(q_qc), axis=1) < 1e-5)[0][0]
if (Gvec_c[G_p] == 0).all():
q_qc[gamma][G_p[0]] = 1.e-12 # Just to avoid zero division
q_qc[:, 0] += Gvec_c[0]
q_qc[:, 1] += Gvec_c[1]
q_qc[:, 2] += Gvec_c[2]
qG = np.dot(q_qc, bcell_cv)
if vcut is None or vcut == '3D':
K0_q = v3D_Coulomb(qG)
if (Gvec_c == 0).all():
R_q0 = (3. * bvol / (4. * np.pi))**(1. / 3.)
K0_q[gamma] = 4. * np.pi * R_q0 / bvol
elif vcut == '2D':
K0_q = v2D_Coulomb(qG, G_p, G_n, R)
if (Gvec_c == 0).all():
R_q0 = (3 * bvol / (4. * np.pi))**(1. / 3.)
K0_q[gamma] = (4. * np.pi * R_q0 / bvol)
elif vcut == '1D':
K0_q = v1D_Coulomb(qG, G_p, G_n, R)
elif vcut == '0D':
K0_q = v0D_Coulomb(qG, R)
else:
NotImplemented
bvol = np.abs(np.linalg.det(bcell))
# Integrated Coulomb kernel
qt_qc = monkhorst_pack((N, N, N))
qt_qcv = np.dot(qt_qc, bcell)
dv = bvol / len(qt_qcv)
K_q = np.zeros(len(q_qc), complex)
for i in range(len(q_qc)):
q = qt_qcv.copy() + qG[i]
if vcut is None or vcut == '3D':
v_q = v3D_Coulomb(q)
elif vcut == '2D':
v_q = v2D_Coulomb(q, G_p, G_n, R)
elif vcut == '1D':
v_q = v1D_Coulomb(q, G_p, G_n, R)
elif vcut == '0D':
v_q = v0D_Coulomb(q, R)
else:
NotImplemented
K_q[i] = np.sum(v_q) * dv / bvol
return 4. * np.pi * K_q, 4. * np.pi * K0_q
gpaw-0.11.0.13004/gpaw/response/df0.py 0000664 0001750 0001750 00000102457 12553643470 017304 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import numpy as np
from math import sqrt, pi
import pickle
from ase.units import Hartree, Bohr
from gpaw.mpi import rank
from gpaw.response.chi import CHI
class DF(CHI):
"""This class defines dielectric function related physical quantities."""
def __init__(self,
calc=None,
nbands=None,
w=None,
q=None,
eshift=None,
ecut=10.,
density_cut=None,
G_plus_q=False,
eta=0.2,
rpad=None,
vcut=None,
ftol=1e-7,
txt=None,
xc='ALDA',
print_xc_scf=False,
hilbert_trans=True,
time_ordered=False,
optical_limit=False,
comm=None,
kcommsize=None):
CHI.__init__(self, calc=calc, nbands=nbands, w=w, q=q, eshift=eshift,
ecut=ecut, density_cut=density_cut,
G_plus_q=G_plus_q, eta=eta, rpad=rpad, vcut=vcut,
ftol=ftol, txt=txt, xc=xc, hilbert_trans=hilbert_trans,
time_ordered=time_ordered, optical_limit=optical_limit,
comm=comm, kcommsize=kcommsize)
self.df_flag = False
self.print_bootstrap = print_xc_scf
self.df1_w = None # NLF RPA
self.df2_w = None # LF RPA
self.df3_w = None # NLF ALDA
self.df4_w = None # LF ALDA
def get_dielectric_matrix(self,
xc='RPA',
overwritechi0=False,
symmetric=True,
chi0_wGG=None,
calc=None,
vcut=None,
dir=None):
if self.chi0_wGG is None and chi0_wGG is None:
self.initialize()
self.calculate()
elif self.chi0_wGG is None and chi0_wGG is not None:
#Read from file and reinitialize
self.xc = xc
from gpaw.response.parallel import par_read
self.chi0_wGG = par_read(chi0_wGG, 'chi0_wGG')
self.nvalbands = self.nbands
#self.parallel_init() # parallelization not yet implemented
self.Nw_local = self.Nw # parallelization not yet implemented
if self.calc is None:
from gpaw import GPAW
self.calc = GPAW(calc,txt=None)
if self.xc == 'ALDA' or self.xc == 'ALDA_X':
from gpaw.response.kernel import calculate_Kxc
from gpaw.grid_descriptor import GridDescriptor
from gpaw.mpi import world, rank, size, serial_comm
self.pbc = self.calc.atoms.pbc
self.gd = GridDescriptor(self.calc.wfs.gd.N_c*self.rpad, self.acell_cv,
pbc_c=True, comm=serial_comm)
R_av = self.calc.atoms.positions / Bohr
nt_sg = self.calc.density.nt_sG
if (self.rpad > 1).any() or (self.pbc - True).any():
nt_sG = self.gd.zeros(self.nspins)
#nt_sG = np.zeros([self.nspins, self.nG[0], self.nG[1], self.nG[2]])
for s in range(self.nspins):
nt_G = self.pad(nt_sg[s])
nt_sG[s] = nt_G
else:
nt_sG = nt_sg
self.Kxc_sGG = calculate_Kxc(self.gd,
nt_sG,
self.npw, self.Gvec_Gc,
self.gd.N_c, self.vol,
self.bcell_cv, R_av,
self.calc.wfs.setups,
self.calc.density.D_asp,
functional=self.xc,
density_cut=self.density_cut)
if overwritechi0:
dm_wGG = self.chi0_wGG
else:
dm_wGG = np.zeros_like(self.chi0_wGG)
if dir is None:
q_c = self.q_c
else:
q_c = np.diag((1,1,1))[dir] * self.qopt
self.chi0_wGG[:,0,:] = self.chi00G_wGv[:,:,dir]
self.chi0_wGG[:,:,0] = self.chi0G0_wGv[:,:,dir]
from gpaw.response.kernel import calculate_Kc, CoulombKernel
kernel = CoulombKernel(vcut=self.vcut,
pbc=self.calc.atoms.pbc,
cell=self.acell_cv)
self.Kc_GG = kernel.calculate_Kc(q_c,
self.Gvec_Gc,
self.bcell_cv,
symmetric=symmetric)
#self.Kc_GG = calculate_Kc(q_c,
# self.Gvec_Gc,
# self.acell_cv,
# self.bcell_cv,
# self.pbc,
# self.vcut,
# symmetric=symmetric)
tmp_GG = np.eye(self.npw, self.npw)
if xc == 'RPA':
self.printtxt('Use RPA.')
for iw in range(self.Nw_local):
dm_wGG[iw] = tmp_GG - self.Kc_GG * self.chi0_wGG[iw]
elif xc == 'ALDA':
self.printtxt('Use ALDA kernel.')
# E_LDA = 1 - v_c chi0 (1-fxc chi0)^-1
# http://prb.aps.org/pdf/PRB/v33/i10/p7017_1 eq. 4
A_wGG = self.chi0_wGG.copy()
for iw in range(self.Nw_local):
A_wGG[iw] = np.dot(self.chi0_wGG[iw], np.linalg.inv(tmp_GG - np.dot(self.Kxc_sGG[0], self.chi0_wGG[iw])))
for iw in range(self.Nw_local):
dm_wGG[iw] = tmp_GG - self.Kc_GG * A_wGG[iw]
return dm_wGG
def get_inverse_dielectric_matrix(self, xc='RPA'):
dm_wGG = self.get_dielectric_matrix(xc=xc)
dminv_wGG = np.zeros_like(dm_wGG)
for iw in range(self.Nw_local):
dminv_wGG[iw] = np.linalg.inv(dm_wGG[iw])
return dminv_wGG
def get_chi(self, xc='RPA'):
"""Solve Dyson's equation."""
if self.chi0_wGG is None:
self.initialize()
self.calculate()
else:
pass # read from file and re-initializing .... need to be implemented
kernel_GG = np.zeros((self.npw, self.npw), dtype=complex)
chi_wGG = np.zeros_like(self.chi0_wGG)
# Coulomb kernel
for iG in range(self.npw):
qG = np.dot(self.q_c + self.Gvec_Gc[iG], self.bcell_cv)
kernel_GG[iG,iG] = 4 * pi / np.dot(qG, qG)
if xc == 'ALDA':
kernel_GG += self.Kxc_sGG[0]
for iw in range(self.Nw_local):
tmp_GG = np.eye(self.npw, self.npw) - np.dot(self.chi0_wGG[iw], kernel_GG)
chi_wGG[iw] = np.dot(np.linalg.inv(tmp_GG) , self.chi0_wGG[iw])
return chi_wGG
def get_dielectric_function(self, xc='RPA', dir=None):
"""Calculate the dielectric function. Returns df1_w and df2_w.
Parameters:
df1_w: ndarray
Dielectric function without local field correction.
df2_w: ndarray
Dielectric function with local field correction.
"""
if not self.optical_limit:
assert dir is None
if self.df_flag is False:
dm_wGG = self.get_dielectric_matrix(xc=xc, dir=dir)
Nw_local = dm_wGG.shape[0]
dfNLF_w = np.zeros(Nw_local, dtype = complex)
dfLFC_w = np.zeros(Nw_local, dtype = complex)
df1_w = np.zeros(self.Nw, dtype = complex)
df2_w = np.zeros(self.Nw, dtype = complex)
for iw in range(Nw_local):
tmp_GG = dm_wGG[iw]
dfLFC_w[iw] = 1. / np.linalg.inv(tmp_GG)[0, 0]
dfNLF_w[iw] = tmp_GG[0, 0]
self.wcomm.all_gather(dfNLF_w, df1_w)
self.wcomm.all_gather(dfLFC_w, df2_w)
if xc == 'RPA':
self.df1_w = df1_w
self.df2_w = df2_w
elif xc=='ALDA' or xc=='ALDA_X':
self.df3_w = df1_w
self.df4_w = df2_w
if xc == 'RPA':
return self.df1_w, self.df2_w
elif xc == 'ALDA' or xc=='ALDA_X':
return self.df3_w, self.df4_w
def get_surface_response_function(self, z0=0., filename='surf_EELS'):
"""Calculate surface response function."""
if self.chi0_wGG is None:
self.initialize()
self.calculate()
g_w2 = np.zeros((self.Nw,2), dtype=complex)
assert self.acell_cv[0, 2] == 0. and self.acell_cv[1, 2] == 0.
Nz = self.gd.N_c[2] # number of points in z direction
tmp = np.zeros(Nz, dtype=int)
nGz = 0 # number of G_z
for i in range(self.npw):
if self.Gvec_Gc[i, 0] == 0 and self.Gvec_Gc[i, 1] == 0:
tmp[nGz] = self.Gvec_Gc[i, 2]
nGz += 1
assert (np.abs(self.Gvec_Gc[:nGz, :2]) < 1e-10).all()
for id, xc in enumerate(['RPA', 'ALDA']):
chi_wGG = self.get_chi(xc=xc)
# The first nGz are all Gx=0 and Gy=0 component
chi_wgg_LFC = chi_wGG[:, :nGz, :nGz]
del chi_wGG
chi_wzz_LFC = np.zeros((self.Nw_local, Nz, Nz), dtype=complex)
# Fourier transform of chi_wgg to chi_wzz
Gz_g = tmp[:nGz] * self.bcell_cv[2,2]
z_z = np.linspace(0, self.acell_cv[2,2]-self.gd.h_cv[2,2], Nz)
phase1_zg = np.exp(1j * np.outer(z_z, Gz_g))
phase2_gz = np.exp(-1j * np.outer(Gz_g, z_z))
for iw in range(self.Nw_local):
chi_wzz_LFC[iw] = np.dot(np.dot(phase1_zg, chi_wgg_LFC[iw]), phase2_gz)
chi_wzz_LFC /= self.acell_cv[2,2]
# Get surface response function
z_z -= z0 / Bohr
q_v = np.dot(self.q_c, self.bcell_cv)
qq = sqrt(np.inner(q_v, q_v))
phase1_1z = np.array([np.exp(qq*z_z)])
phase2_z1 = np.exp(qq*z_z)
tmp_w = np.zeros(self.Nw_local, dtype=complex)
for iw in range(self.Nw_local):
tmp_w[iw] = np.dot(np.dot(phase1_1z, chi_wzz_LFC[iw]), phase2_z1)[0]
tmp_w *= -2 * pi / qq * self.gd.h_cv[2,2]**2
g_w = np.zeros(self.Nw, dtype=complex)
self.wcomm.all_gather(tmp_w, g_w)
g_w2[:, id] = g_w
if rank == 0:
f = open(filename,'w')
for iw in range(self.Nw):
energy = iw * self.dw * Hartree
print(energy, np.imag(g_w2[iw, 0]), np.imag(g_w2[iw, 1]), file=f)
f.close()
# Wait for I/O to finish
self.comm.barrier()
def check_sum_rule(self, df1_w=None, df2_w=None):
"""Check f-sum rule."""
if df1_w is None:
df1_w = self.df1_w
df2_w = self.df2_w
N1 = N2 = 0
for iw in range(self.Nw):
w = iw * self.dw
N1 += np.imag(df1_w[iw]) * w
N2 += np.imag(df2_w[iw]) * w
N1 *= self.dw * self.vol / (2 * pi**2)
N2 *= self.dw * self.vol / (2 * pi**2)
self.printtxt('')
self.printtxt('Sum rule for ABS:')
nv = self.nvalence
self.printtxt('Without local field: N1 = %f, %f %% error' %(N1, (N1 - nv) / nv * 100) )
self.printtxt('Include local field: N2 = %f, %f %% error' %(N2, (N2 - nv) / nv * 100) )
N1 = N2 = 0
for iw in range(self.Nw):
w = iw * self.dw
N1 -= np.imag(1/df1_w[iw]) * w
N2 -= np.imag(1/df2_w[iw]) * w
N1 *= self.dw * self.vol / (2 * pi**2)
N2 *= self.dw * self.vol / (2 * pi**2)
self.printtxt('')
self.printtxt('Sum rule for EELS:')
nv = self.nvalence
self.printtxt('Without local field: N1 = %f, %f %% error' %(N1, (N1 - nv) / nv * 100) )
self.printtxt('Include local field: N2 = %f, %f %% error' %(N2, (N2 - nv) / nv * 100) )
def get_macroscopic_dielectric_constant(self, xc='RPA'):
"""Calculate macroscopic dielectric constant. Returns eM1 and eM2
Macroscopic dielectric constant is defined as the real part of dielectric function at w=0.
Parameters:
eM1: float
Dielectric constant without local field correction. (RPA, ALDA)
eM2: float
Dielectric constant with local field correction.
"""
assert self.optical_limit
self.printtxt('')
self.printtxt('%s Macroscopic Dielectric Constant:' % xc)
dirstr = ['x', 'y', 'z']
for dir in range(3):
eM = np.zeros(2)
df1, df2 = self.get_dielectric_function(xc=xc, dir=dir)
eps0 = np.real(df1[0])
eps = np.real(df2[0])
self.printtxt(' %s direction' %(dirstr[dir]))
self.printtxt(' Without local field: %f' % eps0 )
self.printtxt(' Include local field: %f' % eps )
return eps0, eps
def get_absorption_spectrum(self, filename='Absorption.dat'):
"""Calculate optical absorption spectrum. By default, generate a file 'Absorption.dat'.
Optical absorption spectrum is obtained from the imaginary part of dielectric function.
"""
assert self.optical_limit
for dir in range(3):
df1, df2 = self.get_dielectric_function(xc='RPA', dir=dir)
if self.xc == 'ALDA':
df3, df4 = self.get_dielectric_function(xc='ALDA', dir=dir)
if self.xc == 'ALDA_X':
df3, df4 = self.get_dielectric_function(xc='ALDA_X', dir=dir)
Nw = df1.shape[0]
if self.xc == 'Bootstrap':
# bootstrap doesnt support all direction spectra yet
from gpaw.response.fxc import Bootstrap
Kc_GG = np.zeros((self.npw, self.npw))
q_c = np.diag((1, 1, 1))[dir] * self.qopt
for iG in range(self.npw):
qG = np.dot(q_c + self.Gvec_Gc[iG], self.bcell_cv)
Kc_GG[iG,iG] = 4 * pi / np.dot(qG, qG)
from gpaw.mpi import world
assert self.wcomm.size == world.size
df3 = Bootstrap(self.chi0_wGG, Nw, Kc_GG, self.printtxt, self.print_bootstrap, self.wcomm)
if rank == 0:
f = open('%s.%s' % (filename, 'xyz'[dir]), 'w')
#f = open(filename+'.%s'%(dirstr[dir]),'w') # ????
for iw in range(Nw):
energy = iw * self.dw * Hartree
if self.xc == 'RPA':
print(energy, np.real(df1[iw]), np.imag(df1[iw]), \
np.real(df2[iw]), np.imag(df2[iw]), file=f)
elif self.xc == 'ALDA':
print(energy, np.real(df1[iw]), np.imag(df1[iw]), \
np.real(df2[iw]), np.imag(df2[iw]), \
np.real(df3[iw]), np.imag(df3[iw]), \
np.real(df4[iw]), np.imag(df4[iw]), file=f)
elif self.xc == 'Bootstrap':
print(energy, np.real(df1[iw]), np.imag(df1[iw]), \
np.real(df2[iw]), np.imag(df2[iw]), \
np.real(df3[iw]), np.imag(df3[iw]), file=f)
f.close()
# Wait for I/O to finish
self.comm.barrier()
def get_EELS_spectrum(self, filename='EELS.dat'):
"""Calculate EELS spectrum. By default, generate a file 'EELS.dat'.
EELS spectrum is obtained from the imaginary part of the inverse of dielectric function.
"""
# calculate RPA dielectric function
df1, df2 = self.get_dielectric_function(xc='RPA')
if self.xc == 'ALDA':
df3, df4 = self.get_dielectric_function(xc='ALDA')
Nw = df1.shape[0]
if rank == 0:
f = open(filename,'w')
for iw in range(self.Nw):
energy = iw * self.dw * Hartree
if self.xc == 'RPA':
print(energy, -np.imag(1./df1[iw]), -np.imag(1./df2[iw]), file=f)
elif self.xc == 'ALDA':
print(energy, -np.imag(1./df1[iw]), -np.imag(1./df2[iw]), \
-np.imag(1./df3[iw]), -np.imag(1./df4[iw]), file=f)
f.close()
# Wait for I/O to finish
self.comm.barrier()
def get_jdos(self, f_skn, e_skn, kd, kq, dw, Nw, sigma):
"""Calculate Joint density of states"""
JDOS_w = np.zeros(Nw)
nbands = f_skn[0].shape[1]
for k in range(kd.nbzkpts):
print(k)
ibzkpt1 = kd.bz2ibz_k[k]
ibzkpt2 = kd.bz2ibz_k[kq[k]]
for n in range(nbands):
for m in range(nbands):
focc = f_skn[0][ibzkpt1, n] - f_skn[0][ibzkpt2, m]
w0 = e_skn[0][ibzkpt2, m] - e_skn[0][ibzkpt1, n]
if focc > 0 and w0 >= 0:
w0_id = int(w0 / dw)
if w0_id + 1 < Nw:
alpha = (w0_id + 1 - w0/dw) / dw
JDOS_w[w0_id] += focc * alpha
alpha = (w0/dw-w0_id) / dw
JDOS_w[w0_id+1] += focc * alpha
w = np.arange(Nw) * dw * Hartree
return w, JDOS_w
def calculate_induced_density(self, q, w):
""" Evaluate induced density for a certain q and w.
Parameters:
q: ndarray
Momentum tranfer at reduced coordinate.
w: scalar
Energy (eV).
"""
if isinstance(w, int):
iw = w
w = self.wlist[iw] / Hartree
elif isinstance(w, float):
w /= Hartree
iw = int(np.round(w / self.dw))
else:
raise ValueError('Frequency not correct !')
self.printtxt('Calculating Induced density at q, w (iw)')
self.printtxt('(%f, %f, %f), %f(%d)' %(q[0], q[1], q[2], w*Hartree, iw))
# delta_G0
delta_G = np.zeros(self.npw)
delta_G[0] = 1.
# coef is (q+G)**2 / 4pi
coef_G = np.zeros(self.npw)
for iG in range(self.npw):
qG = np.dot(q + self.Gvec_Gc[iG], self.bcell_cv)
coef_G[iG] = np.dot(qG, qG)
coef_G /= 4 * pi
# obtain chi_G0(q,w)
dm_wGG = self.get_RPA_dielectric_matrix()
tmp_GG = dm_wGG[iw]
del dm_wGG
chi_G = (np.linalg.inv(tmp_GG)[:, 0] - delta_G) * coef_G
gd = self.gd
r = gd.get_grid_point_coordinates()
# calculate dn(r,q,w)
drho_R = gd.zeros(dtype=complex)
for iG in range(self.npw):
qG = np.dot(q + self.Gvec_Gc[iG], self.bcell_cv)
qGr_R = np.inner(qG, r.T).T
drho_R += chi_G[iG] * np.exp(1j * qGr_R)
# phase = sum exp(iq.R_i)
return drho_R
def get_induced_density_z(self, q, w):
"""Get induced density on z axis (summation over xy-plane). """
drho_R = self.calculate_induced_density(q, w)
drho_z = np.zeros(self.gd.N_c[2],dtype=complex)
# dxdy = np.cross(self.h_c[0], self.h_c[1])
for iz in range(self.gd.N_c[2]):
drho_z[iz] = drho_R[:,:,iz].sum()
return drho_z
def get_eigenmodes(self,filename = None, chi0 = None, calc = None, dm = None,
xc = 'RPA', sum = None, vcut = None, checkphase = False,
return_full = False):
"""
Calculate the plasmonic eigenmodes as eigenvectors of the dielectric matrix.
Parameters:
filename: pckl file
output from response calculation.
chi0: gpw file
chi0_wGG from response calculation.
calc: gpaw calculator instance
ground state calculator used in response calculation.
Wavefunctions only needed if chi0 is calculated from scratch
dm: gpw file
dielectric matrix from response calculation
xc: str 'RPA'or 'ALDA' XC- Kernel
sum: str
'2D': sum in the x and y directions
'1D': To be implemented
vcut: str '0D','1D' or '2D'
Cut the Coulomb potential
checkphase: Bool
if True, the eigenfunctions id rotated in the complex
plane, to be made as real as posible
return_full: Bool
if True, the eigenvectors in reciprocal space is also
returned.
"""
self.read(filename)
self.pbc = [1,1,1]
#self.calc.atoms.pbc = [1,1,1]
npw = self.npw
self.w_w = np.linspace(0, self.dw * (self.Nw - 1)*Hartree, self.Nw)
self.vcut = vcut
dm_wGG = self.get_dielectric_matrix(xc=xc,
symmetric=False,
chi0_wGG=chi0,
calc=calc,
vcut=vcut)
q = self.q_c
# get grid on which the eigenmodes are calculated
#gd = self.calc.wfs.gd
#r = gd.get_grid_point_coordinates()
#rrr = r*Bohr
from gpaw.utilities.gpts import get_number_of_grid_points
from gpaw.grid_descriptor import GridDescriptor
grid_size = [1,1,1]
h=0.2
cell_cv = self.acell_cv*np.diag(grid_size)
mode = 'fd'
realspace = True
h /= Bohr
N_c = get_number_of_grid_points(cell_cv, h, mode, realspace)
gd = GridDescriptor(N_c, cell_cv, self.pbc)
#gd = self.calc.wfs.gd
r = gd.get_grid_point_coordinates()
rrr = r*Bohr
eig_0 = np.array([], dtype = complex)
eig_left = np.array([], dtype = complex)
eig_right = np.array([], dtype = complex)
vec_modes = np.zeros([1, self.npw], dtype = complex)
vec_modes_dual = np.zeros([1, self.npw], dtype = complex)
vec_modes_density = np.zeros([1, self.npw], dtype = complex)
vec_modes_norm = np.zeros([1, self.npw], dtype = complex)
eig_all = np.zeros([1, self.npw], dtype = complex)
eig_dummy = np.zeros([1, self.npw], dtype = complex)
v_dummy = np.zeros([1, self.npw], dtype = complex)
vec_dummy = np.zeros([1, self.npw], dtype = complex)
vec_dummy2 = np.zeros([1, self.npw], dtype = complex)
w_0 = np.array([])
w_left = np.array([])
w_right = np.array([])
if sum == '2D':
v_ind = np.zeros([1, r.shape[-1]], dtype = complex)
n_ind = np.zeros([1, r.shape[-1]], dtype = complex)
elif sum == '1D':
self.printtxt('1D sum not implemented')
return
else:
v_ind = np.zeros([1, r.shape[1], r.shape[2], r.shape[3]], dtype = complex)
n_ind = np.zeros([1, r.shape[1], r.shape[2], r.shape[3]], dtype = complex)
eps_GG_plus = dm_wGG[0]
eig_plus, vec_plus = np.linalg.eig(eps_GG_plus) # find eigenvalues and eigenvectors
vec_plus_dual = np.linalg.inv(vec_plus)
# loop over frequencies, where the eigenvalues for the 2D matrix in G,G' are found.
for i in np.array(range(self.Nw-1))+1:
eps_GG = eps_GG_plus
eig, vec = eig_plus,vec_plus
vec_dual = vec_plus_dual
eps_GG_plus = dm_wGG[i] # epsilon_GG'(omega + d-omega)
eig_plus, vec_plus = np.linalg.eig(eps_GG_plus)
vec_plus_dual = np.linalg.inv(vec_plus)
eig_dummy[0,:] = eig
eig_all = np.append(eig_all, eig_dummy, axis=0) # append all eigenvalues to array
# loop to check find the eigenvalues that crosses zero from negative to positive values:
for k in range(self.npw):
for m in range(self.npw):
if eig[k]< 0 and 0 < eig_plus[m]:
# check it's the same mode - Overlap between eigenvectors should be large:
if abs(np.inner(vec[:,k], vec_plus_dual[m,:])) > 0.95:
self.printtxt('crossing found at w = %1.1f eV'%self.w_w[i-1])
eig_left = np.append(eig_left, eig[k])
eig_right = np.append(eig_right, eig_plus[m])
vec_dummy[0, :] = vec[:,k]
vec_modes = np.append(vec_modes, vec_dummy, axis = 0)
vec_dummy[0, :] = vec_dual[k, :].T
vec_modes_dual = np.append(vec_modes_dual, vec_dummy, axis = 0)
w1 = self.w_w[i-1]
w2 = self.w_w[i]
a = np.real((eig_plus[m]-eig[k]) / (w2-w1))
w0 = np.real(-eig[k]) / a + w1
eig0 = a*(w0-w1)+eig[k]
w_0 = np.append(w_0,w0)
w_left = np.append(w_left, w1)
eig_0 = np.append(eig_0,eig0)
n_dummy = np.zeros([1, r.shape[1], r.shape[2],
r.shape[3]], dtype = complex)
v_dummy = np.zeros([1, r.shape[1], r.shape[2],
r.shape[3]], dtype = complex)
vec_n = np.zeros([self.npw])
for iG in range(self.npw): # Fourier transform
qG = np.dot((q + self.Gvec_Gc[iG]), self.bcell_cv)
coef_G = np.dot(qG, qG) / (4 * pi)
qGr_R = np.inner(qG, r.T).T
v_dummy += vec[iG, k] * np.exp(1j * qGr_R)
n_dummy += vec[iG, k] * np.exp(1j * qGr_R) * coef_G
if checkphase: # rotate eigenvectors in complex plane
integral = np.zeros([81])
phases = np.linspace(0,2,81)
for ip in range(81):
v_int = v_dummy * np.exp(1j * pi * phases[ip])
integral[ip] = abs(np.imag(v_int)).sum()
phase = phases[np.argsort(integral)][0]
v_dummy *= np.exp(1j * pi * phase)
n_dummy *= np.exp(1j * pi * phase)
if sum == '2D':
i_xyz = 3
v_dummy_z = np.zeros([1,v_dummy.shape[i_xyz]],
dtype = complex)
n_dummy_z = np.zeros([1,v_dummy.shape[i_xyz]],
dtype = complex)
v_dummy_z[0,:] = np.sum(np.sum(v_dummy, axis = 1),
axis = 1)[0,:]
n_dummy_z[0,:] = np.sum(np.sum(n_dummy, axis = 1),
axis = 1)[0,:]
v_ind = np.append(v_ind, v_dummy_z, axis=0)
n_ind = np.append(n_ind, n_dummy_z, axis=0)
elif sum == '1D':
self.printtxt('1D sum not implemented')
else :
v_ind = np.append(v_ind, v_dummy, axis=0)
n_ind = np.append(n_ind, n_dummy, axis=0)
"""
returns: grid points, frequency grid, all eigenvalues, mode energies, left point energies,
mode eigenvalues, eigenvalues of left and right-side points,
(mode eigenvectors, mode dual eigenvectors,)
induced potential in real space, induced density in real space
"""
if return_full:
return rrr, self.w_w, eig_all[1:], w_0, eig_0, w_left, eig_left, \
eig_right, vec_modes[1:], vec_modes_dual[1:], v_ind[1:], n_ind[1:]
else:
return rrr, self.w_w, eig_all[1:], w_0, eig_0, v_ind[1:], n_ind[1:]
def project_chi_to_LCAO_pair_orbital(self, orb_MG):
nLCAO = orb_MG.shape[0]
N = np.zeros((self.Nw, nLCAO, nLCAO), dtype=complex)
kcoulinv_GG = np.zeros((self.npw, self.npw))
for iG in range(self.npw):
qG = np.dot(self.q_c + self.Gvec_Gc[iG], self.bcell_cv)
kcoulinv_GG[iG, iG] = np.dot(qG, qG)
kcoulinv_GG /= 4.*pi
dm_wGG = self.get_RPA_dielectric_matrix()
for mu in range(nLCAO):
for nu in range(nLCAO):
pairorb_R = orb_MG[mu] * orb_MG[nu]
if not (pairorb_R * pairorb_R.conj() < 1e-10).all():
tmp_G = np.fft.fftn(pairorb_R) * self.vol / self.nG0
pairorb_G = np.zeros(self.npw, dtype=complex)
for iG in range(self.npw):
index = self.Gindex[iG]
pairorb_G[iG] = tmp_G[index[0], index[1], index[2]]
for iw in range(self.Nw):
chi_GG = (dm_wGG[iw] - np.eye(self.npw)) * kcoulinv_GG
N[iw, mu, nu] = (np.outer(pairorb_G.conj(), pairorb_G) * chi_GG).sum()
# N[iw, mu, nu] = np.inner(pairorb_G.conj(),np.inner(pairorb_G, chi_GG))
return N
def write(self, filename, all=False):
"""Dump essential data"""
data = {'nbands': self.nbands,
'acell': self.acell_cv, #* Bohr,
'bcell': self.bcell_cv, #/ Bohr,
'h_cv' : self.gd.h_cv, #* Bohr,
'nG' : self.gd.N_c,
'nG0' : self.nG0,
'vol' : self.vol, #* Bohr**3,
'BZvol': self.BZvol, #/ Bohr**3,
'nkpt' : self.kd.nbzkpts,
'ecut' : self.ecut, #* Hartree,
'npw' : self.npw,
'eta' : self.eta, #* Hartree,
'ftol' : self.ftol,
'Nw' : self.Nw,
'NwS' : self.NwS,
'dw' : self.dw, # * Hartree,
'q_red': self.q_c,
'q_car': self.qq_v, # / Bohr,
'qmod' : np.dot(self.qq_v, self.qq_v), # / Bohr
'vcut' : self.vcut,
'pbc' : self.pbc,
'nvalence' : self.nvalence,
'hilbert_trans' : self.hilbert_trans,
'optical_limit' : self.optical_limit,
'e_skn' : self.e_skn, # * Hartree,
'f_skn' : self.f_skn,
'bzk_kc' : self.kd.bzk_kc,
'ibzk_kc' : self.kd.ibzk_kc,
'kq_k' : self.kq_k,
'Gvec_Gc' : self.Gvec_Gc,
'dfNLFRPA_w' : self.df1_w,
'dfLFCRPA_w' : self.df2_w,
'dfNLFALDA_w' : self.df3_w,
'dfLFCALDA_w' : self.df4_w,
'df_flag' : True}
if all:
from gpaw.response.parallel import par_write
par_write('chi0' + filename,'chi0_wGG',self.wcomm,self.chi0_wGG)
if rank == 0:
pickle.dump(data, open(filename, 'w'), -1)
self.comm.barrier()
def read(self, filename):
"""Read data from pickle file"""
data = pickle.load(open(filename))
self.nbands = data['nbands']
self.acell_cv = data['acell']
self.bcell_cv = data['bcell']
self.nG0 = data['nG0']
self.vol = data['vol']
self.BZvol = data['BZvol']
self.ecut = data['ecut']
self.npw = data['npw']
self.eta = data['eta']
self.ftol = data['ftol']
self.Nw = data['Nw']
self.NwS = data['NwS']
self.dw = data['dw']
self.q_c = data['q_red']
self.qq_v = data['q_car']
self.qmod = data['qmod']
#self.vcut = data['vcut']
#self.pbc = data['pbc']
self.hilbert_trans = data['hilbert_trans']
self.optical_limit = data['optical_limit']
self.e_skn = data['e_skn']
self.f_skn = data['f_skn']
self.nvalence= data['nvalence']
self.kq_k = data['kq_k']
self.Gvec_Gc = data['Gvec_Gc']
self.df1_w = data['dfNLFRPA_w']
self.df2_w = data['dfLFCRPA_w']
self.df3_w = data['dfNLFALDA_w']
self.df4_w = data['dfLFCALDA_w']
self.df_flag = data['df_flag']
self.printtxt('Read succesfully !')
gpaw-0.11.0.13004/gpaw/response/cell.py 0000664 0001750 0001750 00000004361 12553643470 017545 0 ustar jensj jensj 0000000 0000000 import numpy as np
from math import sqrt, pi
def get_primitive_cell(a, rpad=None):
"""From the unit cell, calculate primitive cell and volume. """
if rpad is None:
rpad = np.ones(3, int)
a = (a.T * rpad).T # ???
vol = np.abs(np.dot(a[0], np.cross(a[1], a[2])))
BZvol = (2. * pi)**3 / vol
b = np.linalg.inv(a.T)
b *= 2 * pi
assert np.abs((np.dot(b.T, a) - 2.*pi*np.eye(3)).sum()) < 1e-10
return a, b, vol, BZvol
def set_Gvectors(acell, bcell, nG, Ecut, q=[0., 0., 0.]):
"""Calculate the number of planewaves with a certain cutoff, their reduced coordinates and index."""
# Refer to R.Martin P85
Gmax = np.zeros(3, dtype=int)
Gcut = np.zeros(3, dtype=float)
for i in range(3):
a = acell[i]
Gcut[i] = sqrt(2*Ecut[i])
if Gcut[i] > 0:
Gmax[i] = sqrt(a[0]**2 + a[1]**2 + a[2]**2) * Gcut[i] / (2*pi) + 1
Nmax = np.ones([3], dtype = int)
for dim in range(3):
if Gcut[dim] > 0:
Nmax[dim] = 2 * Gmax[dim] + 2
#assert (nG - Nmax >=0).all() # to prevent too many planewaves
m = {}
for dim in range(3):
m[dim] = np.zeros(Nmax[dim],dtype=int)
for i in range(Nmax[dim]):
m[dim][i] = i
if m[dim][i] > np.int(Gmax[dim]):
m[dim][i] = i - Nmax[dim]
G = np.zeros((Nmax[0]*Nmax[1]*Nmax[2],3),dtype=int)
n = 0
for i in range(Nmax[0]):
for j in range(Nmax[1]):
for k in range(Nmax[2]):
tmp = np.array([m[0][i], m[1][j], m[2][k]])
tmpG = np.dot(tmp+np.array(q), bcell)
Gmod = 0
for dim in range(3):
if Gcut[dim] > 0:
Gmod += tmpG[dim]**2/Gcut[dim]**2
if Gmod < 1:
G[n] = tmp
n += 1
npw = n
Gvec = G[:n]
Gindex = np.zeros(npw, dtype=int)
id = np.zeros(3, dtype=int)
for iG in range(npw):
G = Gvec[iG]
for dim in range(3):
if G[dim] >= 0:
id[dim] = G[dim]
else:
id[dim] = nG[dim] - np.abs(G[dim])
Gindex[iG] = id[0]*nG[1]*nG[2] + id[1]*nG[2] + id[2]
return npw, Gvec, Gindex
gpaw-0.11.0.13004/gpaw/response/tool.py 0000664 0001750 0001750 00000012303 12553643470 017576 0 ustar jensj jensj 0000000 0000000 import numpy as np
from scipy.optimize import leastsq
import pylab as pl
def check_degenerate_bands(filename, etol):
from gpaw import GPAW
calc = GPAW(filename,txt=None)
print('Number of Electrons :', calc.get_number_of_electrons())
nibzkpt = calc.get_ibz_k_points().shape[0]
nbands = calc.get_number_of_bands()
print('Number of Bands :', nbands)
print('Number of ibz-kpoints :', nibzkpt)
e_kn = np.array([calc.get_eigenvalues(k) for k in range(nibzkpt)])
f_kn = np.array([calc.get_occupation_numbers(k) for k in range(nibzkpt)])
for k in range(nibzkpt):
for n in range(1,nbands):
if (f_kn[k,n-1] - f_kn[k,n] > 1e-5) and (np.abs(e_kn[k,n] - e_kn[k,n-1]) < etol):
print(k, n, e_kn[k,n], e_kn[k, n-1])
return
def get_orbitals(calc):
"""Get LCAO orbitals on 3D grid by lcao_to_grid method."""
bfs_a = [setup.phit_j for setup in calc.wfs.setups]
from gpaw.lfc import BasisFunctions
bfs = BasisFunctions(calc.wfs.gd, bfs_a, calc.wfs.kd.comm, cut=True)
spos_ac = calc.atoms.get_scaled_positions()
bfs.set_positions(spos_ac)
nLCAO = calc.get_number_of_bands()
orb_MG = calc.wfs.gd.zeros(nLCAO)
C_M = np.identity(nLCAO)
bfs.lcao_to_grid(C_M, orb_MG,q=-1)
return orb_MG
def find_peaks(x,y,threshold = None):
""" Find peaks for a certain curve.
Usage:
threshold = (xmin, xmax, ymin, ymax)
"""
assert isinstance(x, np.ndarray) and isinstance(y, np.ndarray)
assert x.ndim == 1 and y.ndim == 1
assert x.shape[0] == y.shape[0]
if threshold is None:
threshold = (x.min(), x.max(), y.min(), y.max())
if not isinstance(threshold, tuple):
threshold = (threshold, )
if len(threshold) == 1:
threshold += (x.max(), y.min(), y.max())
elif len(threshold) == 2:
threshold += (y.min(), y.max())
elif len(threshold) == 3:
threshold += (y.max(),)
else:
pass
xmin = threshold[0]
xmax = threshold[1]
ymin = threshold[2]
ymax = threshold[3]
peak = {}
npeak = 0
for i in range(1, x.shape[0]-1):
if (y[i] >= ymin and y[i] <= ymax and
x[i] >= xmin and x[i] <= xmax ):
if y[i] > y[i-1] and y[i] > y[i+1]:
peak[npeak] = np.array([x[i], y[i]])
npeak += 1
peakarray = np.zeros([npeak, 2])
for i in range(npeak):
peakarray[i] = peak[i]
return peakarray
def lorz_fit(x,y, npeak=1, initpara = None):
""" Fit curve using Lorentzian function
Note: currently only valid for one and two lorentizian
The lorentzian function is defined as::
A w
lorz = --------------------- + y0
(x-x0)**2 + w**2
where A is the peak amplitude, w is the width, (x0,y0) the peak position
Parameters:
x, y: ndarray
Input data for analyze
p: ndarray
Parameters for curving fitting function. [A, x0, y0, w]
p0: ndarray
Parameters for initial guessing. similar to p
"""
def residual(p, x, y):
err = y - lorz(x, p, npeak)
return err
def lorz(x, p, npeak):
if npeak == 1:
return p[0] * p[3] / ( (x-p[1])**2 + p[3]**2 ) + p[2]
if npeak == 2:
return ( p[0] * p[3] / ( (x-p[1])**2 + p[3]**2 ) + p[2]
+ p[4] * p[7] / ( (x-p[5])**2 + p[7]**2 ) + p[6] )
else:
raise ValueError('Larger than 2 peaks not supported yet!')
if initpara is None:
if npeak == 1:
initpara[i] = np.array([1., 0., 0., 0.1])
if npeak == 2:
initpara[i] = np.array([1., 0., 0., 0.1,
3., 0., 0., 0.1])
p0 = initpara
result = leastsq(residual, p0, args=(x, y), maxfev=2000)
yfit = lorz(x, result[0],npeak)
return yfit, result[0]
def linear_fit(x,y, initpara = None):
def residual(p, x, y):
err = y - linear(x, p)
return err
def linear(x, p):
return p[0]*x + p[1]
if initpara is None:
initpara = np.array([1.0,1.0])
p0 = initpara
result = leastsq(residual, p0, args=(x, y), maxfev=2000)
yfit = linear(x, result[0])
return yfit, result[0]
def plot_setfont():
params = {
'axes.labelsize': 18,
'text.fontsize': 18,
'legend.fontsize': 18,
'xtick.labelsize': 18,
'ytick.labelsize': 18,
'text.usetex': True}
# 'figure.figsize': fig_size}
pl.rcParams.update(params)
def plot_setticks(x=True, y=True):
pl.minorticks_on()
ax = pl.gca()
if x:
ax.xaxis.set_major_locator(pl.AutoLocator())
x_major = ax.xaxis.get_majorticklocs()
dx_minor = (x_major[-1]-x_major[0])/(len(x_major)-1) /5.
ax.xaxis.set_minor_locator(pl.MultipleLocator(dx_minor))
else:
pl.minorticks_off()
if y:
ax.yaxis.set_major_locator(pl.AutoLocator())
y_major = ax.yaxis.get_majorticklocs()
dy_minor = (y_major[-1]-y_major[0])/(len(y_major)-1) /5.
ax.yaxis.set_minor_locator(pl.MultipleLocator(dy_minor))
else:
pl.minorticks_off()
gpaw-0.11.0.13004/gpaw/response/gw0.py 0000664 0001750 0001750 00000003132 12553643470 017316 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import numpy as np
from gpaw.response.g0w0 import G0W0
class GW0(G0W0):
def __init__(self, calc, filename='gw0', **kwargs):
G0W0.__init__(self, calc, filename, savew=True, **kwargs)
try:
self.qp_xsin = np.load(filename + '-gw0.npy')
except IOError:
self.qp_xsin = np.empty((1,) + self.shape)
self.iteration = len(self.qp_xsin)
def get_k_point(self, s, K, n1, n2):
kpt = G0W0.get_k_point(self, s, K, n1, n2)
if self.iteration > 1:
b1, b2 = self.bands
m1 = max(b1, n1)
m2 = min(b2, n2)
if m2 > m1:
k = self.calc.wfs.kd.bz2ibz_k[K]
i = self.kpts.index(k)
qp_n = self.qp_xsin[-1, s, i, m1 - b1:m2 - b1]
kpt.eps_n[m1 - n1:m2 - n1] = qp_n
return kpt
def update_qp_energies(self):
print('Iteration:', self.iteration, file=self.fd)
if self.iteration == 1:
self.qp_xsin[0] = self.eps_sin
self.Z_sin = 1 / (1 - self.dsigma_sin)
self.qp_sin = self.eps_sin + self.Z_sin * (
self.sigma_sin + self.exx_sin -
self.vxc_sin)
self.iteration += 1
qp_xsin = np.empty((self.iteration,) + self.shape)
qp_xsin[:-1] = self.qp_xsin
qp_xsin[-1] = self.qp_sin
self.qp_xsin = qp_xsin
if self.world.rank == 0:
with open(self.filename + '.qp.npy', 'w') as fd:
np.save(fd, self.qp_xsin)
gpaw-0.11.0.13004/gpaw/response/bse.py 0000664 0001750 0001750 00000103270 12553643470 017376 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import pickle
from math import pi
from time import time, ctime
import numpy as np
from ase.io import write
from ase.units import Hartree
from ase.utils import opencew
from gpaw.response.df0 import DF
from gpaw.io.tar import Writer, Reader
from gpaw.response.base import BASECHI
from gpaw.utilities.memory import maxrss
from gpaw.blacs import BlacsGrid, Redistributor
from gpaw.mpi import world, size, rank, serial_comm
from gpaw.response.kernel import calculate_Kc, calculate_Kc_q
from gpaw.response.parallel import parallel_partition, gatherv
class BSE(BASECHI):
"""This class defines Bethe-Salpeter equations."""
def __init__(self,
calc=None,
nbands=None,
nc=None,
nv=None,
w=None,
q=None,
eshift=None,
ecut=10.,
eta=0.2,
gw_skn=None, # GW QP energies in Hartree
rpad=None,
vcut=None, # Coulomb cutoff only 2D works
ftol=1e-5,
txt=None,
optical_limit=None,
integrate_coulomb=None,
print_coulomb=False,
coupling=False, # False : use Tamm-Dancoff Approx
mode='BSE', # BSE, TDHF or RPA
kernel_file=None,#'W_qGG',
qsymm=True):
BASECHI.__init__(self, calc=calc, nbands=nbands, w=w, q=q,
eshift=eshift, ecut=ecut, eta=eta, rpad=rpad,
ftol=ftol, txt=txt, optical_limit=optical_limit)
assert mode in ['RPA', 'TDHF', 'BSE']
self.epsilon_w = None
self.coupling = coupling
self.vcut = vcut
self.nc = nc # conduction band index
self.nv = nv # valence band index
self.gw_skn = gw_skn
self.mode = mode
self.integrate_coulomb = integrate_coulomb
self.print_coulomb = print_coulomb
self.kernel_file = kernel_file
self.qsymm = qsymm
def initialize(self):
self.printtxt('----------------------------------------')
self.printtxt('Bethe-Salpeter Equation calculation')
self.printtxt('----------------------------------------')
self.printtxt('Started at: %s' % ctime())
self.printtxt('')
BASECHI.initialize(self)
assert self.nspins == 1
calc = self.calc
self.kd = kd = calc.wfs.kd
# frequency points init
self.dw = self.w_w[1] - self.w_w[0]
assert ((self.w_w[1:] - self.w_w[:-1] - self.dw) < 1e-10).all() # make sure its linear w grid
assert self.w_w.max() == self.w_w[-1]
self.dw /= Hartree
self.w_w /= Hartree
self.wmax = self.w_w[-1]
self.Nw = int(self.wmax / self.dw) + 1
# band init
if self.nc is None:
nv = self.nvalence / 2 - 1
self.nv = np.array([nv, nv+1]) # conduction band start / end
self.nc = np.array([nv+1, nv+2]) # valence band start / end
self.printtxt('')
self.printtxt('Number of electrons : %d' % (self.nvalence))
self.printtxt('Valence band included : (band %d to band %d)' %(self.nv[0], self.nv[1]-1))
self.printtxt('Conduction band included : (band %d to band %d)' %(self.nc[0], self.nc[1]-1))
if self.eshift is not None:
self.printtxt('Scissors operator : %2.3f eV' % self.eshift)
self.printtxt('')
# find the pair index and initialized pair energy (e_i - e_j) and occupation(f_i-f_j)
self.e_S = {}
focc_s = {}
self.Sindex_S3 = {}
iS = 0
kq_k = self.kq_k
for k1 in range(self.kd.nbzkpts):
ibzkpt1 = kd.bz2ibz_k[k1]
ibzkpt2 = kd.bz2ibz_k[kq_k[k1]]
for n1 in range(self.nv[0], self.nv[1]):
for m1 in range(self.nc[0], self.nc[1]):
focc = self.f_skn[0][ibzkpt1,n1] - self.f_skn[0][ibzkpt2,m1]
if self.coupling: # Dont use Tamm-Dancoff Approx.
check_ftol = np.abs(focc) > self.ftol
else:
check_ftol = focc > self.ftol
if check_ftol:
if self.gw_skn is None:
self.e_S[iS] = self.e_skn[0][ibzkpt2,m1] - self.e_skn[0][ibzkpt1,n1]
else:
self.e_S[iS] = self.gw_skn[0][ibzkpt2,m1] - self.gw_skn[0][ibzkpt1,n1]
focc_s[iS] = focc
self.Sindex_S3[iS] = (k1, n1, m1)
iS += 1
self.nS = iS
self.focc_S = np.zeros(self.nS)
for iS in range(self.nS):
self.focc_S[iS] = focc_s[iS]
# q points init
self.bzq_qc = kd.get_bz_q_points()
if not self.qsymm:
self.ibzq_qc = self.bzq_qc
else:
(self.ibzq_qc, self.ibzq_q, self.iop_q,
self.timerev_q, self.diff_qc) = kd.get_ibz_q_points(self.bzq_qc,
calc.wfs.kd.symmetry.op_scc)
if np.abs(self.bzq_qc - kd.bzk_kc).sum() < 1e-8:
assert np.abs(self.ibzq_qc - kd.ibzk_kc).sum() < 1e-8
self.nibzq = len(self.ibzq_qc)
# Parallel initialization
# kcomm and wScomm is only to be used when wavefunctions are distributed in parallel.
self.comm = self.Scomm = world
self.kcomm = world
self.wScomm = serial_comm
self.nS, self.nS_local, self.nS_start, self.nS_end = parallel_partition(
self.nS, world.rank, world.size, reshape=False)
self.print_bse()
if calc.input_parameters['mode'] == 'lcao':
calc.initialize_positions()
# Coulomb interaction at q=0 for Hartree coupling
### 2D z direction only !!!!!!!!!!!!!!!!!!!!!!
if self.integrate_coulomb is None:
self.integrate_coulomb = []
if self.vcut is None:
pass
elif self.vcut == '2D':
for iG in range(len(self.Gvec_Gc)):
if self.Gvec_Gc[iG, 0] == 0 and self.Gvec_Gc[iG, 1] == 0:
self.integrate_coulomb.append(iG)
else:
raise NotImplementedError
elif isinstance(self.integrate_coulomb, int):
self.integrate_coulomb = range(self.integrate_coulomb)
elif self.integrate_coulomb == 'all':
self.integrate_coulomb = range(len(self.Gvec_Gc))
elif isinstance(self.integrate_coulomb, list):
pass
else:
raise 'Invalid option for integrate_coulomb'
self.printtxt('')
self.printtxt('Calculating bare Coulomb kernel')
if not len(self.integrate_coulomb) == 0:
self.printtxt('Integrating Coulomb kernel at %s reciprocal lattice vector(s)' % len(self.integrate_coulomb))
# Coulomb interaction at problematic G's for exchange coupling
if len(self.integrate_coulomb) != 0:
self.vint_Gq = []
for iG in self.integrate_coulomb:
v_q, v0_q = calculate_Kc_q(self.acell_cv,
self.bcell_cv,
self.pbc,
self.kd.N_c,
vcut=self.vcut,
Gvec_c=self.Gvec_Gc[iG],
q_qc=self.ibzq_qc.copy())
self.vint_Gq.append(v_q)
if self.print_coulomb:
self.printtxt('')
self.printtxt('Average kernel relative to bare kernel - \int v(q)dq / v(q0): ')
self.printtxt(' G: % s' % self.Gvec_Gc[iG])
for iq in range(len(v_q)):
q_s = ' q = [%1.2f, %1.2f, %1.2f]: ' % (self.ibzq_qc[iq,0],
self.ibzq_qc[iq,1],
self.ibzq_qc[iq,2])
v_rel = v_q[iq] / v0_q[iq]
self.printtxt(q_s + '%1.3f' % v_rel)
self.printtxt('')
self.V_qGG = self.full_bare_interaction()
def calculate(self):
calc = self.calc
focc_S = self.focc_S
e_S = self.e_S
op_scc = calc.wfs.kd.symmetry.op_scc
# Get phi_qaGp
if self.mode == 'RPA':
self.phi_aGp = self.get_phi_aGp()
else:
fd = opencew('phi_qaGp')
if fd is None:
self.reader = Reader('phi_qaGp')
tmp = self.load_phi_aGp(self.reader, 0)[0]
assert len(tmp) == self.npw
self.printtxt('Finished reading phi_aGp')
else:
self.printtxt('Calculating phi_qaGp')
self.get_phi_qaGp()
world.barrier()
self.reader = Reader('phi_qaGp')
self.printtxt('Memory used %f M' % (maxrss() / 1024.**2))
self.printtxt('')
if self.optical_limit:
iq = np.where(np.sum(abs(self.ibzq_qc), axis=1) < 1e-5)[0][0]
else:
iq = np.where(np.sum(abs(self.ibzq_qc - self.q_c), axis=1) < 1e-5)[0][0]
kc_G = np.array([self.V_qGG[iq, iG, iG] for iG in range(self.npw)])
if self.optical_limit:
kc_G[0] = 0.
# Get screened Coulomb kernel
if self.mode == 'BSE':
try:
# Read
data = pickle.load(open(self.kernel_file+'.pckl'))
W_qGG = data['W_qGG']
assert np.shape(W_qGG) == np.shape(self.V_qGG)
self.printtxt('Finished reading screening interaction kernel')
except:
# Calculate from scratch
self.printtxt('Calculating screening interaction kernel.')
W_qGG = self.full_static_screened_interaction()
self.printtxt('')
else:
W_qGG = self.V_qGG
t0 = time()
self.printtxt('Calculating %s matrix elements' % self.mode)
# Calculate full kernel
K_SS = np.zeros((self.nS_local, self.nS), dtype=complex)
self.rhoG0_S = np.zeros(self.nS, dtype=complex)
#noGmap = 0
for iS in range(self.nS_start, self.nS_end):
k1, n1, m1 = self.Sindex_S3[iS]
rho1_G = self.density_matrix(n1,m1,k1)
self.rhoG0_S[iS] = rho1_G[0]
for jS in range(self.nS):
k2, n2, m2 = self.Sindex_S3[jS]
rho2_G = self.density_matrix(n2,m2,k2)
K_SS[iS-self.nS_start, jS] = np.sum(rho1_G.conj() * rho2_G * kc_G)
if not self.mode == 'RPA':
rho3_G = self.density_matrix(n1,n2,k1,k2)
rho4_G = self.density_matrix(m1,m2,self.kq_k[k1],
self.kq_k[k2])
q_c = self.kd.bzk_kc[k2] - self.kd.bzk_kc[k1]
q_c[np.where(q_c > 0.501)] -= 1.
q_c[np.where(q_c < -0.499)] += 1.
iq = self.kd.where_is_q(q_c, self.bzq_qc)
if not self.qsymm:
W_GG = W_qGG[iq]
else:
ibzq = self.ibzq_q[iq]
W_GG_tmp = W_qGG[ibzq]
iop = self.iop_q[iq]
timerev = self.timerev_q[iq]
diff_c = self.diff_qc[iq]
invop = np.linalg.inv(op_scc[iop])
Gindex = np.zeros(self.npw, dtype=int)
for iG in range(self.npw):
G_c = self.Gvec_Gc[iG]
if timerev:
RotG_c = -np.int8(np.dot(invop, G_c+diff_c).round())
else:
RotG_c = np.int8(np.dot(invop, G_c+diff_c).round())
tmp_G = np.abs(self.Gvec_Gc - RotG_c).sum(axis=1)
try:
Gindex[iG] = np.where(tmp_G < 1e-5)[0][0]
except:
#noGmap += 1
Gindex[iG] = -1
W_GG = np.zeros_like(W_GG_tmp)
for iG in range(self.npw):
for jG in range(self.npw):
if Gindex[iG] == -1 or Gindex[jG] == -1:
W_GG[iG, jG] = 0
else:
W_GG[iG, jG] = W_GG_tmp[Gindex[iG], Gindex[jG]]
if self.mode == 'BSE':
tmp_GG = np.outer(rho3_G.conj(), rho4_G) * W_GG
K_SS[iS-self.nS_start, jS] -= 0.5 * np.sum(tmp_GG)
else:
tmp_G = rho3_G.conj() * rho4_G * np.diag(W_GG)
K_SS[iS-self.nS_start, jS] -= 0.5 * np.sum(tmp_G)
self.timing(iS, t0, self.nS_local, 'pair orbital')
K_SS /= self.vol
world.sum(self.rhoG0_S)
#self.printtxt('Number of G indices outside the Gvec_Gc: %d' % noGmap)
# Get and solve Hamiltonian
H_sS = np.zeros_like(K_SS)
for iS in range(self.nS_start, self.nS_end):
H_sS[iS-self.nS_start,iS] = e_S[iS]
for jS in range(self.nS):
H_sS[iS-self.nS_start,jS] += focc_S[iS] * K_SS[iS-self.nS_start,jS]
# Force matrix to be Hermitian
if not self.coupling:
if world.size > 1:
H_Ss = self.redistribute_H(H_sS)
else:
H_Ss = H_sS
H_sS = (np.real(H_sS) + np.real(H_Ss.T)) / 2. + 1j * (np.imag(H_sS) - np.imag(H_Ss.T)) /2.
# Save H_sS matrix
self.par_save('H_SS','H_SS', H_sS)
return H_sS
def diagonalize(self, H_sS):
if self.coupling: # Non-Hermitian matrix can only use linalg.eig
self.printtxt('Use numpy.linalg.eig')
H_SS = np.zeros((self.nS, self.nS), dtype=complex)
if self.nS % world.size == 0:
world.all_gather(H_sS, H_SS)
else:
H_SS = gatherv(H_sS)
self.w_S, self.v_SS = np.linalg.eig(H_SS)
self.par_save('v_SS', 'v_SS', self.v_SS[self.nS_start:self.nS_end, :].copy())
else:
if world.size == 1:
self.printtxt('Use lapack.')
from gpaw.utilities.lapack import diagonalize
self.w_S = np.zeros(self.nS)
H_SS = H_sS
diagonalize(H_SS, self.w_S)
self.v_SS = H_SS.conj() # eigenvectors in the rows, transposed later
else:
self.printtxt('Use scalapack')
self.w_S, self.v_sS = self.scalapack_diagonalize(H_sS)
self.v_SS = self.v_sS # just use the same name
self.par_save('v_SS', 'v_SS', self.v_SS)
return
def par_save(self,filename, name, A_sS):
from gpaw.io import open
nS = self.nS
if rank == 0:
w = open(filename, 'w', world)
w.dimension('nS', nS)
if name == 'v_SS':
w.add('w_S', ('nS',), dtype=self.w_S.dtype)
w.fill(self.w_S)
w.add('rhoG0_S', ('nS',), dtype=complex)
w.fill(self.rhoG0_S)
w.add(name, ('nS', 'nS'), dtype=complex)
tmp = np.zeros_like(A_sS)
# Assumes that H_SS is written in order from rank 0 - rank N
for irank in range(size):
if irank == 0:
if rank == 0:
w.fill(A_sS)
else:
if rank == irank:
world.send(A_sS, 0, irank+100)
if rank == 0:
world.receive(tmp, irank, irank+100)
w.fill(tmp)
if rank == 0:
w.close()
world.barrier()
def par_load(self,filename, name):
from gpaw.io import open
r = open(filename, 'r')
nS = r.dimension('nS')
if name == 'v_SS':
self.w_S = r.get('w_S')
A_SS = np.zeros((self.nS_local, nS), dtype=complex)
for iS in range(self.nS_start, self.nS_end):
A_SS[iS-self.nS_start,:] = r.get(name, iS)
self.rhoG0_S = r.get('rhoG0_S')
r.close()
return A_SS
def full_static_screened_interaction(self):
"""Calcuate W_GG(q)"""
W_qGG = np.zeros((self.nibzq, self.npw, self.npw), dtype=complex)
t0 = time()
for iq in range(self.nibzq):
q = self.ibzq_qc[iq]
optical_limit = False
if np.abs(q).sum() < 1e-8:
q = np.array([0.0001, 0, 0])
optical_limit = True
df = DF(calc=self.calc,
q=q,
w=(0.,),
optical_limit=optical_limit,
nbands=self.nbands,
hilbert_trans=False,
eta=0.0001,
ecut=self.ecut*Hartree,
xc='RPA',
txt='df.out')
df.initialize()
df.calculate()
if optical_limit:
K_GG = self.V_qGG[iq].copy()
K0 = calculate_Kc(q,
self.Gvec_Gc,
self.acell_cv,
self.bcell_cv,
self.pbc,
vcut=self.vcut)[0,0]
for iG in range(1,self.npw):
K_GG[0, iG] = self.V_qGG[iq, iG, iG]**0.5 * K0**0.5
K_GG[iG, 0] = self.V_qGG[iq, iG, iG]**0.5 * K0**0.5
K_GG[0,0] = K0
df_GG = np.eye(self.npw, self.npw) - K_GG*df.chi0_wGG[0]
else:
df_GG = np.eye(self.npw, self.npw) - self.V_qGG[iq]*df.chi0_wGG[0]
dfinv_GG = np.linalg.inv(df_GG)
if optical_limit:
eps = 1/dfinv_GG[0,0]
self.printtxt(' RPA macroscopic dielectric constant is: %3.3f' % eps.real)
W_qGG[iq] = dfinv_GG * self.V_qGG[iq]
self.timing(iq, t0, self.nibzq, 'iq')
if rank == 0:
if self.kernel_file is not None:
data = {'W_qGG': W_qGG}
name = self.kernel_file+'.pckl'
pickle.dump(data, open(name, 'w'), -1)
return W_qGG
def full_bare_interaction(self):
"""Calculate V_GG(q)"""
V_qGG = np.zeros((self.nibzq, self.npw, self.npw), dtype=complex)
for iq in range(self.nibzq):
q = self.ibzq_qc[iq]
Vq_G = np.diag(calculate_Kc(q,
self.Gvec_Gc,
self.acell_cv,
self.bcell_cv,
self.pbc,
integrate_gamma=True,
N_k=self.kd.N_c,
vcut=self.vcut))**0.5
for i, iG in enumerate(self.integrate_coulomb):
Vq_G[iG] = self.vint_Gq[i][iq]**0.5
V_qGG[iq] = np.outer(Vq_G, Vq_G)
return V_qGG
def print_bse(self):
printtxt = self.printtxt
if not self.mode == 'RPA':
printtxt('Number of q points : %d' %(self.nibzq))
printtxt('Number of frequency points : %d' %(self.Nw) )
printtxt('Number of pair orbitals : %d' %(self.nS) )
printtxt('')
printtxt('Parallelization scheme:')
printtxt(' Total cpus : %d' %(world.size))
printtxt(' pair orb parsize : %d' %(self.Scomm.size))
return
def get_phi_qaGp(self):
N1_max = 0
N2_max = 0
natoms = len(self.calc.wfs.setups)
for id in range(natoms):
N1 = self.npw
N2 = self.calc.wfs.setups[id].ni**2
if N1 > N1_max:
N1_max = N1
if N2 > N2_max:
N2_max = N2
nbzq = self.kd.nbzkpts
nbzq, nq_local, q_start, q_end = parallel_partition(
nbzq, world.rank, world.size, reshape=False)
phimax_qaGp = np.zeros((nq_local, natoms, N1_max, N2_max), dtype=complex)
#phimax_qaGp = np.zeros((nbzq, natoms, N1_max, N2_max), dtype=complex)
t0 = time()
for iq in range(nq_local):
q_c = self.bzq_qc[iq + q_start]
tmp_aGp = self.get_phi_aGp(q_c, parallel=False)
for id in range(natoms):
N1, N2 = tmp_aGp[id].shape
phimax_qaGp[iq, id, :N1, :N2] = tmp_aGp[id]
self.timing(iq*world.size, t0, nq_local, 'iq')
world.barrier()
# Write to disk
filename = 'phi_qaGp'
if world.rank == 0:
w = Writer(filename)
w.dimension('nbzq', nbzq)
w.dimension('natoms', natoms)
w.dimension('nG', N1_max)
w.dimension('nii', N2_max)
w.add('phi_qaGp', ('nbzq', 'natoms', 'nG', 'nii',), dtype=complex)
for q in range(nbzq):
residual = nbzq % size
N_local = nbzq // size
if q < residual * (N_local + 1):
qrank = q // (N_local + 1)
else:
qrank = (q - residual * (N_local + 1)) // N_local + residual
if qrank == 0:
if world.rank == 0:
phi_aGp = phimax_qaGp[q - q_start]
else:
if world.rank == qrank:
phi_aGp = phimax_qaGp[q - q_start]
world.send(phi_aGp, 0, q)
elif world.rank == 0:
world.receive(phi_aGp, qrank, q)
if world.rank == 0:
w.fill(phi_aGp)
if world.rank == 0:
w.close()
world.barrier()
def load_phi_aGp(self, reader, iq):
phimax_aGp = np.array(reader.get('phi_qaGp', iq), complex)
phi_aGp = {}
natoms = len(phimax_aGp)
for a in range(natoms):
N1 = self.npw
N2 = self.calc.wfs.setups[a].ni**2
phi_aGp[a] = phimax_aGp[a, :N1, :N2]
return phi_aGp
def get_dielectric_function(self, filename='df.dat', readfile=None):
if self.epsilon_w is None:
self.initialize()
if readfile is None:
H_sS = self.calculate()
self.printtxt('Diagonalizing %s matrix.' % self.mode)
self.diagonalize(H_sS)
self.printtxt('Calculating dielectric function.')
elif readfile == 'H_SS':
H_sS = self.par_load('H_SS', 'H_SS')
self.printtxt('Finished reading H_SS.gpw')
self.diagonalize(H_sS)
self.printtxt('Finished diagonalizing BSE matrix')
elif readfile == 'v_SS':
self.v_SS = self.par_load('v_SS', 'v_SS')
self.printtxt('Finished reading v_SS.gpw')
else:
1 / 0
w_S = self.w_S
if not self.coupling:
v_SS = self.v_SS.T # v_SS[:,lamda]
else:
v_SS = self.v_SS
rhoG0_S = self.rhoG0_S
focc_S = self.focc_S
# get overlap matrix
if self.coupling:
tmp = np.dot(v_SS.conj().T, v_SS )
overlap_SS = np.linalg.inv(tmp)
# get chi
epsilon_w = np.zeros(self.Nw, dtype=complex)
A_S = np.dot(rhoG0_S, v_SS)
B_S = np.dot(rhoG0_S*focc_S, v_SS)
if self.coupling:
C_S = np.dot(B_S.conj(), overlap_SS.T) * A_S
else:
if world.size == 1:
C_S = B_S.conj() * A_S
else:
tmp = B_S.conj() * A_S
C_S = gatherv(tmp, self.nS)
for iw in range(self.Nw):
tmp_S = 1. / (iw*self.dw - w_S + 1j*self.eta)
epsilon_w[iw] += np.dot(tmp_S, C_S)
epsilon_w *= - 4 * pi / np.inner(self.qq_v, self.qq_v) / self.vol
epsilon_w += 1
self.epsilon_w = epsilon_w
if rank == 0:
f = open(filename, 'w')
for iw in range(self.Nw):
energy = iw * self.dw * Hartree
print(energy, np.real(epsilon_w[iw]), np.imag(epsilon_w[iw]),
file=f)
f.close()
#g.close()
# Wait for I/O to finish
world.barrier()
"""Check f-sum rule."""
N1 = 0
for iw in range(self.Nw):
w = iw * self.dw
N1 += np.imag(epsilon_w[iw]) * w
N1 *= self.dw * self.vol / (2 * pi**2)
self.printtxt('')
self.printtxt('Sum rule:')
nv = self.nvalence
self.printtxt('N1 = %f, %f %% error' %(N1, (N1 - nv) / nv * 100) )
return epsilon_w
def get_e_h_density(self, lamda=None, filename=None):
if filename is not None:
self.load(filename)
self.initialize()
gd = self.gd
v_SS = self.v_SS
A_S = v_SS[:, lamda]
kq_k = self.kq_k
kd = self.kd
# Electron density
nte_R = gd.zeros()
for iS in range(self.nS_start, self.nS_end):
print('electron density:', iS)
k1, n1, m1 = self.Sindex_S3[iS]
ibzkpt1 = kd.bz2ibz_k[k1]
psitold_g = self.get_wavefunction(ibzkpt1, n1)
psit1_g = kd.transform_wave_function(psitold_g, k1)
for jS in range(self.nS):
k2, n2, m2 = self.Sindex_S3[jS]
if m1 == m2 and k1 == k2:
psitold_g = self.get_wavefunction(ibzkpt1, n2)
psit2_g = kd.transform_wave_function(psitold_g, k1)
nte_R += A_S[iS] * A_S[jS].conj() * psit1_g.conj() * psit2_g
# Hole density
nth_R = gd.zeros()
for iS in range(self.nS_start, self.nS_end):
print('hole density:', iS)
k1, n1, m1 = self.Sindex_S3[iS]
ibzkpt1 = kd.bz2ibz_k[kq_k[k1]]
psitold_g = self.get_wavefunction(ibzkpt1, m1)
psit1_g = kd.transform_wave_function(psitold_g, kq_k[k1])
for jS in range(self.nS):
k2, n2, m2 = self.Sindex_S3[jS]
if n1 == n2 and k1 == k2:
psitold_g = self.get_wavefunction(ibzkpt1, m2)
psit2_g = kd.transform_wave_function(psitold_g, kq_k[k1])
nth_R += A_S[iS] * A_S[jS].conj() * psit1_g * psit2_g.conj()
self.Scomm.sum(nte_R)
self.Scomm.sum(nth_R)
if rank == 0:
write('rho_e.cube',self.calc.atoms, format='cube', data=nte_R)
write('rho_h.cube',self.calc.atoms, format='cube', data=nth_R)
world.barrier()
return
def get_excitation_wavefunction(self, lamda=None,filename=None, re_c=None, rh_c=None):
""" garbage at the moment. come back later"""
if filename is not None:
self.load(filename)
self.initialize()
gd = self.gd
v_SS = self.v_SS
A_S = v_SS[:, lamda]
kq_k = self.kq_k
kd = self.kd
nx, ny, nz = self.gd.N_c
nR = 9
nR2 = (nR - 1 ) // 2
if re_c is not None:
psith_R = gd.zeros(dtype=complex)
psith2_R = np.zeros((nR*nx, nR*ny, nz), dtype=complex)
elif rh_c is not None:
psite_R = gd.zeros(dtype=complex)
psite2_R = np.zeros((nR*nx, ny, nR*nz), dtype=complex)
else:
self.printtxt('No wavefunction output !')
return
for iS in range(self.nS_start, self.nS_end):
k, n, m = self.Sindex_S3[iS]
ibzkpt1 = kd.bz2ibz_k[k]
ibzkpt2 = kd.bz2ibz_k[kq_k[k]]
print('hole wavefunction', iS, (k,n,m),A_S[iS])
psitold_g = self.get_wavefunction(ibzkpt1, n)
psit1_g = kd.transform_wave_function(psitold_g, k)
psitold_g = self.get_wavefunction(ibzkpt2, m)
psit2_g = kd.transform_wave_function(psitold_g, kq_k[k])
if re_c is not None:
# given electron position, plot hole wavefunction
tmp = A_S[iS] * psit1_g[re_c].conj() * psit2_g
psith_R += tmp
k_c = self.kd.bzk_kc[k] + self.q_c
for i in range(nR):
for j in range(nR):
R_c = np.array([i-nR2, j-nR2, 0])
psith2_R[i*nx:(i+1)*nx, j*ny:(j+1)*ny, 0:nz] += \
tmp * np.exp(1j*2*pi*np.dot(k_c,R_c))
elif rh_c is not None:
# given hole position, plot electron wavefunction
tmp = A_S[iS] * psit1_g.conj() * psit2_g[rh_c] * self.expqr_g
psite_R += tmp
k_c = self.kd.bzk_kc[k]
k_v = np.dot(k_c, self.bcell_cv)
for i in range(nR):
for j in range(nR):
R_c = np.array([i-nR2, 0, j-nR2])
R_v = np.dot(R_c, self.acell_cv)
assert np.abs(np.dot(k_v, R_v) - np.dot(k_c, R_c) * 2*pi).sum() < 1e-5
psite2_R[i*nx:(i+1)*nx, 0:ny, j*nz:(j+1)*nz] += \
tmp * np.exp(-1j*np.dot(k_v,R_v))
else:
pass
if re_c is not None:
self.Scomm.sum(psith_R)
self.Scomm.sum(psith2_R)
if rank == 0:
write('psit_h.cube',self.calc.atoms, format='cube', data=psith_R)
atoms = self.calc.atoms
shift = atoms.cell[0:2].copy()
atoms.cell[0:2] *= nR2
atoms.positions += shift * (nR2 - 1)
write('psit_bigcell_h.cube',atoms, format='cube', data=psith2_R)
elif rh_c is not None:
self.Scomm.sum(psite_R)
self.Scomm.sum(psite2_R)
if rank == 0:
write('psit_e.cube',self.calc.atoms, format='cube', data=psite_R)
atoms = self.calc.atoms
# shift = atoms.cell[0:2].copy()
atoms.cell[0:2] *= nR2
# atoms.positions += shift * (nR2 - 1)
write('psit_bigcell_e.cube',atoms, format='cube', data=psite2_R)
else:
pass
world.barrier()
return
def load(self, filename):
data = pickle.load(open(filename))
self.w_S = data['w_S']
self.v_SS = data['v_SS']
self.printtxt('Read succesfully !')
def save(self, filename):
"""Dump essential data"""
data = {'w_S' : self.w_S,
'v_SS' : self.v_SS}
if rank == 0:
pickle.dump(data, open(filename, 'w'), -1)
world.barrier()
def redistribute_H(self, H_sS):
g1 = BlacsGrid(world, size, 1)
g2 = BlacsGrid(world, 1, size)
N = self.nS
nndesc1 = g1.new_descriptor(N, N, self.nS_local, N)
nndesc2 = g2.new_descriptor(N, N, N, self.nS_local)
H_Ss = nndesc2.empty(dtype=H_sS.dtype)
redistributor = Redistributor(world, nndesc1, nndesc2)
redistributor.redistribute(H_sS, H_Ss)
return H_Ss
def scalapack_diagonalize(self, H_sS):
mb = 32
N = self.nS
g1 = BlacsGrid(world, size, 1)
g2 = BlacsGrid(world, size//2, 2)
nndesc1 = g1.new_descriptor(N, N, self.nS_local, N)
nndesc2 = g2.new_descriptor(N, N, mb, mb)
A_ss = nndesc2.empty(dtype=H_sS.dtype)
redistributor = Redistributor(world, nndesc1, nndesc2)
redistributor.redistribute(H_sS, A_ss)
# diagonalize
v_ss = nndesc2.zeros(dtype=A_ss.dtype)
w_S = np.zeros(N,dtype=float)
nndesc2.diagonalize_dc(A_ss, v_ss, w_S, 'L')
# distribute the eigenvectors to master
v_sS = np.zeros_like(H_sS)
redistributor = Redistributor(world, nndesc2, nndesc1)
redistributor.redistribute(v_ss, v_sS)
# v2_SS = np.zeros((self.nS, self.nS), dtype=complex)
# world.all_gather(v_sS, v2_SS)
return w_S, v_sS.conj()
"""
def get_chi(self, w):
H_SS = self.calculate()
self.printtxt('Diagonalizing BSE matrix.')
self.diagonalize(H_SS)
self.printtxt('Calculating BSE response function.')
w_S = self.w_S
if not self.coupling:
v_SS = self.v_SS.T # v_SS[:,lamda]
else:
v_SS = self.v_SS
rhoG0_S = self.rhoG0_S
focc_S = self.focc_S
# get overlap matrix
if self.coupling:
tmp = np.dot(v_SS.conj().T, v_SS )
overlap_SS = np.linalg.inv(tmp)
# get chi
chi_wGG = np.zeros((len(w), self.npw, self.npw), dtype=complex)
t0 = time()
A_S = np.dot(rhoG0_S, v_SS)
B_S = np.dot(rhoG0_S*focc_S, v_SS)
if self.coupling:
C_S = np.dot(B_S.conj(), overlap_SS.T) * A_S
else:
C_S = B_S.conj() * A_S
return chi_wGG
"""
gpaw-0.11.0.13004/gpaw/response/qeh.py 0000664 0001750 0001750 00000060643 12553643470 017410 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import pickle
import numpy as np
Hartree = 27.2113956555
Bohr = 0.529177257507
class Heterostructure:
"""This class defines dielectric function of heterostructures
and related physical quantities."""
def __init__(self, structure, d,
include_dipole=True, d0=None,
wmax=10, qmax=None):
"""Creates a Heterostructure object.
structure: list of str
Heterostructure set up. Each entry should consist of number of
layers + chemical formula.
For example: ['3H-MoS2', graphene', '10H-WS2'] gives 3 layers of
H-MoS2, 1 layer of graphene and 10 layers of H-WS2.
d: array of floats
Interlayer distances for neighboring layers in Ang.
Length of array = number of layers - 1
d0: float
The width of a single layer in Ang, only used for monolayer
calculation. The layer separation in bulk is typically a good
measure.
include_dipole: Bool
Includes dipole contribution if True
wmax: float
Cutoff for frequency grid (eV)
qmax: float
Cutoff for wave-vector grid (1/Ang)
"""
chi_monopole = []
drho_monopole = []
if include_dipole:
chi_dipole = []
drho_dipole = []
else:
self.chi_dipole = None
drho_dipole = None
self.z = []
layer_indices = []
self.n_layers = 0
namelist = []
for n in range(len(structure)):
name = structure[n]
num = ''
while name[0].isdigit():
num += name[0]
name = name[1:]
if num == '':
num = '1'
self.n_layers += int(num)
if name not in namelist:
namelist.append(name)
name += '-chi.pckl'
q, w, chim, chid, zi, drhom, drhod = pickle.load(open(name))
if qmax is not None:
qindex = np.argmin(abs(q - qmax * Bohr)) + 1
else:
qindex = -1
if wmax is not None:
windex = np.argmin(abs(w - wmax / Hartree)) + 1
else:
windex = -1
chi_monopole.append(np.array(chim[:qindex, :windex]))
drho_monopole.append(np.array(drhom[:qindex]))
if include_dipole:
chi_dipole.append(np.array(chid[:qindex, :windex]))
drho_dipole.append(np.array(drhod[:qindex]))
self.z.append(np.array(zi))
else:
n = namelist.index(name)
indices = [n for i in range(int(num))]
layer_indices = np.append(layer_indices, indices)
self.layer_indices = np.array(layer_indices, dtype=int)
self.q_abs = q[:qindex]
self.frequencies = w[:windex]
self.n_types = len(namelist)
# layers and distances
self.d = np.array(d) / Bohr # interlayer distances
if self.n_layers > 1:
# space around each layer
self.s = (np.insert(self.d, 0, self.d[0]) +
np.append(self.d, self.d[-1])) / 2.
else: # Monolayer calculation
self.s = [d0 / Bohr] # Width of single layer
self.dim = self.n_layers
if include_dipole:
self.dim *= 2
# Grid stuff
self.poisson_lim = 100 # above this limit use potential model
edgesize = 50
system_size = np.sum(self.d) + edgesize
self.z_lim = system_size
self.dz = 0.01
# master grid
self.z_big = np.arange(0, self.z_lim, self.dz) - edgesize / 2.
self.z0 = np.append(np.array([0]), np.cumsum(self.d))
# arange potential and density
self.chi_monopole = np.array(chi_monopole)
if include_dipole:
self.chi_dipole = np.array(chi_dipole)
self.drho_monopole, self.drho_dipole, self.basis_array, \
self.drho_array = self.arange_basis(drho_monopole, drho_dipole)
self.dphi_array = self.get_induced_potentials()
self.kernel_qij = None
def arange_basis(self, drhom, drhod=None):
from scipy.interpolate import interp1d
Nz = len(self.z_big)
drho_array = np.zeros([self.dim, len(self.q_abs),
Nz], dtype=complex)
basis_array = np.zeros([self.dim, len(self.q_abs),
Nz], dtype=complex)
for i in range(self.n_types):
z = self.z[i] - self.z[i][len(self.z[i]) / 2]
drhom_i = drhom[i]
fm = interp1d(z, np.real(drhom_i))
fm2 = interp1d(z, np.imag(drhom_i))
if drhod is not None:
drhod_i = drhod[i]
fd = interp1d(z, np.real(drhod_i))
fd2 = interp1d(z, np.imag(drhod_i))
for k in [k for k in range(self.n_layers)
if self.layer_indices[k] == i]:
z_big = self.z_big - self.z0[k]
i_1s = np.argmin(np.abs(-self.s[i] / 2. - z_big))
i_2s = np.argmin(np.abs(self.s[i] / 2. - z_big))
i_1 = np.argmin(np.abs(z[0] - z_big)) + 1
i_2 = np.argmin(np.abs(z[-1] - z_big)) - 1
if drhod is not None:
drho_array[2 * k, :, i_1: i_2] = \
fm(z_big[i_1: i_2]) + 1j * fm2(z_big[i_1: i_2])
basis_array[2 * k, :, i_1s: i_2s] = 1. / self.s[i]
drho_array[2 * k + 1, :, i_1: i_2] = \
fd(z_big[i_1: i_2]) + 1j * fd2(z_big[i_1: i_2])
basis_array[2 * k + 1, :, i_1: i_2] = \
fd(z_big[i_1: i_2]) + 1j * fd2(z_big[i_1: i_2])
else:
drho_array[k, :, i_1: i_2] = \
fm(z_big[i_1: i_2]) + 1j * fm2(z_big[i_1: i_2])
basis_array[k, :, i_1s: i_2s] = 1. / self.s[i]
return drhom, drhod, basis_array, drho_array
def get_induced_potentials(self):
from scipy.interpolate import interp1d
Nz = len(self.z_big)
dphi_array = np.zeros([self.dim, len(self.q_abs), Nz], dtype=complex)
for i in range(self.n_types):
z = self.z[i]
for iq in range(len(self.q_abs)):
q = self.q_abs[iq]
drho_m = self.drho_monopole[i][iq].copy()
poisson_m = self.solve_poisson_1D(drho_m, q, z)
z_poisson = self.get_z_grid(z, z_lim=self.poisson_lim)
if not len(z_poisson) == len(np.real(poisson_m)):
z_poisson = z_poisson[:len(poisson_m)]
poisson_m = poisson_m[:len(z_poisson)]
fm = interp1d(z_poisson, np.real(poisson_m))
fm2 = interp1d(z_poisson, np.imag(poisson_m))
if self.chi_dipole is not None:
drho_d = self.drho_dipole[i][iq].copy()
# delta is the distance between dipole peaks / 2
delta = np.abs(z[np.argmax(drho_d)] -
z[np.argmin(drho_d)]) / 2.
poisson_d = self.solve_poisson_1D(drho_d, q, z,
dipole=True,
delta=delta)
fd = interp1d(z_poisson, np.real(poisson_d))
for k in [k for k in range(self.n_layers)
if self.layer_indices[k] == i]:
z_big = self.z_big - self.z0[k]
i_1 = np.argmin(np.abs(z_poisson[0] - z_big)) + 1
i_2 = np.argmin(np.abs(z_poisson[-1] - z_big)) - 1
dphi_array[self.dim / self.n_layers * k, iq] = \
self.potential_model(self.q_abs[iq], self.z_big,
self.z0[k])
dphi_array[self.dim / self.n_layers * k, iq, i_1: i_2] = \
fm(z_big[i_1: i_2]) + 1j * fm2(z_big[i_1: i_2])
if self.chi_dipole is not None:
dphi_array[2 * k + 1, iq] = \
self.potential_model(self.q_abs[iq], self.z_big,
self.z0[k], dipole=True,
delta=delta)
dphi_array[2 * k + 1, iq, i_1: i_2] = \
fd(z_big[i_1: i_2])
return dphi_array
def get_z_grid(self, z, z_lim=None):
dz = z[1] - z[0]
if z_lim is None:
z_lim = self.z_lim
z_lim = int(z_lim / dz) * dz
z_grid = np.insert(z, 0, np.arange(-z_lim, z[0], dz))
z_grid = np.append(z_grid, np.arange(z[-1] + dz, z_lim + dz, dz))
return z_grid
def potential_model(self, q, z, z0=0, dipole=False, delta=None):
"""
2D Coulomb: 2 pi / q with exponential decay in z-direction
"""
if dipole: # Two planes separated by 2 * delta
V = np.pi / (q * delta) * \
(-np.exp(-q * np.abs(z - z0 + delta)) +
np.exp(-q * np.abs(z - z0 - delta)))
else: # Monopole potential from single plane
V = 2 * np.pi / q * np.exp(-q * np.abs(z - z0))
return V
def solve_poisson_1D(self, drho, q, z,
dipole=False, delta=None):
"""
Solves poissons equation in 1D using finite difference method.
drho: induced potential basis function
q: momentum transfer.
"""
z -= np.mean(z) # center arround 0
z_grid = self.get_z_grid(z, z_lim=self.poisson_lim)
dz = z[1] - z[0]
Nz_loc = (len(z_grid) - len(z)) / 2
drho = np.append(np.insert(drho, 0, np.zeros([Nz_loc])),
np.zeros([Nz_loc]))
Nint = len(drho) - 1
bc_v0 = self.potential_model(q, z_grid[0], dipole=dipole,
delta=delta)
bc_vN = self.potential_model(q, z_grid[-1], dipole=dipole,
delta=delta)
M = np.zeros((Nint + 1, Nint + 1))
f_z = np.zeros(Nint + 1, dtype=complex)
f_z[:] = - 4 * np.pi * drho[:]
# Finite Difference Matrix
for i in range(1, Nint):
M[i, i] = -2. / (dz**2) - q**2
M[i, i + 1] = 1. / dz**2
M[i, i - 1] = 1. / dz**2
M[0, 0] = 1.
M[Nint, Nint] = 1.
f_z[0] = bc_v0
f_z[Nint] = bc_vN
# Getting the Potential
M_inv = np.linalg.inv(M)
dphi = np.dot(M_inv, f_z)
return dphi
def get_Coulomb_Kernel(self, step_potential=False):
kernel_qij = np.zeros([len(self.q_abs), self.dim, self.dim],
dtype=complex)
for iq in range(len(self.q_abs)):
if step_potential:
# Use step-function average for monopole contribution
kernel_qij[iq] = np.dot(self.basis_array[:, iq],
self.dphi_array[:, iq].T) * self.dz
else: # Normal kernel
kernel_qij[iq] = np.dot(self.drho_array[:, iq],
self.dphi_array[:, iq].T) * self.dz
return kernel_qij
def get_chi_matrix(self):
"""
Dyson equation: chi_full = chi_intra + chi_intra V_inter chi_full
"""
Nls = self.n_layers
q_abs = self.q_abs
chi_m_iqw = self.chi_monopole
chi_d_iqw = self.chi_dipole
if self.kernel_qij is None:
self.kernel_qij = self.get_Coulomb_Kernel()
chi_qwij = np.zeros((len(self.q_abs), len(self.frequencies),
self.dim, self.dim), dtype=complex)
for iq in range(len(q_abs)):
kernel_ij = self.kernel_qij[iq].copy()
np.fill_diagonal(kernel_ij, 0) # Diagonal is set to zero
for iw in range(0, len(self.frequencies)):
chi_intra_i = chi_m_iqw[self.layer_indices, iq, iw]
if self.chi_dipole is not None:
chi_intra_i = np.insert(chi_intra_i, np.arange(Nls) + 1,
chi_d_iqw[self.layer_indices,
iq, iw])
chi_intra_ij = np.diag(chi_intra_i)
chi_qwij[iq, iw, :, :] = np.dot(np.linalg.inv(
np.eye(self.dim) - np.dot(chi_intra_ij, kernel_ij)),
chi_intra_ij)
return chi_qwij
def get_eps_matrix(self, step_potential=False):
"""
Get dielectric matrix as: eps^{-1} = 1 + V chi_full
"""
self.kernel_qij =\
self.get_Coulomb_Kernel(step_potential=step_potential)
chi_qwij = self.get_chi_matrix()
eps_qwij = np.zeros((len(self.q_abs), len(self.frequencies),
self.dim, self.dim), dtype=complex)
for iq in range(len(self.q_abs)):
kernel_ij = self.kernel_qij[iq]
for iw in range(0, len(self.frequencies)):
eps_qwij[iq, iw, :, :] = np.linalg.inv(
np.eye(kernel_ij.shape[0]) + np.dot(kernel_ij,
chi_qwij[iq, iw,
:, :]))
return eps_qwij
def get_exciton_screened_potential(self, e_distr, h_distr):
v_screened_qw = np.zeros((len(self.q_abs),
len(self.frequencies)))
eps_qwij = self.get_eps_matrix()
h_distr = h_distr.transpose()
kernel_qij = self.get_Coulomb_Kernel()
for iq in range(0, len(self.q_abs)):
ext_pot = np.dot(kernel_qij[iq], h_distr)
for iw in range(0, len(self.frequencies)):
v_screened_qw[iq, iw] =\
np.dot(e_distr,
np.dot(np.linalg.inv(eps_qwij[iq, iw, :, :]),
ext_pot))
return self.q_abs, -v_screened_qw, kernel_qij
def get_macroscopic_dielectric_function(self, layers=None):
"""
Calculates the averaged dielectric matrix over the structure in the
static limit omega = 0.
Parameters:
layers: array of integers
list with index of specific layers to include in the average.
Returns list of q-points, dielectric function.
"""
constant_perturbation = np.ones([self.n_layers])
layer_weight = self.s / np.sum(self.s) * self.n_layers
if self.chi_dipole is not None:
constant_perturbation = np.insert(constant_perturbation,
np.arange(self.n_layers) + 1,
np.zeros([self.n_layers]))
layer_weight = np.insert(layer_weight,
np.arange(self.n_layers) + 1,
layer_weight)
if layers is None: # average over entire structure
N = self.n_layers
potential = constant_perturbation
else: # average over selected layers
N = len(layers)
potential = np.zeros([self.dim])
index = layers * self.dim / self.n_layers
potential[index] = 1.
epsM_q = []
eps_qij = self.get_eps_matrix(step_potential=True)[:, 0]
for iq in range(len(self.q_abs)):
eps_ij = eps_qij[iq]
epsinv_ij = np.linalg.inv(eps_ij)
epsinv_M = 1. / N * np.dot(np.array(potential) * layer_weight,
np.dot(epsinv_ij,
np.array(constant_perturbation)))
epsM_q.append(1. / epsinv_M.real)
return self.q_abs / Bohr, epsM_q
def get_response(self, iw=0, dipole=False):
"""
Get the induced density and potential due to constant perturbation
obtained as: rho_ind(r) = \int chi(r,r') dr'
"""
constant_perturbation = np.ones([self.n_layers])
if self.chi_dipole is not None:
constant_perturbation = np.insert(constant_perturbation,
np.arange(self.n_layers) + 1,
np.zeros([self.n_layers]))
if dipole:
constant_perturbation = self.z0 - self.z0[-1] / 2.
constant_perturbation = np.insert(constant_perturbation,
np.arange(self.n_layers) + 1,
np.ones([self.n_layers]))
chi_qij = self.get_chi_matrix()[:, iw]
Vind_z = np.zeros((len(self.q_abs), len(self.z_big)))
rhoind_z = np.zeros((len(self.q_abs), len(self.z_big)))
drho_array = self.drho_array.copy()
dphi_array = self.dphi_array.copy()
# Expand on potential and density basis function
# to get spatial detendence
for iq in range(len(self.q_abs)):
chi_ij = chi_qij[iq]
Vind_qi = np.dot(chi_ij, np.array(constant_perturbation))
rhoind_z[iq] = np.dot(drho_array[:, iq].T, Vind_qi)
Vind_z[iq] = np.dot(dphi_array[:, iq].T, Vind_qi)
return self.z_big * Bohr, rhoind_z, Vind_z, self.z0 * Bohr
def get_plasmon_eigenmodes(self):
"""
Diagonalize the dieletric matrix to get the plasmon eigenresonances
of the system.
Returns:
Eigenvalue array (shape Nq x nw x dim), z-grid, induced densities,
induced potentials, energies at zero crossings.
"""
eps_qwij = self.get_eps_matrix()
Nw = len(self.frequencies)
Nq = len(self.q_abs)
w_w = self.frequencies
eig = np.zeros([Nq, Nw, self.dim], dtype=complex)
vec = np.zeros([Nq, Nw, self.dim, self.dim],
dtype=complex)
omega0 = [[] for i in range(Nq)]
rho_z = [np.zeros([0, len(self.z_big)]) for i in range(Nq)]
phi_z = [np.zeros([0, len(self.z_big)]) for i in range(Nq)]
for iq in range(Nq):
m = 0
eig[iq, 0], vec[iq, 0] = np.linalg.eig(eps_qwij[iq, 0])
vec_dual = np.linalg.inv(vec[iq, 0])
for iw in range(1, Nw):
eig[iq, iw], vec_p = np.linalg.eig(eps_qwij[iq, iw])
vec_dual_p = np.linalg.inv(vec_p)
overlap = np.abs(np.dot(vec_dual, vec_p))
index = list(np.argsort(overlap)[:, -1])
if len(np.unique(index)) < self.dim: # add missing indices
addlist = []
removelist = []
for j in range(self.dim):
if index.count(j) < 1:
addlist.append(j)
if index.count(j) > 1:
for l in range(1, index.count(j)):
removelist.append(
np.argwhere(np.array(index) == j)[l])
for j in range(len(addlist)):
index[removelist[j]] = addlist[j]
vec[iq, iw] = vec_p[:, index]
vec_dual = vec_dual_p[index, :]
eig[iq, iw, :] = eig[iq, iw, index]
klist = [k for k in range(self.dim)
if (eig[iq, iw - 1, k] < 0 and eig[iq, iw, k] > 0)]
for k in klist: # Eigenvalue crossing
a = np.real((eig[iq, iw, k] - eig[iq, iw - 1, k]) /
(w_w[iw] - w_w[iw - 1]))
# linear interp for crossing point
w0 = np.real(-eig[iq, iw - 1, k]) / a + w_w[iw - 1]
rho = np.dot(self.drho_array[:, iq, :].T, vec_dual_p[k, :])
phi = np.dot(self.dphi_array[:, iq, :].T, vec_dual_p[k, :])
rho_z[iq] = np.append(rho_z[iq], rho[np.newaxis, :],
axis=0)
phi_z[iq] = np.append(phi_z[iq], phi[np.newaxis, :],
axis=0)
omega0[iq].append(w0)
m += 1
return eig, self.z_big * Bohr, rho_z, phi_z, np.array(omega0)
"""TOOLS"""
def get_chi_2D(filenames=None, name=None):
"""Calculate the monopole and dipole contribution to the
2D susceptibillity chi_2D, defined as
::
\chi^M_2D(q, \omega) = \int\int dr dr' \chi(q, \omega, r,r') \\
= L \chi_{G=G'=0}(q, \omega)
\chi^D_2D(q, \omega) = \int\int dr dr' z \chi(q, \omega, r,r') z'
= 1/L sum_{G_z,G_z'} z_factor(G_z)
chi_{G_z,G_z'} z_factor(G_z'),
Where z_factor(G_z) = +/- i e^{+/- i*G_z*z0}
(L G_z cos(G_z L/2)-2 sin(G_z L/2))/G_z^2
input parameters:
filenames: list of str
list of chi_wGG.pckl files for different q calculated with
the DielectricFunction module in GPAW
name: str
name writing output files
"""
q_list_abs = []
omega_w, pd, chi_wGG, q0 = read_chi_wGG(filenames[0])
nq = len(filenames)
nw = omega_w.shape[0]
r = pd.gd.get_grid_point_coordinates()
z = r[2, 0, 0, :]
L = pd.gd.cell_cv[2, 2] # Length of cell in Bohr
z0 = L / 2. # position of layer
chiM_2D_qw = np.zeros([nq, nw], dtype=complex)
chiD_2D_qw = np.zeros([nq, nw], dtype=complex)
drho_M_qz = np.zeros([nq, len(z)], dtype=complex) # induced density
drho_D_qz = np.zeros([nq, len(z)], dtype=complex) # induced dipole density
for iq in range(nq):
if not iq == 0:
omega_w, pd, chi_wGG, q0 = read_chi_wGG(filenames[iq])
if q0 is not None:
q = q0
else:
q = pd.K_qv
npw = chi_wGG.shape[1]
Gvec = pd.get_reciprocal_vectors(add_q=False)
Glist = []
for iG in range(npw): # List of G with Gx,Gy = 0
if Gvec[iG, 0] == 0 and Gvec[iG, 1] == 0:
Glist.append(iG)
chiM_2D_qw[iq] = L * chi_wGG[:, 0, 0]
drho_M_qz[iq] += chi_wGG[0, 0, 0]
q_abs = np.linalg.norm(q)
q_list_abs.append(q_abs)
for iG in Glist[1:]:
G_z = Gvec[iG, 2]
qGr_R = np.inner(G_z, z.T).T
# Fourier transform to get induced density at \omega=0
drho_M_qz[iq] += np.exp(1j * qGr_R) * chi_wGG[0, iG, 0]
for iG1 in Glist[1:]:
G_z1 = Gvec[iG1, 2]
# integrate with z along both coordinates
factor = z_factor(z0, L, G_z)
factor1 = z_factor(z0, L, G_z1, sign=-1)
chiD_2D_qw[iq, :] += 1. / L * factor * chi_wGG[:, iG, iG1] * \
factor1
# induced dipole density due to V_ext = z
drho_D_qz[iq, :] += 1. / L * np.exp(1j * qGr_R) * \
chi_wGG[0, iG, iG1] * factor1
# Normalize induced densities with chi
drho_M_qz /= np.repeat(chiM_2D_qw[:, 0, np.newaxis], drho_M_qz.shape[1],
axis=1)
drho_D_qz /= np.repeat(chiD_2D_qw[:, 0, np.newaxis], drho_M_qz.shape[1],
axis=1)
""" Returns q array, frequency array, chi2D monopole and dipole, induced
densities and z array (all in Bohr)
"""
pickle.dump((np.array(q_list_abs), omega_w, chiM_2D_qw, chiD_2D_qw,
z, drho_M_qz, drho_D_qz), open(name + '-chi.pckl', 'w'))
return np.array(q_list_abs) / Bohr, omega_w * Hartree, chiM_2D_qw, \
chiD_2D_qw, z, drho_M_qz, drho_D_qz
def z_factor(z0, d, G, sign=1):
factor = -1j * sign * np.exp(1j * sign * G * z0) * \
(d * G * np.cos(G * d / 2.) - 2. * np.sin(G * d / 2.)) / G**2
return factor
def z_factor2(z0, d, G, sign=1):
factor = sign * np.exp(1j * sign * G * z0) * np.sin(G * d / 2.)
return factor
def read_chi_wGG(name):
"""
Read density response matrix calculated with the DielectricFunction
module in GPAW.
Returns frequency grid, gpaw.wavefunctions object, chi_wGG
"""
fd = open(name)
omega_w, pd, chi_wGG, q0, chi0_wvv = pickle.load(fd)
nw = len(omega_w)
nG = pd.ngmax
chi_wGG = np.empty((nw, nG, nG), complex)
for chi_GG in chi_wGG:
chi_GG[:] = pickle.load(fd)
return omega_w, pd, chi_wGG, q0
gpaw-0.11.0.13004/gpaw/response/wstc.py 0000664 0001750 0001750 00000005264 12553643470 017611 0 ustar jensj jensj 0000000 0000000 """Wigner-Seitz truncated coulomb interaction.
See:
Ravishankar Sundararaman and T. A. Arias:
Phys. Rev. B 87, 165122 (2013)
Regularization of the Coulomb singularity in exact exchange by
Wigner-Seitz truncated interactions: Towards chemical accuracy
in nontrivial systems
"""
import sys
from math import pi
import numpy as np
from ase.units import Bohr
from ase.utils import prnt
import gpaw.mpi as mpi
from gpaw.utilities import erf
from gpaw.fftw import get_efficient_fft_size
from gpaw.grid_descriptor import GridDescriptor
class WignerSeitzTruncatedCoulomb:
def __init__(self, cell_cv, nk_c, txt=sys.stdout):
self.nk_c = nk_c
bigcell_cv = cell_cv * nk_c[:, np.newaxis]
L_c = (np.linalg.inv(bigcell_cv)**2).sum(0)**-0.5
rc = 0.5 * L_c.min()
prnt('Inner radius for %dx%dx%d Wigner-Seitz cell: %.3f Ang' %
(tuple(nk_c) + (rc * Bohr,)), file=txt)
self.a = 5 / rc
prnt('Range-separation parameter: %.3f Ang^-1' % (self.a / Bohr),
file=txt)
# nr_c = [get_efficient_fft_size(2 * int(L * self.a * 1.5))
nr_c = [get_efficient_fft_size(2 * int(L * self.a * 3.0))
for L in L_c]
prnt('FFT size for calculating truncated Coulomb: %dx%dx%d' %
tuple(nr_c), file=txt)
self.gd = GridDescriptor(nr_c, bigcell_cv, comm=mpi.serial_comm)
v_R = self.gd.empty()
v_i = v_R.ravel()
pos_iv = self.gd.get_grid_point_coordinates().reshape((3, -1)).T
corner_jv = np.dot(np.indices((2, 2, 2)).reshape((3, 8)).T, bigcell_cv)
for i, pos_v in enumerate(pos_iv):
r = ((pos_v - corner_jv)**2).sum(axis=1).min()**0.5
if r == 0:
v_i[i] = 2 * self.a / pi**0.5
else:
v_i[i] = erf(self.a * r) / r
self.K_Q = np.fft.fftn(v_R) * self.gd.dv
def get_potential(self, pd):
q_c = pd.kd.bzk_kc[0]
shift_c = (q_c * self.nk_c).round().astype(int)
max_c = self.gd.N_c // 2
K_G = pd.zeros()
N_c = pd.gd.N_c
for G, Q in enumerate(pd.Q_qG[0]):
Q_c = (np.unravel_index(Q, N_c) + N_c // 2) % N_c - N_c // 2
Q_c = Q_c * self.nk_c + shift_c
if (abs(Q_c) < max_c).all():
K_G[G] = self.K_Q[tuple(Q_c)]
G2_G = pd.G2_qG[0]
a = self.a
if pd.kd.gamma:
K_G[0] += pi / a**2
else:
K_G[0] += 4 * pi * (1 - np.exp(-G2_G[0] / (4 * a**2))) / G2_G[0]
K_G[1:] += 4 * pi * (1 - np.exp(-G2_G[1:] / (4 * a**2))) / G2_G[1:]
assert pd.dtype == complex
return K_G
gpaw-0.11.0.13004/gpaw/response/kernel2.py 0000664 0001750 0001750 00000012267 12553643470 020174 0 ustar jensj jensj 0000000 0000000 # -*- coding: utf-8
# In an attempt to appease epydoc and still have readable docstrings,
# the vertical bar | is represented by u'\u2758' in this module.
"""This module defines Coulomb and XC kernels for the response model.
"""
import numpy as np
#from math import sqrt, pi, sin, cos, exp
from gpaw.utilities.blas import gemmdot
from gpaw.xc import XC
from gpaw.sphere.lebedev import weight_n, R_nv
from gpaw.mpi import world, rank, size
from ase.dft.kpoints import monkhorst_pack
def truncated_coulomb(pd, q0=None):
""" Simple truncation of Coulomb kernel along z
Rozzi, C., Varsano, D., Marini, A., Gross, E., & Rubio, A. (2006).
Exact Coulomb cutoff technique for supercell calculations.
Physical Review B, 73(20), 205119. doi:10.1103/PhysRevB.73.205119
"""
qG = pd.get_reciprocal_vectors(add_q=True)
if pd.kd.gamma: # Set small finite q to handle divergence
if q0 is None:
q0 = 0.0000001
qG += [q0, 0, 0]
nG = len(qG)
L = pd.gd.cell_cv[2, 2]
R = L / 2. # Truncation length is half of unit cell
qG_par = ((qG[:, 0])**2 + (qG[:, 1]**2))**0.5
qG_z = qG[:, 2]
K_G = 4 * np.pi / (qG**2).sum(axis=1)
# K_G *= 1. + np.exp(-qG_par * R) * (qG_z / qG_par * np.sin(qG_z * R)\
# - np.cos(qG_z * R))
# sin(qG_z * R) = 0 when R = L/2
K_G *= 1. - np.exp(-qG_par * R) * np.cos(qG_z * R)
K_G **= 0.5
return K_G.astype(complex)
def calculate_Kxc(pd, nt_sG, R_av, setups, D_asp, functional='ALDA',
density_cut=None):
"""ALDA kernel"""
gd = pd.gd
npw = pd.ngmax
nG = pd.gd.N_c
vol = pd.gd.volume
bcell_cv = np.linalg.inv(pd.gd.cell_cv)
G_Gv = pd.get_reciprocal_vectors()
# The soft part
#assert np.abs(nt_sG[0].shape - nG).sum() == 0
if functional == 'ALDA_X':
x_only = True
A_x = -3. / 4. * (3. / np.pi)**(1. / 3.)
nspins = len(nt_sG)
assert nspins in [1, 2]
fxc_sg = nspins**(1. / 3.) * 4. / 9. * A_x * nt_sG**(-2. / 3.)
else:
assert len(nt_sG) == 1
x_only = False
fxc_sg = np.zeros_like(nt_sG)
xc = XC(functional[1:])
xc.calculate_fxc(gd, nt_sG, fxc_sg)
if density_cut is not None:
fxc_sg[np.where(nt_sG * len(nt_sG) < density_cut)] = 0.0
# FFT fxc(r)
nG0 = nG[0] * nG[1] * nG[2]
tmp_sg = [np.fft.fftn(fxc_sg[s]) * vol / nG0 for s in range(len(nt_sG))]
r_vg = gd.get_grid_point_coordinates()
Kxc_sGG = np.zeros((len(fxc_sg), npw, npw), dtype=complex)
for s in range(len(fxc_sg)):
for iG, iQ in enumerate(pd.Q_qG[0]):
iQ_c = (np.unravel_index(iQ, nG) + nG // 2) % nG - nG // 2
for jG, jQ in enumerate(pd.Q_qG[0]):
jQ_c = (np.unravel_index(jQ, nG) + nG // 2) % nG - nG // 2
ijQ_c = (iQ_c - jQ_c)
if (abs(ijQ_c) < nG // 2).all():
Kxc_sGG[s, iG, jG] = tmp_sg[s][tuple(ijQ_c)]
# The PAW part
KxcPAW_sGG = np.zeros_like(Kxc_sGG)
dG_GGv = np.zeros((npw, npw, 3))
for v in range(3):
dG_GGv[:, :, v] = np.subtract.outer(G_Gv[:, v], G_Gv[:, v])
for a, setup in enumerate(setups):
if rank == a % size:
rgd = setup.xc_correction.rgd
n_qg = setup.xc_correction.n_qg
nt_qg = setup.xc_correction.nt_qg
nc_g = setup.xc_correction.nc_g
nct_g = setup.xc_correction.nct_g
Y_nL = setup.xc_correction.Y_nL
dv_g = rgd.dv_g
D_sp = D_asp[a]
B_pqL = setup.xc_correction.B_pqL
D_sLq = np.inner(D_sp, B_pqL.T)
nspins = len(D_sp)
f_sg = rgd.empty(nspins)
ft_sg = rgd.empty(nspins)
n_sLg = np.dot(D_sLq, n_qg)
nt_sLg = np.dot(D_sLq, nt_qg)
# Add core density
n_sLg[:, 0] += np.sqrt(4. * np.pi) / nspins * nc_g
nt_sLg[:, 0] += np.sqrt(4. * np.pi) / nspins * nct_g
coefatoms_GG = np.exp(-1j * np.inner(dG_GGv, R_av[a]))
for n, Y_L in enumerate(Y_nL):
w = weight_n[n]
f_sg[:] = 0.0
n_sg = np.dot(Y_L, n_sLg)
if x_only:
f_sg = nspins * (4 / 9.) * A_x * (nspins * n_sg)**(-2 / 3.)
else:
xc.calculate_fxc(rgd, n_sg, f_sg)
ft_sg[:] = 0.0
nt_sg = np.dot(Y_L, nt_sLg)
if x_only:
ft_sg = nspins * (4 / 9.) * (A_x
* (nspins * nt_sg)**(-2 / 3.))
else:
xc.calculate_fxc(rgd, nt_sg, ft_sg)
for i in range(len(rgd.r_g)):
coef_GG = np.exp(-1j * np.inner(dG_GGv, R_nv[n])
* rgd.r_g[i])
for s in range(len(f_sg)):
KxcPAW_sGG[s] += w * np.dot(coef_GG,
(f_sg[s, i] -
ft_sg[s, i])
* dv_g[i]) * coefatoms_GG
world.sum(KxcPAW_sGG)
Kxc_sGG += KxcPAW_sGG
return Kxc_sGG / vol
gpaw-0.11.0.13004/gpaw/response/g0w0.py 0000664 0001750 0001750 00000061203 12553643470 017401 0 ustar jensj jensj 0000000 0000000 # This makes sure that division works as in Python3
from __future__ import division, print_function
import functools
import pickle
from math import pi
import numpy as np
from ase.dft.kpoints import monkhorst_pack
from ase.units import Hartree
from ase.utils import opencew, devnull
from ase.utils.timing import timer
import gpaw.mpi as mpi
from gpaw import debug
from gpaw.kpt_descriptor import KPointDescriptor
from gpaw.response.chi0 import Chi0, HilbertTransform
from gpaw.response.pair import PairDensity
from gpaw.response.wstc import WignerSeitzTruncatedCoulomb
from gpaw.wavefunctions.pw import PWDescriptor, count_reciprocal_vectors
from gpaw.xc.exx import EXX, select_kpts
from gpaw.xc.tools import vxc
class G0W0(PairDensity):
"""This class defines the G0W0 calculator. The G0W0 calculator is used
is used to calculate the quasi particle energies through the G0W0
approximation for a number of states.
Note: So far the G0W0 calculation only works for spin-paired systems.
Parameters:
calc: str or PAW object
GPAW calculator object or filename of saved calculator object.
filename: str
Base filename of output files.
kpts: list
List of indices of the IBZ k-points to calculate the quasi particle
energies for.
bands: tuple
Range of band indices, like (n1, n2+1), to calculate the quasi
particle energies for. Note that the second band index is not
included.
ecut: float
Plane wave cut-off energy in eV.
nbands: int
Number of bands to use in the calculation. If :None: the number will
be determined from :ecut: to yield a number close to the number of
plane waves used.
ppa: bool
Sets whether the Godby-Needs plasmon-pole approximation for the
dielectric function should be used.
E0: float
Energy (in eV) used for fitting in the plasmon-pole approximation.
domega0: float
Minimum frequency step (in eV) used in the generation of the non-
linear frequency grid.
omega2: float
Control parameter for the non-linear frequency grid, equal to the
frequency where the grid spacing has doubled in size.
wstc: bool
Sets whether a Wigner-Seitz truncation should be used for the
Coloumb potential.
"""
def __init__(self, calc, filename='gw',
kpts=None, bands=None, nbands=None, ppa=False,
wstc=False,
ecut=150.0, eta=0.1, E0=1.0 * Hartree,
domega0=0.025, omega2=10.0,
nblocks=1, savew=False,
world=mpi.world):
if world.rank != 0:
txt = devnull
else:
txt = open(filename + '.txt', 'w')
p = functools.partial(print, file=txt)
p(' ___ _ _ _ ')
p(' | || | | |')
p(' | | || | | |')
p(' |__ ||_____|')
p(' |___|')
p()
self.inputcalc = calc
PairDensity.__init__(self, calc, ecut, world=world, nblocks=nblocks,
txt=txt)
self.filename = filename
self.savew = savew
ecut /= Hartree
self.ppa = ppa
self.wstc = wstc
self.eta = eta / Hartree
self.E0 = E0 / Hartree
self.domega0 = domega0 / Hartree
self.omega2 = omega2 / Hartree
self.kpts = list(select_kpts(kpts, self.calc))
if bands is None:
bands = [0, self.nocc2]
self.bands = bands
b1, b2 = bands
self.shape = shape = (self.calc.wfs.nspins, len(self.kpts), b2 - b1)
self.eps_sin = np.empty(shape) # KS-eigenvalues
self.f_sin = np.empty(shape) # occupation numbers
self.sigma_sin = np.zeros(shape) # self-energies
self.dsigma_sin = np.zeros(shape) # derivatives of self-energies
self.vxc_sin = None # KS XC-contributions
self.exx_sin = None # exact exchange contributions
self.Z_sin = None # renormalization factors
if nbands is None:
nbands = int(self.vol * ecut**1.5 * 2**0.5 / 3 / pi**2)
self.nbands = nbands
p()
p('Quasi particle states:')
if kpts is None:
p('All k-points in IBZ')
else:
kptstxt = ', '.join(['{0:d}'.format(k) for k in self.kpts])
p('k-points (IBZ indices): [' + kptstxt + ']')
p('Band range: ({0:d}, {1:d})'.format(b1, b2))
p()
p('Computational parameters:')
p('Plane wave cut-off: {0:g} eV'.format(self.ecut * Hartree))
p('Number of bands: {0:d}'.format(self.nbands))
p('Broadening: {0:g} eV'.format(self.eta * Hartree))
kd = self.calc.wfs.kd
self.mysKn1n2 = None # my (s, K, n1, n2) indices
self.distribute_k_points_and_bands(b1, b2, kd.ibz2bz_k[self.kpts])
# Find q-vectors and weights in the IBZ:
assert -1 not in kd.bz2bz_ks
offset_c = 0.5 * ((kd.N_c + 1) % 2) / kd.N_c
bzq_qc = monkhorst_pack(kd.N_c) + offset_c
self.qd = KPointDescriptor(bzq_qc)
self.qd.set_symmetry(self.calc.atoms, kd.symmetry)
assert self.calc.wfs.nspins == 1
@timer('G0W0')
def calculate(self, ecuts=None):
"""Starts the G0W0 calculation. Returns a dict with the results with
the following key/value pairs:
f: (s, k, n) ndarray
Occupation numbers
eps: (s, k, n) ndarray
Kohn-Sham eigenvalues in eV
vxc: (s, k, n) ndarray
Exchange-correlation contributions in eV
exx: (s, k, n) ndarray
Exact exchange contributions in eV
sigma: (s, k, n) ndarray
Self-energy contributions in eV
Z: (s, k, n) ndarray
Renormalization factors
qp: (s, k, n) ndarray
Quasi particle energies in eV
"""
kd = self.calc.wfs.kd
self.calculate_ks_xc_contribution()
self.calculate_exact_exchange()
# Reset calculation
self.sigma_sin = np.zeros(self.shape) # self-energies
self.dsigma_sin = np.zeros(self.shape) # derivatives of self-energies
# Get KS eigenvalues and occupation numbers:
b1, b2 = self.bands
for i, k in enumerate(self.kpts):
kpt = self.calc.wfs.kpt_u[k]
self.eps_sin[0, i] = kpt.eps_n[b1:b2]
self.f_sin[0, i] = kpt.f_n[b1:b2] / kpt.weight
# My part of the states we want to calculate QP-energies for:
mykpts = [self.get_k_point(s, K, n1, n2)
for s, K, n1, n2 in self.mysKn1n2]
# Loop over q in the IBZ:
for pd0, W0, q_c in self.calculate_screened_potential():
for kpt1 in mykpts:
K2 = kd.find_k_plus_q(q_c, [kpt1.K])[0]
kpt2 = self.get_k_point(0, K2, 0, self.nbands, block=True)
k1 = kd.bz2ibz_k[kpt1.K]
i = self.kpts.index(k1)
self.calculate_q(i, kpt1, kpt2, pd0, W0)
self.world.sum(self.sigma_sin)
self.world.sum(self.dsigma_sin)
self.Z_sin = 1 / (1 - self.dsigma_sin)
self.qp_sin = self.eps_sin + self.Z_sin * (self.sigma_sin +
self.exx_sin -
self.vxc_sin)
results = {'f': self.f_sin,
'eps': self.eps_sin * Hartree,
'vxc': self.vxc_sin * Hartree,
'exx': self.exx_sin * Hartree,
'sigma': self.sigma_sin * Hartree,
'Z': self.Z_sin,
'qp': self.qp_sin * Hartree}
self.print_results(results)
return results
def calculate_q(self, i, kpt1, kpt2, pd0, W0):
"""Calculates the contribution to the self-energy and its derivative
for a given set of k-points, kpt1 and kpt2."""
wfs = self.calc.wfs
N_c = pd0.gd.N_c
i_cG = self.sign * np.dot(self.U_cc,
np.unravel_index(pd0.Q_qG[0], N_c))
q_c = wfs.kd.bzk_kc[kpt2.K] - wfs.kd.bzk_kc[kpt1.K]
q0 = np.allclose(q_c, 0) and not self.wstc
shift0_c = q_c - self.sign * np.dot(self.U_cc, pd0.kd.bzk_kc[0])
assert np.allclose(shift0_c.round(), shift0_c)
shift0_c = shift0_c.round().astype(int)
shift_c = kpt1.shift_c - kpt2.shift_c - shift0_c
I_G = np.ravel_multi_index(i_cG + shift_c[:, None], N_c, 'wrap')
G_Gv = pd0.get_reciprocal_vectors()
pos_av = np.dot(self.spos_ac, pd0.gd.cell_cv)
M_vv = np.dot(pd0.gd.cell_cv.T,
np.dot(self.U_cc.T,
np.linalg.inv(pd0.gd.cell_cv).T))
Q_aGii = []
for a, Q_Gii in enumerate(self.Q_aGii):
x_G = np.exp(1j * np.dot(G_Gv, (pos_av[a] -
self.sign *
np.dot(M_vv, pos_av[a]))))
U_ii = self.calc.wfs.setups[a].R_sii[self.s]
Q_Gii = np.dot(np.dot(U_ii, Q_Gii * x_G[:, None, None]),
U_ii.T).transpose(1, 0, 2)
Q_aGii.append(Q_Gii)
if debug:
self.check(i_cG, shift0_c, N_c, q_c, Q_aGii)
if self.ppa:
calculate_sigma = self.calculate_sigma_ppa
else:
calculate_sigma = self.calculate_sigma
for n in range(kpt1.n2 - kpt1.n1):
ut1cc_R = kpt1.ut_nR[n].conj()
eps1 = kpt1.eps_n[n]
C1_aGi = [np.dot(Qa_Gii, P1_ni[n].conj())
for Qa_Gii, P1_ni in zip(Q_aGii, kpt1.P_ani)]
n_mG = self.calculate_pair_densities(ut1cc_R, C1_aGi, kpt2,
pd0, I_G)
if self.sign == 1:
n_mG = n_mG.conj()
if q0:
n_mG[:, 0] = 0
m = n + kpt1.n1 - kpt2.n1
if 0 <= m < len(n_mG):
n_mG[m, 0] = 1.0
f_m = kpt2.f_n
deps_m = eps1 - kpt2.eps_n
sigma, dsigma = calculate_sigma(n_mG, deps_m, f_m, W0)
nn = kpt1.n1 + n - self.bands[0]
self.sigma_sin[kpt1.s, i, nn] += sigma
self.dsigma_sin[kpt1.s, i, nn] += dsigma
def check(self, i_cG, shift0_c, N_c, q_c, Q_aGii):
I0_G = np.ravel_multi_index(i_cG - shift0_c[:, None], N_c, 'wrap')
qd1 = KPointDescriptor([q_c])
pd1 = PWDescriptor(self.ecut, self.calc.wfs.gd, complex, qd1)
G_I = np.empty(N_c.prod(), int)
G_I[:] = -1
I1_G = pd1.Q_qG[0]
G_I[I1_G] = np.arange(len(I0_G))
G_G = G_I[I0_G]
assert len(I0_G) == len(I1_G)
assert (G_G >= 0).all()
for a, Q_Gii in enumerate(self.initialize_paw_corrections(pd1)):
e = abs(Q_aGii[a] - Q_Gii[G_G]).max()
assert e < 1e-12
@timer('Sigma')
def calculate_sigma(self, n_mG, deps_m, f_m, C_swGG):
"""Calculates a contribution to the self-energy and its derivative for
a given (k, k-q)-pair from its corresponding pair-density and
energy."""
o_m = abs(deps_m)
# Add small number to avoid zeros for degenerate states:
sgn_m = np.sign(deps_m + 1e-15)
# Pick +i*eta or -i*eta:
s_m = (1 + sgn_m * np.sign(0.5 - f_m)).astype(int) // 2
beta = (2**0.5 - 1) * self.domega0 / self.omega2
w_m = (o_m / (self.domega0 + beta * o_m)).astype(int)
o1_m = self.omega_w[w_m]
o2_m = self.omega_w[w_m + 1]
x = 1.0 / (self.qd.nbzkpts * 2 * pi * self.vol)
sigma = 0.0
dsigma = 0.0
# Performing frequency integration
for o, o1, o2, sgn, s, w, n_G in zip(o_m, o1_m, o2_m,
sgn_m, s_m, w_m, n_mG):
C1_GG = C_swGG[s][w]
C2_GG = C_swGG[s][w + 1]
p = x * sgn
myn_G = n_G[self.Ga:self.Gb]
sigma1 = p * np.dot(np.dot(myn_G, C1_GG), n_G.conj()).imag
sigma2 = p * np.dot(np.dot(myn_G, C2_GG), n_G.conj()).imag
sigma += ((o - o1) * sigma2 + (o2 - o) * sigma1) / (o2 - o1)
dsigma += sgn * (sigma2 - sigma1) / (o2 - o1)
return sigma, dsigma
def calculate_screened_potential(self):
"""Calculates the screened potential for each q-point in the 1st BZ.
Since many q-points are related by symmetry, the actual calculation is
only done for q-points in the IBZ and the rest are obtained by symmetry
transformations. Results are returned as a generator to that it is not
necessary to store a huge matrix for each q-point in the memory."""
# The decorator $timer('W') doesn't work for generators, do we will
# have to manually start and stop the timer here:
self.timer.start('W')
print('Calculating screened Coulomb potential', file=self.fd)
if self.wstc:
print('Using Wigner-Seitz truncated Coloumb potential',
file=self.fd)
if self.ppa:
print('Using Godby-Needs plasmon-pole approximation:',
file=self.fd)
print(' Fitting energy: i*E0, E0 = %.3f Hartee' % self.E0,
file=self.fd)
# use small imaginary frequency to avoid dividing by zero:
frequencies = [1e-10j, 1j * self.E0 * Hartree]
parameters = {'eta': 0,
'hilbert': False,
'timeordered': False,
'frequencies': frequencies}
else:
print('Using full frequency integration:', file=self.fd)
print(' domega0: {0:g}'.format(self.domega0 * Hartree),
file=self.fd)
print(' omega2: {0:g}'.format(self.omega2 * Hartree),
file=self.fd)
parameters = {'eta': self.eta * Hartree,
'hilbert': True,
'timeordered': True,
'domega0': self.domega0 * Hartree,
'omega2': self.omega2 * Hartree}
chi0 = Chi0(self.inputcalc,
nbands=self.nbands,
ecut=self.ecut * Hartree,
intraband=False,
real_space_derivatives=False,
txt=self.filename + '.w.txt',
timer=self.timer,
keep_occupied_states=True,
nblocks=self.blockcomm.size,
no_optical_limit=self.wstc,
**parameters)
if self.wstc:
wstc = WignerSeitzTruncatedCoulomb(
self.calc.wfs.gd.cell_cv,
self.calc.wfs.kd.N_c,
chi0.fd)
else:
wstc = None
self.omega_w = chi0.omega_w
self.omegamax = chi0.omegamax
htp = HilbertTransform(self.omega_w, self.eta, gw=True)
htm = HilbertTransform(self.omega_w, -self.eta, gw=True)
# Find maximum size of chi-0 matrices:
gd = self.calc.wfs.gd
nGmax = max(count_reciprocal_vectors(self.ecut, gd, q_c)
for q_c in self.qd.ibzk_kc)
nw = len(self.omega_w)
size = self.blockcomm.size
mynGmax = (nGmax + size - 1) // size
mynw = (nw + size - 1) // size
# Allocate memory in the beginning and use for all q:
A1_x = np.empty(nw * mynGmax * nGmax, complex)
A2_x = np.empty(max(mynw * nGmax, nw * mynGmax) * nGmax, complex)
# Need to pause the timer in between iterations
self.timer.stop('W')
for iq, q_c in enumerate(self.qd.ibzk_kc):
self.timer.start('W')
if self.savew:
wfilename = self.filename + '.w.q%d.pckl' % iq
fd = opencew(wfilename)
if self.savew and fd is None:
# Read screened potential from file
with open(wfilename) as fd:
pd, W = pickle.load(fd)
# We also need to initialize the PAW corrections
self.Q_aGii = self.initialize_paw_corrections(pd)
else:
# First time calculation
pd, W = self.calculate_w(chi0, q_c, htp, htm, wstc, A1_x, A2_x)
if self.savew:
pickle.dump((pd, W), fd, pickle.HIGHEST_PROTOCOL)
self.timer.stop('W')
# Loop over all k-points in the BZ and find those that are related
# to the current IBZ k-point by symmetry
Q1 = self.qd.ibz2bz_k[iq]
done = set()
for s, Q2 in enumerate(self.qd.bz2bz_ks[Q1]):
if Q2 >= 0 and Q2 not in done:
s = self.qd.sym_k[Q2]
self.s = s
self.U_cc = self.qd.symmetry.op_scc[s]
time_reversal = self.qd.time_reversal_k[Q2]
self.sign = 1 - 2 * time_reversal
Q_c = self.qd.bzk_kc[Q2]
d_c = self.sign * np.dot(self.U_cc, q_c) - Q_c
assert np.allclose(d_c.round(), d_c)
yield pd, W, Q_c
done.add(Q2)
@timer('WW')
def calculate_w(self, chi0, q_c, htp, htm, wstc, A1_x, A2_x):
"""Calculates the screened potential for a specified q-point."""
pd, chi0_wGG = chi0.calculate(q_c, A_x=A1_x)[:2]
self.Q_aGii = chi0.Q_aGii
self.Ga = chi0.Ga
self.Gb = chi0.Gb
if self.blockcomm.size > 1:
A1_x = chi0_wGG.ravel()
chi0_wGG = chi0.redistribute(chi0_wGG, A2_x)
if self.wstc:
iG_G = (wstc.get_potential(pd) / (4 * pi))**0.5
if np.allclose(q_c, 0):
chi0_wGG[:, 0] = 0.0
chi0_wGG[:, :, 0] = 0.0
G0inv = 0.0
G20inv = 0.0
else:
G0inv = None
G20inv = None
else:
if np.allclose(q_c, 0):
dq3 = (2 * pi)**3 / (self.qd.nbzkpts * self.vol)
qc = (dq3 / 4 / pi * 3)**(1 / 3)
G0inv = 2 * pi * qc**2 / dq3
G20inv = 4 * pi * qc / dq3
G_G = pd.G2_qG[0]**0.5
G_G[0] = 1
iG_G = 1 / G_G
else:
iG_G = pd.G2_qG[0]**-0.5
G0inv = None
G20inv = None
delta_GG = np.eye(len(iG_G))
if self.ppa:
return pd, self.ppa_w(chi0_wGG, iG_G, delta_GG, G0inv, G20inv, q_c)
self.timer.start('Dyson eq.')
# Calculate W and store it in chi0_wGG ndarray:
for chi0_GG in chi0_wGG:
e_GG = (delta_GG -
4 * pi * chi0_GG * iG_G * iG_G[:, np.newaxis])
W_GG = chi0_GG
W_GG[:] = 4 * pi * (np.linalg.inv(e_GG) -
delta_GG) * iG_G * iG_G[:, np.newaxis]
if np.allclose(q_c, 0):
W_GG[0, 0] *= G20inv
W_GG[1:, 0] *= G0inv
W_GG[0, 1:] *= G0inv
if self.blockcomm.size > 1:
Wm_wGG = chi0.redistribute(chi0_wGG, A1_x)
else:
Wm_wGG = chi0_wGG
Wp_wGG = A2_x[:Wm_wGG.size].reshape(Wm_wGG.shape)
Wp_wGG[:] = Wm_wGG
with self.timer('Hilbert transform'):
htp(Wp_wGG)
htm(Wm_wGG)
self.timer.stop('Dyson eq.')
return pd, [Wp_wGG, Wm_wGG]
@timer('Kohn-Sham XC-contribution')
def calculate_ks_xc_contribution(self):
name = self.filename + '.vxc.npy'
fd = opencew(name)
if fd is None:
print('Reading Kohn-Sham XC contribution from file:', name,
file=self.fd)
with open(name) as fd:
self.vxc_sin = np.load(fd)
assert self.vxc_sin.shape == self.shape, self.vxc_sin.shape
return
print('Calculating Kohn-Sham XC contribution', file=self.fd)
if self.reader is not None:
self.calc.wfs.read_projections(self.reader)
vxc_skn = vxc(self.calc, self.calc.hamiltonian.xc) / Hartree
n1, n2 = self.bands
self.vxc_sin = vxc_skn[:, self.kpts, n1:n2]
np.save(fd, self.vxc_sin)
@timer('EXX')
def calculate_exact_exchange(self):
name = self.filename + '.exx.npy'
fd = opencew(name)
if fd is None:
print('Reading EXX contribution from file:', name, file=self.fd)
with open(name) as fd:
self.exx_sin = np.load(fd)
assert self.exx_sin.shape == self.shape, self.exx_sin.shape
return
print('Calculating EXX contribution', file=self.fd)
exx = EXX(self.calc, kpts=self.kpts, bands=self.bands,
txt=self.filename + '.exx.txt', timer=self.timer)
exx.calculate()
self.exx_sin = exx.get_eigenvalue_contributions() / Hartree
np.save(fd, self.exx_sin)
def print_results(self, results):
description = ['f: Occupation numbers',
'eps: KS-eigenvalues [eV]',
'vxc: KS vxc [eV]',
'exx: Exact exchange [eV]',
'sigma: Self-energies [eV]',
'Z: Renormalization factors',
'qp: QP-energies [eV]']
print('\nResults:', file=self.fd)
for line in description:
print(line, file=self.fd)
b1, b2 = self.bands
names = [line.split(':', 1)[0] for line in description]
ibzk_kc = self.calc.wfs.kd.ibzk_kc
for s in range(self.calc.wfs.nspins):
for i, ik in enumerate(self.kpts):
print('\nk-point ' +
'{0} ({1}): ({2:.3f}, {3:.3f}, {4:.3f})'.format(
i, ik, *ibzk_kc[ik]), file=self.fd)
print('band' +
''.join('{0:>8}'.format(name) for name in names),
file=self.fd)
for n in range(b2 - b1):
print('{0:4}'.format(n + b1) +
''.join('{0:8.3f}'.format(results[name][s, i, n])
for name in names),
file=self.fd)
self.timer.write(self.fd)
@timer('PPA')
def ppa_w(self, chi0_wGG, iG_G, delta_GG, G0inv, G20inv, q_c):
einv_wGG = []
for chi0_GG in chi0_wGG:
e_GG = (delta_GG -
4 * pi * chi0_GG * iG_G * iG_G[:, np.newaxis])
einv_wGG.append(np.linalg.inv(e_GG) - delta_GG)
if self.wstc and np.allclose(q_c, 0):
einv_wGG[0][0] = 42
einv_wGG[0][:, 0] = 42
omegat_GG = self.E0 * np.sqrt(einv_wGG[1] /
(einv_wGG[0] - einv_wGG[1]))
R_GG = -0.5 * omegat_GG * einv_wGG[0]
W_GG = 4 * pi**2 * R_GG * iG_G * iG_G[:, np.newaxis]
if np.allclose(q_c, 0):
W_GG[0, 0] *= G20inv
W_GG[1:, 0] *= G0inv
W_GG[0, 1:] *= G0inv
return [W_GG, omegat_GG]
@timer('PPA-Sigma')
def calculate_sigma_ppa(self, n_mG, deps_m, f_m, W):
W_GG, omegat_GG = W
sigma = 0.0
dsigma = 0.0
# init variables (is this necessary?)
nG = n_mG.shape[1]
deps_GG = np.empty((nG, nG))
sign_GG = np.empty((nG, nG))
x1_GG = np.empty((nG, nG))
x2_GG = np.empty((nG, nG))
x3_GG = np.empty((nG, nG))
x4_GG = np.empty((nG, nG))
x_GG = np.empty((nG, nG))
dx_GG = np.empty((nG, nG))
nW_G = np.empty(nG)
for m in range(np.shape(n_mG)[0]):
deps_GG = deps_m[m]
sign_GG = 2 * f_m[m] - 1
x1_GG = 1 / (deps_GG + omegat_GG - 1j * self.eta)
x2_GG = 1 / (deps_GG - omegat_GG + 1j * self.eta)
x3_GG = 1 / (deps_GG + omegat_GG - 1j * self.eta * sign_GG)
x4_GG = 1 / (deps_GG - omegat_GG - 1j * self.eta * sign_GG)
x_GG = W_GG * (sign_GG * (x1_GG - x2_GG) + x3_GG + x4_GG)
dx_GG = W_GG * (sign_GG * (x1_GG**2 - x2_GG**2) +
x3_GG**2 + x4_GG**2)
nW_G = np.dot(n_mG[m], x_GG)
sigma += np.vdot(n_mG[m], nW_G).real
nW_G = np.dot(n_mG[m], dx_GG)
dsigma -= np.vdot(n_mG[m], nW_G).real
x = 1 / (self.qd.nbzkpts * 2 * pi * self.vol)
return x * sigma, x * dsigma
gpaw-0.11.0.13004/gpaw/response/gw.py 0000664 0001750 0001750 00000070761 12553643470 017252 0 ustar jensj jensj 0000000 0000000 import os
import sys
import pickle
import numpy as np
from math import pi, sqrt
from time import time, ctime
from datetime import timedelta
from ase.parallel import paropen
from ase.units import Hartree, Bohr
from ase.utils import devnull
from gpaw import GPAW
from gpaw.version import version
from gpaw.mpi import world, rank, size, serial_comm
from gpaw.utilities.blas import gemmdot
from gpaw.xc.tools import vxc
from gpaw.wavefunctions.pw import PWWaveFunctions
from gpaw.response.parallel import set_communicator, parallel_partition, SliceAlongFrequency, GatherOrbitals
from gpaw.response.base import BASECHI
from gpaw.response.df0 import DF
from gpaw.response.kernel import calculate_Kxc, calculate_Kc, calculate_Kc_q
class GW(BASECHI):
def __init__(
self,
file=None,
nbands=None,
bands=None,
kpoints=None,
e_skn=None,
eshift=None,
w=None,
ecut=150.,
eta=0.1,
ppa=False,
E0=None,
hilbert_trans=False,
wpar=1,
vcut=None,
numint=False,
txt=None
):
BASECHI.__init__(self, calc=file, nbands=nbands, w=w, eshift=eshift, ecut=ecut, eta=eta, txt=devnull)
self.file = file
self.gwnbands = nbands
self.bands = bands
self.kpoints = kpoints
self.user_skn = e_skn
self.ppa = ppa
self.E0 = E0
self.hilbert_trans = hilbert_trans
self.wpar = wpar
self.vcut = vcut
self.numint = numint
self.gwtxtname = txt
def initialize(self):
self.ini = True
BASECHI.initialize(self)
self.txtname = self.gwtxtname
self.output_init()
self.printtxt('GPAW version %s' %(version))
self.printtxt('-----------------------------------------------')
self.printtxt('GW calculation started at:')
self.printtxt(ctime())
self.printtxt('-----------------------------------------------')
self.starttime = time()
calc = self.calc
kd = self.kd
# band init
if self.gwnbands is None:
if self.npw > calc.wfs.bd.nbands:
self.nbands = calc.wfs.bd.nbands
else:
self.nbands = self.npw
# eigenvalue init
if self.user_skn is not None:
self.printtxt('Use eigenvalues from user.')
assert np.shape(self.user_skn)[0] == self.nspins, 'Eigenvalues not compatible with .gpw file!'
assert np.shape(self.user_skn)[1] == self.kd.nibzkpts, 'Eigenvalues not compatible with .gpw file!'
assert np.shape(self.user_skn)[2] >= self.nbands, 'Too few eigenvalues!'
self.e_skn = self.user_skn
else:
self.printtxt('Use eigenvalues from the calculator.')
# q point init
self.bzq_kc = kd.get_bz_q_points()
self.ibzq_qc = self.bzq_kc # q point symmetry is not used at the moment.
self.nqpt = np.shape(self.bzq_kc)[0]
# frequency points init
self.static=False
if self.ppa: # Plasmon Pole Approximation
if self.E0 is None:
self.E0 = Hartree
self.E0 /= Hartree
self.w_w = np.array([0., 1j*self.E0])
self.hilbert_trans=False
self.wpar=1
elif self.w_w is None: # static COHSEX
self.w_w = np.array([0.])
self.static=True
self.hilbert_trans=False
self.wpar=1
self.eta = 0.0001 / Hartree
else:
# create nonlinear frequency grid
# grid is linear from 0 to wcut with spacing dw
# spacing is linearily increasing between wcut and wmax
# Hilbert transforms are still carried out on linear grid
wcut = self.w_w[0]
wmax = self.w_w[1]
dw = self.w_w[2]
w_w = np.linspace(0., wcut, wcut/dw+1)
i=1
wi=wcut
while wi < wmax:
wi += i*dw
w_w = np.append(w_w, wi)
i+=1
while len(w_w) % self.wpar != 0:
wi += i*dw
w_w = np.append(w_w, wi)
i+=1
dw_w = np.zeros(len(w_w))
dw_w[0] = dw
dw_w[1:] = w_w[1:] - w_w[:-1]
self.w_w = w_w / Hartree
self.dw_w = dw_w / Hartree
self.eta_w = dw_w * 4 / Hartree
self.wcut = wcut
self.wmax = self.w_w[-1]
self.wmin = self.w_w[0]
self.dw = self.w_w[1] - self.w_w[0]
self.Nw = len(self.w_w)
# self.wpar = int(self.Nw * self.npw**2 * 16. / 1024**2) // 1500 + 1 # estimate memory and parallelize over frequencies
for s in range(self.nspins):
emaxdiff = self.e_skn[s][:,self.nbands-1].max() - self.e_skn[s][:,0].min()
assert (self.wmax > emaxdiff), 'Maximum frequency must be larger than %f' %(emaxdiff*Hartree)
# GW kpoints init
if self.kpoints is None:
self.gwnkpt = self.kd.nibzkpts
self.gwkpt_k = kd.ibz2bz_k
else:
self.gwnkpt = np.shape(self.kpoints)[0]
self.gwkpt_k = self.kpoints
# GW bands init
if self.bands is None:
self.gwnband = self.nbands
self.bands = self.gwbands_n = np.arange(self.nbands)
else:
self.gwnband = np.shape(self.bands)[0]
self.gwbands_n = self.bands
self.alpha = 1j/(2*pi * self.vol * self.kd.nbzkpts)
# parallel init
assert len(self.w_w) % self.wpar == 0
self.wcommsize = self.wpar
self.qcommsize = size // self.wpar
assert self.qcommsize * self.wcommsize == size, 'wpar must be integer divisor of number of requested cores'
if self.nqpt != 1: # parallelize over q-points
self.wcomm, self.qcomm, self.worldcomm = set_communicator(world, rank, size, self.wpar)
self.ncomm = serial_comm
self.dfcomm = self.wcomm
self.kcommsize = 1
else: # parallelize over bands
self.wcomm, self.ncomm, self.worldcomm = set_communicator(world, rank, size, self.wpar)
self.qcomm = serial_comm
if self.wpar > 1:
self.dfcomm = self.wcomm
self.kcommsize = 1
else:
self.dfcomm = self.ncomm
self.kcommsize = self.ncomm.size
nq, self.nq_local, self.q_start, self.q_end = parallel_partition(
self.nqpt, self.qcomm.rank, self.qcomm.size, reshape=False)
nb, self.nbands_local, self.m_start, self.m_end = parallel_partition(
self.nbands, self.ncomm.rank, self.ncomm.size, reshape=False)
def get_QP_spectrum(self, exxfile='EXX.pckl', file='GW.pckl'):
try:
self.ini
except:
self.initialize()
self.print_gw_init()
self.printtxt("calculating Self energy")
Sigma_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
dSigma_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
Z_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
t0 = time()
t_w = 0
t_selfenergy = 0
for iq in range(self.q_start, self.q_end):
if iq >= self.nqpt:
continue
t1 = time()
# get screened interaction.
df, W_wGG = self.screened_interaction_kernel(iq)
t2 = time()
t_w += t2 - t1
# get self energy
S, dS = self.get_self_energy(df, W_wGG)
t3 = time() - t2
t_selfenergy += t3
Sigma_skn += S
dSigma_skn += dS
del df, W_wGG
self.timing(iq, t0, self.nq_local, 'iq')
self.qcomm.barrier()
self.qcomm.sum(Sigma_skn)
self.qcomm.sum(dSigma_skn)
self.printtxt('W_wGG takes %s ' %(timedelta(seconds=round(t_w))))
self.printtxt('Self energy takes %s ' %(timedelta(seconds=round(t_selfenergy))))
Z_skn = 1. / (1. - dSigma_skn)
# exact exchange
exx = os.path.isfile(exxfile)
world.barrier()
if exx:
open(exxfile)
self.printtxt("reading Exact exchange and E_XC from file")
else:
t0 = time()
self.get_exact_exchange()
world.barrier()
exxfile='EXX.pckl'
self.printtxt('EXX takes %s ' %(timedelta(seconds=round(time()-t0))))
data = pickle.load(open(exxfile, 'rb'))
vxc_skn = data['vxc_skn'] # in Hartree
exx_skn = data['exx_skn'] # in Hartree
f_skn = data['f_skn']
gwkpt_k = data['gwkpt_k']
gwbands_n = data['gwbands_n']
assert (gwkpt_k == self.gwkpt_k).all(), 'exxfile inconsistent with input parameters'
assert (gwbands_n == self.gwbands_n).all(), 'exxfile inconsistent with input parameters'
if self.user_skn is None:
e_skn = data['e_skn'] # in Hartree
else:
e_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
for s in range(self.nspins):
for i, k in enumerate(self.gwkpt_k):
ik = self.kd.bz2ibz_k[k]
for j, n in enumerate(self.gwbands_n):
if self.user_skn is None:
assert e_skn[s][i][j] == self.e_skn[s][ik][n], 'exxfile inconsistent with eigenvalues'
else:
e_skn[s][i][j] = self.e_skn[s][ik][n]
if not self.static:
QP_skn = e_skn + Z_skn * (Sigma_skn + exx_skn - vxc_skn)
else:
QP_skn = e_skn + Sigma_skn - vxc_skn
self.QP_skn = QP_skn
# finish
self.print_gw_finish(e_skn, f_skn, vxc_skn, exx_skn, Sigma_skn, Z_skn, QP_skn)
data = {
'gwkpt_k': self.gwkpt_k,
'gwbands_n': self.gwbands_n,
'f_skn': f_skn,
'e_skn': e_skn, # in Hartree
'vxc_skn': vxc_skn, # in Hartree
'exx_skn': exx_skn, # in Hartree
'Sigma_skn': Sigma_skn, # in Hartree
'Z_skn': Z_skn, # dimensionless
'QP_skn': QP_skn # in Hartree
}
if rank == 0:
pickle.dump(data, open(file, 'wb'), -1)
def screened_interaction_kernel(self, iq):
"""Calcuate W_GG(w) for a given q.
if static: return W_GG(w=0)
is not static: return W_GG(q,w) - Vc_GG
"""
q = self.ibzq_qc[iq]
w = self.w_w.copy()*Hartree
optical_limit = False
if np.abs(q).sum() < 1e-8:
q = np.array([1e-12, 0, 0]) # arbitrary q, not really need to be calculated
optical_limit = True
hilbert_trans = True
if self.ppa or self.static:
hilbert_trans = False
df = DF(calc=self.calc, q=q.copy(), w=w, nbands=self.nbands, eshift=None,
optical_limit=optical_limit, hilbert_trans=hilbert_trans, xc='RPA', time_ordered=True,
rpad=self.rpad, vcut=self.vcut, G_plus_q=True,
eta=self.eta*Hartree, ecut=self.ecut.copy()*Hartree,
txt='df.out', comm=self.dfcomm, kcommsize=self.kcommsize)
df.initialize()
df.e_skn = self.e_skn.copy()
df.calculate()
dfinv_wGG = df.get_inverse_dielectric_matrix(xc='RPA')
assert df.ecut[0] == self.ecut[0]
if not self.static and not self.ppa:
assert df.eta == self.eta
assert df.Nw == self.Nw
assert df.dw == self.dw
# calculate Coulomb kernel and use truncation in 2D
delta_GG = np.eye(df.npw)
Vq_G = np.diag(calculate_Kc(q,
df.Gvec_Gc,
self.acell_cv,
self.bcell_cv,
self.pbc,
integrate_gamma=True,
N_k=self.kd.N_c,
vcut=self.vcut))**0.5
if (self.vcut == '2D' and df.optical_limit) or self.numint:
for iG in range(len(df.Gvec_Gc)):
if df.Gvec_Gc[iG, 0] == 0 and df.Gvec_Gc[iG, 1] == 0:
v_q, v0_q = calculate_Kc_q(self.acell_cv,
self.bcell_cv,
self.pbc,
self.kd.N_c,
vcut=self.vcut,
q_qc=np.array([q]),
Gvec_c=df.Gvec_Gc[iG])
Vq_G[iG] = v_q[0]**0.5
self.Kc_GG = np.outer(Vq_G, Vq_G)
if self.ppa:
dfinv1_GG = dfinv_wGG[0] - delta_GG
dfinv2_GG = dfinv_wGG[1] - delta_GG
self.wt_GG = self.E0 * np.sqrt(dfinv2_GG / (dfinv1_GG - dfinv2_GG))
self.R_GG = - self.wt_GG / 2 * dfinv1_GG
del dfinv_wGG
dfinv_wGG = np.array([1j*pi*self.R_GG + delta_GG])
if self.static:
assert len(dfinv_wGG) == 1
W_GG = dfinv_wGG[0] * self.Kc_GG
return df, W_GG
else:
Nw = np.shape(dfinv_wGG)[0]
W_wGG = np.zeros_like(dfinv_wGG)
for iw in range(Nw):
dfinv_wGG[iw] -= delta_GG
W_wGG[iw] = dfinv_wGG[iw] * self.Kc_GG
return df, W_wGG
def get_self_energy(self, df, W_wGG):
Sigma_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
dSigma_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
wcomm = df.wcomm
if self.static:
W_wGG = np.array([W_wGG])
if not self.hilbert_trans: #method 1
Wbackup_wG0 = W_wGG[:,:,0].copy()
Wbackup_w0G = W_wGG[:,0,:].copy()
else: #method 2, perform Hilbert transform
nG = np.shape(W_wGG)[1]
coords = np.zeros(wcomm.size, dtype=int)
nG_local = nG**2 // wcomm.size
if wcomm.rank == wcomm.size - 1:
nG_local = nG**2 - (wcomm.size - 1) * nG_local
wcomm.all_gather(np.array([nG_local]), coords)
W_Wg = SliceAlongFrequency(W_wGG, coords, wcomm)
ng = np.shape(W_Wg)[1]
Nw = int(self.w_w[-1] / self.dw)
w1_ww = np.zeros((Nw, df.Nw), dtype=complex)
for iw in range(Nw):
w1 = iw * self.dw
w1_ww[iw] = 1./(w1 + self.w_w + 1j*self.eta_w) + 1./(w1 - self.w_w + 1j*self.eta_w)
w1_ww[iw,0] -= 1./(w1 + 1j*self.eta_w[0]) # correct w'=0
w1_ww[iw] *= self.dw_w
Cplus_Wg = np.zeros((Nw, ng), dtype=complex)
Cminus_Wg = np.zeros((Nw, ng), dtype=complex)
Cplus_Wg = gemmdot(w1_ww, W_Wg, beta=0.0)
Cminus_Wg = gemmdot(w1_ww.conj(), W_Wg, beta=0.0)
for s in range(self.nspins):
for i, k in enumerate(self.gwkpt_k): # k is bzk index
if df.optical_limit:
kq_c = df.kd.bzk_kc[k]
else:
kq_c = df.kd.bzk_kc[k] - df.q_c # k - q
kq = df.kd.where_is_q(kq_c, df.kd.bzk_kc)
assert df.kq_k[kq] == k
ibzkpt1 = df.kd.bz2ibz_k[k]
ibzkpt2 = df.kd.bz2ibz_k[kq]
for j, n in enumerate(self.bands):
for m in range(self.m_start, self.m_end):
if self.e_skn[s][ibzkpt2, m] > self.eFermi:
sign = 1.
else:
sign = -1.
rho_G = df.density_matrix(m, n, kq, spin1=s, spin2=s)
if not self.hilbert_trans: #method 1
W_wGG[:,:,0] = Wbackup_wG0
W_wGG[:,0,:] = Wbackup_w0G
# w1 = w - epsilon_m,k-q
w1 = self.e_skn[s][ibzkpt1,n] - self.e_skn[s][ibzkpt2,m]
if self.ppa:
# analytical expression for Plasmon Pole Approximation
W_GG = sign * W_wGG[0] * (1./(w1 + self.wt_GG - 1j*self.eta) -
1./(w1 - self.wt_GG + 1j*self.eta))
W_GG -= W_wGG[0] * (1./(w1 + self.wt_GG + 1j*self.eta*sign) +
1./(w1 - self.wt_GG + 1j*self.eta*sign))
W_G = gemmdot(W_GG, rho_G, beta=0.0)
Sigma_skn[s,i,j] += np.real(gemmdot(W_G, rho_G, alpha=self.alpha, beta=0.0,trans='c'))
W_GG = sign * W_wGG[0] * (1./(w1 - self.wt_GG + 1j*self.eta)**2 -
1./(w1 + self.wt_GG - 1j*self.eta)**2)
W_GG += W_wGG[0] * (1./(w1 - self.wt_GG + 1j*self.eta*sign)**2 +
1./(w1 + self.wt_GG + 1j*self.eta*sign)**2)
W_G = gemmdot(W_GG, rho_G, beta=0.0)
dSigma_skn[s,i,j] += np.real(gemmdot(W_G, rho_G, alpha=self.alpha, beta=0.0,trans='c'))
elif self.static:
W1_GG = W_wGG[0] - np.eye(df.npw)*self.Kc_GG
W2_GG = W_wGG[0]
# perform W_GG * np.outer(rho_G.conj(), rho_G).sum(GG)
W_G = gemmdot(W1_GG, rho_G, beta=0.0) # Coulomb Hole
Sigma_skn[s,i,j] += np.real(gemmdot(W_G, rho_G, alpha=self.alpha*pi/1j, beta=0.0,trans='c'))
if sign == -1:
W_G = gemmdot(W2_GG, rho_G, beta=0.0) # Screened Exchange
Sigma_skn[s,i,j] -= np.real(gemmdot(W_G, rho_G, alpha=2*self.alpha*pi/1j, beta=0.0,trans='c'))
del W1_GG, W2_GG, W_G, rho_G
else:
# perform W_wGG * np.outer(rho_G.conj(), rho_G).sum(GG)
W_wG = gemmdot(W_wGG, rho_G, beta=0.0)
C_wlocal = gemmdot(W_wG, rho_G, alpha=self.alpha, beta=0.0,trans='c')
del W_wG, rho_G
C_w = np.zeros(df.Nw, dtype=complex)
wcomm.all_gather(C_wlocal, C_w)
del C_wlocal
# calculate self energy
w1_w = 1./(w1 - self.w_w + 1j*self.eta_w*sign) + 1./(w1 + self.w_w + 1j*self.eta_w*sign)
w1_w[0] -= 1./(w1 + 1j*self.eta_w[0]*sign) # correct w'=0
w1_w *= self.dw_w
Sigma_skn[s,i,j] += np.real(gemmdot(C_w, w1_w, beta=0.0))
# calculate derivate of self energy with respect to w
w1_w = 1./(w1 - self.w_w + 1j*self.eta_w*sign)**2 + 1./(w1 + self.w_w + 1j*self.eta_w*sign)**2
w1_w[0] -= 1./(w1 + 1j*self.eta_w[0]*sign)**2 # correct w'=0
w1_w *= self.dw_w
dSigma_skn[s,i,j] -= np.real(gemmdot(C_w, w1_w, beta=0.0))
else: #method 2
if not np.abs(self.e_skn[s][ibzkpt2,m] - self.e_skn[s][ibzkpt1,n]) < 1e-10:
sign *= np.sign(self.e_skn[s][ibzkpt1,n] - self.e_skn[s][ibzkpt2,m])
# find points on frequency grid
w0 = self.e_skn[s][ibzkpt1,n] - self.e_skn[s][ibzkpt2,m]
w0_id = np.abs(int(w0 / self.dw))
w1 = w0_id * self.dw
w2 = (w0_id + 1) * self.dw
# choose plus or minus, treat optical limit:
if sign == 1:
C_Wg = Cplus_Wg[w0_id:w0_id+2] # only two grid points needed for each w0
if sign == -1:
C_Wg = Cminus_Wg[w0_id:w0_id+2] # only two grid points needed for each w0
C_wGG = GatherOrbitals(C_Wg, coords, wcomm).copy()
del C_Wg
# special treat of w0 = 0 (degenerate states):
if w0_id == 0:
Cplustmp_GG = GatherOrbitals(Cplus_Wg[1], coords, wcomm).copy()
Cminustmp_GG = GatherOrbitals(Cminus_Wg[1], coords, wcomm).copy()
# perform C_wGG * np.outer(rho_G.conj(), rho_G).sum(GG)
if w0_id == 0:
Sw0_G = gemmdot(C_wGG[0], rho_G, beta=0.0)
Sw0 = np.real(gemmdot(Sw0_G, rho_G, alpha=self.alpha, beta=0.0, trans='c'))
Sw1_G = gemmdot(Cplustmp_GG, rho_G, beta=0.0)
Sw1 = np.real(gemmdot(Sw1_G, rho_G, alpha=self.alpha, beta=0.0, trans='c'))
Sw2_G = gemmdot(Cminustmp_GG, rho_G, beta=0.0)
Sw2 = np.real(gemmdot(Sw2_G, rho_G, alpha=self.alpha, beta=0.0, trans='c'))
Sigma_skn[s,i,j] += Sw0
dSigma_skn[s,i,j] += (Sw1 + Sw2)/(2*self.dw)
else:
Sw1_G = gemmdot(C_wGG[0], rho_G, beta=0.0)
Sw1 = np.real(gemmdot(Sw1_G, rho_G, alpha=self.alpha, beta=0.0, trans='c'))
Sw2_G = gemmdot(C_wGG[1], rho_G, beta=0.0)
Sw2 = np.real(gemmdot(Sw2_G, rho_G, alpha=self.alpha, beta=0.0, trans='c'))
Sw0 = (w2-np.abs(w0))/self.dw * Sw1 + (np.abs(w0)-w1)/self.dw * Sw2
Sigma_skn[s,i,j] += np.sign(self.e_skn[s][ibzkpt1,n] - self.e_skn[s][ibzkpt2,m]) * Sw0
dSigma_skn[s,i,j] += (Sw2 - Sw1)/self.dw
self.ncomm.barrier()
self.ncomm.sum(Sigma_skn)
self.ncomm.sum(dSigma_skn)
return Sigma_skn, dSigma_skn
def get_exact_exchange(self, ecut=None, communicator=world, file='EXX.pckl'):
try:
self.ini
except:
self.initialize()
self.printtxt('------------------------------------------------')
self.printtxt("calculating Exact exchange and E_XC")
calc = GPAW(self.file, communicator=communicator, parallel={'domain':1, 'band':1}, txt=None)
v_xc = vxc(calc)
if ecut is None:
ecut = self.ecut.max()
else:
ecut /= Hartree
if self.pwmode: # planewave mode
from gpaw.xc.hybridg import HybridXC
self.printtxt('Use planewave ecut from groundstate calculator: %4.1f eV' % (calc.wfs.pd.ecut*Hartree) )
exx = HybridXC('EXX', alpha=5.0, bandstructure=True, bands=self.bands)
else: # grid mode
from gpaw.xc.hybridk import HybridXC
self.printtxt('Planewave ecut (eV): %4.1f' % (ecut*Hartree) )
exx = HybridXC('EXX', alpha=5.0, ecut=ecut, bands=self.bands)
calc.get_xc_difference(exx)
e_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
f_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
vxc_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
exx_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
for s in range(self.nspins):
for i, k in enumerate(self.gwkpt_k):
ik = self.kd.bz2ibz_k[k]
for j, n in enumerate(self.gwbands_n):
e_skn[s][i][j] = self.e_skn[s][ik][n]
f_skn[s][i][j] = self.f_skn[s][ik][n]
vxc_skn[s][i][j] = v_xc[s][ik][n] / Hartree
exx_skn[s][i][j] = exx.exx_skn[s][ik][n]
if self.eshift is not None:
if e_skn[s][i][j] > self.eFermi:
vxc_skn[s][i][j] += self.eshift / Hartree
data = {
'e_skn': e_skn, # in Hartree
'vxc_skn': vxc_skn, # in Hartree
'exx_skn': exx_skn, # in Hartree
'f_skn': f_skn,
'gwkpt_k': self.gwkpt_k,
'gwbands_n': self.gwbands_n
}
if rank == 0:
pickle.dump(data, open(file, 'wb'), -1)
self.printtxt("------------------------------------------------")
self.printtxt("non-selfconsistent HF eigenvalues are (eV):")
self.printtxt((e_skn - vxc_skn + exx_skn)*Hartree)
def print_gw_init(self):
if self.eshift is not None:
self.printtxt('Shift unoccupied bands by %f eV' % (self.eshift))
for s in range(self.nspins):
self.printtxt('Lowest eigenvalue (spin=%s) : %f eV' %(s, self.e_skn[s][:, 0].min()*Hartree))
self.printtxt('Highest eigenvalue (spin=%s): %f eV' %(s, self.e_skn[s][:, self.nbands-1].max()*Hartree))
self.printtxt('')
if self.ecut[0] == self.ecut[1] and self.ecut[0] == self.ecut[2]:
self.printtxt('Plane wave ecut (eV) : %4.1f' % (self.ecut[0]*Hartree))
else:
self.printtxt('Plane wave ecut (eV) : (%f, %f, %f)' % (self.ecut[0]*Hartree,self.ecut[1]*Hartree,self.ecut[2]*Hartree) )
self.printtxt('Number of plane waves used : %d' %(self.npw) )
self.printtxt('Number of bands : %d' %(self.nbands) )
self.printtxt('Number of k points : %d' %(self.kd.nbzkpts) )
self.printtxt("Number of IBZ k points : %d" %(self.kd.nibzkpts))
self.printtxt("Number of spins : %d" %(self.nspins))
self.printtxt('')
if self.ppa:
self.printtxt("Use Plasmon Pole Approximation")
self.printtxt("imaginary frequency (eV) : %.2f" %(self.E0*Hartree))
self.printtxt("broadening (eV) : %.2f" %(self.eta*Hartree))
elif self.static:
self.printtxt("Use static COHSEX")
else:
self.printtxt("Linear frequency grid (eV) : %.2f - %.2f in %.2f" %(self.wmin*Hartree, self.wcut, self.dw*Hartree))
self.printtxt("Maximum frequency (eV) : %.2f" %(self.wmax*Hartree))
self.printtxt("Number of frequency points : %d" %(self.Nw))
self.printtxt("Use Hilbert transform : %s" %(self.hilbert_trans))
self.printtxt('')
self.printtxt('Coulomb interaction cutoff : %s' % self.vcut)
self.printtxt('')
self.printtxt('Calculate matrix elements for k = :')
for k in self.gwkpt_k:
self.printtxt(self.kd.bzk_kc[k])
self.printtxt('')
self.printtxt('Calculate matrix elements for n = :')
self.printtxt(self.gwbands_n)
self.printtxt('')
def print_gw_finish(self, e_skn, f_skn, vxc_skn, exx_skn, Sigma_skn, Z_skn, QP_skn):
self.printtxt("------------------------------------------------")
self.printtxt("Kohn-Sham eigenvalues are (eV): ")
self.printtxt("%s \n" %(e_skn*Hartree))
self.printtxt("Occupation numbers are: ")
self.printtxt("%s \n" %(f_skn*self.kd.nbzkpts))
self.printtxt("Kohn-Sham exchange-correlation contributions are (eV): ")
self.printtxt("%s \n" %(vxc_skn*Hartree))
self.printtxt("Exact exchange contributions are (eV): ")
self.printtxt("%s \n" %(exx_skn*Hartree))
self.printtxt("Self energy contributions are (eV):")
self.printtxt("%s \n" %(Sigma_skn*Hartree))
if not self.static:
self.printtxt("Renormalization factors are:")
self.printtxt("%s \n" %(Z_skn))
totaltime = round(time() - self.starttime)
self.printtxt("GW calculation finished in %s " %(timedelta(seconds=totaltime)))
self.printtxt("------------------------------------------------")
self.printtxt("Quasi-particle energies are (eV): ")
self.printtxt(QP_skn*Hartree)
gpaw-0.11.0.13004/gpaw/response/math_func.py 0000664 0001750 0001750 00000021650 12553643470 020572 0 ustar jensj jensj 0000000 0000000 from math import sqrt, pi
import numpy as np
from scipy.special.specfun import sphj
from gpaw.utilities.blas import gemmdot
from gpaw.gaunt import nabla, gaunt
from gpaw.spherical_harmonics import Y
def delta_function(x0, dx, Nx, sigma):
deltax = np.zeros(Nx)
for i in range(Nx):
deltax[i] = np.exp(-(i * dx - x0)**2 / (4. * sigma))
return deltax / (2. * sqrt(pi * sigma))
def hilbert_transform(specfunc_wGG, w_w, Nw, dw, eta, fullresponse=False):
NwS = specfunc_wGG.shape[0]
tmp_ww = np.zeros((Nw, NwS), dtype=complex)
ww_w = np.linspace(0., (NwS - 1) * dw, NwS)
for iw in range(Nw):
if fullresponse is False:
tmp_ww[iw] = (1. / (w_w[iw] - ww_w + 1j * eta)
- 1. / (w_w[iw] + ww_w + 1j * eta))
else:
tmp_ww[iw] = (1. / (w_w[iw] - ww_w + 1j * eta)
- 1. / (w_w[iw] + ww_w - 1j * eta))
chi0_wGG = gemmdot(tmp_ww, specfunc_wGG, beta=0.)
return chi0_wGG * dw
def two_phi_planewave_integrals(k_Gv, setup=None, Gstart=0, Gend=None,
rgd=None, phi_jg=None,
phit_jg=None, l_j=None):
"""Calculate PAW-correction matrix elements with planewaves.
::
/ _ _ ik.r _ ~ _ ik.r ~ _
| dr [phi (r) e phi (r) - phi (r) e phi (r)]
/ 1 2 1 2
ll - / 2 ~ ~
= 4pi \sum_lm i Y (k) | dr r [ phi (r) phi (r) - phi (r) phi (r) j (kr)
lm / 1 2 1 2 ll
/
* | d\Omega Y Y Y
/ l1m1 l2m2 lm
"""
if Gend is None:
Gend = len(k_Gv)
if setup is not None:
rgd = setup.rgd
l_j = setup.l_j
# Obtain the phi_j and phit_j
phi_jg = []
phit_jg = []
rcut2 = 2 * max(setup.rcut_j)
gcut2 = rgd.ceil(rcut2)
for phi_g, phit_g in zip(setup.data.phi_jg, setup.data.phit_jg):
phi_g = phi_g.copy()
phit_g = phit_g.copy()
phi_g[gcut2:] = phit_g[gcut2:] = 0.
phi_jg.append(phi_g)
phit_jg.append(phit_g)
else:
assert rgd is not None
assert phi_jg is not None
assert l_j is not None
ng = rgd.N
r_g = rgd.r_g
dr_g = rgd.dr_g
# Construct L (l**2 + m) and j (nl) index
L_i = []
j_i = []
for j, l in enumerate(l_j):
for m in range(2 * l + 1):
L_i.append(l**2 + m)
j_i.append(j)
ni = len(L_i)
nj = len(l_j)
lmax = max(l_j) * 2 + 1
if setup is not None:
assert ni == setup.ni and nj == setup.nj
# Initialize
npw = k_Gv.shape[0]
R_jj = np.zeros((nj, nj))
R_ii = np.zeros((ni, ni))
phi_Gii = np.zeros((npw, ni, ni), dtype=complex)
j_lg = np.zeros((lmax, ng))
# Store (phi_j1 * phi_j2 - phit_j1 * phit_j2 ) for further use
tmp_jjg = np.zeros((nj, nj, ng))
for j1 in range(nj):
for j2 in range(nj):
tmp_jjg[j1, j2] = (phi_jg[j1] * phi_jg[j2] -
phit_jg[j1] * phit_jg[j2])
G_LLL = gaunt(max(l_j))
# Loop over G vectors
for iG in range(Gstart, Gend):
kk = k_Gv[iG]
k = np.sqrt(np.dot(kk, kk)) # calculate length of q+G
# Calculating spherical bessel function
for g, r in enumerate(r_g):
j_lg[:, g] = sphj(lmax - 1, k * r)[1]
for li in range(lmax):
# Radial part
for j1 in range(nj):
for j2 in range(nj):
R_jj[j1, j2] = np.dot(r_g**2 * dr_g,
tmp_jjg[j1, j2] * j_lg[li])
for mi in range(2 * li + 1):
# Angular part
for i1 in range(ni):
L1 = L_i[i1]
j1 = j_i[i1]
for i2 in range(ni):
L2 = L_i[i2]
j2 = j_i[i2]
R_ii[i1, i2] = G_LLL[L1, L2, li**2 + mi] * R_jj[j1, j2]
phi_Gii[iG] += R_ii * Y(li**2 + mi,
kk[0] / k,
kk[1] / k,
kk[2] / k) * (-1j)**li
phi_Gii *= 4 * pi
return phi_Gii.reshape(npw, ni * ni)
def two_phi_nabla_planewave_integrals(k_Gv, setup=None, Gstart=0, Gend=None,
rgd=None, phi_jg=None,
phit_jg=None, l_j=None):
"""Calculate PAW-correction matrix elements with planewaves and gradient.
::
/ _ _ ik.r d _ ~ _ ik.r d ~ _
| dr [phi (r) e -- phi (r) - phi (r) e -- phi (r)]
/ 1 dx 2 1 dx 2
and similar for y and z."""
if Gend is None:
Gend = len(k_Gv)
if setup is not None:
rgd = setup.rgd
l_j = setup.l_j
# Obtain the phi_j and phit_j
phi_jg = []
phit_jg = []
rcut2 = 2 * max(setup.rcut_j)
gcut2 = rgd.ceil(rcut2)
for phi_g, phit_g in zip(setup.data.phi_jg, setup.data.phit_jg):
phi_g = phi_g.copy()
phit_g = phit_g.copy()
phi_g[gcut2:] = phit_g[gcut2:] = 0.
phi_jg.append(phi_g)
phit_jg.append(phit_g)
else:
assert rgd is not None
assert phi_jg is not None
assert l_j is not None
ng = rgd.N
r_g = rgd.r_g
dr_g = rgd.dr_g
# Construct L (l**2 + m) and j (nl) index
L_i = []
j_i = []
for j, l in enumerate(l_j):
for m in range(2 * l + 1):
L_i.append(l**2 + m)
j_i.append(j)
ni = len(L_i)
nj = len(l_j)
lmax = max(l_j) * 2 + 1
ljdef = 3
l2max = max(l_j) * (max(l_j) > ljdef) + ljdef * (max(l_j) <= ljdef)
G_LLL = gaunt(l2max)
Y_LLv = nabla(2 * l2max)
if setup is not None:
assert ni == setup.ni and nj == setup.nj
# Initialize
npw = k_Gv.shape[0]
R1_jj = np.zeros((nj, nj))
R2_jj = np.zeros((nj, nj))
R_vii = np.zeros((3, ni, ni))
phi_vGii = np.zeros((3, npw, ni, ni), dtype=complex)
j_lg = np.zeros((lmax, ng))
# Store (phi_j1 * dphidr_j2 - phit_j1 * dphitdr_j2) for further use
tmp_jjg = np.zeros((nj, nj, ng))
tmpder_jjg = np.zeros((nj, nj, ng))
for j1 in range(nj):
for j2 in range(nj):
dphidr_g = np.empty_like(phi_jg[j2])
rgd.derivative(phi_jg[j2], dphidr_g)
dphitdr_g = np.empty_like(phit_jg[j2])
rgd.derivative(phit_jg[j2], dphitdr_g)
tmpder_jjg[j1, j2] = (phi_jg[j1] * dphidr_g -
phit_jg[j1] * dphitdr_g)
tmp_jjg[j1, j2] = (phi_jg[j1] * phi_jg[j2] -
phit_jg[j1] * phit_jg[j2])
# Loop over G vectors
for iG in range(Gstart, Gend):
kk = k_Gv[iG]
k = np.sqrt(np.dot(kk, kk)) # calculate length of q+G
# Calculating spherical bessel function
for g, r in enumerate(r_g):
j_lg[:, g] = sphj(lmax - 1, k * r)[1]
for li in range(lmax):
# Radial part
for j1 in range(nj):
for j2 in range(nj):
R1_jj[j1, j2] = np.dot(r_g**2 * dr_g,
tmpder_jjg[j1, j2] * j_lg[li])
R2_jj[j1, j2] = np.dot(r_g * dr_g,
tmp_jjg[j1, j2] * j_lg[li])
for mi in range(2 * li + 1):
if k == 0:
Ytmp = Y(li**2 + mi, 1.0, 0, 0)
else:
# Note the spherical bessel gives
# zero when k == 0 for li != 0
Ytmp = Y(li**2 + mi, kk[0] / k, kk[1] / k, kk[2] / k)
for v in range(3):
Lv = 1 + (v + 2) % 3
# Angular part
for i1 in range(ni):
L1 = L_i[i1]
j1 = j_i[i1]
for i2 in range(ni):
L2 = L_i[i2]
j2 = j_i[i2]
l2 = l_j[j2]
R_vii[v, i1, i2] = ((4 * pi / 3)**0.5 *
np.dot(G_LLL[L1, L2],
G_LLL[Lv, li**2 + mi])
* (R1_jj[j1, j2] - l2 *
R2_jj[j1, j2]))
R_vii[v, i1, i2] += (R2_jj[j1, j2] *
np.dot(G_LLL[L1, li**2 + mi],
Y_LLv[:, L2, v]))
phi_vGii[:, iG] += (R_vii * Ytmp * (-1j)**li)
phi_vGii *= 4 * pi
return phi_vGii.reshape(3, npw, ni * ni)
gpaw-0.11.0.13004/gpaw/response/chi.py 0000664 0001750 0001750 00000066424 12553643470 017401 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import sys
from time import time, ctime
import numpy as np
from math import sqrt, pi
from ase.units import Hartree, Bohr
from gpaw import extra_parameters
from gpaw.utilities.blas import gemv, scal, axpy, czher
from gpaw.mpi import world, rank, size, serial_comm
from gpaw.fd_operators import Gradient
from gpaw.response.math_func import hilbert_transform
from gpaw.response.parallel import set_communicator, \
parallel_partition, parallel_partition_list, SliceAlongFrequency, SliceAlongOrbitals
from gpaw.response.kernel import calculate_Kxc, calculate_Kc
from gpaw.response.kernel import CoulombKernel
from gpaw.utilities.memory import maxrss
from gpaw.response.base import BASECHI
class CHI(BASECHI):
"""This class is a calculator for the linear density response function.
Parameters:
nband: int
Number of bands.
wmax: floadent
Maximum energy for spectrum.
dw: float
Frequency interval.
wlist: tuple
Frequency points.
q: ndarray
Momentum transfer in reduced coordinate.
Ecut: ndarray
Planewave cutoff energy.
eta: float
Spectrum broadening factor.
sigma: float
Width for delta function.
"""
def __init__(self,
calc=None,
nbands=None,
w=None,
q=None,
eshift=None,
ecut=10.,
density_cut=None,
G_plus_q=False,
eta=0.2,
rpad=None,
vcut=None,
ftol=1e-5,
txt=None,
xc='ALDA',
hilbert_trans=True,
time_ordered=False,
optical_limit=False,
comm=None,
kcommsize=None):
BASECHI.__init__(self, calc=calc, nbands=nbands, w=w, q=q,
eshift=eshift, ecut=ecut,
density_cut=density_cut, G_plus_q=G_plus_q, eta=eta,
rpad=rpad, ftol=ftol, txt=txt,
optical_limit=optical_limit)
#if vcut is None:
# vcut = '%dD' % self.calc.wfs.gd.pbc_c.sum()
self.vcut = vcut
self.xc = xc
self.hilbert_trans = hilbert_trans
self.full_hilbert_trans = time_ordered
self.kcommsize = kcommsize
self.comm = comm
if self.comm is None:
self.comm = world
self.chi0_wGG = None
def initialize(self, simple_version=False):
self.printtxt('')
self.printtxt('-----------------------------------------')
self.printtxt('Response function calculation started at:')
self.starttime = time()
self.printtxt(ctime())
BASECHI.initialize(self)
# Frequency init
self.dw = None
if len(self.w_w) == 1:
self.hilbert_trans = False
if self.hilbert_trans:
self.dw = self.w_w[1] - self.w_w[0]
# assert ((self.w_w[1:] - self.w_w[:-1] - self.dw) < 1e-10).all() # make sure its linear w grid
assert self.w_w.max() == self.w_w[-1]
self.dw /= Hartree
self.w_w /= Hartree
self.wmax = self.w_w[-1]
self.wcut = self.wmax + 5. / Hartree
# self.Nw = int(self.wmax / self.dw) + 1
self.Nw = len(self.w_w)
self.NwS = int(self.wcut / self.dw) + 1
else:
self.Nw = len(self.w_w)
self.NwS = 0
if len(self.w_w) > 2:
self.dw = self.w_w[1] - self.w_w[0]
assert ((self.w_w[1:] - self.w_w[:-1] - self.dw) < 1e-10).all()
self.dw /= Hartree
self.nvalbands = self.nbands
tmpn = np.zeros(self.nspins, dtype=int)
for spin in range(self.nspins):
for n in range(self.nbands):
if (self.f_skn[spin][:, n] - self.ftol < 0).all():
tmpn[spin] = n
break
if tmpn.max() > 0:
self.nvalbands = tmpn.max()
# Parallelization initialize
self.parallel_init()
# Printing calculation information
self.print_chi()
if extra_parameters.get('df_dry_run'):
raise SystemExit
calc = self.calc
# For LCAO wfs
if calc.input_parameters['mode'] == 'lcao':
calc.initialize_positions()
self.printtxt(' Max mem sofar : %f M / cpu' %(maxrss() / 1024**2))
if simple_version is True:
return
# PAW part init
# calculate
# G != 0 part
self.phi_aGp, self.phiG0_avp = self.get_phi_aGp(alldir=True)
self.printtxt('Finished phi_aGp !')
mem = np.array([self.phi_aGp[i].size * 16 /1024.**2 for i in range(len(self.phi_aGp))])
self.printtxt(' Phi_aGp : %f M / cpu' %(mem.sum()))
# Calculate ALDA kernel (not used in chi0)
R_av = calc.atoms.positions / Bohr
if self.xc == 'RPA': #type(self.w_w[0]) is float:
self.Kc_GG = None
self.printtxt('RPA calculation.')
elif self.xc == 'ALDA' or self.xc == 'ALDA_X':
#self.Kc_GG = calculate_Kc(self.q_c,
# self.Gvec_Gc,
# self.acell_cv,
# self.bcell_cv,
# self.calc.atoms.pbc,
# self.vcut)
# Initialize a CoulombKernel instance
kernel = CoulombKernel(vcut=self.vcut,
pbc=self.calc.atoms.pbc,
cell=self.acell_cv)
self.Kc_GG = kernel.calculate_Kc(self.q_c,
self.Gvec_Gc,
self.bcell_cv)
self.Kxc_sGG = calculate_Kxc(self.gd, # global grid
self.gd.zero_pad(calc.density.nt_sG),
self.npw, self.Gvec_Gc,
self.gd.N_c, self.vol,
self.bcell_cv, R_av,
calc.wfs.setups,
calc.density.D_asp,
functional=self.xc,
density_cut=self.density_cut)
self.printtxt('Finished %s kernel ! ' % self.xc)
return
def pawstuff(self, psit_g, k, n, spin, u, ibzkpt):
if not self.pwmode:
if self.calc.wfs.world.size > 1 or self.kd.nbzkpts == 1:
P_ai = self.pt.dict()
self.pt.integrate(psit_g, P_ai, k)
else:
P_ai = self.get_P_ai(k, n, spin)
else:
# first calculate P_ai at ibzkpt, then rotate to k
Ptmp_ai = self.pt.dict()
kpt = self.calc.wfs.kpt_u[u]
self.pt.integrate(kpt.psit_nG[n], Ptmp_ai, ibzkpt)
P_ai = self.get_P_ai(k, n, spin, Ptmp_ai)
return P_ai
def calculate(self, seperate_spin=None):
"""Calculate the non-interacting density response function. """
calc = self.calc
kd = self.kd
gd = self.gd
sdisp_cd = gd.sdisp_cd
ibzk_kc = kd.ibzk_kc
bzk_kc = kd.bzk_kc
kq_k = self.kq_k
f_skn = self.f_skn
e_skn = self.e_skn
# Matrix init
chi0_wGG = np.zeros((self.Nw_local, self.npw, self.npw), dtype=complex)
if self.hilbert_trans:
specfunc_wGG = np.zeros((self.NwS_local, self.npw, self.npw), dtype = complex)
# Prepare for the derivative of pseudo-wavefunction
if self.optical_limit:
d_c = [Gradient(gd, i, n=4, dtype=complex).apply for i in range(3)]
dpsit_g = gd.empty(dtype=complex)
tmp = np.zeros((3), dtype=complex)
rhoG0_v = np.zeros(3, dtype=complex)
self.chi0G0_wGv = np.zeros((self.Nw_local, self.npw, 3), dtype=complex)
self.chi00G_wGv = np.zeros((self.Nw_local, self.npw, 3), dtype=complex)
specfuncG0_wGv = np.zeros((self.NwS_local, self.npw, 3), dtype=complex)
specfunc0G_wGv = np.zeros((self.NwS_local, self.npw, 3), dtype=complex)
use_zher = False
if self.eta < 1e-5:
use_zher = True
rho_G = np.zeros(self.npw, dtype=complex)
t0 = time()
if seperate_spin is None:
spinlist = np.arange(self.nspins)
else:
spinlist = [seperate_spin]
for spin in spinlist:
if not (f_skn[spin] > self.ftol).any():
self.chi0_wGG = chi0_wGG
continue
for k in range(self.kstart, self.kend):
k_pad = False
if k >= self.kd.nbzkpts:
k = 0
k_pad = True
# Find corresponding kpoint in IBZ
ibzkpt1 = kd.bz2ibz_k[k]
if self.optical_limit:
ibzkpt2 = ibzkpt1
else:
ibzkpt2 = kd.bz2ibz_k[kq_k[k]]
if self.pwmode:
N_c = self.gd.N_c
k_c = self.kd.ibzk_kc[ibzkpt1]
eikr1_R = np.exp(2j * pi * np.dot(np.indices(N_c).T, k_c / N_c).T)
k_c = self.kd.ibzk_kc[ibzkpt2]
eikr2_R = np.exp(2j * pi * np.dot(np.indices(N_c).T, k_c / N_c).T)
index1_g, phase1_g = kd.get_transform_wavefunction_index(self.gd.N_c - (self.pbc == False), k)
index2_g, phase2_g = kd.get_transform_wavefunction_index(self.gd.N_c - (self.pbc == False), kq_k[k])
for n in range(self.nvalbands):
if self.calc.wfs.world.size == 1:
if (self.f_skn[spin][ibzkpt1, n] - self.ftol < 0):
continue
t1 = time()
if self.pwmode:
u = self.kd.get_rank_and_index(spin, ibzkpt1)[1]
psitold_g = calc.wfs._get_wave_function_array(u, n, realspace=True, phase=eikr1_R)
else:
u = None
psitold_g = self.get_wavefunction(ibzkpt1, n, True, spin=spin)
psit1new_g = kd.transform_wave_function(psitold_g,k,index1_g,phase1_g)
P1_ai = self.pawstuff(psit1new_g, k, n, spin, u, ibzkpt1)
psit1_g = psit1new_g.conj() * self.expqr_g
for m in self.mlist:
if self.nbands > 1000 and m % 200 == 0:
print(' ', k, n, m, time() - t0, file=self.txt)
check_focc = (f_skn[spin][ibzkpt1, n] - f_skn[spin][ibzkpt2, m]) > self.ftol
if not self.pwmode:
psitold_g = self.get_wavefunction(ibzkpt2, m, check_focc, spin=spin)
if check_focc:
if self.pwmode:
u = self.kd.get_rank_and_index(spin, ibzkpt2)[1]
psitold_g = calc.wfs._get_wave_function_array(u, m, realspace=True, phase=eikr2_R)
psit2_g = kd.transform_wave_function(psitold_g, kq_k[k], index2_g, phase2_g)
# zero padding is included through the FFT
rho_g = np.fft.fftn(psit2_g * psit1_g, s=self.nGrpad) * self.vol / self.nG0rpad
# Here, planewave cutoff is applied
rho_G = rho_g.ravel()[self.Gindex_G]
if self.optical_limit:
phase_cd = np.exp(2j * pi * sdisp_cd * kd.bzk_kc[kq_k[k], :, np.newaxis])
for ix in range(3):
d_c[ix](psit2_g, dpsit_g, phase_cd)
tmp[ix] = gd.integrate(psit1_g * dpsit_g)
rho_G[0] = -1j * np.dot(self.qq_v, tmp)
for ix in range(3):
q2_c = np.diag((1,1,1))[ix] * self.qopt
qq2_v = np.dot(q2_c, self.bcell_cv) # summation over c
rhoG0_v[ix] = -1j * np.dot(qq2_v, tmp)
P2_ai = self.pawstuff(psit2_g, kq_k[k], m, spin, u, ibzkpt2)
for a, id in enumerate(calc.wfs.setups.id_a):
P_p = np.outer(P1_ai[a].conj(), P2_ai[a]).ravel()
gemv(1.0, self.phi_aGp[a], P_p, 1.0, rho_G)
if self.optical_limit:
gemv(1.0, self.phiG0_avp[a], P_p, 1.0, rhoG0_v)
if self.optical_limit:
if np.abs(self.enoshift_skn[spin][ibzkpt2, m] -
self.enoshift_skn[spin][ibzkpt1, n]) > 0.1/Hartree:
rho_G[0] /= self.enoshift_skn[spin][ibzkpt2, m] \
- self.enoshift_skn[spin][ibzkpt1, n]
rhoG0_v /= self.enoshift_skn[spin][ibzkpt2, m] \
- self.enoshift_skn[spin][ibzkpt1, n]
else:
rho_G[0] = 0.
rhoG0_v[:] = 0.
if k_pad:
rho_G[:] = 0.
if self.optical_limit:
rho0G_Gv = np.outer(rho_G.conj(), rhoG0_v)
rhoG0_Gv = np.outer(rho_G, rhoG0_v.conj())
rho0G_Gv[0,:] = rhoG0_v * rhoG0_v.conj()
rhoG0_Gv[0,:] = rhoG0_v * rhoG0_v.conj()
if not self.hilbert_trans:
if not use_zher:
rho_GG = np.outer(rho_G, rho_G.conj())
for iw in range(self.Nw_local):
w = self.w_w[iw + self.wstart] / Hartree
coef = ( 1. / (w + e_skn[spin][ibzkpt1, n] - e_skn[spin][ibzkpt2, m]
+ 1j * self.eta)
- 1. / (w - e_skn[spin][ibzkpt1, n] + e_skn[spin][ibzkpt2, m]
+ 1j * self.eta) )
C = (f_skn[spin][ibzkpt1, n] - f_skn[spin][ibzkpt2, m]) * coef
if use_zher:
czher(C.real, rho_G.conj(), chi0_wGG[iw])
else:
axpy(C, rho_GG, chi0_wGG[iw])
if self.optical_limit:
axpy(C, rho0G_Gv, self.chi00G_wGv[iw])
axpy(C, rhoG0_Gv, self.chi0G0_wGv[iw])
else:
rho_GG = np.outer(rho_G, rho_G.conj())
focc = f_skn[spin][ibzkpt1,n] - f_skn[spin][ibzkpt2,m]
w0 = e_skn[spin][ibzkpt2,m] - e_skn[spin][ibzkpt1,n]
scal(focc, rho_GG)
if self.optical_limit:
scal(focc, rhoG0_Gv)
scal(focc, rho0G_Gv)
# calculate delta function
w0_id = int(w0 / self.dw)
if w0_id + 1 < self.NwS:
# rely on the self.NwS_local is equal in each node!
if self.wScomm.rank == w0_id // self.NwS_local:
alpha = (w0_id + 1 - w0/self.dw) / self.dw
axpy(alpha, rho_GG, specfunc_wGG[w0_id % self.NwS_local] )
if self.optical_limit:
axpy(alpha, rho0G_Gv, specfunc0G_wGv[w0_id % self.NwS_local] )
axpy(alpha, rhoG0_Gv, specfuncG0_wGv[w0_id % self.NwS_local] )
if self.wScomm.rank == (w0_id+1) // self.NwS_local:
alpha = (w0 / self.dw - w0_id) / self.dw
axpy(alpha, rho_GG, specfunc_wGG[(w0_id+1) % self.NwS_local] )
if self.optical_limit:
axpy(alpha, rho0G_Gv, specfunc0G_wGv[(w0_id+1) % self.NwS_local] )
axpy(alpha, rhoG0_Gv, specfuncG0_wGv[(w0_id+1) % self.NwS_local] )
# deltaw = delta_function(w0, self.dw, self.NwS, self.sigma)
# for wi in range(self.NwS_local):
# if deltaw[wi + self.wS1] > 1e-8:
# specfunc_wGG[wi] += tmp_GG * deltaw[wi + self.wS1]
if self.kd.nbzkpts == 1:
if n == 0:
dt = time() - t0
totaltime = dt * self.nvalbands * self.nspins
self.printtxt('Finished n 0 in %d seconds, estimate %d seconds left.' %(dt, totaltime) )
if rank == 0 and self.nvalbands // 5 > 0:
if n > 0 and n % (self.nvalbands // 5) == 0:
dt = time() - t0
self.printtxt('Finished n %d in %d seconds, estimate %d seconds left.'%(n, dt, totaltime-dt))
if calc.wfs.world.size != 1:
self.kcomm.barrier()
if k == 0:
dt = time() - t0
totaltime = dt * self.nkpt_local * self.nspins
self.printtxt('Finished k 0 in %d seconds, estimate %d seconds left.' %(dt, totaltime))
if rank == 0 and self.nkpt_local // 5 > 0:
if k > 0 and k % (self.nkpt_local // 5) == 0:
dt = time() - t0
self.printtxt('Finished k %d in %d seconds, estimate %d seconds left. '%(k, dt, totaltime - dt) )
self.printtxt('Finished summation over k')
self.kcomm.barrier()
# Hilbert Transform
if not self.hilbert_trans:
for iw in range(self.Nw_local):
self.kcomm.sum(chi0_wGG[iw])
if self.optical_limit:
self.kcomm.sum(self.chi0G0_wGv[iw])
self.kcomm.sum(self.chi00G_wGv[iw])
if use_zher:
assert (np.abs(chi0_wGG[0,1:,0]) < 1e-10).all()
for iw in range(self.Nw_local):
chi0_wGG[iw] += chi0_wGG[iw].conj().T
for iG in range(self.npw):
chi0_wGG[iw, iG, iG] /= 2.
assert np.abs(np.imag(chi0_wGG[iw, iG, iG])) < 1e-10
else:
for iw in range(self.NwS_local):
self.kcomm.sum(specfunc_wGG[iw])
if self.optical_limit:
self.kcomm.sum(specfuncG0_wGv[iw])
self.kcomm.sum(specfunc0G_wGv[iw])
if self.wScomm.size == 1:
chi0_wGG = hilbert_transform(specfunc_wGG, self.w_w, self.Nw, self.dw, self.eta,
self.full_hilbert_trans)[self.wstart:self.wend]
self.printtxt('Finished hilbert transform !')
del specfunc_wGG
else:
# redistribute specfunc_wGG to all nodes
size = self.comm.size
assert self.NwS % size == 0
NwStmp1 = (rank % self.kcomm.size) * self.NwS // size
NwStmp2 = (rank % self.kcomm.size + 1) * self.NwS // size
specfuncnew_wGG = specfunc_wGG[NwStmp1:NwStmp2]
del specfunc_wGG
coords = np.zeros(self.wcomm.size, dtype=int)
nG_local = self.npw**2 // self.wcomm.size
if self.wcomm.rank == self.wcomm.size - 1:
nG_local = self.npw**2 - (self.wcomm.size - 1) * nG_local
self.wcomm.all_gather(np.array([nG_local]), coords)
specfunc_Wg = SliceAlongFrequency(specfuncnew_wGG, coords, self.wcomm)
self.printtxt('Finished Slice Along Frequency !')
chi0_Wg = hilbert_transform(specfunc_Wg, self.w_w, self.Nw, self.dw, self.eta,
self.full_hilbert_trans)[:self.Nw]
self.printtxt('Finished hilbert transform !')
self.comm.barrier()
del specfunc_Wg
chi0_wGG = SliceAlongOrbitals(chi0_Wg, coords, self.wcomm)
self.printtxt('Finished Slice along orbitals !')
self.comm.barrier()
del chi0_Wg
if self.optical_limit:
specfuncG0_WGv = np.zeros((self.NwS, self.npw, 3), dtype=complex)
specfunc0G_WGv = np.zeros((self.NwS, self.npw, 3), dtype=complex)
self.wScomm.all_gather(specfunc0G_wGv, specfunc0G_WGv)
self.wScomm.all_gather(specfuncG0_wGv, specfuncG0_WGv)
specfunc0G_wGv = specfunc0G_WGv
specfuncG0_wGv = specfuncG0_WGv
if self.optical_limit:
self.chi00G_wGv = hilbert_transform(specfunc0G_wGv, self.w_w, self.Nw, self.dw, self.eta,
self.full_hilbert_trans)[self.wstart:self.wend]
self.chi0G0_wGv = hilbert_transform(specfuncG0_wGv, self.w_w, self.Nw, self.dw, self.eta,
self.full_hilbert_trans)[self.wstart:self.wend]
if self.optical_limit:
self.chi00G_wGv /= self.vol
self.chi0G0_wGv /= self.vol
self.chi0_wGG = chi0_wGG
self.chi0_wGG /= self.vol
self.printtxt('')
self.printtxt('Finished chi0 !')
def parallel_init(self):
"""Parallel initialization. By default, only use kcomm and wcomm.
Parameters:
kcomm:
kpoint communicator
wScomm:
spectral function communicator
wcomm:
frequency communicator
"""
if extra_parameters.get('df_dry_run'):
from gpaw.mpi import DryRunCommunicator
size = extra_parameters['df_dry_run']
world = DryRunCommunicator(size)
rank = world.rank
self.comm = world
else:
world = self.comm
rank = self.comm.rank
size = self.comm.size
wcommsize = int(self.NwS * self.npw**2 * 16. / 1024**2) // 1500 # megabyte
wcommsize += 1
if size < wcommsize:
raise ValueError('Number of cpus are not enough ! ')
if self.kcommsize is None:
self.kcommsize = world.size
if wcommsize > size // self.kcommsize: # if matrix too large, overwrite kcommsize and distribute matrix
self.printtxt('kcommsize is over written ! ')
while size % wcommsize != 0:
wcommsize += 1
self.kcommsize = size // wcommsize
assert self.kcommsize * wcommsize == size
if self.kcommsize < 1:
raise ValueError('Number of cpus are not enough ! ')
self.kcomm, self.wScomm, self.wcomm = set_communicator(world, rank, size, self.kcommsize)
if self.kd.nbzkpts >= world.size:
self.nkpt_reshape = self.kd.nbzkpts
self.nkpt_reshape, self.nkpt_local, self.kstart, self.kend = parallel_partition(
self.nkpt_reshape, self.kcomm.rank, self.kcomm.size, reshape=True, positive=True)
self.mband_local = self.nvalbands
self.mlist = np.arange(self.nbands)
else:
# if number of kpoints == 1, use band parallelization
self.nkpt_local = self.kd.nbzkpts
self.kstart = 0
self.kend = self.kd.nbzkpts
self.nkpt_reshape = self.kd.nbzkpts
self.nbands, self.mband_local, self.mlist = parallel_partition_list(
self.nbands, self.kcomm.rank, self.kcomm.size)
if self.NwS % size != 0:
self.NwS -= self.NwS % size
self.NwS, self.NwS_local, self.wS1, self.wS2 = parallel_partition(
self.NwS, self.wScomm.rank, self.wScomm.size, reshape=False)
if self.hilbert_trans:
self.Nw, self.Nw_local, self.wstart, self.wend = parallel_partition(
self.Nw, self.wcomm.rank, self.wcomm.size, reshape=True)
else:
if self.Nw > 1:
# assert self.Nw % (self.comm.size / self.kcomm.size) == 0
self.wcomm = self.wScomm
self.Nw, self.Nw_local, self.wstart, self.wend = parallel_partition(
self.Nw, self.wcomm.rank, self.wcomm.size, reshape=False)
else:
# if frequency point is too few, then dont parallelize
self.wcomm = serial_comm
self.wstart = 0
self.wend = self.Nw
self.Nw_local = self.Nw
return
def print_chi(self):
printtxt = self.printtxt
printtxt('Use Hilbert Transform: %s' %(self.hilbert_trans) )
printtxt('Calculate time-ordered Response Function: %s' %(self.full_hilbert_trans) )
printtxt('')
printtxt('Number of frequency points : %d' %(self.Nw) )
if self.hilbert_trans:
printtxt('Number of specfunc points : %d' % (self.NwS))
printtxt('')
printtxt('Parallelization scheme:')
printtxt(' Total cpus : %d' %(self.comm.size))
if self.kd.nbzkpts == 1:
printtxt(' nbands parsize : %d' %(self.kcomm.size))
else:
printtxt(' kpoint parsize : %d' %(self.kcomm.size))
if self.nkpt_reshape > self.kd.nbzkpts:
self.printtxt(' kpoints (%d-%d) are padded with zeros' % (self.kd.nbzkpts, self.nkpt_reshape))
if self.hilbert_trans:
printtxt(' specfunc parsize: %d' %(self.wScomm.size))
printtxt(' w parsize : %d' %(self.wcomm.size))
printtxt('')
printtxt('Memory usage estimation:')
printtxt(' chi0_wGG : %f M / cpu' %(self.Nw_local * self.npw**2 * 16. / 1024**2) )
if self.hilbert_trans:
printtxt(' specfunc_wGG : %f M / cpu' %(self.NwS_local *self.npw**2 * 16. / 1024**2) )
gpaw-0.11.0.13004/gpaw/response/chi0.py 0000664 0001750 0001750 00000060641 12553643470 017454 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function, division
import sys
from time import ctime
import numpy as np
from ase.units import Hartree
from ase.utils.timing import timer
import gpaw.mpi as mpi
from gpaw import extra_parameters
from gpaw.blacs import (BlacsGrid, BlacsDescriptor, Redistributor,
DryRunBlacsGrid)
from gpaw.kpt_descriptor import KPointDescriptor
from gpaw.occupations import FermiDirac
from gpaw.response.pair import PairDensity
from gpaw.utilities.memory import maxrss
from gpaw.utilities.blas import gemm, rk, czher, mmm
from gpaw.wavefunctions.pw import PWDescriptor
from gpaw.response.pair import PWSymmetryAnalyzer
def frequency_grid(domega0, omega2, omegamax):
beta = (2**0.5 - 1) * domega0 / omega2
wmax = int(omegamax / (domega0 + beta * omegamax)) + 2
w = np.arange(wmax)
omega_w = w * domega0 / (1 - beta * w)
return omega_w
class Chi0(PairDensity):
def __init__(self, calc,
frequencies=None, domega0=0.1, omega2=10.0, omegamax=None,
ecut=50, hilbert=True, nbands=None,
timeordered=False, eta=0.2, ftol=1e-6, threshold=1,
real_space_derivatives=False, intraband=True,
world=mpi.world, txt=sys.stdout, timer=None,
nblocks=1, no_optical_limit=False,
keep_occupied_states=False, gate_voltage=None,
disable_point_group=False, disable_time_reversal=False,
use_more_memory=0, unsymmetrized=True):
PairDensity.__init__(self, calc, ecut, ftol, threshold,
real_space_derivatives, world, txt, timer,
nblocks=nblocks,
gate_voltage=gate_voltage)
self.eta = eta / Hartree
self.domega0 = domega0 / Hartree
self.omega2 = omega2 / Hartree
self.omegamax = None if omegamax is None else omegamax / Hartree
self.nbands = nbands or self.calc.wfs.bd.nbands
self.keep_occupied_states = keep_occupied_states
self.intraband = intraband
self.no_optical_limit = no_optical_limit
self.disable_point_group = disable_point_group
self.disable_time_reversal = disable_time_reversal
self.use_more_memory = use_more_memory
self.unsymmetrized = unsymmetrized
omax = self.find_maximum_frequency()
if frequencies is None:
if self.omegamax is None:
self.omegamax = omax
print('Using nonlinear frequency grid from 0 to %.3f eV' %
(self.omegamax * Hartree), file=self.fd)
self.omega_w = frequency_grid(self.domega0, self.omega2,
self.omegamax)
else:
self.omega_w = np.asarray(frequencies) / Hartree
assert not hilbert
self.hilbert = hilbert
self.timeordered = bool(timeordered)
if self.eta == 0.0:
assert not hilbert
assert not timeordered
assert not self.omega_w.real.any()
# Occupied states:
wfs = self.calc.wfs
self.mysKn1n2 = None # my (s, K, n1, n2) indices
self.distribute_k_points_and_bands(0, self.nocc2,
kpts=range(wfs.kd.nibzkpts))
self.mykpts = None
self.prefactor = 2 / self.vol / wfs.kd.nbzkpts / wfs.nspins
self.chi0_vv = None # strength of intraband peak
def find_maximum_frequency(self):
self.epsmin = 10000.0
self.epsmax = -10000.0
for kpt in self.calc.wfs.kpt_u:
self.epsmin = min(self.epsmin, kpt.eps_n[0])
self.epsmax = max(self.epsmax, kpt.eps_n[self.nbands - 1])
print('Minimum eigenvalue: %10.3f eV' % (self.epsmin * Hartree),
file=self.fd)
print('Maximum eigenvalue: %10.3f eV' % (self.epsmax * Hartree),
file=self.fd)
return self.epsmax - self.epsmin
def calculate(self, q_c, spin='all', A_x=None):
wfs = self.calc.wfs
if spin == 'all':
spins = range(wfs.nspins)
else:
assert spin in range(wfs.nspins)
spins = [spin]
q_c = np.asarray(q_c, dtype=float)
qd = KPointDescriptor([q_c])
pd = PWDescriptor(self.ecut, wfs.gd, complex, qd)
self.print_chi(pd)
if extra_parameters.get('df_dry_run'):
print(' Dry run exit', file=self.fd)
raise SystemExit
nG = pd.ngmax
nw = len(self.omega_w)
mynG = (nG + self.blockcomm.size - 1) // self.blockcomm.size
self.Ga = self.blockcomm.rank * mynG
self.Gb = min(self.Ga + mynG, nG)
assert mynG * (self.blockcomm.size - 1) < nG
if A_x is not None:
nx = nw * (self.Gb - self.Ga) * nG
chi0_wGG = A_x[:nx].reshape((nw, self.Gb - self.Ga, nG))
chi0_wGG[:] = 0.0
else:
chi0_wGG = np.zeros((nw, self.Gb - self.Ga, nG), complex)
if np.allclose(q_c, 0.0):
chi0_wxvG = np.zeros((len(self.omega_w), 2, 3, nG), complex)
chi0_wvv = np.zeros((len(self.omega_w), 3, 3), complex)
self.chi0_vv = np.zeros((3, 3), complex)
else:
chi0_wxvG = None
chi0_wvv = None
# Do all empty bands:
m1 = self.nocc1
m2 = self.nbands
self._calculate(pd, chi0_wGG, chi0_wxvG, chi0_wvv, m1, m2, spins)
return pd, chi0_wGG, chi0_wxvG, chi0_wvv
@timer('Calculate CHI_0')
def _calculate(self, pd, chi0_wGG, chi0_wxvG, chi0_wvv, m1, m2, spins):
# Choose which update method to use
if self.eta == 0.0:
update = self.update_hermitian
elif self.hilbert:
update = self.update_hilbert
else:
update = self.update
q_c = pd.kd.bzk_kc[0]
optical_limit = not self.no_optical_limit and np.allclose(q_c, 0.0)
generator = self.generate_pair_densities
# Use symmetries
PWSA = PWSymmetryAnalyzer
PWSA = PWSA(self.calc.wfs.kd, pd,
disable_point_group=self.disable_point_group,
disable_time_reversal=self.disable_time_reversal,
timer=self.timer, txt=self.fd)
# If chi's are supplied it
# is assumed that they are symmetric
# and we have to divide by the number of
# symmetries if we are adding
# the unsymmetric chi
if self.unsymmetrized:
nsym = PWSA.how_many_symmetries()
if nsym > 1:
chi0_wGG /= nsym
if chi0_wxvG is not None:
chi0_wxvG /= nsym
if chi0_wvv is not None:
chi0_wvv /= nsym
# Calculate unsymmetrized chi or spectral function
self.timer.start('Loop')
for f2_m, df_m, deps_m, n_mG, n_mv, vel_mv in \
generator(pd, m1, m2, spins, PWSA=PWSA,
disable_optical_limit=not optical_limit,
intraband=self.intraband,
use_more_memory=self.use_more_memory,
unsymmetrized=self.unsymmetrized):
# If the generator returns None for a pair-density
# then skip updating
if n_mG is not None:
update(np.ascontiguousarray(n_mG), deps_m, df_m, chi0_wGG)
if optical_limit and n_mv is not None:
self.update_optical_limit(n_mv, deps_m, df_m,
n_mG, chi0_wxvG, chi0_wvv)
if optical_limit and self.intraband and vel_mv is not None:
self.update_intraband(f2_m, vel_mv, self.chi0_vv)
self.timer.stop('Loop')
# Sum chi
with self.timer('Sum CHI_0'):
for chi0_GG in chi0_wGG:
self.kncomm.sum(chi0_GG)
if optical_limit:
self.kncomm.sum(chi0_wxvG)
self.kncomm.sum(chi0_wvv)
if self.intraband:
self.kncomm.sum(self.chi0_vv)
print('Memory used: {0:.3f} MB / CPU'.format(maxrss() / 1024**2),
file=self.fd)
if (self.eta == 0.0 or self.hilbert) and self.blockcomm.size == 1:
# Fill in upper/lower triangle also:
nG = pd.ngmax
il = np.tril_indices(nG, -1)
iu = il[::-1]
if self.hilbert:
for chi0_GG in chi0_wGG:
chi0_GG[il] = chi0_GG[iu].conj()
else:
for chi0_GG in chi0_wGG:
chi0_GG[iu] = chi0_GG[il].conj()
if self.hilbert:
with self.timer('Hilbert transform'):
ht = HilbertTransform(self.omega_w, self.eta,
self.timeordered)
ht(chi0_wGG)
if optical_limit:
ht(chi0_wvv)
ht(chi0_wxvG)
print('Hilbert transform done', file=self.fd)
if optical_limit and self.intraband: # Add intraband contribution
omega_w = self.omega_w.copy()
if omega_w[0] == 0.0:
omega_w[0] = 1e-14
chi0_vv = self.chi0_vv
self.world.broadcast(chi0_vv, 0)
chi0_wvv += (chi0_vv[np.newaxis] /
(omega_w[:, np.newaxis, np.newaxis]
+ 1j * self.eta)**2)
if self.unsymmetrized:
# Carry out symmetrization
# Redistribute if block par
tmpchi0_wGG = self.redistribute(chi0_wGG)
PWSA.symmetrize_wGG(tmpchi0_wGG)
self.redistribute(tmpchi0_wGG, chi0_wGG)
if optical_limit:
PWSA.symmetrize_wxvG(chi0_wxvG)
PWSA.symmetrize_wvv(chi0_wvv)
# Since chi_wGG is nonanalytic in the head
# and wings we have to take care that
# these are handled correctly. Note that
# it is important that the wings are overwritten first.
chi0_wGG[:, :, 0] = chi0_wxvG[:, 1, 0, self.Ga:self.Gb]
if self.blockcomm.rank == 0:
chi0_wGG[:, 0] = chi0_wxvG[:, 0, 0]
chi0_wGG[:, 0, 0] = chi0_wvv[:, 0, 0]
return pd, chi0_wGG, chi0_wxvG, chi0_wvv
@timer('CHI_0 update')
def update(self, n_mG, deps_m, df_m, chi0_wGG):
"""Update chi."""
if self.timeordered:
deps1_m = deps_m + 1j * self.eta * np.sign(deps_m)
deps2_m = deps1_m
else:
deps1_m = deps_m + 1j * self.eta
deps2_m = deps_m - 1j * self.eta
for omega, chi0_GG in zip(self.omega_w, chi0_wGG):
x_m = df_m * (1 / (omega + deps1_m) - 1 / (omega - deps2_m))
if self.blockcomm.size > 1:
nx_mG = n_mG[:, self.Ga:self.Gb] * x_m[:, np.newaxis]
else:
nx_mG = n_mG * x_m[:, np.newaxis]
gemm(self.prefactor, n_mG.conj(), np.ascontiguousarray(nx_mG.T),
1.0, chi0_GG)
@timer('CHI_0 hermetian update')
def update_hermitian(self, n_mG, deps_m, df_m, chi0_wGG):
"""If eta=0 use hermitian update."""
for w, omega in enumerate(self.omega_w):
if self.blockcomm.size == 1:
x_m = (-2 * df_m * deps_m / (omega.imag**2 + deps_m**2))**0.5
nx_mG = n_mG.conj() * x_m[:, np.newaxis]
rk(-self.prefactor, nx_mG, 1.0, chi0_wGG[w], 'n')
else:
x_m = 2 * df_m * deps_m / (omega.imag**2 + deps_m**2)
mynx_mG = n_mG[:, self.Ga:self.Gb] * x_m[:, np.newaxis]
mmm(self.prefactor, mynx_mG, 'c', n_mG, 'n', 1.0, chi0_wGG[w])
@timer('CHI_0 spectral function update')
def update_hilbert(self, n_mG, deps_m, df_m, chi0_wGG):
"""Update spectral function.
Updates spectral function A_wGG and saves it to chi0_wGG for
later hilbert-transform."""
self.timer.start('prep')
beta = (2**0.5 - 1) * self.domega0 / self.omega2
o_m = abs(deps_m)
w_m = (o_m / (self.domega0 + beta * o_m)).astype(int)
o1_m = self.omega_w[w_m]
o2_m = self.omega_w[w_m + 1]
p_m = self.prefactor * abs(df_m) / (o2_m - o1_m)**2 # XXX abs()?
p1_m = p_m * (o2_m - o_m)
p2_m = p_m * (o_m - o1_m)
self.timer.stop('prep')
if self.blockcomm.size > 1:
for p1, p2, n_G, w in zip(p1_m, p2_m, n_mG, w_m):
myn_G = n_G[self.Ga:self.Gb].reshape((-1, 1))
gemm(p1, n_G.reshape((-1, 1)), myn_G, 1.0, chi0_wGG[w], 'c')
gemm(p2, n_G.reshape((-1, 1)), myn_G, 1.0, chi0_wGG[w + 1],
'c')
return
for p1, p2, n_G, w in zip(p1_m, p2_m, n_mG, w_m):
czher(p1, n_G.conj(), chi0_wGG[w])
czher(p2, n_G.conj(), chi0_wGG[w + 1])
@timer('CHI_0 optical limit update')
def update_optical_limit(self, n0_mv, deps_m, df_m, n_mG,
chi0_wxvG, chi0_wvv):
"""Optical limit update of chi."""
if self.hilbert: # Do something special when hilbert transforming
self.update_optical_limit_hilbert(n0_mv, deps_m, df_m, n_mG,
chi0_wxvG, chi0_wvv)
return
if self.timeordered:
# avoid getting a zero from np.sign():
deps1_m = deps_m + 1j * self.eta * np.sign(deps_m + 1e-20)
deps2_m = deps1_m
else:
deps1_m = deps_m + 1j * self.eta
deps2_m = deps_m - 1j * self.eta
for w, omega in enumerate(self.omega_w):
x_m = self.prefactor * df_m * (1 / (omega + deps1_m) -
1 / (omega - deps2_m))
chi0_wvv[w] += np.dot(x_m * n0_mv.T, n0_mv.conj())
chi0_wxvG[w, 0, :, 1:] += np.dot(x_m * n0_mv.T, n_mG[:, 1:].conj())
chi0_wxvG[w, 1, :, 1:] += np.dot(x_m * n0_mv.T.conj(), n_mG[:, 1:])
@timer('CHI_0 optical limit hilbert-update')
def update_optical_limit_hilbert(self, n0_mv, deps_m, df_m, n_mG,
chi0_wxvG, chi0_wvv):
"""Optical limit update of chi-head and -wings."""
beta = (2**0.5 - 1) * self.domega0 / self.omega2
for deps, df, n0_v, n_G in zip(deps_m, df_m, n0_mv, n_mG):
o = abs(deps)
w = int(o / (self.domega0 + beta * o))
if w + 2 > len(self.omega_w):
break
o1, o2 = self.omega_w[w:w + 2]
assert o1 <= o <= o2, (o1, o, o2)
p = self.prefactor * abs(df) / (o2 - o1)**2 # XXX abs()?
p1 = p * (o2 - o)
p2 = p * (o - o1)
x_vv = np.outer(n0_v, n0_v.conj())
chi0_wvv[w] += p1 * x_vv
chi0_wvv[w + 1] += p2 * x_vv
x_vG = np.outer(n0_v, n_G[1:].conj())
chi0_wxvG[w, 0, :, 1:] += p1 * x_vG
chi0_wxvG[w + 1, 0, :, 1:] += p2 * x_vG
chi0_wxvG[w, 1, :, 1:] += p1 * x_vG.conj()
chi0_wxvG[w + 1, 1, :, 1:] += p2 * x_vG.conj()
@timer('CHI_0 intraband update')
def update_intraband(self, f_m, vel_mv, chi0_vv):
"""Add intraband contributions"""
assert len(f_m) == len(vel_mv), print(len(f_m), len(vel_mv))
width = self.calc.occupations.width
if width == 0.0:
return
assert isinstance(self.calc.occupations, FermiDirac)
dfde_m = - 1. / width * (f_m - f_m**2.0)
partocc_m = np.abs(dfde_m) > 1e-5
if not partocc_m.any():
return
for dfde, vel_v in zip(dfde_m, vel_mv):
x_vv = (-self.prefactor * dfde *
np.outer(vel_v, vel_v))
chi0_vv += x_vv
@timer('redist')
def redistribute(self, in_wGG, out_x=None):
"""Redistribute array.
Switch between two kinds of parallel distributions:
1) parallel over G-vectors (second dimension of in_wGG)
2) parallel over frequency (first dimension of in_wGG)
Returns new array using the memory in the 1-d array out_x.
"""
comm = self.blockcomm
if comm.size == 1:
return in_wGG
nw = len(self.omega_w)
nG = in_wGG.shape[2]
mynw = (nw + comm.size - 1) // comm.size
mynG = (nG + comm.size - 1) // comm.size
bg1 = BlacsGrid(comm, comm.size, 1)
bg2 = BlacsGrid(comm, 1, comm.size)
md1 = BlacsDescriptor(bg1, nw, nG**2, mynw, nG**2)
md2 = BlacsDescriptor(bg2, nw, nG**2, nw, mynG * nG)
if len(in_wGG) == nw:
mdin = md2
mdout = md1
else:
mdin = md1
mdout = md2
r = Redistributor(comm, mdin, mdout)
outshape = (mdout.shape[0], mdout.shape[1] // nG, nG)
if out_x is None:
out_wGG = np.empty(outshape, complex)
else:
out_wGG = out_x[:np.product(outshape)].reshape(outshape)
r.redistribute(in_wGG.reshape(mdin.shape),
out_wGG.reshape(mdout.shape))
return out_wGG
@timer('dist freq')
def distribute_frequencies(self, chi0_wGG):
"""Distribute frequencies to all cores."""
world = self.world
comm = self.blockcomm
if world.size == 1:
return chi0_wGG
nw = len(self.omega_w)
nG = chi0_wGG.shape[2]
mynw = (nw + world.size - 1) // world.size
mynG = (nG + comm.size - 1) // comm.size
wa = min(world.rank * mynw, nw)
wb = min(wa + mynw, nw)
if self.blockcomm.size == 1:
return chi0_wGG[wa:wb].copy()
if self.kncomm.rank == 0:
bg1 = BlacsGrid(comm, 1, comm.size)
in_wGG = chi0_wGG.reshape((nw, -1))
else:
bg1 = DryRunBlacsGrid(mpi.serial_comm, 1, 1)
in_wGG = np.zeros((0, 0), complex)
md1 = BlacsDescriptor(bg1, nw, nG**2, nw, mynG * nG)
bg2 = BlacsGrid(world, world.size, 1)
md2 = BlacsDescriptor(bg2, nw, nG**2, mynw, nG**2)
r = Redistributor(world, md1, md2)
shape = (wb - wa, nG, nG)
out_wGG = np.empty(shape, complex)
r.redistribute(in_wGG, out_wGG.reshape((wb - wa, nG**2)))
return out_wGG
def print_chi(self, pd):
calc = self.calc
gd = calc.wfs.gd
if extra_parameters.get('df_dry_run'):
from gpaw.mpi import DryRunCommunicator
size = extra_parameters['df_dry_run']
world = DryRunCommunicator(size)
else:
world = self.world
print('%s' % ctime(), file=self.fd)
print('Called response.chi0.calculate with', file=self.fd)
q_c = pd.kd.bzk_kc[0]
print(' q_c: [%f, %f, %f]' % (q_c[0], q_c[1], q_c[2]), file=self.fd)
nw = len(self.omega_w)
print(' Number of frequency points: %d' % nw, file=self.fd)
ecut = self.ecut * Hartree
print(' Planewave cutoff: %f' % ecut, file=self.fd)
ns = calc.wfs.nspins
print(' Number of spins: %d' % ns, file=self.fd)
nbands = self.nbands
print(' Number of bands: %d' % nbands, file=self.fd)
nk = calc.wfs.kd.nbzkpts
print(' Number of kpoints: %d' % nk, file=self.fd)
nik = calc.wfs.kd.nibzkpts
print(' Number of irredicible kpoints: %d' % nik, file=self.fd)
ngmax = pd.ngmax
print(' Number of planewaves: %d' % ngmax, file=self.fd)
eta = self.eta * Hartree
print(' Broadening (eta): %f' % eta, file=self.fd)
wsize = world.size
print(' world.size: %d' % wsize, file=self.fd)
knsize = self.kncomm.size
print(' kncomm.size: %d' % knsize, file=self.fd)
bsize = self.blockcomm.size
print(' blockcomm.size: %d' % bsize, file=self.fd)
nocc = self.nocc1
print(' Number of completely occupied states: %d'
% nocc, file=self.fd)
npocc = self.nocc2
print(' Number of partially occupied states: %d'
% npocc, file=self.fd)
keep = self.keep_occupied_states
print(' Keep occupied states: %s' % keep, file=self.fd)
print('', file=self.fd)
print(' Memory estimate of potentially large arrays:', file=self.fd)
chisize = nw * pd.ngmax**2 * 16. / 1024**2
print(' chi0_wGG: %f M / cpu' % chisize, file=self.fd)
ngridpoints = gd.N_c[0] * gd.N_c[1] * gd.N_c[2]
if self.keep_occupied_states:
nstat = (ns * nk * npocc + world.size - 1) // world.size
else:
nstat = (ns * npocc + world.size - 1) // world.size
occsize = nstat * ngridpoints * 16. / 1024**2
print(' Occupied states: %f M / cpu' % occsize,
file=self.fd)
print(' Memory usage before allocation: %f M / cpu'
% (maxrss() / 1024**2), file=self.fd)
print('', file=self.fd)
class HilbertTransform:
def __init__(self, omega_w, eta, timeordered=False, gw=False,
blocksize=500):
"""Analytic Hilbert transformation using linear interpolation.
Hilbert transform::
oo
/ 1 1
|dw' (-------------- - --------------) S(w').
/ w - w' + i eta w + w' + i eta
0
With timeordered=True, you get::
oo
/ 1 1
|dw' (-------------- - --------------) S(w').
/ w - w' - i eta w + w' + i eta
0
With gw=True, you get::
oo
/ 1 1
|dw' (-------------- + --------------) S(w').
/ w - w' + i eta w + w' + i eta
0
"""
self.blocksize = blocksize
if timeordered:
self.H_ww = self.H(omega_w, -eta) + self.H(omega_w, -eta, -1)
elif gw:
self.H_ww = self.H(omega_w, eta) - self.H(omega_w, -eta, -1)
else:
self.H_ww = self.H(omega_w, eta) + self.H(omega_w, -eta, -1)
def H(self, o_w, eta, sign=1):
"""Calculate transformation matrix.
With s=sign (+1 or -1)::
oo
/ dw'
X (w, eta) = | ---------------- S(w').
s / s w - w' + i eta
0
Returns H_ij so that X_i = np.dot(H_ij, S_j), where::
X_i = X (omega_w[i]) and S_j = S(omega_w[j])
s
"""
nw = len(o_w)
H_ij = np.zeros((nw, nw), complex)
do_j = o_w[1:] - o_w[:-1]
for i, o in enumerate(o_w):
d_j = o_w - o * sign
y_j = 1j * np.arctan(d_j / eta) + 0.5 * np.log(d_j**2 + eta**2)
y_j = (y_j[1:] - y_j[:-1]) / do_j
H_ij[i, :-1] = 1 - (d_j[1:] - 1j * eta) * y_j
H_ij[i, 1:] -= 1 - (d_j[:-1] - 1j * eta) * y_j
return H_ij
def __call__(self, S_wx):
"""Inplace transform"""
B_wx = S_wx.reshape((len(S_wx), -1))
nw, nx = B_wx.shape
tmp_wx = np.zeros((nw, min(nx, self.blocksize)), complex)
for x in range(0, nx, self.blocksize):
b_wx = B_wx[:, x:x + self.blocksize]
c_wx = tmp_wx[:, :b_wx.shape[1]]
gemm(1.0, b_wx, self.H_ww, 0.0, c_wx)
b_wx[:] = c_wx
if __name__ == '__main__':
do = 0.025
eta = 0.1
omega_w = frequency_grid(do, 10.0, 3)
print(len(omega_w))
X_w = omega_w * 0j
Xt_w = omega_w * 0j
Xh_w = omega_w * 0j
for o in -np.linspace(2.5, 2.9, 10):
X_w += (1 / (omega_w + o + 1j * eta) -
1 / (omega_w - o + 1j * eta)) / o**2
Xt_w += (1 / (omega_w + o - 1j * eta) -
1 / (omega_w - o + 1j * eta)) / o**2
w = int(-o / do / (1 + 3 * -o / 10))
o1, o2 = omega_w[w:w + 2]
assert o1 - 1e-12 <= -o <= o2 + 1e-12, (o1, -o, o2)
p = 1 / (o2 - o1)**2 / o**2
Xh_w[w] += p * (o2 - -o)
Xh_w[w + 1] += p * (-o - o1)
ht = HilbertTransform(omega_w, eta, 1)
ht(Xh_w)
import matplotlib.pyplot as plt
plt.plot(omega_w, X_w.imag, label='ImX')
plt.plot(omega_w, X_w.real, label='ReX')
plt.plot(omega_w, Xt_w.imag, label='ImXt')
plt.plot(omega_w, Xt_w.real, label='ReXt')
plt.plot(omega_w, Xh_w.imag, label='ImXh')
plt.plot(omega_w, Xh_w.real, label='ReXh')
plt.legend()
plt.show()
gpaw-0.11.0.13004/gpaw/response/pair.py 0000664 0001750 0001750 00000140451 12553643470 017562 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import sys
import functools
from math import pi
import numpy as np
from ase.units import Hartree
from ase.utils import devnull
from ase.utils.timing import timer, Timer
import gpaw.mpi as mpi
from gpaw import GPAW
from gpaw.fd_operators import Gradient
from gpaw.occupations import FermiDirac
from gpaw.response.math_func import (two_phi_planewave_integrals,
two_phi_nabla_planewave_integrals)
from gpaw.utilities.blas import gemm
from gpaw.utilities.progressbar import ProgressBar
from gpaw.wavefunctions.pw import PWLFC
import gpaw.io.tar as io
class KPoint:
def __init__(self, s, K, n1, n2, blocksize, na, nb,
ut_nR, eps_n, f_n, P_ani, shift_c):
self.s = s # spin index
self.K = K # BZ k-point index
self.n1 = n1 # first band
self.n2 = n2 # first band not included
self.blocksize = blocksize
self.na = na # first band of block
self.nb = nb # first band of block not included
self.ut_nR = ut_nR # periodic part of wave functions in real-space
self.eps_n = eps_n # eigenvalues
self.f_n = f_n # occupation numbers
self.P_ani = P_ani # PAW projections
self.shift_c = shift_c # long story - see the
# PairDensity.construct_symmetry_operators() method
class KPointPair:
"""This class defines the kpoint-pair container object.
Used for calculating pair quantities it contains two kpoints,
and an associated set of Fourier components."""
def __init__(self, kpt1, kpt2, Q_G):
self.kpt1 = kpt1
self.kpt2 = kpt2
self.Q_G = Q_G
def get_k1(self):
""" Return KPoint object 1."""
return self.kpt1
def get_k2(self):
""" Return KPoint object 2."""
return self.kpt2
def get_planewave_indices(self):
""" Return the planewave indices associated with this pair."""
return self.Q_G
def get_transition_energies(self, n_n, m_m):
"""Return the energy difference for specified bands."""
kpt1 = self.kpt1
kpt2 = self.kpt2
deps_nm = (kpt1.eps_n[n_n][:, np.newaxis] -
kpt2.eps_n[m_m])
return deps_nm
def get_occupation_differences(self, n_n, m_m):
"""Get difference in occupation factor between specified bands."""
kpt1 = self.kpt1
kpt2 = self.kpt2
df_nm = (kpt1.f_n[n_n][:, np.newaxis] -
kpt2.f_n[m_m])
return df_nm
class PWSymmetryAnalyzer:
"""Class for handling planewave symmetries."""
def __init__(self, kd, pd, txt=sys.stdout,
disable_point_group=False,
disable_non_symmorphic=True,
disable_time_reversal=False,
timer=None):
"""Creates a PWSymmetryAnalyzer object.
Determines which of the symmetries of the atomic structure
that is compatible with the reciprocal lattice. Contains the
necessary functions for mapping quantities between kpoints,
and or symmetrizing arrays.
kd: KPointDescriptor
The kpoint descriptor containing the
information about symmetries and kpoints.
pd: PWDescriptor
Plane wave descriptor that contains the reciprocal
lattice .
txt: str
Output file.
disable_point_group: bool
Switch for disabling point group symmetries.
disable_non_symmorphic:
Switch for disabling non symmorphic symmetries.
disable_time_reversal:
Switch for disabling time reversal.
"""
self.pd = pd
self.kd = kd
self.fd = txt
# Caveats
assert disable_non_symmorphic, \
print('You are not allowed to use non symmorphic syms, sorry. ',
file=self.fd)
# Settings
self.disable_point_group = disable_point_group
self.disable_time_reversal = disable_time_reversal
self.disable_non_symmorphic = disable_non_symmorphic
if (kd.symmetry.has_inversion or not kd.symmetry.time_reversal) and \
not self.disable_time_reversal:
print('\nThe ground calculation does not support time-reversal ' +
'symmetry possibly because it has an inversion center ' +
'or that it has been manually deactivated. \n', file=self.fd)
self.disable_time_reversal = True
self.disable_symmetries = (self.disable_point_group and
self.disable_time_reversal and
self.disable_non_symmorphic)
# Number of symmetries
U_scc = kd.symmetry.op_scc
self.nU = len(U_scc)
self.nsym = 2 * self.nU
self.use_time_reversal = not self.disable_time_reversal
# Which timer to use
self.timer = timer or Timer()
# Initialize
self.initialize()
@timer('Initialize')
def initialize(self):
"""Initialize relevant quantities."""
self.infostring = ''
if self.disable_point_group:
self.infostring += 'Point group not included. '
else:
self.infostring += 'Point group included. '
if self.disable_time_reversal:
self.infostring += 'Time reversal not included. '
else:
self.infostring += 'Time reversal included. '
if self.disable_non_symmorphic:
self.infostring += 'Disabled non symmorphic symmetries. '
else:
self.infostring += 'Time reversal included. '
if self.disable_symmetries:
self.infostring += 'All symmetries have been disabled. '
# Do the work
self.analyze_symmetries()
self.analyze_kpoints()
self.initialize_G_maps()
# Print info
print(self.infostring, file=self.fd)
self.print_symmetries()
def print_symmetries(self):
"""Handsome print function for symmetry operations."""
p = functools.partial(print, file=self.fd)
p()
nx = 6 if self.disable_non_symmorphic else 3
ns = len(self.s_s)
y = 0
for y in range((ns + nx - 1) // nx):
for c in range(3):
for x in range(nx):
s = x + y * nx
if s == ns:
break
tmp = self.get_symmetry_operator(self.s_s[s])
op_cc, sign, TR, shift_c, ft_c = tmp
op_c = sign * op_cc[c]
p(' (%2d %2d %2d)' % tuple(op_c), end='')
p()
p()
@timer('Analyze')
def analyze_kpoints(self):
"""Calculate the reduction in the number of kpoints."""
K_gK = self.group_kpoints()
ng = len(K_gK)
self.infostring += '{0} groups of equivalent kpoints. '.format(ng)
percent = (1. - (ng + 0.) / self.kd.nbzkpts) * 100
self.infostring += '{0}% reduction. '.format(percent)
@timer('Analyze symmetries.')
def analyze_symmetries(self):
"""Determine allowed symmetries.
An direct symmetry U must fulfill::
U \mathbf{q} = q + \Delta
Under time-reversal (indirect) it must fulfill::
-U \mathbf{q} = q + \Delta
where :math:`\Delta` is a reciprocal lattice vector.
"""
pd = self.pd
# Shortcuts
q_c = pd.kd.bzk_kc[0]
kd = self.kd
U_scc = kd.symmetry.op_scc
nU = self.nU
nsym = self.nsym
shift_sc = np.zeros((nsym, 3), int)
conserveq_s = np.zeros(nsym, bool)
newq_sc = np.dot(U_scc, q_c)
# Direct symmetries
dshift_sc = (newq_sc - q_c[np.newaxis]).round().astype(int)
inds_s = np.argwhere((newq_sc == q_c[np.newaxis] + dshift_sc).all(1))
conserveq_s[inds_s] = True
shift_sc[:nU] = dshift_sc
# Time reversal
trshift_sc = (-newq_sc - q_c[np.newaxis]).round().astype(int)
trinds_s = np.argwhere((-newq_sc == q_c[np.newaxis]
+ trshift_sc).all(1)) + nU
conserveq_s[trinds_s] = True
shift_sc[nU:nsym] = trshift_sc
# The indices of the allowed symmetries
s_s = conserveq_s.nonzero()[0]
# Filter out disabled symmetries
if self.disable_point_group:
s_s = [s for s in s_s if self.is_not_point_group(s)]
if self.disable_time_reversal:
s_s = [s for s in s_s if self.is_not_time_reversal(s)]
if self.disable_non_symmorphic:
s_s = [s for s in s_s if self.is_not_non_symmorphic(s)]
stmp_s = []
for s in s_s:
if self.kd.bz2bz_ks[0, s] == -1:
assert (self.kd.bz2bz_ks[:, s] == -1).all()
else:
stmp_s.append(s)
s_s = stmp_s
self.infostring += 'Found {0} allowed symmetries. '.format(len(s_s))
self.s_s = s_s
self.shift_sc = shift_sc
def is_not_point_group(self, s):
U_scc = self.kd.symmetry.op_scc
nU = self.nU
return (U_scc[s % nU] == np.eye(3)).all()
def is_not_time_reversal(self, s):
nU = self.nU
return not bool(s // nU)
def is_not_non_symmorphic(self, s):
ft_sc = self.kd.symmetry.ft_sc
nU = self.nU
return not bool(ft_sc[s % nU].any())
def how_many_symmetries(self):
"""Return number of symmetries."""
return len(self.s_s)
@timer('Group kpoints')
def group_kpoints(self, K_k=None):
"""Group kpoints according to the reduced symmetries"""
if K_k is None:
K_k = np.arange(self.kd.nbzkpts)
s_s = self.s_s
bz2bz_ks = self.kd.bz2bz_ks
nk = len(bz2bz_ks)
sbz2sbz_ks = bz2bz_ks[K_k][:, s_s] # Reduced number of symmetries
# Avoid -1 (see documentation in gpaw.symmetry)
sbz2sbz_ks[sbz2sbz_ks == -1] = nk
smallestk_k = np.sort(sbz2sbz_ks)[:, 0]
k2g_g = np.unique(smallestk_k, return_index=True)[1]
K_gs = sbz2sbz_ks[k2g_g]
K_gk = [np.unique(K_s[K_s != nk]) for K_s in K_gs]
return K_gk
def get_kpoint_mapping(self, K1, K2):
"""Get index of symmetry for mapping between K1 and K2"""
s_s = self.s_s
bz2bz_ks = self.kd.bz2bz_ks
bzk2rbz_s = bz2bz_ks[K1][s_s]
try:
s = np.argwhere(bzk2rbz_s == K2)[0][0]
except IndexError:
print('K = {0} cannot be mapped into K = {1}'.format(K1, K2),
file=self.fd)
raise
return s_s[s]
def get_shift(self, K1, K2, U_cc, sign):
"""Get shift for mapping between K1 and K2."""
kd = self.kd
k1_c = kd.bzk_kc[K1]
k2_c = kd.bzk_kc[K2]
shift_c = np.dot(U_cc, k1_c) - k2_c * sign
assert np.allclose(shift_c.round(), shift_c)
shift_c = shift_c.round().astype(int)
return shift_c
@timer('map_G')
def map_G(self, K1, K2, a_MG):
"""Map a function of G from K1 to K2. """
if len(a_MG) == 0:
return []
if K1 == K2:
return a_MG
G_G, sign = self.map_G_vectors(K1, K2)
s = self.get_kpoint_mapping(K1, K2)
U_cc, _, TR, shift_c, ft_c = self.get_symmetry_operator(s)
return TR(a_MG[..., G_G])
def symmetrize_wGG(self, A_wGG):
"""Symmetrize an array in GG'."""
tmp_wGG = np.zeros_like(A_wGG)
if self.use_time_reversal:
AT_wGG = np.transpose(A_wGG, (0, 2, 1))
for s in self.s_s:
G_G, sign, _ = self.G_sG[s]
if sign == 1:
tmp_wGG += A_wGG[:, G_G, :][:, :, G_G]
if sign == -1:
tmp_wGG += AT_wGG[:, G_G, :][:, :, G_G]
# Inplace overwriting
A_wGG[:] = tmp_wGG
def symmetrize_wxvG(self, A_wxvG):
"""Symmetrize chi0_wxvG"""
A_cv = self.pd.gd.cell_cv
iA_cv = self.pd.gd.icell_cv
if self.use_time_reversal:
# ::-1 corresponds to transpose in wing indices
AT_wxvG = A_wxvG[:, ::-1]
tmp_wxvG = np.zeros_like(A_wxvG)
for s in self.s_s:
G_G, sign, shift_c = self.G_sG[s]
U_cc, _, TR, shift_c, ft_c = self.get_symmetry_operator(s)
M_vv = np.dot(np.dot(A_cv.T, U_cc.T), iA_cv)
if sign == 1:
tmp = sign * np.dot(M_vv.T, A_wxvG[..., G_G])
elif sign == -1:
tmp = sign * np.dot(M_vv.T, AT_wxvG[..., G_G])
tmp_wxvG += np.transpose(tmp, (1, 2, 0, 3))
# Overwrite the input
A_wxvG[:] = tmp_wxvG
def symmetrize_wvv(self, A_wvv):
"""Symmetrize chi_wvv."""
A_cv = self.pd.gd.cell_cv
iA_cv = self.pd.gd.icell_cv
tmp_wvv = np.zeros_like(A_wvv)
if self.use_time_reversal:
AT_wvv = np.transpose(A_wvv, (0, 2, 1))
for s in self.s_s:
G_G, sign, shift_c = self.G_sG[s]
U_cc, _, TR, shift_c, ft_c = self.get_symmetry_operator(s)
M_vv = np.dot(np.dot(A_cv.T, U_cc.T), iA_cv)
if sign == 1:
tmp = np.dot(np.dot(M_vv.T, A_wvv), M_vv)
elif sign == -1:
tmp = np.dot(np.dot(M_vv.T, AT_wvv), M_vv)
tmp_wvv += np.transpose(tmp, (1, 0, 2))
# Overwrite the input
A_wvv[:] = tmp_wvv
@timer('map_v')
def map_v(self, K1, K2, a_Mv):
"""Map a function of v (cartesian component) from K1 to K2."""
if len(a_Mv) == 0:
return []
if K1 == K2:
return a_Mv
A_cv = self.pd.gd.cell_cv
iA_cv = self.pd.gd.icell_cv
# Get symmetry
s = self.get_kpoint_mapping(K1, K2)
U_cc, sign, TR, _, ft_c = self.get_symmetry_operator(s)
# Create cartesian operator
M_vv = np.dot(np.dot(A_cv.T, U_cc.T), iA_cv)
return sign * np.dot(TR(a_Mv), M_vv)
def timereversal(self, s):
"""Is this a time-reversal symmetry?"""
tr = bool(s // self.nU)
return tr
def get_symmetry_operator(self, s):
"""Return symmetry operator s."""
U_scc = self.kd.symmetry.op_scc
ft_sc = self.kd.symmetry.op_scc
reds = s % self.nU
if self.timereversal(s):
TR = lambda x: x.conj()
sign = -1
else:
sign = 1
TR = lambda x: x
return U_scc[reds], sign, TR, self.shift_sc[s], ft_sc[reds]
@timer('map_G_vectors')
def map_G_vectors(self, K1, K2):
"""Return G vector mapping."""
s = self.get_kpoint_mapping(K1, K2)
G_G, sign, shift_c = self.G_sG[s]
return G_G, sign
def initialize_G_maps(self):
"""Calculate the Gvector mappings."""
pd = self.pd
B_cv = 2.0 * np.pi * pd.gd.icell_cv
G_Gv = pd.get_reciprocal_vectors(add_q=False)
G_Gc = np.dot(G_Gv, np.linalg.inv(B_cv))
Q_G = pd.Q_qG[0]
G_sG = [None] * self.nsym
UG_sGc = [None] * self.nsym
Q_sG = [None] * self.nsym
for s in self.s_s:
U_cc, sign, TR, shift_c, ft_c = self.get_symmetry_operator(s)
iU_cc = np.linalg.inv(U_cc).T
UG_Gc = np.dot(G_Gc - shift_c, sign * iU_cc)
assert np.allclose(UG_Gc.round(), UG_Gc)
UQ_G = np.ravel_multi_index(UG_Gc.round().astype(int).T,
pd.gd.N_c, 'wrap')
G_G = len(Q_G) * [None]
for G, UQ in enumerate(UQ_G):
try:
G_G[G] = np.argwhere(Q_G == UQ)[0][0]
except IndexError:
print('This should not be possible but' +
'a G-vector was mapped outside the sphere')
raise IndexError
UG_sGc[s] = UG_Gc
Q_sG[s] = UQ_G
G_sG[s] = [G_G, sign, shift_c]
self.G_Gc = G_Gc
self.UG_sGc = UG_sGc
self.Q_sG = Q_sG
self.G_sG = G_sG
def unfold_ibz_kpoint(self, ik):
"""Return kpoints related to irreducible kpoint."""
kd = self.kd
K_k = np.unique(kd.bz2bz_ks[kd.ibz2bz_k[ik]])
K_k = K_k[K_k != -1]
return K_k
class PairDensity:
def __init__(self, calc, ecut=50,
ftol=1e-6, threshold=1,
real_space_derivatives=False,
world=mpi.world, txt=sys.stdout, timer=None, nblocks=1,
gate_voltage=None):
if ecut is not None:
ecut /= Hartree
if gate_voltage is not None:
gate_voltage /= Hartree
self.ecut = ecut
self.ftol = ftol
self.threshold = threshold
self.real_space_derivatives = real_space_derivatives
self.world = world
self.gate_voltage = gate_voltage
if nblocks == 1:
self.blockcomm = self.world.new_communicator([world.rank])
self.kncomm = world
else:
assert world.size % nblocks == 0, world.size
rank1 = world.rank // nblocks * nblocks
rank2 = rank1 + nblocks
self.blockcomm = self.world.new_communicator(range(rank1, rank2))
ranks = np.arange(world.rank % nblocks, world.size, nblocks)
self.kncomm = self.world.new_communicator(ranks)
if world.rank != 0:
txt = devnull
elif isinstance(txt, str):
txt = open(txt, 'w')
self.fd = txt
self.timer = timer or Timer()
with self.timer('Read ground state'):
if isinstance(calc, str):
print('Reading ground state calculation:\n %s' % calc,
file=self.fd)
if not calc.split('.')[-1] == 'gpw':
calc = calc + '.gpw'
self.reader = io.Reader(calc, comm=mpi.serial_comm)
calc = GPAW(calc, txt=None, communicator=mpi.serial_comm,
read_projections=False)
else:
self.reader = None
assert calc.wfs.world.size == 1
assert calc.wfs.kd.symmetry.symmorphic
self.calc = calc
if gate_voltage is not None:
self.add_gate_voltage(gate_voltage)
self.spos_ac = calc.atoms.get_scaled_positions()
self.nocc1 = None # number of completely filled bands
self.nocc2 = None # number of non-empty bands
self.count_occupied_bands()
self.vol = abs(np.linalg.det(calc.wfs.gd.cell_cv))
self.ut_sKnvR = None # gradient of wave functions for optical limit
print('Number of blocks:', nblocks, file=self.fd)
def add_gate_voltage(self, gate_voltage=0):
"""Shifts the Fermi-level by e * Vg. By definition e = 1."""
assert isinstance(self.calc.occupations, FermiDirac)
print('Shifting Fermi-level by %.2f eV' % (gate_voltage * Hartree),
file=self.fd)
for kpt in self.calc.wfs.kpt_u:
kpt.f_n = (self.shift_occupations(kpt.eps_n, gate_voltage)
* kpt.weight)
def shift_occupations(self, eps_n, gate_voltage):
"""Shift fermilevel."""
fermi = self.calc.occupations.get_fermi_level() + gate_voltage
width = self.calc.occupations.width
tmp = (eps_n - fermi) / width
f_n = np.zeros_like(eps_n)
f_n[tmp <= 100] = 1 / (1 + np.exp(tmp[tmp <= 100]))
f_n[tmp > 100] = 0.0
return f_n
def count_occupied_bands(self):
self.nocc1 = 9999999
self.nocc2 = 0
for kpt in self.calc.wfs.kpt_u:
f_n = kpt.f_n / kpt.weight
self.nocc1 = min((f_n > 1 - self.ftol).sum(), self.nocc1)
self.nocc2 = max((f_n > self.ftol).sum(), self.nocc2)
print('Number of completely filled bands:', self.nocc1, file=self.fd)
print('Number of partially filled bands:', self.nocc2, file=self.fd)
print('Total number of bands:', self.calc.wfs.bd.nbands,
file=self.fd)
def distribute_k_points_and_bands(self, band1, band2, kpts=None):
"""Distribute spins, k-points and bands.
nbands: int
Number of bands for each spin/k-point combination.
The attribute self.mysKn1n2 will be set to a list of (s, K, n1, n2)
tuples that this process handles.
"""
wfs = self.calc.wfs
if kpts is None:
kpts = np.arange(wfs.kd.nbzkpts)
nbands = band2 - band1
size = self.kncomm.size
rank = self.kncomm.rank
ns = wfs.nspins
nk = len(kpts)
n = (ns * nk * nbands + size - 1) // size
i1 = rank * n
i2 = min(i1 + n, ns * nk * nbands)
self.mysKn1n2 = []
i = 0
for s in range(ns):
for K in kpts:
n1 = min(max(0, i1 - i), nbands)
n2 = min(max(0, i2 - i), nbands)
if n1 != n2:
self.mysKn1n2.append((s, K, n1 + band1, n2 + band1))
i += nbands
print('BZ k-points:', self.calc.wfs.kd.description, file=self.fd)
print('Distributing spins, k-points and bands (%d x %d x %d)' %
(ns, nk, nbands),
'over %d process%s' %
(self.kncomm.size, ['es', ''][self.kncomm.size == 1]),
file=self.fd)
print('Number of blocks:', self.blockcomm.size, file=self.fd)
@timer('Get a k-point')
def get_k_point(self, s, K, n1, n2, block=False):
"""Return wave functions for a specific k-point and spin.
s: int
Spin index (0 or 1).
K: int
BZ k-point index.
n1, n2: int
Range of bands to include.
"""
wfs = self.calc.wfs
if block:
nblocks = self.blockcomm.size
rank = self.blockcomm.rank
else:
nblocks = 1
rank = 0
blocksize = (n2 - n1 + nblocks - 1) // nblocks
na = min(n1 + rank * blocksize, n2)
nb = min(na + blocksize, n2)
U_cc, T, a_a, U_aii, shift_c, time_reversal = \
self.construct_symmetry_operators(K)
ik = wfs.kd.bz2ibz_k[K]
kpt = wfs.kpt_u[s * wfs.kd.nibzkpts + ik]
assert n2 <= len(kpt.eps_n), \
'Increase GS-nbands or decrease chi0-nbands!'
eps_n = kpt.eps_n[n1:n2]
f_n = kpt.f_n[n1:n2] / kpt.weight
psit_nG = kpt.psit_nG
ut_nR = wfs.gd.empty(nb - na, wfs.dtype)
for n in range(na, nb):
ut_nR[n - na] = T(wfs.pd.ifft(psit_nG[n], ik))
P_ani = []
if self.reader is None:
for b, U_ii in zip(a_a, U_aii):
P_ni = np.dot(kpt.P_ani[b][na:nb], U_ii)
if time_reversal:
P_ni = P_ni.conj()
P_ani.append(P_ni)
else:
II_a = []
I1 = 0
for U_ii in U_aii:
I2 = I1 + len(U_ii)
II_a.append((I1, I2))
I1 = I2
P_ani = []
P_nI = self.reader.get('Projections', kpt.s, kpt.k)
for b, U_ii in zip(a_a, U_aii):
I1, I2 = II_a[b]
P_ni = np.dot(P_nI[na:nb, I1:I2], U_ii)
if time_reversal:
P_ni = P_ni.conj()
P_ani.append(P_ni)
return KPoint(s, K, n1, n2, blocksize, na, nb,
ut_nR, eps_n, f_n, P_ani, shift_c)
def generate_pair_densities(self, pd, m1, m2, spins, intraband=True,
PWSA=None, disable_optical_limit=False,
unsymmetrized=False, use_more_memory=1):
"""Generator for returning pair densities.
Returns the pair densities between the occupied and
the states in range(m1, m2).
pd: PWDescriptor
Plane-wave descriptor for a single q-point.
m1: int
Index of first unoccupied band.
m2: int
Index of last unoccupied band.
spins: list
List of spin indices included.
intraband: bool
Include intraband transitions in optical limit.
PWSA: PlanewaveSymmetryAnalyzer
If supplied uses this object to determine the symmetries
of the pair-densities.
disable_optical_limit: bool
Disable optical limit.
unsymmetrized: bool
Only return pair-densities from one kpoint in each
group of equivalent kpoints.
use_more_memory: float
Group more pair densities for several occupied bands
together before returning. Here 0 <= use_more_memory <= 1,
where zero is the minimal amount of memory, and 1 is the maximal.
"""
assert 0 <= use_more_memory <= 1
q_c = pd.kd.bzk_kc[0]
optical_limit = not disable_optical_limit and np.allclose(q_c, 0.0)
Q_aGii = self.initialize_paw_corrections(pd)
self.Q_aGii = Q_aGii # This is used in g0w0
if PWSA is None:
with self.timer('Symmetry analyzer'):
PWSA = PWSymmetryAnalyzer # Line too long otherwise
PWSA = PWSA(self.calc.wfs.kd, pd,
timer=self.timer, txt=self.fd)
pb = ProgressBar(self.fd)
for kn, (s, ik, n1, n2) in pb.enumerate(self.mysKn1n2):
Kstar_k = PWSA.unfold_ibz_kpoint(ik)
for K_k in PWSA.group_kpoints(Kstar_k):
# Let the first kpoint of the group represent
# the rest of the kpoints
K1 = K_k[0]
# In this way wavefunctions are only loaded into
# memory for this particular set of kpoints
kptpair = self.get_kpoint_pair(pd, s, K1, n1, n2, m1, m2)
kpt1 = kptpair.get_k1() # kpt1 = k
if kpt1.s not in spins:
continue
kpt2 = kptpair.get_k2() # kpt2 = k + q
if unsymmetrized:
# Number of times kpoints are mapped into themselves
weight = np.sqrt(PWSA.how_many_symmetries() / len(K_k))
# Use kpt2 to compute intraband transitions
# These conditions are sufficent to make sure
# that it still works in parallel
if kpt1.n1 == 0 and self.blockcomm.rank == 0 and \
optical_limit and intraband:
assert self.nocc2 <= kpt2.nb, \
print('Error: Too few unoccupied bands')
vel0_mv = self.intraband_pair_density(kpt2)
f_m = kpt2.f_n[kpt2.na - kpt2.n1:kpt2.nb - kpt2.n1]
with self.timer('intraband'):
if vel0_mv is not None:
if unsymmetrized:
yield (f_m, None, None,
None, None, vel0_mv / weight)
else:
for K2 in K_k:
vel_mv = PWSA.map_v(K1, K2, vel0_mv)
yield (f_m, None, None,
None, None, vel_mv)
# Divide the occupied bands into chunks
n_n = np.arange(n2 - n1)
if use_more_memory == 0:
chunksize = 1
else:
chunksize = np.ceil(len(n_n) *
use_more_memory).astype(int)
no_n = []
for i in range(len(n_n) // chunksize):
i1 = i * chunksize
i2 = min((i + 1) * chunksize, len(n_n))
no_n.append(n_n[i1:i2])
# n runs over occupied bands
for n_n in no_n: # n_n is a list of occupied band indices
# m over unoccupied bands
m_m = np.arange(0, kpt2.n2 - kpt2.n1)
deps_nm = kptpair.get_transition_energies(n_n, m_m)
df_nm = kptpair.get_occupation_differences(n_n, m_m)
# This is not quite right for
# degenerate partially occupied
# bands, but good enough for now:
df_nm[df_nm <= 1e-20] = 0.0
# Get pair density for representative kpoint
ol = optical_limit
n0_nmG, n0_nmv, _ = self.get_pair_density(pd, kptpair,
n_n, m_m,
optical_limit=ol,
intraband=False,
Q_aGii=Q_aGii)
n0_nmG[deps_nm >= 0.0] = 0.0
if optical_limit:
n0_nmv[deps_nm >= 0.0] = 0.0
# Reshape nm -> m
nG = pd.ngmax
deps_m = deps_nm.reshape(-1)
df_m = df_nm.reshape(-1)
n0_mG = n0_nmG.reshape((-1, nG))
if optical_limit:
n0_mv = n0_nmv.reshape((-1, 3))
if unsymmetrized:
if optical_limit:
yield (None, df_m, deps_m,
n0_mG / weight, n0_mv / weight, None)
else:
yield (None, df_m, deps_m,
n0_mG / weight, None, None)
continue
# Collect pair densities in a single array
# and return them
nm = n0_mG.shape[0]
nG = n0_mG.shape[1]
nk = len(K_k)
n_MG = np.empty((nm * nk, nG), complex)
if optical_limit:
n_Mv = np.empty((nm * nk, 3), complex)
deps_M = np.tile(deps_m, nk)
df_M = np.tile(df_m, nk)
for i, K2 in enumerate(K_k):
i1 = i * nm
i2 = (i + 1) * nm
n_mG = PWSA.map_G(K1, K2, n0_mG)
if optical_limit:
n_mv = PWSA.map_v(K1, K2, n0_mv)
n_mG[:, 0] = n_mv[:, 0]
n_Mv[i1:i2, :] = n_mv
n_MG[i1:i2, :] = n_mG
if optical_limit:
yield (None, df_M, deps_M, n_MG, n_Mv, None)
else:
yield (None, df_M, deps_M, n_MG, None, None)
pb.finish()
@timer('Get kpoint pair')
def get_kpoint_pair(self, pd, s, K, n1, n2, m1, m2):
wfs = self.calc.wfs
q_c = pd.kd.bzk_kc[0]
with self.timer('get k-points'):
kpt1 = self.get_k_point(s, K, n1, n2)
K2 = wfs.kd.find_k_plus_q(q_c, [kpt1.K])[0]
kpt2 = self.get_k_point(s, K2, m1, m2, block=True)
with self.timer('fft indices'):
Q_G = self.get_fft_indices(kpt1.K, kpt2.K, q_c, pd,
kpt1.shift_c - kpt2.shift_c)
return KPointPair(kpt1, kpt2, Q_G)
@timer('get_pair_density')
def get_pair_density(self, pd, kptpair, n_n, m_m,
optical_limit=False, intraband=False,
Q_aGii=None):
"""Get pair density for a kpoint pair."""
if optical_limit:
assert np.allclose(pd.kd.bzk_kc[0], 0.0)
if Q_aGii is None:
Q_aGii = self.initialize_paw_corrections(pd)
kpt1 = kptpair.kpt1
kpt2 = kptpair.kpt2
Q_G = kptpair.Q_G # Fourier components of kpoint pair
n_nmG = pd.empty((len(n_n), len(m_m)))
if optical_limit:
n_nmv = np.zeros((len(n_n), len(m_m), 3), pd.dtype)
else:
n_nmv = None
for j, n in enumerate(n_n):
Q_G = kptpair.Q_G
with self.timer('conj'):
ut1cc_R = kpt1.ut_nR[n].conj()
with self.timer('paw'):
C1_aGi = [np.dot(Q_Gii, P1_ni[n].conj())
for Q_Gii, P1_ni in zip(Q_aGii, kpt1.P_ani)]
n_nmG[j] = self.calculate_pair_densities(ut1cc_R,
C1_aGi, kpt2,
pd, Q_G)
if optical_limit:
n_nmv[j] = self.optical_pair_density(n, m_m, kpt1, kpt2)
if optical_limit:
n_nmG[..., 0] = n_nmv[..., 0]
if intraband:
vel_mv = self.intraband_pair_density(kpt2)
else:
vel_mv = None
return n_nmG, n_nmv, vel_mv
@timer('get_pair_momentum')
def get_pair_momentum(self, pd, kptpair, n_n, m_m, Q_avGii=None):
"""Calculate matrix elements of the momentum operator.
Calculates::
n_{nm\mathrm{k}}\int_{\Omega_{\mathrm{cell}}}\mathrm{d}\mathbf{r}
\psi_{n\mathrm{k}}^*(\mathbf{r})
e^{-i\,(\mathrm{q} + \mathrm{G})\cdot\mathbf{r}}
\nabla\psi_{m\mathrm{k} + \mathrm{q}}(\mathbf{r})
pd: PlaneWaveDescriptor
Plane wave descriptor of a single q_c.
kptpair: KPointPair
KpointPair object containing the two kpoints.
n_n: list
List of left-band indices (n).
m_m:
List of right-band indices (m).
"""
wfs = self.calc.wfs
kpt1 = kptpair.kpt1
kpt2 = kptpair.kpt2
Q_G = kptpair.Q_G # Fourier components of kpoint pair
# For the same band we
kd = wfs.kd
gd = wfs.gd
k_c = kd.bzk_kc[kpt1.K] + kpt1.shift_c
k_v = 2 * np.pi * np.dot(k_c, np.linalg.inv(gd.cell_cv).T)
# Calculate k + G
G_Gv = pd.get_reciprocal_vectors(add_q=True)
kqG_Gv = k_v[np.newaxis] + G_Gv
# Pair velocities
n_nmvG = pd.zeros((len(n_n), len(m_m), 3))
# Calculate derivatives of left-wavefunction
# (there will typically be fewer of these)
ut_nvR = self.make_derivative(kpt1.s, kpt1.K, kpt1.n1, kpt1.n2)
# PAW-corrections
if Q_avGii is None:
Q_avGii = self.initialize_paw_nabla_corrections(pd)
# Iterate over occupied bands
for j, n in enumerate(n_n):
ut1cc_R = kpt1.ut_nR[n].conj()
n_mG = self.calculate_pair_densities(ut1cc_R,
[], kpt2,
pd, Q_G)
n_nmvG[j] = 1j * kqG_Gv.T[np.newaxis] * n_mG[:, np.newaxis]
# Treat each cartesian component at a time
for v in range(3):
# Minus from integration by parts
utvcc_R = -ut_nvR[n, v].conj()
Cv1_aGi = [np.dot(P1_ni[n].conj(), Q_vGii[v])
for Q_vGii, P1_ni in zip(Q_avGii, kpt1.P_ani)]
nv_mG = self.calculate_pair_densities(utvcc_R,
Cv1_aGi, kpt2,
pd, Q_G)
n_nmvG[j, :, v] += nv_mG
# We want the momentum operator
n_nmvG *= -1j
return n_nmvG
@timer('Calculate pair-densities')
def calculate_pair_densities(self, ut1cc_R, C1_aGi, kpt2, pd, Q_G):
"""Calculate FFT of pair-densities and add PAW corrections.
ut1cc_R: 3-d complex ndarray
Complex conjugate of the periodic part of the left hand side
wave function.
C1_aGi: list of ndarrays
PAW corrections for all atoms.
kpt2: KPoint object
Right hand side k-point object.
pd: PWDescriptor
Plane-wave descriptor for for q=k2-k1.
Q_G: 1-d int ndarray
Mapping from flattened 3-d FFT grid to 0.5(G+q)^2 1:
n0_Mv = np.empty((kpt2.blocksize * self.blockcomm.size, 3),
dtype=complex)
self.blockcomm.all_gather(n0_mv, n0_Mv)
n0_mv = n0_Mv[:kpt2.n2 - kpt2.n1]
return -1j * n0_mv
def optical_pair_density(self, n, m_m, kpt1, kpt2):
# Relative threshold for perturbation theory
threshold = self.threshold
eps1 = kpt1.eps_n[n]
deps_m = (eps1 - kpt2.eps_n)[m_m]
n0_mv = self.optical_pair_velocity(n, m_m, kpt1, kpt2)
deps_m = deps_m.copy()
deps_m[deps_m == 0.0] = np.inf
smallness_mv = np.abs(-1e-3 * n0_mv / deps_m[:, np.newaxis])
inds_mv = (np.logical_and(np.inf > smallness_mv,
smallness_mv > threshold))
n0_mv *= - 1 / deps_m[:, np.newaxis]
n0_mv[inds_mv] = 0
return n0_mv
@timer('Intraband')
def intraband_pair_density(self, kpt, n_n=None,
only_partially_occupied=True):
"""Calculate intraband matrix elements of nabla"""
# Bands and check for block parallelization
na, nb, n1 = kpt.na, kpt.nb, kpt.n1
vel_nv = np.zeros((nb - na, 3), dtype=complex)
if n_n is None:
n_n = np.arange(na, nb)
assert np.max(n_n) < nb, print('This is too many bands')
# Load kpoints
kd = self.calc.wfs.kd
gd = self.calc.wfs.gd
k_c = kd.bzk_kc[kpt.K] + kpt.shift_c
k_v = 2 * np.pi * np.dot(k_c, np.linalg.inv(gd.cell_cv).T)
atomdata_a = self.calc.wfs.setups
f_n = kpt.f_n
# No carriers when T=0
width = self.calc.occupations.width
if width == 0.0:
return None
# Only works with Fermi-Dirac distribution
assert isinstance(self.calc.occupations, FermiDirac)
dfde_n = (- 1. / width * (f_n - f_n**2.0)) # Analytical derivative
partocc_n = np.abs(dfde_n) > 1e-5 # Is part. occupied?
if only_partially_occupied and not partocc_n.any():
return None
if only_partially_occupied:
# Check for block par. consistency
assert (partocc_n < nb).all(), \
print('Include more unoccupied bands ', +
'or less block parr.', file=self.fd)
# Break bands into degenerate chunks
degchunks_cn = [] # indexing c as chunk number
for n in n_n:
inds_n = np.nonzero(np.abs(kpt.eps_n[n - n1] -
kpt.eps_n) < 1e-5)[0] + n1
# Has this chunk already been computed?
oldchunk = any([n in chunk for chunk in degchunks_cn])
if not oldchunk and \
(partocc_n[n - n1] or not only_partially_occupied):
assert all([ind in n_n for ind in inds_n]), \
print('\nYou are cutting over a degenerate band ' +
'using block parallelization.',
inds_n, n_n, file=self.fd)
degchunks_cn.append((inds_n))
# Calculate matrix elements by diagonalizing each block
for ind_n in degchunks_cn:
deg = len(ind_n)
ut_nvR = self.calc.wfs.gd.zeros((deg, 3), complex)
vel_nnv = np.zeros((deg, deg, 3), dtype=complex)
# States are included starting from kpt.na
ut_nR = kpt.ut_nR[ind_n - na]
# Get derivatives
for ind, ut_vR in zip(ind_n, ut_nvR):
ut_vR[:] = self.make_derivative(kpt.s, kpt.K,
ind, ind + 1)[0]
# Treat the whole degenerate chunk
for n in range(deg):
ut_vR = ut_nvR[n]
C_avi = [np.dot(atomdata.nabla_iiv.T, P_ni[ind_n[n] - na])
for atomdata, P_ni in zip(atomdata_a, kpt.P_ani)]
nabla0_nv = -self.calc.wfs.gd.integrate(ut_vR, ut_nR).T
nt_n = self.calc.wfs.gd.integrate(ut_nR[n], ut_nR)
nabla0_nv += 1j * nt_n[:, np.newaxis] * k_v[np.newaxis, :]
for C_vi, P_ni in zip(C_avi, kpt.P_ani):
gemm(1.0, C_vi, P_ni[ind_n - na], 1.0, nabla0_nv, 'c')
vel_nnv[n] = -1j * nabla0_nv
for iv in range(3):
vel, _ = np.linalg.eig(vel_nnv[..., iv])
vel_nv[ind_n - na, iv] = vel # Use eigenvalues
return vel_nv[n_n - na]
def get_fft_indices(self, K1, K2, q_c, pd, shift0_c):
"""Get indices for G-vectors inside cutoff sphere."""
kd = self.calc.wfs.kd
N_G = pd.Q_qG[0]
shift_c = (shift0_c +
(q_c - kd.bzk_kc[K2] + kd.bzk_kc[K1]).round().astype(int))
if shift_c.any():
n_cG = np.unravel_index(N_G, pd.gd.N_c)
n_cG = [n_G + shift for n_G, shift in zip(n_cG, shift_c)]
N_G = np.ravel_multi_index(n_cG, pd.gd.N_c, 'wrap')
return N_G
def construct_symmetry_operators(self, K):
"""Construct symmetry operators for wave function and PAW projections.
We want to transform a k-point in the irreducible part of the BZ to
the corresponding k-point with index K.
Returns U_cc, T, a_a, U_aii, shift_c and time_reversal, where:
* U_cc is a rotation matrix.
* T() is a function that transforms the periodic part of the wave
function.
* a_a is a list of symmetry related atom indices
* U_aii is a list of rotation matrices for the PAW projections
* shift_c is three integers: see code below.
* time_reversal is a flag - if True, projections should be complex
conjugated.
See the get_k_point() method for how to use these tuples.
"""
wfs = self.calc.wfs
kd = wfs.kd
s = kd.sym_k[K]
U_cc = kd.symmetry.op_scc[s]
time_reversal = kd.time_reversal_k[K]
ik = kd.bz2ibz_k[K]
k_c = kd.bzk_kc[K]
ik_c = kd.ibzk_kc[ik]
sign = 1 - 2 * time_reversal
shift_c = np.dot(U_cc, ik_c) - k_c * sign
assert np.allclose(shift_c.round(), shift_c)
shift_c = shift_c.round().astype(int)
if (U_cc == np.eye(3)).all():
T = lambda f_R: f_R
else:
N_c = self.calc.wfs.gd.N_c
i_cr = np.dot(U_cc.T, np.indices(N_c).reshape((3, -1)))
i = np.ravel_multi_index(i_cr, N_c, 'wrap')
T = lambda f_R: f_R.ravel()[i].reshape(N_c)
if time_reversal:
T0 = T
T = lambda f_R: T0(f_R).conj()
shift_c *= -1
a_a = []
U_aii = []
for a, id in enumerate(self.calc.wfs.setups.id_a):
b = kd.symmetry.a_sa[s, a]
S_c = np.dot(self.spos_ac[a], U_cc) - self.spos_ac[b]
x = np.exp(2j * pi * np.dot(ik_c, S_c))
U_ii = wfs.setups[a].R_sii[s].T * x
a_a.append(b)
U_aii.append(U_ii)
return U_cc, T, a_a, U_aii, shift_c, time_reversal
@timer('Initialize PAW corrections')
def initialize_paw_corrections(self, pd, soft=False):
print('Initializing PAW Corrections', file=self.fd)
wfs = self.calc.wfs
q_v = pd.K_qv[0]
optical_limit = np.allclose(q_v, 0)
G_Gv = pd.get_reciprocal_vectors()
if optical_limit:
G_Gv[0] = 1
pos_av = np.dot(self.spos_ac, pd.gd.cell_cv)
# Collect integrals for all species:
Q_xGii = {}
for id, atomdata in wfs.setups.setups.items():
if soft:
ghat = PWLFC([atomdata.ghat_l], pd)
ghat.set_positions(np.zeros((1, 3)))
Q_LG = ghat.expand()
Q_Gii = np.dot(atomdata.Delta_iiL, Q_LG).T
else:
Q_Gii = two_phi_planewave_integrals(G_Gv, atomdata)
ni = atomdata.ni
Q_Gii.shape = (-1, ni, ni)
Q_xGii[id] = Q_Gii
Q_aGii = []
for a, atomdata in enumerate(wfs.setups):
id = wfs.setups.id_a[a]
Q_Gii = Q_xGii[id]
x_G = np.exp(-1j * np.dot(G_Gv, pos_av[a]))
Q_aGii.append(x_G[:, np.newaxis, np.newaxis] * Q_Gii)
if optical_limit:
Q_aGii[a][0] = atomdata.dO_ii
return Q_aGii
@timer('Initialize PAW corrections')
def initialize_paw_nabla_corrections(self, pd, soft=False):
print('Initializing nabla PAW Corrections', file=self.fd)
wfs = self.calc.wfs
G_Gv = pd.get_reciprocal_vectors()
pos_av = np.dot(self.spos_ac, pd.gd.cell_cv)
# Collect integrals for all species:
Q_xvGii = {}
for id, atomdata in wfs.setups.setups.items():
if soft:
raise NotImplementedError
else:
Q_vGii = two_phi_nabla_planewave_integrals(G_Gv, atomdata)
ni = atomdata.ni
Q_vGii.shape = (3, -1, ni, ni)
Q_xvGii[id] = Q_vGii
Q_avGii = []
for a, atomdata in enumerate(wfs.setups):
id = wfs.setups.id_a[a]
Q_vGii = Q_xvGii[id]
x_G = np.exp(-1j * np.dot(G_Gv, pos_av[a]))
Q_avGii.append(x_G[np.newaxis, :, np.newaxis, np.newaxis] * Q_vGii)
return Q_avGii
def calculate_derivatives(self, kpt):
ut_sKnvR = [{}, {}]
ut_nvR = self.make_derivative(kpt.s, kpt.K, kpt.n1, kpt.n2)
ut_sKnvR[kpt.s][kpt.K] = ut_nvR
return ut_sKnvR
@timer('Derivatives')
def make_derivative(self, s, K, n1, n2):
wfs = self.calc.wfs
if self.real_space_derivatives:
grad_v = [Gradient(wfs.gd, v, 1.0, 4, complex).apply
for v in range(3)]
U_cc, T, a_a, U_aii, shift_c, time_reversal = \
self.construct_symmetry_operators(K)
A_cv = wfs.gd.cell_cv
M_vv = np.dot(np.dot(A_cv.T, U_cc.T), np.linalg.inv(A_cv).T)
ik = wfs.kd.bz2ibz_k[K]
kpt = wfs.kpt_u[s * wfs.kd.nibzkpts + ik]
psit_nG = kpt.psit_nG
iG_Gv = 1j * wfs.pd.get_reciprocal_vectors(q=ik, add_q=False)
ut_nvR = wfs.gd.zeros((n2 - n1, 3), complex)
for n in range(n1, n2):
for v in range(3):
if self.real_space_derivatives:
ut_R = T(wfs.pd.ifft(psit_nG[n], ik))
grad_v[v](ut_R, ut_nvR[n - n1, v],
np.ones((3, 2), complex))
else:
ut_R = T(wfs.pd.ifft(iG_Gv[:, v] * psit_nG[n], ik))
for v2 in range(3):
ut_nvR[n - n1, v2] += ut_R * M_vv[v, v2]
return ut_nvR
gpaw-0.11.0.13004/gpaw/response/base.py 0000664 0001750 0001750 00000051124 12553643470 017537 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import sys
from time import time, ctime
import numpy as np
from math import sqrt, pi
from datetime import timedelta
from ase.units import Hartree, Bohr
from ase.utils import devnull
from gpaw import GPAW, extra_parameters
from gpaw.utilities import unpack
from gpaw.utilities.blas import gemmdot, gemv
from gpaw.mpi import world, rank, size, serial_comm
from gpaw.lfc import LocalizedFunctionsCollection as LFC
from gpaw.grid_descriptor import GridDescriptor
from gpaw.utilities.memory import maxrss
from gpaw.fd_operators import Gradient
from gpaw.response.cell import get_primitive_cell, set_Gvectors
from gpaw.response.math_func import delta_function, \
two_phi_planewave_integrals
from gpaw.response.parallel import set_communicator, \
parallel_partition, SliceAlongFrequency, SliceAlongOrbitals
from gpaw.response.kernel import calculate_Kxc, calculate_Kc, calculate_Kc_q
from gpaw.kpt_descriptor import KPointDescriptor
from gpaw.wavefunctions.pw import PWLFC
import gpaw.wavefunctions.pw as pw
class BASECHI:
"""This class is to store the basic common stuff for chi and bse."""
def __init__(self,
calc=None,
nbands=None,
w=None,
q=None,
eshift=None,
ecut=10.,
density_cut=None,
G_plus_q=False,
eta=0.2,
rpad=None,
ftol=1e-5,
txt=None,
optical_limit=False):
if rpad is None:
rpad = np.ones(3, int)
self.txtname = txt
self.output_init()
if isinstance(calc, str):
# Always use serial_communicator when a filename is given.
self.calc = GPAW(calc, communicator=serial_comm, txt=None)
else:
# To be optimized so that the communicator is loaded automatically
# according to kcommsize.
#
# so temporarily it is used like this :
# kcommsize = int (should <= world.size)
# r0 = rank % kcommsize
# ranks = np.arange(r0, r0+size, kcommsize)
# calc = GPAW(filename.gpw, communicator=ranks, txt=None)
self.calc = calc
if self.calc is not None:
self.pwmode = isinstance(self.calc.wfs, pw.PWWaveFunctions)
else:
self.pwmode = False
if self.pwmode:
assert self.calc.wfs.world.size == 1
self.nbands = nbands
self.q_c = q
# chi.py modifies the input array w by dividing by Hartree.
# This will change the user-supplied arrays in-place unless
# we create a copy. So now we create a copy. *Grumble*
#
# To make matters worse, w is allowed to be None (why not take
# care of that *before*?? This should really be cleaned up.
if isinstance(w, np.ndarray):
w = w.copy()
self.w_w = w
self.eta = eta
self.ftol = ftol
if isinstance(ecut, int) or isinstance(ecut, float):
self.ecut = np.ones(3) * ecut
else:
assert len(ecut) == 3
self.ecut = np.array(ecut, dtype=float)
self.density_cut = density_cut
self.G_plus_q = G_plus_q
self.rpad = rpad
self.optical_limit = optical_limit
#if self.optical_limit:
self.qopt = 1e-5
self.eshift = eshift
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 output_init(self):
if self.txtname is None:
if rank == 0:
self.txt = sys.stdout
else:
sys.stdout = devnull
self.txt = devnull
elif self.txtname == devnull:
self.txt = devnull
else:
assert isinstance(self.txtname, str)
from ase.parallel import paropen
self.txt = paropen(self.txtname,'w')
def printtxt(self, text):
print(text, file=self.txt)
def print_stuff(self):
printtxt = self.printtxt
printtxt('')
printtxt('Parameters used:')
printtxt('')
printtxt('Unit cell (a.u.):')
printtxt(self.acell_cv)
printtxt('Volume of cell (a.u.**3) : %f' % self.vol)
printtxt('Reciprocal cell (1/a.u.)')
printtxt(self.bcell_cv)
printtxt('BZ volume (1/a.u.**3) : %f' % self.BZvol)
printtxt('Number of G-vectors / Grid : %d %s'
% (self.nG0, tuple(self.gd.N_c)))
printtxt('')
printtxt('Coulomb interaction cutoff : %s' % self.vcut)
printtxt('')
printtxt('Number of bands : %d' % self.nbands)
printtxt('Number of kpoints : %d' % self.kd.nbzkpts)
if self.ecut[0] == self.ecut[1] and self.ecut[0] == self.ecut[2]:
printtxt('Planewave ecut (eV) : %4.1f' % (self.ecut[0] * Hartree))
else:
printtxt('Planewave ecut (eV) : (%f, %f, %f)' % tuple(self.ecut * Hartree))
printtxt('Number of planewave used : %d' % self.npw)
printtxt('Broadening (eta) : %f' % (self.eta * Hartree))
printtxt('')
if self.q_c is not None:
if self.optical_limit:
printtxt('Optical limit calculation ! (q=1e-5)')
else:
printtxt('q in reduced coordinate : (%f %f %f)' % tuple(self.q_c))
printtxt('q in cartesian coordinate (1/A): (%f %f %f)' % tuple(self.qq_v / Bohr))
printtxt('|q| (1/A) : %f' % np.linalg.norm(self.qq_v / Bohr))
def timing(self, i, t0, n_local, txt):
if i == 0:
dt = time() - t0
self.totaltime = dt * n_local
self.printtxt(' Finished %s 0 in %s, estimate %s left.'
% (txt, timedelta(seconds=round(dt)),
timedelta(seconds=round(self.totaltime))))
if rank == 0 and n_local // 5 > 0:
if i > 0 and i % (n_local // 5) == 0:
dt = time() - t0
self.printtxt(' Finished %s %d in %s, estimate %s left.'
% (txt, i, timedelta(seconds=round(dt)),
timedelta(seconds=round(self.totaltime
- dt))))
def get_phi_aGp(self, q_c=None, parallel=True, alldir=False):
if q_c is None:
q_c = self.q_c
qq_v = self.qq_v
optical_limit = self.optical_limit
else:
optical_limit = False
if np.abs(q_c).sum() < 1e-8:
q_c = np.array([0.0001, 0, 0])
optical_limit = True
qq_v = np.dot(q_c, self.bcell_cv)
setups = self.calc.wfs.setups
spos_ac = self.calc.atoms.get_scaled_positions()
kk_Gv = gemmdot(q_c + self.Gvec_Gc, self.bcell_cv.copy(), beta=0.0)
phi_aGp = {}
phiG0_avp = {}
if parallel:
from gpaw.response.parallel import parallel_partition
npw, npw_local, Gstart, Gend = parallel_partition(
self.npw, self.comm.rank, self.comm.size, reshape=False)
else:
Gstart = 0
Gend = self.npw
for a, id in enumerate(setups.id_a):
phi_aGp[a] = two_phi_planewave_integrals(kk_Gv, setups[a], Gstart, Gend)
for iG in range(Gstart, Gend):
phi_aGp[a][iG] *= np.exp(-1j * 2. * pi *
np.dot(q_c + self.Gvec_Gc[iG], spos_ac[a]) )
if parallel:
self.comm.sum(phi_aGp[a])
# For optical limit, G == 0 part should change
if optical_limit:
for a, id in enumerate(setups.id_a):
nabla_iiv = setups[a].nabla_iiv
phi_aGp[a][0] = -1j * (np.dot(nabla_iiv, qq_v)).ravel()
phiG0_avp[a] = np.zeros((3, len(phi_aGp[a][0])), complex)
for dir in range(3): # 3 dimension
q2_c = np.diag((1,1,1))[dir] * self.qopt
qq2_v = np.dot(q2_c, self.bcell_cv) # summation over c
phiG0_avp[a][dir] = -1j * (np.dot(nabla_iiv, qq2_v)).ravel()
if alldir:
return phi_aGp, phiG0_avp
else:
return phi_aGp
def get_wavefunction(self, ibzk, n, check_focc=True, spin=0):
if (self.calc.wfs.world.size == 1 or self.calc.wfs.gd.comm.size != 1
or self.calc.input_parameters['mode'] == 'lcao'):
if not check_focc:
return
else:
psit_G = self.calc.wfs.get_wave_function_array(n, ibzk, spin)
if self.calc.wfs.world.size == 1:
return np.complex128(psit_G)
if self.calc.wfs.world.rank != 0:
psit_G = self.calc.wfs.gd.empty(dtype=self.calc.wfs.dtype,
global_array=True)
self.calc.wfs.world.broadcast(psit_G, 0)
return np.complex128(psit_G)
else:
# support ground state calculation with kpoint and band parallelization
# but domain decomposition must = 1
kpt_rank, u = self.calc.wfs.kd.get_rank_and_index(0, ibzk)
bzkpt_rank = self.kcomm.rank
band_rank, myn = self.calc.wfs.bd.who_has(n)
assert self.calc.wfs.gd.comm.size == 1
world_rank = (kpt_rank * self.calc.wfs.band_comm.size + band_rank)
# in the following, kpt_rank is assigned to world_rank
klist = np.array([world_rank, u, bzkpt_rank, myn])
klist_kcomm = np.zeros((self.kcomm.size, 4), dtype=int)
self.kcomm.all_gather(klist, klist_kcomm)
check_focc_global = np.zeros(self.kcomm.size, dtype=bool)
self.kcomm.all_gather(np.array([check_focc]), check_focc_global)
psit_G = self.calc.wfs.gd.empty(dtype=self.calc.wfs.dtype)
for i in range(self.kcomm.size):
if check_focc_global[i]:
kpt_rank, u, bzkpt_rank, nlocal = klist_kcomm[i]
if kpt_rank == bzkpt_rank:
if rank == kpt_rank:
psit_G = self.calc.wfs.kpt_u[u].psit_nG[nlocal]
else:
if rank == kpt_rank:
world.send(self.calc.wfs.kpt_u[u].psit_nG[nlocal],
bzkpt_rank, 1300+bzkpt_rank)
if rank == bzkpt_rank:
psit_G = self.calc.wfs.gd.empty(dtype=self.calc.wfs.dtype)
world.receive(psit_G, kpt_rank, 1300+bzkpt_rank)
self.wScomm.broadcast(psit_G, 0)
return psit_G
def add_discontinuity(self, shift):
for ispin in range(self.nspins):
for k in range(self.kd.nibzkpts):
for i in range(self.e_skn[0].shape[1]):
if self.e_skn[ispin][k,i] > self.eFermi:
self.e_skn[ispin][k,i] += shift / Hartree
def density_matrix(self, n, m, k, kq=None,
spin1=0, spin2=0, phi_aGp=None, Gspace=True):
gd = self.gd
kd = self.kd
optical_limit = False
if kq is None:
kq = self.kq_k[k]
expqr_g = self.expqr_g
q_v = self.qq_v
optical_limit = self.optical_limit
q_c = self.q_c
else:
q_c = kd.bzk_kc[kq] - kd.bzk_kc[k]
q_c[np.where(q_c>0.501)] -= 1
q_c[np.where(q_c<-0.499)] += 1
if (np.abs(q_c) < self.ftol).all():
optical_limit = True
q_c = self.q_c
q_v = np.dot(q_c, self.bcell_cv)
r_vg = gd.get_grid_point_coordinates() # (3, nG)
qr_g = gemmdot(q_v, r_vg, beta=0.0)
expqr_g = np.exp(-1j * qr_g)
if optical_limit:
expqr_g = 1
ibzkpt1 = kd.bz2ibz_k[k]
ibzkpt2 = kd.bz2ibz_k[kq]
psitold_g = self.get_wavefunction(ibzkpt1, n, True, spin=spin1)
psit1_g = kd.transform_wave_function(psitold_g, k)
psitold_g = self.get_wavefunction(ibzkpt2, m, True, spin=spin2)
psit2_g = kd.transform_wave_function(psitold_g, kq)
if Gspace is False:
return psit1_g.conj() * psit2_g * expqr_g
else:
tmp_g = psit1_g.conj()* psit2_g * expqr_g
# zero padding is included through the FFT
rho_g = np.fft.fftn(tmp_g, s=self.nGrpad) * self.vol / self.nG0rpad
# Here, planewave cutoff is applied
rho_G = rho_g.ravel()[self.Gindex_G]
if optical_limit:
dpsit_g = gd.empty(dtype=complex)
tmp = np.zeros((3), dtype=complex)
phase_cd = np.exp(2j * pi * gd.sdisp_cd * kd.bzk_kc[kq, :, np.newaxis])
for ix in range(3):
self.d_c[ix](psit2_g, dpsit_g, phase_cd)
tmp[ix] = gd.integrate(psit1_g.conj() * dpsit_g)
rho_G[0] = -1j * np.dot(q_v, tmp)
calc = self.calc
pt = self.pt
if not self.pwmode:
if calc.wfs.world.size > 1 or kd.nbzkpts == 1:
P1_ai = pt.dict()
pt.integrate(psit1_g, P1_ai, k)
P2_ai = pt.dict()
pt.integrate(psit2_g, P2_ai, kq)
else:
P1_ai = self.get_P_ai(k, n, spin1)
P2_ai = self.get_P_ai(kq, m, spin2)
else:
# first calculate P_ai at ibzkpt, then rotate to k
u = self.kd.get_rank_and_index(spin1, ibzkpt1)[1]
Ptmp_ai = pt.dict()
kpt = calc.wfs.kpt_u[u]
pt.integrate(kpt.psit_nG[n], Ptmp_ai, ibzkpt1)
P1_ai = self.get_P_ai(k, n, spin1, Ptmp_ai)
u = self.kd.get_rank_and_index(spin2, ibzkpt2)[1]
Ptmp_ai = pt.dict()
kpt = calc.wfs.kpt_u[u]
pt.integrate(kpt.psit_nG[m], Ptmp_ai, ibzkpt2)
P2_ai = self.get_P_ai(kq, m, spin2, Ptmp_ai)
if phi_aGp is None:
try:
if not self.mode == 'RPA':
if optical_limit:
iq = kd.where_is_q(np.zeros(3), self.bzq_qc)
else:
iq = kd.where_is_q(q_c, self.bzq_qc)
assert np.abs(self.bzq_qc[iq] - q_c).sum() < 1e-8
phi_aGp = self.load_phi_aGp(self.reader, iq) #phi_qaGp[iq]
except AttributeError:
phi_aGp = self.phi_aGp
for a, id in enumerate(self.calc.wfs.setups.id_a):
P_p = np.outer(P1_ai[a].conj(), P2_ai[a]).ravel()
phi_Gp = np.ascontiguousarray(phi_aGp[a], complex)
gemv(1.0, phi_Gp, P_p, 1.0, rho_G)
if optical_limit:
if n==m:
rho_G[0] = 1.
elif np.abs(self.e_skn[spin2][ibzkpt2, m] - self.e_skn[spin1][ibzkpt1, n]) < 1e-5:
rho_G[0] = 0.
else:
rho_G[0] /= (self.enoshift_skn[spin2][ibzkpt2, m] - self.enoshift_skn[spin1][ibzkpt1, n])
return rho_G
def get_P_ai(self, k, n, spin=0, Ptmp_ai=None):
calc = self.calc
kd = self.calc.wfs.kd
spos_ac = self.spos_ac
ibzkpt = kd.bz2ibz_k[k]
u = ibzkpt + kd.nibzkpts * spin
kpt = calc.wfs.kpt_u[u]
s = kd.sym_k[k]
time_reversal = kd.time_reversal_k[k]
P_ai = {}
for a, id in enumerate(calc.wfs.setups.id_a):
b = kd.symmetry.a_sa[s, a]
S_c = (np.dot(spos_ac[a], kd.symmetry.op_scc[s]) - kd.symmetry.ft_sc[s] - spos_ac[b])
#print abs(S_c.round() - S_c).max()
#print 'S_c', abs(S_c).max()
assert abs(S_c.round() - S_c).max() < 1e-8 ##############
k_c = kd.ibzk_kc[kpt.k]
x = np.exp(2j * pi * np.dot(k_c, S_c))
if Ptmp_ai is None:
P_i = np.dot(calc.wfs.setups[a].R_sii[s], kpt.P_ani[b][n]) * x
else:
P_i = np.dot(calc.wfs.setups[a].R_sii[s], Ptmp_ai[b]) * x
if time_reversal:
P_i = P_i.conj()
P_ai[a] = P_i
return P_ai
gpaw-0.11.0.13004/gpaw/response/fxc.py 0000664 0001750 0001750 00000003361 12553643470 017405 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import numpy as np
def Bootstrap(chi0_wGG, Nw, Kc_GG, printtxt, print_bootstrap, world):
Nw_local = chi0_wGG.shape[0]
npw = chi0_wGG.shape[1]
# arxiv 1107.0199
fxc_GG = np.zeros((npw, npw), dtype=complex)
tmp_GG = np.eye(npw, npw)
dminv_wGG = np.zeros((Nw_local, npw, npw), dtype=complex)
dflocal_w = np.zeros(Nw_local, dtype=complex)
df_w = np.zeros(Nw, dtype=complex)
for iscf in range(120):
dminvold_wGG = dminv_wGG.copy()
Kxc_GG = Kc_GG + fxc_GG
for iw in range(Nw_local):
chi_GG = np.dot(chi0_wGG[iw], np.linalg.inv(tmp_GG - np.dot(Kxc_GG, chi0_wGG[iw])))
dminv_wGG[iw] = tmp_GG + np.dot(Kc_GG, chi_GG)
if world.rank == 0:
alpha = dminv_wGG[0,0,0] / (Kc_GG[0,0] * chi0_wGG[0,0,0])
fxc_GG = alpha * Kc_GG
world.broadcast(fxc_GG, 0)
error = np.abs(dminvold_wGG - dminv_wGG).sum()
if world.sum(error) < 0.1:
printtxt('Self consistent fxc finished in %d iterations ! ' %(iscf))
break
if iscf > 100:
printtxt('Too many fxc scf steps !')
if print_bootstrap:
for iw in range(Nw_local):
dflocal_w[iw] = np.linalg.inv(dminv_wGG[iw])[0,0]
world.all_gather(dflocal_w, df_w)
if world.rank == 0:
f = open('df_scf%d' %(iscf), 'w')
for iw in range(Nw):
print(np.real(df_w[iw]), np.imag(df_w[iw]), file=f)
f.close()
world.barrier()
for iw in range(Nw_local):
dflocal_w[iw] = np.linalg.inv(dminv_wGG[iw])[0,0]
world.all_gather(dflocal_w, df_w)
return df_w
gpaw-0.11.0.13004/gpaw/response/parallel.py 0000664 0001750 0001750 00000021140 12553643470 020414 0 ustar jensj jensj 0000000 0000000 # The parallel code is from Carsten Rostgaard #
import numpy as np
from gpaw.mpi import serial_comm
from gpaw.mpi import rank, size, world
from gpaw.io import open
def set_communicator(world, rank, size, kcommsize=None):
"""Communicator inilialized."""
# wcomm is always set to world
wcomm = world
if kcommsize is None or kcommsize == size or size == 1:
# By default, only use parallization in kpoints
# then kcomm is set to world communicator
# and wS is not parallelized
kcomm = world
wScomm = serial_comm
else:
# If use wS parallization for storage of spectral function
# then new kpoint and wS communicator are generated
assert kcommsize != size
r0 = (rank // kcommsize) * kcommsize
ranks = np.arange(r0, r0 + kcommsize)
kcomm = world.new_communicator(ranks)
# wS comm generated
r0 = rank % kcommsize
ranks = np.arange(r0, r0+size, kcommsize)
wScomm = world.new_communicator(ranks)
return kcomm, wScomm, wcomm
def parallel_partition(N, commrank, commsize, reshape=True, positive=False):
if reshape is True:
if N % commsize != 0:
N -= N % commsize
if positive:
N += commsize
assert N % commsize == 0
N_local = N // commsize
N_residual = N - N_local * commsize
if commrank < N_residual:
N_local += 1
N_start = commrank * N_local
N_end = (commrank + 1) * N_local
else:
offset = N_residual * (N_local + 1)
N_start = offset + (commrank - N_residual) * N_local
N_end = offset + (commrank + 1 - N_residual) * N_local
return N, N_local, N_start, N_end
def parallel_partition_list(N, commrank, commsize):
Nlist = []
for i in range(N):
if commrank == i % commsize:
Nlist.append(i)
N_local = len(Nlist)
return N, N_local, Nlist
def collect_orbitals(a_xo, coords, comm, root=0):
"""Collect array distributed over orbitals to root-CPU.
Input matrix has last axis distributed amongst CPUs,
return is None on slaves, and the collected array on root.
The distribution can be uneven amongst CPUs. The list coords gives the
number of values for each CPU.
"""
a_xo = np.ascontiguousarray(a_xo)
if comm.size == 1:
return a_xo
# All slaves send their piece to ``root``:
# There can be several sends before the corresponding receives
# are posted, so use syncronous send here
if comm.rank != root:
comm.ssend(a_xo, root, 112)
return None
# On root, put the subdomains from the slaves into the big array
# for the whole domain on root:
xshape = a_xo.shape[:-1]
Norb2 = sum(coords) # total number of orbital indices
a_xO = np.empty(xshape + (Norb2,), a_xo.dtype)
o = 0
for rank, norb in enumerate(coords):
if rank != root:
tmp_xo = np.empty(xshape + (norb,), a_xo.dtype)
comm.receive(tmp_xo, rank, 112)
a_xO[..., o:o + norb] = tmp_xo
else:
a_xO[..., o:o + norb] = a_xo
o += norb
return a_xO
def collect_energies(a_ex, comm, root=0):
"""Collect array distributed over energies to root-CPU.
Input matrix has first axis distributed evenly amongst CPUs,
return is None on slaves, and the collected array on root.
As the distribution is even amongst CPUs, gather can be used here.
"""
a_ex = np.ascontiguousarray(a_ex)
if comm.size == 1:
return a_ex
nenergies, xshape = a_ex.shape[0], a_ex.shape[1:]
if comm.rank == root:
a_Ex = np.empty((comm.size, nenergies) + xshape, a_ex.dtype)
comm.gather(a_ex, root, a_Ex)
return a_Ex.reshape((comm.size * nenergies,) + xshape)
else:
comm.gather(a_ex, root)
return None
def SliceAlongFrequency(a_eO, coords, comm):
"""Slice along frequency axis.
Input array has subset of energies, but full orbital matrix.
Output has full energy, but subset of flattened orbital matrix.
coords is a list of the number of orbital indices per cpu.
"""
# flatten orbital axis
a_eO = np.ascontiguousarray(a_eO).reshape(len(a_eO), -1)
if comm.size == 1:
return a_eO
o = 0
for rank, norb in enumerate(coords):
a_eo = a_eO[:, o:o + norb].copy()
tmp = collect_energies(a_eo, comm, root=rank)
if rank == comm.rank:
a_Eo = tmp
o += norb
return a_Eo
def SliceAlongOrbitals(a_Eo, coords, comm):
"""Slice along orbital axis.
Input has full energy, but subset of flattened orbital matrix.
Output array has subset of energies, but full orbital matrix.
coords is a list of the number of orbital indices per cpu.
"""
Norb = np.sqrt(sum(coords)).astype(int)
nenergies = len(a_Eo) // comm.size # energy points per processor.
a_Eo = np.ascontiguousarray(a_Eo)
if comm.size == 1:
return a_Eo.reshape(nenergies, Norb, Norb)
for rank in range(comm.size):
a_eo = a_Eo[rank * nenergies:(rank + 1) * nenergies, :].copy()
tmp = collect_orbitals(a_eo, coords, comm, root=rank)
if rank == comm.rank:
a_eO = tmp.reshape(nenergies, Norb, Norb)
return a_eO
def GatherOrbitals(a_Eo, coords, comm):
"""Slice along orbital axis.
Input has subset of flattened orbital matrix.
Output array has full orbital matrix.
coords is a list of the number of orbital indices per cpu.
"""
Norb = np.sqrt(sum(coords)).astype(int)
if len(np.shape(a_Eo)) == 1:
nenergies = 1
else:
nenergies = len(a_Eo)
a_Eo = np.ascontiguousarray(a_Eo)
if comm.size == 1:
if nenergies == 1:
return a_Eo.reshape(nenergies, Norb, Norb)[0]
else:
return a_Eo.reshape(nenergies, Norb, Norb)
for rank in range(comm.size):
tmp = collect_orbitals(a_Eo, coords, comm, root=rank)
if rank == comm.rank:
if nenergies==1:
a_EO = tmp.reshape(Norb, Norb)
else:
a_EO = tmp.reshape(nenergies, Norb, Norb)
return a_EO
def par_write(filename, name, comm, chi0_wGG):
## support only world communicator at the moment
assert comm.size == size
assert comm.rank == rank
Nw_local, npw, npw1 = chi0_wGG.shape
assert npw == npw1
Nw = Nw_local * size
w = open(filename, 'w', comm)
w.dimension('Nw', Nw)
w.dimension('npw', npw)
w.add(name, ('Nw', 'npw', 'npw'), dtype=complex)
if rank == 0:
tmp = np.zeros_like(chi0_wGG[0])
for iw in range(Nw):
irank = iw // Nw_local
if irank == 0:
if rank == 0:
w.fill(chi0_wGG[iw])
else:
if rank == irank:
world.send(chi0_wGG[iw-rank*Nw_local], 0, irank+100)
if rank == 0:
world.receive(tmp, irank, irank+100)
w.fill(tmp)
if rank == 0:
w.close()
world.barrier()
def par_read(filename, name, Nw=None):
r = open(filename, 'r')
if Nw is None:
Nw = r.dimension('Nw')
else:
assert Nw <= r.dimension('Nw')
npw = r.dimension('npw')
Nw_local = Nw // size
chi0_wGG = np.zeros((Nw_local, npw, npw), dtype=complex)
for iw in range(Nw_local):
chi0_wGG[iw] = r.get(name, iw+rank*Nw_local)
r.close()
return chi0_wGG
def gatherv(m, N=None):
if world.size == 1:
return m
ndim = m.ndim
if ndim == 2:
n, N = m.shape
assert n < N
M = np.zeros((N, N), dtype=complex)
elif ndim == 1:
n = m.shape[0]
M = np.zeros(N, dtype=complex)
else:
print('Not Implemented')
XX
n_index = np.zeros(size, dtype=int)
world.all_gather(np.array([n]), n_index)
root = 0
if rank != root:
world.ssend(m, root, 112+rank)
else:
for irank, n in enumerate(n_index):
if irank == root:
if ndim == 2:
M[:n_index[0] :] = m
else:
M[:n_index[0]] = m
else:
n_start = n_index[0:irank].sum()
n_end = n_index[0:irank+1].sum()
if ndim == 2:
tmp_nN = np.zeros((n, N), dtype=complex)
world.receive(tmp_nN, irank, 112+irank)
M[n_start:n_end, :] = tmp_nN
else:
tmp_n = np.zeros(n, dtype=complex)
world.receive(tmp_n, irank, 112+irank)
M[n_start:n_end] = tmp_n
world.broadcast(M, root)
return M
gpaw-0.11.0.13004/gpaw/response/__init__.py 0000664 0001750 0001750 00000000000 12553643470 020347 0 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/hgh.py 0000664 0001750 0001750 00000046227 12553643470 015545 0 ustar jensj jensj 0000000 0000000 import hashlib
import numpy as np
from ase.data import atomic_numbers
from gpaw.utilities import pack2
from gpaw.atom.radialgd import AERadialGridDescriptor
from gpaw.atom.configurations import configurations
from gpaw.pseudopotential import PseudoPotential
setups = {} # Filled out during parsing below
sc_setups = {} # Semicore
# Tabulated values of Gamma(m + 1/2)
half_integer_gamma = [np.sqrt(np.pi)]
for m in range(20):
half_integer_gamma.append(half_integer_gamma[m] * (m + 0.5))
class HGHSetupData:
"""Setup-compatible class implementing HGH pseudopotential.
To the PAW code this will appear as a legit PAW setup, but is
in fact considerably simpler. In particular, all-electron and
pseudo partial waves are all zero, and compensation charges do not
depend on environment.
A HGH setup has the following form::
----
\
V = Vlocal + ) | p > h < p |
/ i ij j
----
ij
Vlocal contains a short-range term which is Gaussian-shaped and
implemented as vbar of a PAW setup, along with a long-range term
which goes like 1/r and is implemented in terms of a compensation
charge.
The non-local part contains KB projector functions which are
essentially similar to those in PAW, while h_ij are constants.
h_ij are provided by setting the K_p variable of the normal
setup.
Most other properties of a PAW setup do not exist for HGH setups, for
which reason they are generally set to zero:
* All-electron partial waves: always zero
* Pseudo partial waves: always zero
* Projectors: HGH projectors
* Zero potential (vbar): Gaussian times polynomial
* Compensation charges: One Gaussian-shaped spherically symmetric charge
* All-electron core density: Delta function corresponding to core electron
charge
* Pseudo core density: always zero
* Pseudo valence density: always zero
* PS/AE Kinetic energy density: always zero
* The mysterious constants K_p of a setup correspond to h_ij.
Note that since the pseudo partial waves are set to zero,
initialization of atomic orbitals requires loading a custom basis
set.
Absolute energies become numerically large since no atomic
reference is subtracted.
"""
def __init__(self, hghdata):
if isinstance(hghdata, str):
symbol = hghdata
if symbol.endswith('.sc'):
hghdata = sc_setups[symbol[:-3]]
else:
hghdata = setups[symbol]
self.hghdata = hghdata
chemsymbol = hghdata.symbol
if '.' in chemsymbol:
chemsymbol, sc = chemsymbol.split('.')
assert sc == 'sc'
self.symbol = chemsymbol
self.type = hghdata.symbol
self.name = 'LDA'
self.initialize_setup_data()
def initialize_setup_data(self):
hghdata = self.hghdata
beta = 0.1
N = 450
rgd = AERadialGridDescriptor(beta / N, 1.0 / N, N,
default_spline_points=100)
#rgd = EquidistantRadialGridDescriptor(0.001, 10000)
self.rgd = rgd
self.Z = hghdata.Z
self.Nc = hghdata.Z - hghdata.Nv
self.Nv = hghdata.Nv
self.rcgauss = np.sqrt(2.0) * hghdata.rloc
threshold = 1e-8
if len(hghdata.c_n) > 0:
vloc_g = create_local_shortrange_potential(rgd.r_g, hghdata.rloc,
hghdata.c_n)
gcutvbar, rcutvbar = self.find_cutoff(rgd.r_g, rgd.dr_g, vloc_g,
threshold)
self.vbar_g = np.sqrt(4.0 * np.pi) * vloc_g[:gcutvbar]
else:
rcutvbar = 0.5
gcutvbar = rgd.ceil(rcutvbar)
self.vbar_g = np.zeros(gcutvbar)
nj = sum([v.nn for v in hghdata.v_l])
if nj == 0:
nj = 1 # Code assumes nj > 0 elsewhere, we fill out with zeroes
if not hghdata.v_l:
# No projectors. But the remaining code assumes that everything
# has projectors! We'll just add the zero function then
hghdata.v_l = [VNonLocal(0, 0.01, [[0.]])]
n_j = []
l_j = []
# j ordering is significant, must be nl rather than ln
for n, l in self.hghdata.nl_iter():
n_j.append(n + 1) # Note: actual n must be positive!
l_j.append(l)
assert nj == len(n_j)
self.nj = nj
self.l_j = l_j
self.l_orb_j = l_j
self.n_j = n_j
self.rcut_j = []
self.pt_jg = []
for n, l in zip(n_j, l_j):
# Note: even pseudopotentials without projectors will get one
# projector, but the coefficients h_ij should be zero so it
# doesn't matter
pt_g = create_hgh_projector(rgd.r_g, l, n, hghdata.v_l[l].r0)
norm = np.sqrt(np.dot(rgd.dr_g, pt_g**2 * rgd.r_g**2))
assert np.abs(1 - norm) < 1e-5, str(1 - norm)
gcut, rcut = self.find_cutoff(rgd.r_g, rgd.dr_g, pt_g, threshold)
if rcut < 0.5:
rcut = 0.5
gcut = rgd.ceil(rcut)
pt_g = pt_g[:gcut].copy()
rcut = max(rcut, 0.5)
self.rcut_j.append(rcut)
self.pt_jg.append(pt_g)
# This is the correct magnitude of the otherwise normalized
# compensation charge
self.Delta0 = -self.Nv / np.sqrt(4.0 * np.pi)
f_ln = self.hghdata.get_occupation_numbers()
f_j = [0] * nj
for j, (n, l) in enumerate(self.hghdata.nl_iter()):
try:
f_j[j] = f_ln[l][n]
except IndexError:
pass
self.f_ln = f_ln
self.f_j = f_j
def find_cutoff(self, r_g, dr_g, f_g, sqrtailnorm=1e-5):
g = len(r_g)
acc_sqrnorm = 0.0
while acc_sqrnorm <= sqrtailnorm:
g -= 1
acc_sqrnorm += (r_g[g] * f_g[g])**2.0 * dr_g[g]
if r_g[g] < 0.5: # XXX
return g, r_g[g]
return g, r_g[g]
def expand_hamiltonian_matrix(self):
"""Construct K_p from individual h_nn for each l."""
ni = sum([2 * l + 1 for l in self.l_j])
H_ii = np.zeros((ni, ni))
# The H_ii used in gpaw is much larger and more general than the one
# required for HGH pseudopotentials. This means a lot of the elements
# must be assigned the same value. Not a performance issue though,
# since these are small matrices
M1start = 0
for n1, l1 in self.hghdata.nl_iter():
M1end = M1start + 2 * l1 + 1
M2start = 0
v = self.hghdata.v_l[l1]
for n2, l2 in self.hghdata.nl_iter():
M2end = M2start + 2 * l2 + 1
if l1 == l2:
h_nn = v.expand_hamiltonian_diagonal()
H_mm = np.identity(M2end - M2start) * h_nn[n1, n2]
H_ii[M1start:M1end, M2start:M2end] += H_mm
M2start = M2end
M1start = M1end
K_p = pack2(H_ii)
return K_p
def __str__(self):
return "HGHSetupData('%s')" % self.type
def __repr__(self):
return self.__str__()
def print_info(self, text, _setup):
self.hghdata.print_info(text)
def plot(self):
"""Plot localized functions of HGH setup."""
import pylab as pl
rgd = self.rgd
pl.subplot(211) # vbar, compensation charge
gcutvbar = len(self.vbar_g)
pl.plot(rgd.r_g[:gcutvbar], self.vbar_g, 'r', label='vloc',
linewidth=3)
rcc, gcc = self.get_compensation_charge_functions()
gcc = gcc[0]
pl.plot(rcc, gcc * self.Delta0, 'b--', label='Comp charge [arb. unit]',
linewidth=3)
pl.legend(loc='best')
pl.subplot(212) # projectors
for j, (n, l, pt_g) in enumerate(zip(self.n_j, self.l_j, self.pt_jg)):
label = 'n=%d, l=%d' % (n, l)
pl.ylabel('$p_n^l(r)$')
ng = len(pt_g)
r_g = rgd.r_g[:ng]
pl.plot(r_g, pt_g, label=label)
pl.legend()
def get_projectors(self):
# XXX equal-range projectors still required for some reason
maxlen = max([len(pt_g) for pt_g in self.pt_jg])
pt_j = []
for l, pt1_g in zip(self.l_j, self.pt_jg):
pt2_g = self.rgd.zeros()[:maxlen]
pt2_g[:len(pt1_g)] = pt1_g
pt_j.append(self.rgd.spline(pt2_g, self.rgd.r_g[maxlen - 1], l))
return pt_j
def create_basis_functions(self):
from gpaw.pseudopotential import generate_basis_functions
return generate_basis_functions(self)
def get_compensation_charge_functions(self):
alpha = self.rcgauss**-2
rcutgauss = self.rcgauss * 5.0
# smaller values break charge conservation
r = np.linspace(0.0, rcutgauss, 100)
g = alpha**1.5 * np.exp(-alpha * r**2) * 4.0 / np.sqrt(np.pi)
g[-1] = 0.0
return r, [0], [g]
def get_local_potential(self):
n = len(self.vbar_g)
return self.rgd.spline(self.vbar_g, self.rgd.r_g[n - 1])
def build(self, xcfunc, lmax, basis, filter=None):
if basis is None:
basis = self.create_basis_functions()
setup = PseudoPotential(self, basis)
setup.fingerprint = hashlib.md5(str(self.hghdata).encode()).hexdigest()
return setup
def create_local_shortrange_potential(r_g, rloc, c_n):
rr_g = r_g / rloc # "Relative r"
rr2_g = rr_g**2
rr4_g = rr2_g**2
rr6_g = rr4_g * rr2_g
gaussianpart = np.exp(-.5 * rr2_g)
polypart = np.zeros(r_g.shape)
for c, rrn_g in zip(c_n, [1, rr2_g, rr4_g, rr6_g]):
polypart += c * rrn_g
vloc_g = gaussianpart * polypart
return vloc_g
def create_hgh_projector(r_g, l, n, r0):
poly_g = r_g**(l + 2 * (n - 1))
gauss_g = np.exp(-.5 * r_g**2 / r0**2)
A = r0**(l + (4 * n - 1) / 2.0)
assert (4 * n - 1) % 2 == 1
B = half_integer_gamma[l + (4 * n - 1) // 2]**.5
pt_g = 2.**.5 / A / B * poly_g * gauss_g
return pt_g
# Coefficients determining off-diagonal elements of h_nn for l = 0...2
# given the diagonal elements
hcoefs_l = [
[-.5 * (3. / 5.)**.5, .5 * (5. / 21.)**.5, -.5 * (100. / 63.)**.5],
[-.5 * (5. / 7.)**.5, 1. / 6. * (35. / 11.)**.5, -1. / 6. * 14. / 11.**.5],
[-.5 * (7. / 9.)**.5, .5 * (63. / 143)**.5, -.5 * 18. / 143.**.5]
]
class VNonLocal:
"""Wrapper class for one nonlocal term of an HGH potential."""
def __init__(self, l, r0, h_n):
self.l = l
self.r0 = r0
h_n = np.array(h_n)
nn = len(h_n)
self.nn = nn
self.h_n = h_n
def expand_hamiltonian_diagonal(self):
"""Construct full atomic Hamiltonian from diagonal elements."""
nn = self.nn
h_n = self.h_n
h_nn = np.zeros((nn, nn))
for n, h in enumerate(h_n):
h_nn[n, n] = h
if self.l > 2:
#print 'Warning: no diagonal elements for l=%d' % l
# Some elements have projectors corresponding to l=3, but
# the HGH article only specifies how to calculate the
# diagonal elements of the atomic hamiltonian for l = 0, 1, 2 !
return
coefs = hcoefs_l[self.l]
if nn > 2:
h_nn[0, 2] = h_nn[2, 0] = coefs[1] * h_n[2]
h_nn[1, 2] = h_nn[2, 1] = coefs[2] * h_n[2]
if nn > 1:
h_nn[0, 1] = h_nn[1, 0] = coefs[0] * h_n[1]
return h_nn
def copy(self):
return VNonLocal(self.l, self.r0, self.h_n.copy())
def serialize(self): # no spin-orbit part
return ' '.join([' ', '%-10s' % self.r0] +
['%10f' % h for h in self.h_n])
class HGHParameterSet:
"""Wrapper class for HGH-specific data corresponding to one element."""
def __init__(self, symbol, Z, Nv, rloc, c_n, v_l):
self.symbol = symbol # Identifier, e.g. 'Na', 'Na.sc', ...
self.Z = Z # Actual atomic number
self.Nv = Nv # Valence electron count
self.rloc = rloc # Characteristic radius of local part
self.c_n = np.array(c_n) # Polynomial coefficients for local part
self.v_l = list(v_l) # Non-local parts
Z, nlfe_j = configurations[self.symbol.split('.')[0]]
self.configuration = nlfe_j
def __str__(self):
strings = ['HGH setup for %s\n' % self.symbol,
' Valence Z=%d, rloc=%.05f\n' % (self.Nv, self.rloc)]
if len(self.c_n) > 0:
coef_string = ', '.join(['%.05f' % c for c in self.c_n])
else:
coef_string = 'zeros'
strings.append(' Local part coeffs: %s\n' % coef_string)
strings.append(' Projectors:\n')
if not self.v_l:
strings.append(' None\n')
for v in self.v_l:
strings.append(' l=%d, rc=%.05f\n' % (v.l, v.r0))
strings.append(' Diagonal coefficients of nonlocal parts:')
if not self.v_l:
strings.append('\n None\n')
for v in self.v_l:
strings.append('\n')
strings.append(' l=%d: ' % v.l +
', '.join(['%8.05f' % h for h in v.h_n]))
return ''.join(strings)
def copy(self):
other = HGHParameterSet(self.symbol, self.Z, self.Nv, self.rloc,
self.c_n, self.v_l)
return other
def print_info(self, txt):
txt(str(self))
txt()
def nl_iter(self):
for n in range(4):
for l, v in enumerate(self.v_l):
if n < v.nn:
yield n, l
def get_occupation_numbers(self):
nlfe_j = list(self.configuration)
nlfe_j.reverse()
f_ln = [[], [], []] # [[s], [p], [d]]
# f states will be ignored as the atomic Hamiltonians
# of those are, carelessly, not defined in the article.
lmax = len(self.v_l) - 1
Nv = 0
# Right. We need to find the occupation numbers of each state and
# put them into a nice list of lists f_ln.
#
# We loop over states starting with the least bound one
# (i.e. reversed nlfe_j), adding the occupation numbers of each state
# as appropriate. Once we have the right number of electrons, we
# end the loop.
#
# Some states in the standard configuration might
# be f-type; these should be skipped (unless the HGH setup actually
# has a valence f-state; however as noted above, some of the
# parameters are undefined in that case so are ignored anyway). More
# generally if for some state l > lmax,
# we can skip that state.
for n, l, f, e in nlfe_j:
if l > lmax:
continue
Nv += f
f_n = f_ln[l]
assert f_n == [] or self.symbol.endswith('.sc')
f_n.append(f)
if Nv >= self.Nv:
break
assert Nv == self.Nv
return f_ln
def zeropad(self):
"""Return a new HGHParameterSet with all arrays zero padded so they
have the same (max) length for all such HGH setups. Makes
plotting multiple HGH setups easier because they have compatible
arrays."""
c_n = np.zeros(4)
for n, c in enumerate(self.c_n):
c_n[n] = c
v_l = []
for l, v in enumerate(self.v_l):
h_n = np.zeros(3)
h_n[:len(v.h_n)] = list(v.h_n)
v2 = VNonLocal(l, v.r0, h_n)
v_l.append(v2)
for l in range(len(self.v_l), 3):
v_l.append(VNonLocal(l, 0.5, np.zeros(3)))
copy = HGHParameterSet(self.symbol, self.Z, self.Nv, self.rloc, c_n,
v_l)
return copy
def serialize(self):
string1 = '%-5s %-12s %10s ' % (self.symbol, self.Z, self.rloc)
string2 = ' '.join(['%.10s' % c for c in self.c_n])
nonlocal_strings = [v.serialize() for v in self.v_l]
return '\n'.join([string1 + string2] + nonlocal_strings)
def parse_local_part(string):
"""Create HGHParameterSet object with local part initialized."""
tokens = iter(string.split())
symbol = next(tokens)
actual_chemical_symbol = symbol.split('.')[0]
Z = atomic_numbers[actual_chemical_symbol]
Nv = int(next(tokens))
rloc = float(next(tokens))
c_n = [float(token) for token in tokens]
return symbol, Z, Nv, rloc, c_n
class HGHBogusNumbersError(ValueError):
"""Error which is raised when the HGH parameters contain f-type
or higher projectors. The HGH article only defines atomic Hamiltonian
matrices up to l=2, so these are meaningless."""
pass
def parse_hgh_setup(lines):
"""Initialize HGHParameterSet object from text representation."""
lines = iter(lines)
symbol, Z, Nv, rloc, c_n = parse_local_part(next(lines))
def pair_up_nonlocal_lines(lines):
yield next(lines), ''
while True:
yield next(lines), next(lines)
v_l = []
for l, (non_local, spinorbit) in enumerate(pair_up_nonlocal_lines(lines)):
# we discard the spinorbit 'k_n' data so far
nltokens = non_local.split()
r0 = float(nltokens[0])
h_n = [float(token) for token in nltokens[1:]]
#if h_n[-1] == 0.0: # Only spin-orbit contributes. Discard.
# h_n.pop()
# Actually the above causes trouble. Probably it messes up state
# ordering or something else that shouldn't have any effect.
vnl = VNonLocal(l, r0, h_n)
v_l.append(vnl)
if l > 2:
raise HGHBogusNumbersError
hgh = HGHParameterSet(symbol, Z, Nv, rloc, c_n, v_l)
return hgh
def str2hgh(string):
return parse_hgh_setup(string.splitlines())
def hgh2str(hgh):
return hgh.serialize()
def parse_setups(lines):
"""Read HGH data from file."""
setups = {}
entry_lines = [i for i in range(len(lines))
if lines[i][0].isalpha()]
lines_by_element = [lines[entry_lines[i]:entry_lines[i + 1]]
for i in range(len(entry_lines) - 1)]
lines_by_element.append(lines[entry_lines[-1]:])
for elines in lines_by_element:
try:
hgh = parse_hgh_setup(elines)
except HGHBogusNumbersError:
continue
assert hgh.symbol not in setups
setups[hgh.symbol] = hgh
return setups
def plot(symbol, extension=None):
import pylab as pl
try:
s = HGHSetupData(symbol)
except IndexError:
print('Nooooo')
return
s.plot()
if extension is not None:
pl.savefig('hgh.%s.%s' % (symbol, extension))
def plot_many(*symbols):
import pylab as pl
if not symbols:
symbols = setups.keys() + [key + '.sc' for key in sc_setups.keys()]
for symbol in symbols:
pl.figure(1)
plot(symbol, extension='png')
pl.clf()
def parse_default_setups():
from gpaw.hgh_parameters import parameters
lines = parameters.splitlines()
setups0 = parse_setups(lines)
for key, value in setups0.items():
if key.endswith('.sc'):
sym, sc = key.split('.')
sc_setups[sym] = value
else:
setups[key] = value
parse_default_setups()
gpaw-0.11.0.13004/gpaw/solvation/ 0000775 0001750 0001750 00000000000 12553644063 016427 5 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/solvation/poisson.py 0000664 0001750 0001750 00000026450 12553643471 020504 0 ustar jensj jensj 0000000 0000000 from gpaw.poisson import PoissonSolver
from gpaw.transformers import Transformer
from gpaw.fd_operators import Laplace, Gradient
from gpaw.wfd_operators import WeightedFDOperator
from gpaw.utilities.gauss import Gaussian
from gpaw.utilities import erf
import warnings
import numpy as np
class SolvationPoissonSolver(PoissonSolver):
"""Base class for Poisson solvers with spatially varying dielectric.
The Poisson equation
div(epsilon(r) grad phi(r)) = -4 pi rho(r)
is solved.
"""
def __init__(self, nn=3, relax='J', eps=2e-10, maxiter=1000,
remove_moment=None, use_charge_center=True):
if remove_moment is not None:
raise NotImplementedError(
'Removing arbitrary multipole moments '
'is not implemented for SolvationPoissonSolver!'
)
PoissonSolver.__init__(self, nn, relax, eps, maxiter, remove_moment,
use_charge_center=use_charge_center)
def set_dielectric(self, dielectric):
"""Set the dielectric.
Arguments:
dielectric -- A Dielectric instance.
"""
self.dielectric = dielectric
def load_gauss(self, center=None):
"""Load compensating charge distribution for charged systems.
See Appendix B of
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
"""
# XXX Check if update is needed (dielectric changed)?
epsr, dx_epsr, dy_epsr, dz_epsr = self.dielectric.eps_gradeps
gauss = Gaussian(self.gd, center=center)
rho_g = gauss.get_gauss(0)
phi_g = gauss.get_gauss_pot(0)
x, y, z = gauss.xyz
fac = 2. * np.sqrt(gauss.a) * np.exp(-gauss.a * gauss.r2)
fac /= np.sqrt(np.pi) * gauss.r2
fac -= erf(np.sqrt(gauss.a) * gauss.r) / (gauss.r2 * gauss.r)
fac *= 2.0 * 1.7724538509055159
dx_phi_g = fac * x
dy_phi_g = fac * y
dz_phi_g = fac * z
sp = dx_phi_g * dx_epsr + dy_phi_g * dy_epsr + dz_phi_g * dz_epsr
rho = epsr * rho_g - 1. / (4. * np.pi) * sp
invnorm = np.sqrt(4. * np.pi) / self.gd.integrate(rho)
self.phi_gauss = phi_g * invnorm
self.rho_gauss = rho * invnorm
class WeightedFDPoissonSolver(SolvationPoissonSolver):
"""Weighted finite difference Poisson solver with dielectric.
Following V. M. Sanchez, M. Sued and D. A. Scherlis,
J. Chem. Phys. 131, 174108 (2009).
"""
def solve(self, phi, rho, charge=None, eps=None,
maxcharge=1e-6,
zero_initial_phi=False):
if self.gd.pbc_c.all():
actual_charge = self.gd.integrate(rho)
if abs(actual_charge) > maxcharge:
raise NotImplementedError(
'charged periodic systems are not implemented'
)
self.restrict_op_weights()
ret = PoissonSolver.solve(self, phi, rho, charge, eps, maxcharge,
zero_initial_phi)
return ret
def restrict_op_weights(self):
"""Restric operator weights to coarse grids."""
weights = [self.dielectric.eps_gradeps] + self.op_coarse_weights
for i, res in enumerate(self.restrictors):
for j in range(4):
res.apply(weights[i][j], weights[i + 1][j])
self.step = 0.66666666 / self.operators[0].get_diagonal_element()
def set_grid_descriptor(self, gd):
self.gd = gd
self.gds = [gd]
self.dv = gd.dv
gd = self.gd
self.B = None
self.interpolators = []
self.restrictors = []
self.operators = []
level = 0
self.presmooths = [2]
self.postsmooths = [1]
self.weights = [2. / 3.]
while level < 8:
try:
gd2 = gd.coarsen()
except ValueError:
break
self.gds.append(gd2)
self.interpolators.append(Transformer(gd2, gd))
self.restrictors.append(Transformer(gd, gd2))
self.presmooths.append(4)
self.postsmooths.append(4)
self.weights.append(1.0)
level += 1
gd = gd2
self.levels = level
def get_description(self):
if len(self.operators) == 0:
return 'uninitialized WeightedFDPoissonSolver'
else:
description = SolvationPoissonSolver.get_description(self)
return description.replace(
'solver with',
'weighted FD solver with dielectric and'
)
def initialize(self, load_gauss=False):
self.presmooths[self.levels] = 8
self.postsmooths[self.levels] = 8
self.phis = [None] + [gd.zeros() for gd in self.gds[1:]]
self.residuals = [gd.zeros() for gd in self.gds]
self.rhos = [gd.zeros() for gd in self.gds]
self.op_coarse_weights = [
[g.empty() for g in (gd, ) * 4] for gd in self.gds[1:]
]
scale = -0.25 / np.pi
for i, gd in enumerate(self.gds):
if i == 0:
nn = self.nn
weights = self.dielectric.eps_gradeps
else:
nn = 1
weights = self.op_coarse_weights[i - 1]
operators = [Laplace(gd, scale, nn)] + \
[Gradient(gd, j, scale, nn) for j in (0, 1, 2)]
self.operators.append(WeightedFDOperator(weights, operators))
if load_gauss:
self.load_gauss()
class PolarizationPoissonSolver(SolvationPoissonSolver):
"""Poisson solver with dielectric.
Calculates the polarization charges first using only the
vacuum poisson equation, then solves the vacuum equation
with polarization charges.
Warning: Not intended for production use, as it is not exact enough,
since the electric field is not exact enough!
"""
def __init__(self, nn=3, relax='J', eps=2e-10, maxiter=1000,
remove_moment=None, use_charge_center=True):
polarization_warning = UserWarning(
(
'PolarizationPoissonSolver is not accurate enough'
' and therefore not recommended for production code!'
)
)
warnings.warn(polarization_warning)
SolvationPoissonSolver.__init__(
self, nn, relax, eps, maxiter, remove_moment,
use_charge_center=use_charge_center
)
self.phi_tilde = None
def get_description(self):
if len(self.operators) == 0:
return 'uninitialized PolarizationPoissonSolver'
else:
description = SolvationPoissonSolver.get_description(self)
return description.replace(
'solver with',
'polarization solver with dielectric and'
)
def solve(self, phi, rho, charge=None, eps=None,
maxcharge=1e-6,
zero_initial_phi=False):
if self.phi_tilde is None:
self.phi_tilde = self.gd.zeros()
phi_tilde = self.phi_tilde
niter_tilde = PoissonSolver.solve(
self, phi_tilde, rho, None, self.eps,
maxcharge, False
)
epsr, dx_epsr, dy_epsr, dz_epsr = self.dielectric.eps_gradeps
dx_phi_tilde = self.gd.empty()
dy_phi_tilde = self.gd.empty()
dz_phi_tilde = self.gd.empty()
Gradient(self.gd, 0, 1.0, self.nn).apply(phi_tilde, dx_phi_tilde)
Gradient(self.gd, 1, 1.0, self.nn).apply(phi_tilde, dy_phi_tilde)
Gradient(self.gd, 2, 1.0, self.nn).apply(phi_tilde, dz_phi_tilde)
scalar_product = (
dx_epsr * dx_phi_tilde +
dy_epsr * dy_phi_tilde +
dz_epsr * dz_phi_tilde
)
rho_and_pol = (
rho / epsr + scalar_product / (4. * np.pi * epsr ** 2)
)
niter = PoissonSolver.solve(
self, phi, rho_and_pol, None, eps,
maxcharge, zero_initial_phi
)
return niter_tilde + niter
def load_gauss(self, center=None):
return PoissonSolver.load_gauss(self, center=center)
class ADM12PoissonSolver(SolvationPoissonSolver):
"""Poisson solver with dielectric.
Following O. Andreussi, I. Dabo, and N. Marzari,
J. Chem. Phys. 136, 064102 (2012).
Warning: Not intended for production use, as it is not tested
thouroughly!
XXX TODO : * Correction for charged systems???
* Check: Can the polarization charge introduce a monopole?
* Convergence problems depending on eta. Apparently this
method works best with FFT as in the original Paper.
* Optimize numerics.
"""
def __init__(self, nn=3, relax='J', eps=2e-10, maxiter=1000,
remove_moment=None, eta=.6, use_charge_center=True):
"""Constructor for ADM12PoissonSolver.
Additional arguments not present in SolvationPoissonSolver:
eta -- linear mixing parameter
"""
adm12_warning = UserWarning(
(
'ADM12PoissonSolver is not tested thoroughly'
' and therefore not recommended for production code!'
)
)
warnings.warn(adm12_warning)
self.eta = eta
SolvationPoissonSolver.__init__(
self, nn, relax, eps, maxiter, remove_moment,
use_charge_center=use_charge_center
)
def set_grid_descriptor(self, gd):
SolvationPoissonSolver.set_grid_descriptor(self, gd)
self.gradx = Gradient(gd, 0, 1.0, self.nn)
self.grady = Gradient(gd, 1, 1.0, self.nn)
self.gradz = Gradient(gd, 2, 1.0, self.nn)
def get_description(self):
if len(self.operators) == 0:
return 'uninitialized ADM12PoissonSolver'
else:
description = SolvationPoissonSolver.get_description(self)
return description.replace(
'solver with',
'ADM12 solver with dielectric and'
)
def initialize(self, load_gauss=False):
self.rho_iter = self.gd.zeros()
self.d_phi = self.gd.empty()
return SolvationPoissonSolver.initialize(self, load_gauss)
def solve(self, phi, rho, charge=None, eps=None,
maxcharge=1e-6,
zero_initial_phi=False):
if self.gd.pbc_c.all():
actual_charge = self.gd.integrate(rho)
if abs(actual_charge) > maxcharge:
raise NotImplementedError(
'charged periodic systems are not implemented'
)
return PoissonSolver.solve(
self, phi, rho, charge, eps, maxcharge, zero_initial_phi
)
def solve_neutral(self, phi, rho, eps=2e-10):
self.rho = rho
return SolvationPoissonSolver.solve_neutral(self, phi, rho, eps)
def iterate2(self, step, level=0):
if level == 0:
epsr, dx_epsr, dy_epsr, dz_epsr = self.dielectric.eps_gradeps
self.gradx.apply(self.phis[0], self.d_phi)
sp = dx_epsr * self.d_phi
self.grady.apply(self.phis[0], self.d_phi)
sp += dy_epsr * self.d_phi
self.gradz.apply(self.phis[0], self.d_phi)
sp += dz_epsr * self.d_phi
self.rho_iter = self.eta / (4. * np.pi) * sp + \
(1. - self.eta) * self.rho_iter
self.rhos[0][:] = (self.rho_iter + self.rho) / epsr
return SolvationPoissonSolver.iterate2(self, step, level)
gpaw-0.11.0.13004/gpaw/solvation/hamiltonian.py 0000664 0001750 0001750 00000017024 12553643471 021312 0 ustar jensj jensj 0000000 0000000 from gpaw.hamiltonian import RealSpaceHamiltonian
from gpaw.solvation.poisson import WeightedFDPoissonSolver
from gpaw.fd_operators import Gradient
import numpy as np
class SolvationRealSpaceHamiltonian(RealSpaceHamiltonian):
"""Realspace Hamiltonian with continuum solvent model.
See also Section III of
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
"""
def __init__(
self,
# solvation related arguments:
cavity, dielectric, interactions,
# RealSpaceHamiltonian arguments:
gd, finegd, nspins, setups, timer, xc, world,
kptband_comm, vext=None, collinear=True, psolver=None,
stencil=3
):
"""Constructor of SolvationRealSpaceHamiltonian class.
Additional arguments not present in RealSpaceHamiltonian:
cavity -- A Cavity instance.
dielectric -- A Dielectric instance.
interactions -- A list of Interaction instances.
"""
self.cavity = cavity
self.dielectric = dielectric
self.interactions = interactions
cavity.set_grid_descriptor(finegd)
dielectric.set_grid_descriptor(finegd)
for ia in interactions:
ia.set_grid_descriptor(finegd)
if psolver is None:
psolver = WeightedFDPoissonSolver()
psolver.set_dielectric(self.dielectric)
self.gradient = None
RealSpaceHamiltonian.__init__(
self,
gd, finegd, nspins, setups, timer, xc, world,
kptband_comm, vext, collinear, psolver,
stencil
)
for ia in interactions:
setattr(self, 'E_' + ia.subscript, None)
self.new_atoms = None
self.vt_ia_g = None
def estimate_memory(self, mem):
RealSpaceHamiltonian.estimate_memory(self, mem)
solvation = mem.subnode('Solvation')
for name, obj in [
('Cavity', self.cavity),
('Dielectric', self.dielectric),
] + [('Interaction: ' + ia.subscript, ia) for ia in self.interactions]:
obj.estimate_memory(solvation.subnode(name))
def update_atoms(self, atoms):
self.new_atoms = atoms.copy()
def initialize(self):
self.gradient = [
Gradient(self.finegd, i, 1.0, self.poisson.nn) for i in (0, 1, 2)
]
self.vt_ia_g = self.finegd.zeros()
self.cavity.allocate()
self.dielectric.allocate()
for ia in self.interactions:
ia.allocate()
RealSpaceHamiltonian.initialize(self)
def update(self, density):
self.timer.start('Hamiltonian')
if self.vt_sg is None:
self.timer.start('Initialize Hamiltonian')
self.initialize()
self.timer.stop('Initialize Hamiltonian')
cavity_changed = self.cavity.update(self.new_atoms, density)
if cavity_changed:
self.cavity.update_vol_surf()
self.dielectric.update(self.cavity)
Epot, Ebar, Eext, Exc = self.update_pseudo_potential(density)
ia_changed = [
ia.update(
self.new_atoms,
density,
self.cavity if cavity_changed else None
) for ia in self.interactions
]
if np.any(ia_changed):
self.vt_ia_g.fill(.0)
for ia in self.interactions:
if ia.depends_on_el_density:
self.vt_ia_g += ia.delta_E_delta_n_g
if self.cavity.depends_on_el_density:
self.vt_ia_g += (ia.delta_E_delta_g_g *
self.cavity.del_g_del_n_g)
if len(self.interactions) > 0:
for vt_g in self.vt_sg[:self.nspins]:
vt_g += self.vt_ia_g
Eias = [ia.E for ia in self.interactions]
Ekin = self.calculate_kinetic_energy(density)
W_aL = self.calculate_atomic_hamiltonians(density)
Ekin, Epot, Ebar, Eext, Exc = self.update_corrections(
density, Ekin, Epot, Ebar, Eext, Exc, W_aL
)
energies = np.array([Ekin, Epot, Ebar, Eext, Exc] + Eias)
self.timer.start('Communicate energies')
self.gd.comm.sum(energies)
# Make sure that all CPUs have the same energies
self.world.broadcast(energies, 0)
self.cavity.communicate_vol_surf(self.world)
self.timer.stop('Communicate energies')
(self.Ekin0, self.Epot, self.Ebar, self.Eext, self.Exc) = energies[:5]
for E, ia in zip(energies[5:], self.interactions):
setattr(self, 'E_' + ia.subscript, E)
# self.Exc += self.Enlxc
# self.Ekin0 += self.Enlkin
self.new_atoms = None
self.timer.stop('Hamiltonian')
def update_pseudo_potential(self, density):
ret = RealSpaceHamiltonian.update_pseudo_potential(self, density)
if not self.cavity.depends_on_el_density:
return ret
del_g_del_n_g = self.cavity.del_g_del_n_g
# XXX optimize numerics
del_eps_del_g_g = self.dielectric.del_eps_del_g_g
Veps = -1. / (8. * np.pi) * del_eps_del_g_g * del_g_del_n_g
Veps *= self.grad_squared(self.vHt_g)
for vt_g in self.vt_sg[:self.nspins]:
vt_g += Veps
return ret
def calculate_forces(self, dens, F_av):
# XXX reorganize
self.el_force_correction(dens, F_av)
for ia in self.interactions:
if self.cavity.depends_on_atomic_positions:
for a, F_v in enumerate(F_av):
del_g_del_r_vg = self.cavity.get_del_r_vg(a, dens)
for v in (0, 1, 2):
F_v[v] -= self.finegd.integrate(
ia.delta_E_delta_g_g * del_g_del_r_vg[v],
global_integral=False
)
if ia.depends_on_atomic_positions:
for a, F_v in enumerate(F_av):
del_E_del_r_vg = ia.get_del_r_vg(a, dens)
for v in (0, 1, 2):
F_v[v] -= self.finegd.integrate(
del_E_del_r_vg[v],
global_integral=False
)
return RealSpaceHamiltonian.calculate_forces(
self, dens, F_av
)
def el_force_correction(self, dens, F_av):
if not self.cavity.depends_on_atomic_positions:
return
del_eps_del_g_g = self.dielectric.del_eps_del_g_g
fixed = 1. / (8. * np.pi) * del_eps_del_g_g * \
self.grad_squared(self.vHt_g) # XXX grad_vHt_g inexact in bmgs
for a, F_v in enumerate(F_av):
del_g_del_r_vg = self.cavity.get_del_r_vg(a, dens)
for v in (0, 1, 2):
F_v[v] += self.finegd.integrate(
fixed * del_g_del_r_vg[v],
global_integral=False
)
def get_energy(self, occupations):
self.Ekin = self.Ekin0 + occupations.e_band
self.S = occupations.e_entropy
self.Eel = (
self.Ekin + self.Epot + self.Eext + self.Ebar + self.Exc - self.S
)
Etot = self.Eel
for ia in self.interactions:
Etot += getattr(self, 'E_' + ia.subscript)
self.Etot = Etot
return self.Etot
def grad_squared(self, x):
# XXX ugly
gs = np.empty_like(x)
tmp = np.empty_like(x)
self.gradient[0].apply(x, gs)
np.square(gs, gs)
self.gradient[1].apply(x, tmp)
np.square(tmp, tmp)
gs += tmp
self.gradient[2].apply(x, tmp)
np.square(tmp, tmp)
gs += tmp
return gs
gpaw-0.11.0.13004/gpaw/solvation/dielectric.py 0000664 0001750 0001750 00000007544 12553643471 021124 0 ustar jensj jensj 0000000 0000000 from gpaw.fd_operators import Gradient
from gpaw.solvation.gridmem import NeedsGD
import numpy as np
class Dielectric(NeedsGD):
"""Class representing a spatially varying permittivity.
Attributes:
eps_gradeps -- List [eps_g, dxeps_g, dyeps_g, dzeps_g]
with
eps_g: permittivity on the fine grid
dieps_g: gradient of eps_g.
del_eps_del_g_g -- Partial derivative with respect to
the cavity. (A point-wise dependence
on the cavity is assumed).
"""
def __init__(self, epsinf):
"""Constructor for the Dielectric class.
Arguments:
epsinf -- Static dielectric constant
at infinite distance from the solute.
"""
NeedsGD.__init__(self)
self.epsinf = float(epsinf)
self.eps_gradeps = None # eps_g, dxeps_g, dyeps_g, dzeps_g
self.del_eps_del_g_g = None
def estimate_memory(self, mem):
nbytes = self.gd.bytecount()
mem.subnode('Permittivity', nbytes)
mem.subnode('Permittivity Gradient', 3 * nbytes)
mem.subnode('Permittivity Derivative', nbytes)
def allocate(self):
NeedsGD.allocate(self)
self.eps_gradeps = []
eps_g = self.gd.empty()
eps_g.fill(1.0)
self.eps_gradeps.append(eps_g)
self.eps_gradeps.extend([gd.zeros() for gd in (self.gd, ) * 3])
self.del_eps_del_g_g = self.gd.empty()
def update(self, cavity):
"""Calculate eps_gradeps and del_eps_del_g_g from the cavity."""
raise NotImplementedError
def print_parameters(self, text):
"""Print parameters using text function."""
text('epsilon_inf: %s' % (self.epsinf, ))
class FDGradientDielectric(Dielectric):
"""Dielectric with finite difference gradient."""
def __init__(self, epsinf, nn=3):
"""Constructor for the FDGradientDielectric class.
Additional arguments not present in the base Dielectric class:
nn -- Stencil size for finite difference gradient.
"""
Dielectric.__init__(self, epsinf)
self.nn = nn
self.eps_hack_g = None
self.gradient = None
def estimate_memory(self, mem):
Dielectric.estimate_memory(self, mem)
mem.subnode('Boundary Correction', self.gd.bytecount())
def allocate(self):
Dielectric.allocate(self)
self.eps_hack_g = self.gd.empty()
self.gradient = [
Gradient(self.gd, i, 1.0, self.nn) for i in (0, 1, 2)
]
def update_gradient(self):
"""Update the gradient.
Usage note:
Call this method at the end of the update method of a subclass.
"""
# zero on boundary, since bmgs supports only zero or periodic BC
np.subtract(self.eps_gradeps[0], self.epsinf, out=self.eps_hack_g)
for i in (0, 1, 2):
self.gradient[i].apply(self.eps_hack_g, self.eps_gradeps[i + 1])
class LinearDielectric(FDGradientDielectric):
"""Dielectric depending (affine) linearly on the cavity.
See also
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
"""
def allocate(self):
FDGradientDielectric.allocate(self)
self.del_eps_del_g_g = self.epsinf - 1. # frees array
def update(self, cavity):
np.multiply(cavity.g_g, self.epsinf - 1., self.eps_gradeps[0])
self.eps_gradeps[0] += 1.
self.update_gradient()
class CMDielectric(FDGradientDielectric):
"""Clausius-Mossotti like dielectric.
Untested, use at own risk!
"""
def update(self, cavity):
ei = self.epsinf
t = 1. - cavity.g_g
self.eps_gradeps[0][:] = (3. * (ei + 2.)) / ((ei - 1.) * t + 3.) - 2.
self.del_eps_del_g_g[:] = (
(3. * (ei - 1.) * (ei + 2.)) / ((ei - 1.) * t + 3.) ** 2
)
self.update_gradient()
gpaw-0.11.0.13004/gpaw/solvation/cavity.py 0000664 0001750 0001750 00000074555 12553643471 020322 0 ustar jensj jensj 0000000 0000000 from ase.units import kB, Hartree, Bohr
from gpaw.solvation.gridmem import NeedsGD
from gpaw.fd_operators import Gradient
import numpy as np
def get_pbc_positions(atoms, r_max):
"""Return dict mapping atom index to positions in Bohr.
With periodic boundary conditions, it also includes neighbouring
cells up to a distance of r_max (in Bohr).
"""
# code snippet taken from ase/calculators/vdwcorrection.py
pbc_c = atoms.get_pbc()
cell_cv = atoms.get_cell() / Bohr
Rcell_c = np.sqrt(np.sum(cell_cv ** 2, axis=1))
ncells_c = np.ceil(np.where(pbc_c, 1. + r_max / Rcell_c, 1)).astype(int)
pos_aav = {}
# loop over all atoms in the cell (and neighbour cells for PBC)
for index1, atom in enumerate(atoms):
pos = atom.position / Bohr
pos_aav[index1] = np.empty((np.prod(ncells_c * 2 - 1), 3))
# loops over neighbour cells
index2 = 0
for ix in range(-ncells_c[0] + 1, ncells_c[0]):
for iy in range(-ncells_c[1] + 1, ncells_c[1]):
for iz in range(-ncells_c[2] + 1, ncells_c[2]):
i_c = np.array([ix, iy, iz])
pos_aav[index1][index2, :] = pos + np.dot(i_c, cell_cv)
index2 += 1
return pos_aav
def divide_silently(x, y):
"""Divide numpy arrays x / y ignoring all floating point errors.
Use with caution!
"""
old_err = np.seterr(all='ignore')
result = x / y
np.seterr(**old_err)
return result
class Cavity(NeedsGD):
"""Base class for representing a cavity in the solvent.
Attributes:
g_g -- The cavity on the fine grid. It varies from zero at the
solute location to one in the bulk solvent.
del_g_del_n_g -- The partial derivative of the cavity with respect to
the electron density on the fine grid.
V -- global Volume in Bohr ** 3 or None
A -- global Area in Bohr ** 2 or None
"""
def __init__(self, surface_calculator=None, volume_calculator=None):
"""Constructor for the Cavity class.
Arguments:
surface_calculator -- A SurfaceCalculator instance or None
volume_calculator -- A VolumeCalculator instance or None
"""
NeedsGD.__init__(self)
self.g_g = None
self.del_g_del_n_g = None
self.surface_calculator = surface_calculator
self.volume_calculator = volume_calculator
self.V = None # global Volume
self.A = None # global Surface
def estimate_memory(self, mem):
ngrids = 1 + self.depends_on_el_density
mem.subnode('Distribution Function', ngrids * self.gd.bytecount())
if self.surface_calculator is not None:
self.surface_calculator.estimate_memory(
mem.subnode('Surface Calculator')
)
if self.volume_calculator is not None:
self.volume_calculator.estimate_memory(
mem.subnode('Volume Calculator')
)
def update(self, atoms, density):
"""Update the cavity.
atoms are None, iff they have not changed.
Return whether the cavity has changed.
"""
raise NotImplementedError()
def update_vol_surf(self):
"""Update volume and surface."""
if self.surface_calculator is not None:
self.surface_calculator.update(self)
if self.volume_calculator is not None:
self.volume_calculator.update(self)
def communicate_vol_surf(self, world):
"""Communicate global volume and surface."""
if self.surface_calculator is not None:
A = np.array([self.surface_calculator.A])
self.gd.comm.sum(A)
world.broadcast(A, 0)
self.A = A[0]
else:
self.A = None
if self.volume_calculator is not None:
V = np.array([self.volume_calculator.V])
self.gd.comm.sum(V)
world.broadcast(V, 0)
self.V = V[0]
else:
self.V = None
def allocate(self):
NeedsGD.allocate(self)
self.g_g = self.gd.empty()
if self.depends_on_el_density:
self.del_g_del_n_g = self.gd.empty()
if self.surface_calculator is not None:
self.surface_calculator.allocate()
if self.volume_calculator is not None:
self.volume_calculator.allocate()
def set_grid_descriptor(self, gd):
NeedsGD.set_grid_descriptor(self, gd)
if self.surface_calculator is not None:
self.surface_calculator.set_grid_descriptor(gd)
if self.volume_calculator is not None:
self.volume_calculator.set_grid_descriptor(gd)
def get_del_r_vg(self, atom_index, density):
"""Return spatial derivatives with respect to atomic position."""
raise NotImplementedError()
@property
def depends_on_el_density(self):
"""Return whether the cavity depends on the electron density."""
raise NotImplementedError()
@property
def depends_on_atomic_positions(self):
"""Return whether the cavity depends explicitly on atomic positions."""
raise NotImplementedError()
def print_parameters(self, text):
"""Print parameters using text function."""
typ = self.surface_calculator and self.surface_calculator.__class__
text('surface calculator: %s' % (typ, ))
if self.surface_calculator is not None:
self.surface_calculator.print_parameters(text)
text()
typ = self.volume_calculator and self.volume_calculator.__class__
text('volume calculator: %s' % (typ, ))
if self.volume_calculator is not None:
self.volume_calculator.print_parameters(text)
class EffectivePotentialCavity(Cavity):
"""Cavity built from effective potential and Boltzmann distribution.
See also
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
"""
def __init__(
self,
effective_potential,
temperature,
surface_calculator=None, volume_calculator=None
):
"""Constructor for the EffectivePotentialCavity class.
Additional arguments not present in base Cavity class:
effective_potential -- A Potential instance.
temperature -- Temperature for the Boltzmann distribution
in Kelvin.
"""
Cavity.__init__(self, surface_calculator, volume_calculator)
self.effective_potential = effective_potential
self.temperature = float(temperature)
self.minus_beta = -1. / (kB * temperature / Hartree)
def estimate_memory(self, mem):
Cavity.estimate_memory(self, mem)
self.effective_potential.estimate_memory(
mem.subnode('Effective Potential')
)
def set_grid_descriptor(self, gd):
Cavity.set_grid_descriptor(self, gd)
self.effective_potential.set_grid_descriptor(gd)
def allocate(self):
Cavity.allocate(self)
self.effective_potential.allocate()
def update(self, atoms, density):
if not self.effective_potential.update(atoms, density):
return False
u_g = self.effective_potential.u_g
np.exp(u_g * self.minus_beta, out=self.g_g)
if self.depends_on_el_density:
self.del_g_del_n_g.fill(self.minus_beta)
self.del_g_del_n_g *= self.g_g
self.del_g_del_n_g *= self.effective_potential.del_u_del_n_g
return True
def get_del_r_vg(self, atom_index, density):
u = self.effective_potential
del_u_del_r_vg = u.get_del_r_vg(atom_index, density)
# asserts lim_(||r - r_atom|| -> 0) dg/du * du/dr_atom = 0
del_u_del_r_vg[np.isnan(del_u_del_r_vg)] = .0
return self.minus_beta * self.g_g * del_u_del_r_vg
@property
def depends_on_el_density(self):
return self.effective_potential.depends_on_el_density
@property
def depends_on_atomic_positions(self):
return self.effective_potential.depends_on_atomic_positions
def print_parameters(self, text):
text('effective potential: %s' % (self.effective_potential.__class__))
self.effective_potential.print_parameters(text)
text()
Cavity.print_parameters(self, text)
# --- BEGIN GradientSurface API ---
def get_inner_function(self):
return np.minimum(self.effective_potential.u_g, 1e20)
def get_inner_function_boundary_value(self):
if hasattr(self.effective_potential, 'grad_u_vg'):
raise NotImplementedError
else:
return .0
def get_grad_inner(self):
if hasattr(self.effective_potential, 'grad_u_vg'):
return self.effective_potential.grad_u_vg
else:
raise NotImplementedError
def get_del_outer_del_inner(self):
return self.minus_beta * self.g_g
# --- END GradientSurface API ---
class Potential(NeedsGD):
"""Base class for describing an effective potential.
Attributes:
u_g -- The potential on the fine grid in Hartree.
del_u_del_n_g -- Partial derivative with respect to the electron density.
"""
def __init__(self):
NeedsGD.__init__(self)
self.u_g = None
self.del_u_del_n_g = None
@property
def depends_on_el_density(self):
"""Return whether the cavity depends on the electron density."""
raise NotImplementedError()
@property
def depends_on_atomic_positions(self):
"""returns whether the cavity depends explicitly on atomic positions"""
raise NotImplementedError()
def estimate_memory(self, mem):
ngrids = 1 + self.depends_on_el_density
mem.subnode('Potential', ngrids * self.gd.bytecount())
def allocate(self):
NeedsGD.allocate(self)
self.u_g = self.gd.empty()
if self.depends_on_el_density:
self.del_u_del_n_g = self.gd.empty()
def update(self, atoms, density):
"""Update the potential.
atoms are None, iff they have not changed.
Return whether the potential has changed.
"""
raise NotImplementedError()
def get_del_r_vg(self, atom_index, density):
"""Return spatial derivatives with respect to atomic position."""
raise NotImplementedError()
def print_parameters(self, text):
pass
class Power12Potential(Potential):
"""Inverse power law potential.
An 1 / r ** 12 repulsive potential
taking the value u0 at the atomic radius.
See also
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
"""
depends_on_el_density = False
depends_on_atomic_positions = True
def __init__(self, atomic_radii, u0, pbc_cutoff=1e-6):
"""Constructor for the Power12Potential class.
Arguments:
atomic_radii -- Callable mapping an ase.Atoms object
to an iterable of atomic radii in Angstroms.
u0 -- Strength of the potential at the atomic radius in eV.
pbc_cutoff -- Cutoff in eV for including neighbor cells in
a calculation with periodic boundary conditions.
"""
Potential.__init__(self)
self.atomic_radii = atomic_radii
self.u0 = float(u0)
self.pbc_cutoff = float(pbc_cutoff)
self.r12_a = None
self.r_vg = None
self.pos_aav = None
self.del_u_del_r_vg = None
self.atomic_radii_output = None
self.symbols = None
self.grad_u_vg = None
def estimate_memory(self, mem):
Potential.estimate_memory(self, mem)
nbytes = self.gd.bytecount()
mem.subnode('Coordinates', 3 * nbytes)
mem.subnode('Atomic Position Derivative', 3 * nbytes)
mem.subnode('Gradient', 3 * nbytes)
def allocate(self):
Potential.allocate(self)
self.r_vg = self.gd.get_grid_point_coordinates()
self.del_u_del_r_vg = self.gd.empty(3)
self.grad_u_vg = self.gd.empty(3)
def update(self, atoms, density):
if atoms is None:
return False
self.atomic_radii_output = np.array(self.atomic_radii(atoms))
self.symbols = atoms.get_chemical_symbols()
self.r12_a = (self.atomic_radii_output / Bohr) ** 12
r_cutoff = (self.r12_a.max() * self.u0 / self.pbc_cutoff) ** (1. / 12.)
self.pos_aav = get_pbc_positions(atoms, r_cutoff)
self.u_g.fill(.0)
self.grad_u_vg.fill(.0)
na = np.newaxis
for index, pos_av in self.pos_aav.items():
r12 = self.r12_a[index]
for pos_v in pos_av:
origin_vg = pos_v[:, na, na, na]
r_diff_vg = self.r_vg - origin_vg
r_diff2_g = (r_diff_vg ** 2).sum(0)
r12_g = r_diff2_g ** 6
r14_g = r12_g * r_diff2_g
self.u_g += divide_silently(r12, r12_g)
self.grad_u_vg += divide_silently(r12 * r_diff_vg, r14_g)
self.u_g *= self.u0 / Hartree
# np.exp(-np.inf) = .0
self.u_g[np.isnan(self.u_g)] = np.inf
self.grad_u_vg *= -12. * self.u0 / Hartree
# mask points where the limit of all later
# calculations is zero anyways
self.grad_u_vg[...] = np.nan_to_num(self.grad_u_vg)
# avoid overflow in norm calculation:
self.grad_u_vg[self.grad_u_vg < -1e20] = -1e20
self.grad_u_vg[self.grad_u_vg > 1e20] = 1e20
return True
def get_del_r_vg(self, atom_index, density):
u0 = self.u0 / Hartree
r12 = self.r12_a[atom_index]
na = np.newaxis
self.del_u_del_r_vg.fill(.0)
for pos_v in self.pos_aav[atom_index]:
origin_vg = pos_v[:, na, na, na]
diff_vg = self.r_vg - origin_vg
r14_g = np.sum(diff_vg ** 2, axis=0) ** 7
self.del_u_del_r_vg += divide_silently(diff_vg, r14_g)
self.del_u_del_r_vg *= (12. * u0 * r12)
return self.del_u_del_r_vg
def print_parameters(self, text):
if self.symbols is None:
text('atomic_radii: not initialized (dry run)')
else:
text('atomic_radii:')
for a, (s, r) in enumerate(
zip(self.symbols, self.atomic_radii_output)
):
text('%3d %-2s %10.5f' % (a, s, r))
text('u0: %s' % (self.u0, ))
text('pbc_cutoff: %s' % (self.pbc_cutoff, ))
Potential.print_parameters(self, text)
class SmoothStepCavity(Cavity):
"""Base class for cavities based on a smooth step function and a density.
Attributes:
del_g_del_rho_g -- Partial derivative with respect to the density.
"""
def __init__(
self,
density,
surface_calculator=None, volume_calculator=None
):
"""Constructor for the SmoothStepCavity class.
Additional arguments not present in the base Cavity class:
density -- A Density instance
"""
Cavity.__init__(self, surface_calculator, volume_calculator)
self.del_g_del_rho_g = None
self.density = density
@property
def depends_on_el_density(self):
return self.density.depends_on_el_density
@property
def depends_on_atomic_positions(self):
return self.density.depends_on_atomic_positions
def set_grid_descriptor(self, gd):
Cavity.set_grid_descriptor(self, gd)
self.density.set_grid_descriptor(gd)
def estimate_memory(self, mem):
Cavity.estimate_memory(self, mem)
mem.subnode('Cavity Derivative', self.gd.bytecount())
self.density.estimate_memory(mem.subnode('Density'))
def allocate(self):
Cavity.allocate(self)
self.del_g_del_rho_g = self.gd.empty()
self.density.allocate()
def update(self, atoms, density):
if not self.density.update(atoms, density):
return False
self.update_smooth_step(self.density.rho_g)
if self.depends_on_el_density:
np.multiply(
self.del_g_del_rho_g,
self.density.del_rho_del_n_g,
self.del_g_del_n_g
)
return True
def update_smooth_step(self, rho_g):
"""Calculate self.g_g and self.del_g_del_rho_g."""
raise NotImplementedError()
def get_del_r_vg(self, atom_index, density):
return self.del_g_del_rho_g * self.density.get_del_r_vg(
atom_index, density
)
def print_parameters(self, text):
text('density: %s' % (self.density.__class__))
self.density.print_parameters(text)
text()
Cavity.print_parameters(self, text)
# --- BEGIN GradientSurface API ---
def get_inner_function(self):
return self.density.rho_g
def get_inner_function_boundary_value(self):
return .0
def get_grad_inner(self):
raise NotImplementedError
def get_del_outer_del_inner(self):
return self.del_g_del_rho_g
# --- END GradientSurface API ---
class Density(NeedsGD):
"""Class representing a density for the use with a SmoothStepCavity.
Attributes:
rho_g -- The density on the fine grid in 1 / Bohr ** 3.
del_rho_del_n_g -- Partial derivative with respect to the electron density.
"""
def __init__(self):
NeedsGD.__init__(self)
self.rho_g = None
self.del_rho_del_n_g = None
def estimate_memory(self, mem):
nbytes = self.gd.bytecount()
mem.subnode('Density', nbytes)
if self.depends_on_el_density:
mem.subnode('Density Derivative', nbytes)
def allocate(self):
NeedsGD.allocate(self)
self.rho_g = self.gd.empty()
if self.depends_on_el_density:
self.del_rho_del_n_g = self.gd.empty()
def update(self, atoms, density):
raise NotImplementedError()
@property
def depends_on_el_density(self):
raise NotImplementedError()
@property
def depends_on_atomic_positions(self):
raise NotImplementedError()
def print_parameters(self, text):
pass
class ElDensity(Density):
"""Wrapper class for using the electron density in a SmoothStepCavity.
(Hopefully small) negative values of the electron density are set to zero.
"""
depends_on_el_density = True
depends_on_atomic_positions = False
def allocate(self):
Density.allocate(self)
self.del_rho_del_n_g = 1. # free array
def update(self, atoms, density):
self.rho_g[:] = density.nt_g
self.rho_g[self.rho_g < .0] = .0
return True
class SSS09Density(Density):
"""Fake density from atomic radii for the use in a SmoothStepCavity.
Following V. M. Sanchez, M. Sued and D. A. Scherlis,
J. Chem. Phys. 131, 174108 (2009).
"""
depends_on_el_density = False
depends_on_atomic_positions = True
def __init__(self, atomic_radii, pbc_cutoff=1e-3):
"""Constructor for the SSS09Density class.
Arguments:
atomic_radii -- Callable mapping an ase.Atoms object
to an iterable of atomic radii in Angstroms.
pbc_cutoff -- Cutoff in eV for including neighbor cells in
a calculation with periodic boundary conditions.
"""
Density.__init__(self)
self.atomic_radii = atomic_radii
self.atomic_radii_output = None
self.symbols = None
self.pbc_cutoff = float(pbc_cutoff)
self.pos_aav = None
self.r_vg = None
self.del_rho_del_r_vg = None
def estimate_memory(self, mem):
Density.estimate_memory(self, mem)
nbytes = self.gd.bytecount()
mem.subnode('Coordinates', 3 * nbytes)
mem.subnode('Atomic Position Derivative', 3 * nbytes)
def allocate(self):
Density.allocate(self)
self.r_vg = self.gd.get_grid_point_coordinates()
self.del_rho_del_r_vg = self.gd.empty(3)
def update(self, atoms, density):
if atoms is None:
return False
self.atomic_radii_output = np.array(self.atomic_radii(atoms))
self.symbols = atoms.get_chemical_symbols()
r_a = self.atomic_radii_output / Bohr
r_cutoff = r_a.max() - np.log(self.pbc_cutoff)
self.pos_aav = get_pbc_positions(atoms, r_cutoff)
self.rho_g.fill(.0)
na = np.newaxis
for index, pos_av in self.pos_aav.items():
for pos_v in pos_av:
origin_vg = pos_v[:, na, na, na]
r_diff_vg = self.r_vg - origin_vg
norm_r_diff_g = (r_diff_vg ** 2).sum(0) ** .5
self.rho_g += np.exp(r_a[index] - norm_r_diff_g)
return True
def get_del_r_vg(self, atom_index, density):
r_a = self.atomic_radii_output[atom_index] / Bohr
na = np.newaxis
self.del_rho_del_r_vg.fill(.0)
for pos_v in self.pos_aav[atom_index]:
origin_vg = pos_v[:, na, na, na]
r_diff_vg = self.r_vg - origin_vg
norm_r_diff_g = np.sum(r_diff_vg ** 2, axis=0) ** .5
exponential = np.exp(r_a - norm_r_diff_g)
self.del_rho_del_r_vg += divide_silently(
exponential * r_diff_vg, norm_r_diff_g
)
return self.del_rho_del_r_vg
def print_parameters(self, text):
if self.symbols is None:
text('atomic_radii: not initialized (dry run)')
else:
text('atomic_radii:')
for a, (s, r) in enumerate(
zip(self.symbols, self.atomic_radii_output)
):
text('%3d %-2s %10.5f' % (a, s, r))
text('pbc_cutoff: %s' % (self.pbc_cutoff, ))
Density.print_parameters(self, text)
class ADM12SmoothStepCavity(SmoothStepCavity):
"""Cavity from smooth step function.
Following O. Andreussi, I. Dabo, and N. Marzari,
J. Chem. Phys. 136, 064102 (2012).
"""
def __init__(
self,
rhomin, rhomax, epsinf,
density,
surface_calculator=None, volume_calculator=None
):
"""Constructor for the ADM12SmoothStepCavity class.
Additional arguments not present in the SmoothStepCavity class:
rhomin -- Lower density isovalue in 1 / Angstrom ** 3.
rhomax -- Upper density isovalue in 1 / Angstrom ** 3.
epsinf -- Static dielectric constant of the solvent.
"""
SmoothStepCavity.__init__(
self, density, surface_calculator, volume_calculator
)
self.rhomin = float(rhomin)
self.rhomax = float(rhomax)
self.epsinf = float(epsinf)
def update_smooth_step(self, rho_g):
eps = self.epsinf
inside = rho_g > self.rhomax * Bohr ** 3
outside = rho_g < self.rhomin * Bohr ** 3
transition = np.logical_not(
np.logical_or(inside, outside)
)
self.g_g[inside] = .0
self.g_g[outside] = 1.
self.del_g_del_rho_g.fill(.0)
t, dt = self._get_t_dt(np.log(rho_g[transition]))
if eps == 1.0:
# lim_{eps -> 1} (eps - eps ** t) / (eps - 1) = 1 - t
self.g_g[transition] = t
self.del_g_del_rho_g[transition] = dt / rho_g[transition]
else:
eps_to_t = eps ** t
self.g_g[transition] = (eps_to_t - 1.) / (eps - 1.)
self.del_g_del_rho_g[transition] = (
eps_to_t * np.log(eps) * dt
) / (
rho_g[transition] * (eps - 1.)
)
def _get_t_dt(self, x):
lnmax = np.log(self.rhomax * Bohr ** 3)
lnmin = np.log(self.rhomin * Bohr ** 3)
twopi = 2. * np.pi
arg = twopi * (lnmax - x) / (lnmax - lnmin)
t = (arg - np.sin(arg)) / twopi
dt = -2. * np.sin(arg / 2.) ** 2 / (lnmax - lnmin)
return (t, dt)
def print_parameters(self, text):
text('rhomin: %s' % (self.rhomin, ))
text('rhomax: %s' % (self.rhomax, ))
text('epsinf: %s' % (self.epsinf, ))
SmoothStepCavity.print_parameters(self, text)
class FG02SmoothStepCavity(SmoothStepCavity):
"""Cavity from smooth step function.
Following J. Fattebert and F. Gygi, J. Comput. Chem. 23, 662 (2002).
"""
def __init__(
self,
rho0,
beta,
density,
surface_calculator=None, volume_calculator=None
):
"""Constructor for the FG02SmoothStepCavity class.
Additional arguments not present in the SmoothStepCavity class:
rho0 -- Density isovalue in 1 / Angstrom ** 3.
beta -- Parameter controlling the steepness of the transition.
"""
SmoothStepCavity.__init__(
self, density, surface_calculator, volume_calculator
)
self.rho0 = float(rho0)
self.beta = float(beta)
def update_smooth_step(self, rho_g):
rho0 = self.rho0 / (1. / Bohr ** 3)
rho_scaled_g = rho_g / rho0
exponent = 2. * self.beta
np.divide(1., rho_scaled_g ** exponent + 1., self.g_g)
np.multiply(
(-exponent / rho0) * rho_scaled_g ** (exponent - 1.),
self.g_g ** 2,
self.del_g_del_rho_g
)
def print_parameters(self, text):
text('rho0: %s' % (self.rho0, ))
text('beta: %s' % (self.beta, ))
SmoothStepCavity.print_parameters(self, text)
class SurfaceCalculator(NeedsGD):
"""Base class for surface calculators.
Attributes:
A -- Local area in Bohr ** 2.
delta_A_delta_g_g -- Functional derivative with respect to the cavity
on the fine grid.
"""
def __init__(self):
NeedsGD.__init__(self)
self.A = None
self.delta_A_delta_g_g = None
def estimate_memory(self, mem):
mem.subnode('Functional Derivative', self.gd.bytecount())
def allocate(self):
NeedsGD.allocate(self)
self.delta_A_delta_g_g = self.gd.empty()
def print_parameters(self, text):
pass
def update(self, cavity):
"""Calculate A and delta_A_delta_g_g."""
raise NotImplementedError()
class GradientSurface(SurfaceCalculator):
"""Class for getting the surface area from the gradient of the cavity.
See also W. Im, D. Beglov and B. Roux,
Comput. Phys. Commun. 111, 59 (1998)
and
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
"""
def __init__(self, nn=3):
SurfaceCalculator.__init__(self)
self.nn = nn
self.gradient = None
self.gradient_in = None
self.gradient_out = None
self.norm_grad_out = None
self.div_tmp = None
def estimate_memory(self, mem):
SurfaceCalculator.estimate_memory(self, mem)
nbytes = self.gd.bytecount()
mem.subnode('Gradient', 5 * nbytes)
mem.subnode('Divergence', nbytes)
def allocate(self):
SurfaceCalculator.allocate(self)
self.gradient = [
Gradient(self.gd, i, 1.0, self.nn) for i in (0, 1, 2)
]
self.gradient_in = self.gd.empty()
self.gradient_out = self.gd.empty(3)
self.norm_grad_out = self.gd.empty()
self.div_tmp = self.gd.empty()
def update(self, cavity):
inner = cavity.get_inner_function()
del_outer_del_inner = cavity.get_del_outer_del_inner()
sign = np.sign(del_outer_del_inner.max() + del_outer_del_inner.min())
try:
self.gradient_out[...] = cavity.get_grad_inner()
self.norm_grad_out = (self.gradient_out ** 2).sum(0) ** .5
except NotImplementedError:
self.calc_grad(inner, cavity.get_inner_function_boundary_value())
self.A = sign * self.gd.integrate(
del_outer_del_inner * self.norm_grad_out, global_integral=False
)
mask = self.norm_grad_out > 1e-12 # avoid division by zero or overflow
imask = np.logical_not(mask)
masked_norm_grad = self.norm_grad_out[mask]
for i in (0, 1, 2):
self.gradient_out[i][mask] /= masked_norm_grad
# set limit for later calculations:
self.gradient_out[i][imask] = .0
self.calc_div(self.gradient_out, self.delta_A_delta_g_g)
if sign == 1:
self.delta_A_delta_g_g *= -1.
def calc_grad(self, x, boundary):
if boundary != .0:
np.subtract(x, boundary, self.gradient_in)
gradient_in = self.gradient_in
else:
gradient_in = x
self.norm_grad_out.fill(.0)
for i in (0, 1, 2):
self.gradient[i].apply(gradient_in, self.gradient_out[i])
self.norm_grad_out += self.gradient_out[i] ** 2
self.norm_grad_out **= .5
def calc_div(self, vec, out):
self.gradient[0].apply(vec[0], out)
self.gradient[1].apply(vec[1], self.div_tmp)
out += self.div_tmp
self.gradient[2].apply(vec[2], self.div_tmp)
out += self.div_tmp
class VolumeCalculator(NeedsGD):
"""Base class for volume calculators.
Attributes:
V -- Local volume in Bohr ** 3.
delta_V_delta_g_g -- Functional derivative with respect to the cavity
on the fine grid.
"""
def __init__(self):
NeedsGD.__init__(self)
self.V = None
self.delta_V_delta_g_g = None
def estimate_memory(self, mem):
mem.subnode('Functional Derivative', self.gd.bytecount())
def allocate(self):
NeedsGD.allocate(self)
self.delta_V_delta_g_g = self.gd.empty()
def print_parameters(self, text):
pass
def update(self, cavity):
"""Calculate V and delta_V_delta_g_g"""
raise NotImplementedError()
class KB51Volume(VolumeCalculator):
"""KB51 Volume Calculator.
V = Integral(1 - g) + kappa_T * k_B * T
Following J. G. Kirkwood and F. P. Buff, J. Chem. Phys. 19, 6, 774 (1951).
"""
def __init__(self, compressibility=.0, temperature=.0):
"""Constructor for KB51Volume class.
Arguments:
compressibility -- Isothermal compressibility of the solvent
in Angstrom ** 3 / eV.
temperature -- Temperature in Kelvin.
"""
VolumeCalculator.__init__(self)
self.compressibility = float(compressibility)
self.temperature = float(temperature)
def print_parameters(self, text):
text('compressibility: %s' % (self.compressibility, ))
text('temperature: %s' % (self.temperature, ))
VolumeCalculator.print_parameters(self, text)
def allocate(self):
VolumeCalculator.allocate(self)
self.delta_V_delta_g_g = -1. # frees array
def update(self, cavity):
self.V = self.gd.integrate(1. - cavity.g_g, global_integral=False)
V_compress = self.compressibility * kB * self.temperature / Bohr ** 3
self.V += V_compress / self.gd.comm.size
gpaw-0.11.0.13004/gpaw/solvation/calculator.py 0000664 0001750 0001750 00000011146 12553643471 021137 0 ustar jensj jensj 0000000 0000000 from gpaw import GPAW
from gpaw.solvation.hamiltonian import SolvationRealSpaceHamiltonian
from ase.units import Hartree, Bohr
class NIReciprocalSpaceHamiltonian:
def __init__(self, *args, **kwargs):
raise NotImplementedError(
'SolvationGPAW does not support '
'calculations in reciprocal space yet.'
)
class SolvationGPAW(GPAW):
"""Subclass of gpaw.GPAW calculator with continuum solvent model.
See also Section III of
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
"""
reciprocal_space_hamiltonian_class = NIReciprocalSpaceHamiltonian
def __init__(self, cavity, dielectric, interactions=None,
**gpaw_kwargs):
"""Constructor for SolvationGPAW class.
Additional arguments not present in GPAW class:
cavity -- A Cavity instance.
dielectric -- A Dielectric instance.
interactions -- A list of Interaction instances.
"""
if interactions is None:
interactions = []
def real_space_hamiltonian_factory(*args, **kwargs):
return SolvationRealSpaceHamiltonian(
cavity, dielectric, interactions,
*args, **kwargs
)
self.real_space_hamiltonian_class = real_space_hamiltonian_factory
GPAW.__init__(self, **gpaw_kwargs)
def initialize_positions(self, atoms=None):
spos_ac = GPAW.initialize_positions(self, atoms)
self.hamiltonian.update_atoms(self.atoms)
return spos_ac
def get_electrostatic_energy(self, atoms=None, force_consistent=False):
"""Return electrostatic part of the total energy.
The electrostatic part consists of everything except
the short-range interactions defined in the interactions list.
See the get_potential_energy method for the meaning
of the force_consistent option.
"""
self.calculate(atoms, converge=True)
if force_consistent:
# Free energy:
return Hartree * self.hamiltonian.Eel
else:
# Energy extrapolated to zero width:
return Hartree * self._extrapolate_energy_to_zero_width(
self.hamiltonian.Eel
)
def get_solvation_interaction_energy(self, subscript, atoms=None):
"""Return a specific part of the solvation interaction energy.
The subscript parameter defines which part is to be returned.
It has to match the value of a subscript attribute of one of
the interactions in the interactions list.
"""
self.calculate(atoms, converge=True)
return Hartree * getattr(self.hamiltonian, 'E_' + subscript)
def get_cavity_volume(self, atoms=None):
"""Return the cavity volume in Angstrom ** 3.
In case no volume calculator has been set for the cavity, None
is returned.
"""
self.calculate(atoms, converge=True)
V = self.hamiltonian.cavity.V
return V and V * Bohr ** 3
def get_cavity_surface(self, atoms=None):
"""Return the cavity surface area in Angstrom ** 2.
In case no surface calculator has been set for the cavity,
None is returned.
"""
self.calculate(atoms, converge=True)
A = self.hamiltonian.cavity.A
return A and A * Bohr ** 2
def print_parameters(self):
GPAW.print_parameters(self)
t = self.text
t()
def ul(s, l):
t(s)
t(l * len(s))
ul('Solvation Parameters:', '=')
ul('Cavity:', '-')
t('type: %s' % (self.hamiltonian.cavity.__class__, ))
self.hamiltonian.cavity.print_parameters(t)
t()
ul('Dielectric:', '-')
t('type: %s' % (self.hamiltonian.dielectric.__class__, ))
self.hamiltonian.dielectric.print_parameters(t)
t()
for ia in self.hamiltonian.interactions:
ul('Interaction:', '-')
t('type: %s' % (ia.__class__, ))
t('subscript: %s' % (ia.subscript, ))
ia.print_parameters(t)
t()
def print_all_information(self):
t = self.text
t()
t('Solvation Energy Contributions:')
for ia in self.hamiltonian.interactions:
E = Hartree * getattr(self.hamiltonian, 'E_' + ia.subscript)
t('%-14s: %+11.6f' % (ia.subscript, E))
Eel = Hartree * getattr(self.hamiltonian, 'Eel')
t('%-14s: %+11.6f' % ('el', Eel))
GPAW.print_all_information(self)
def write(self, *args, **kwargs):
raise NotImplementedError(
'IO is not implemented yet for SolvationGPAW!'
)
gpaw-0.11.0.13004/gpaw/solvation/interactions.py 0000664 0001750 0001750 00000012426 12553643471 021512 0 ustar jensj jensj 0000000 0000000 from gpaw.solvation.gridmem import NeedsGD
from ase.units import Bohr, Hartree
import numpy as np
class Interaction(NeedsGD):
"""Base class for non-electrostatic solvent solute interactions.
See also Section III of
A. Held and M. Walter, J. Chem. Phys. 141, 174108 (2014).
Attributes:
subscript -- Short label used to reference the interaction.
E -- Local interaction energy in Hartree
delta_E_delta_n_g -- Functional derivative of the interaction energy
with respect to the electron density.
delta_E_delta_n_g -- Functional derivative of the interaction energy
with respect to the cavity.
"""
subscript = 'unnamed'
def __init__(self):
NeedsGD.__init__(self)
self.E = None
self.delta_E_delta_n_g = None
self.delta_E_delta_g_g = None
def update(self, atoms, density, cavity):
"""Update the Kohn-Sham potential and the energy.
atoms and/or cavity are None iff they have not changed
since the last call
Return whether the interaction has changed.
"""
raise NotImplementedError
def estimate_memory(self, mem):
ngrids = 1 + self.depends_on_el_density
mem.subnode('Functional Derivatives', ngrids * self.gd.bytecount())
def allocate(self):
NeedsGD.allocate(self)
self.delta_E_delta_g_g = self.gd.empty()
if self.depends_on_el_density:
self.delta_E_delta_n_g = self.gd.empty()
@property
def depends_on_atomic_positions(self):
"""Return whether the ia depends explicitly on atomic positions."""
raise NotImplementedError
@property
def depends_on_el_density(self):
"""Return whether the ia depends explicitly on the electron density."""
raise NotImplementedError
def get_del_r_vg(self, atomic_index, density):
"""Return spatial derivatives with respect to atomic position."""
raise NotImplementedError
def print_parameters(self, text):
"""Print parameters using text function."""
pass
class SurfaceInteraction(Interaction):
"""An interaction with energy proportional to the cavity surface area."""
subscript = 'surf'
depends_on_el_density = False
depends_on_atomic_positions = False
def __init__(self, surface_tension):
"""Constructor for SurfaceInteraction class.
Arguments:
surface_tension -- Proportionality factor to calculate
energy from surface area in eV / Angstrom ** 2.
"""
Interaction.__init__(self)
self.surface_tension = float(surface_tension)
def update(self, atoms, density, cavity):
if cavity is None:
return False
acalc = cavity.surface_calculator
st = self.surface_tension * Bohr ** 2 / Hartree
self.E = st * acalc.A
np.multiply(st, acalc.delta_A_delta_g_g, self.delta_E_delta_g_g)
return True
def print_parameters(self, text):
Interaction.print_parameters(self, text)
text('surface_tension: %s' % (self.surface_tension, ))
class VolumeInteraction(Interaction):
"""An interaction with energy proportional to the cavity volume"""
subscript = 'vol'
depends_on_el_density = False
depends_on_atomic_positions = False
def __init__(self, pressure):
"""Constructor for VolumeInteraction class.
Arguments:
pressure -- Proportionality factor to calculate
energy from volume in eV / Angstrom ** 3.
"""
Interaction.__init__(self)
self.pressure = float(pressure)
def update(self, atoms, density, cavity):
if cavity is None:
return False
vcalc = cavity.volume_calculator
pressure = self.pressure * Bohr ** 3 / Hartree
self.E = pressure * vcalc.V
np.multiply(pressure, vcalc.delta_V_delta_g_g, self.delta_E_delta_g_g)
return True
def print_parameters(self, text):
Interaction.print_parameters(self, text)
text('pressure: %s' % (self.pressure, ))
class LeakedDensityInteraction(Interaction):
"""Interaction proportional to charge leaking outside cavity.
The charge outside the cavity is calculated as
"""
subscript = 'leak'
depends_on_el_density = True
depends_on_atomic_positions = False
def __init__(self, voltage):
"""Constructor for LeakedDensityInteraction class.
Arguments:
voltage -- Proportionality factor to calculate
energy from integrated electron density in Volts.
A positive value of the voltage leads to a
positive interaction energy.
"""
Interaction.__init__(self)
self.voltage = float(voltage)
def update(self, atoms, density, cavity):
E0 = self.voltage / Hartree
if cavity is not None:
np.multiply(E0, cavity.g_g, self.delta_E_delta_n_g)
np.multiply(E0, density.nt_g, self.delta_E_delta_g_g)
self.E = self.gd.integrate(
density.nt_g * self.delta_E_delta_n_g,
global_integral=False
)
return True
def print_parameters(self, text):
Interaction.print_parameters(self, text)
text('voltage: %s' % (self.voltage, ))
gpaw-0.11.0.13004/gpaw/solvation/__init__.py 0000664 0001750 0001750 00000001067 12553643471 020546 0 ustar jensj jensj 0000000 0000000 """The gpaw.solvation package.
This packages extends GPAW to be used with different
continuum solvent models.
"""
from gpaw.solvation.calculator import SolvationGPAW
from gpaw.solvation.cavity import (
EffectivePotentialCavity,
Power12Potential,
ElDensity,
SSS09Density,
ADM12SmoothStepCavity,
FG02SmoothStepCavity,
GradientSurface,
KB51Volume)
from gpaw.solvation.dielectric import LinearDielectric, CMDielectric
from gpaw.solvation.interactions import (
SurfaceInteraction,
VolumeInteraction,
LeakedDensityInteraction)
gpaw-0.11.0.13004/gpaw/solvation/gridmem.py 0000664 0001750 0001750 00000000452 12553643471 020430 0 ustar jensj jensj 0000000 0000000 class NeedsGD:
"""Common base class for classes using a grid descriptor."""
def __init__(self):
self.gd = None
def set_grid_descriptor(self, gd):
self.gd = gd
def allocate(self):
pass
def estimate_memory(self, mem):
raise NotImplementedError
gpaw-0.11.0.13004/gpaw/spline.py 0000664 0001750 0001750 00000004713 12553643470 016263 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
import numpy as np
from gpaw import debug
from gpaw.utilities import is_contiguous
import _gpaw
class Spline:
def __init__(self, l, rmax, f_g):
"""Spline(l, rcut, list) -> 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).
"""
assert 0.0 < rmax
f_g = np.array(f_g, float)
# Copy so we don't change the values of the input array
f_g[-1] = 0.0
self.spline = _gpaw.Spline(l, rmax, f_g)
def get_cutoff(self):
"""Return the radial cutoff."""
return self.spline.get_cutoff()
def get_angular_momentum_number(self):
"""Return the angular momentum quantum number."""
return self.spline.get_angular_momentum_number()
def get_value_and_derivative(self, r):
"""Return the value and derivative."""
return self.spline.get_value_and_derivative(r)
def __call__(self, r):
assert r >= 0.0
return self.spline(r)
def map(self, r_x):
return np.vectorize(self, [float])(r_x)
def get_functions(self, gd, start_c, end_c, spos_c):
h_cv = gd.h_cv
# start_c is the new origin so we translate gd.beg_c to start_c
origin_c = np.array([0,0,0])
pos_v = np.dot(spos_c, gd.cell_cv) - np.dot(start_c, h_cv)
A_gm, G_b = _gpaw.spline_to_grid(self.spline, origin_c, end_c-start_c,
pos_v, h_cv, end_c-start_c, origin_c)
if debug:
assert G_b.ndim == 1 and G_b.shape[0] % 2 == 0
assert is_contiguous(G_b, np.intc)
assert A_gm.shape[:-1] == np.sum(G_b[1::2]-G_b[::2])
indices_gm, ng, nm = self.spline.get_indices_from_zranges(start_c,
end_c, G_b)
shape = (nm,) + tuple(end_c-start_c)
work_mB = np.zeros(shape, dtype=A_gm.dtype)
np.put(work_mB, indices_gm, A_gm)
return work_mB
## class rspline:
## def __init__(self, r_g, f_g, l=0):
## self.rcut = r_g[-1]
## self.l = l
## ...
## def __call__(self, r):
## return self.spline(r)*r**l
gpaw-0.11.0.13004/gpaw/version.py 0000664 0001750 0001750 00000000476 12553643470 016460 0 ustar jensj jensj 0000000 0000000 # Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
version_base = '0.11.0'
ase_required_version = '3.9.1'
try:
from gpaw.svnversion import svnversion
except (AttributeError, ImportError):
version = version_base
else:
version = version_base + '.' + svnversion
gpaw-0.11.0.13004/gpaw/hgh_parameters.py 0000664 0001750 0001750 00000077777 12553643470 020006 0 ustar jensj jensj 0000000 0000000 parameters = """\
H 1 .200000 -4.180237 .725075
He 2 .200000 -9.112023 1.698368
Li 1 .787553 -1.892612 .286060
.666375 1.858811
1.079306 -.005895
.000019
Li.sc 3 .400000 -14.034868 9.553476 -1.766488 .084370
Be 2 .739009 -2.592951 .354839
.528797 3.061666
.658153 .092462
.000129
Be.sc 4 .325000 -24.015041 17.204014 -3.326390 .165419
B 3 .433930 -5.578642 .804251
.373843 6.233928
.360393 .000000
.000878
C 4 .348830 -8.513771 1.228432
.304553 9.522842
.232677 .000000
.004104
N 5 .289179 -12.234820 1.766407
.256605 13.552243
.270134 .000000
.003131
O 6 .247621 -16.580318 2.395701
.221786 18.266917
.256829 .000000
.004476
F 7 .218525 -21.307361 3.072869
.195567 23.584942
.174268 .000000
.015106
Ne 8 .190000 -27.692852 4.005906
.179488 28.506098 -1.076245
.214913 -.000090
.010336
Na 1 .885509 -1.238867
.661104 1.847271 .582004
.857119 .471133
.002623
Na.sc 9 .246318 -7.545593 1.125997
.141251 36.556987
.139668 -10.392083
.038386
Mg 2 .651812 -2.864297
.556478 2.970957 1.329941
.677569 1.049881
.005152
Mg.sc 10 .210950 -19.419008 2.871331
.141547 40.316626
.105469 -10.891113
.096277
Al 3 .450000 -8.491351
.460104 5.088340 2.679700
.536744 2.193438 .000000
.006154 .003947
Si 4 .440000 -7.336103
.422738 5.906928 3.258196
.484278 2.727013 .000000
.000373 .014437
P 5 .430000 -6.654220
.389803 6.842136 3.856693
.440796 3.282606 .000000
.002544 .017895
S 6 .420000 -6.554492
.361757 7.905303 4.471698
.405285 3.866579 .000000
.005372 .022062
Cl 7 .410000 -6.864754
.338208 9.062240 5.065682
.376137 4.465876 .000000
.010020 .025784
Ar 8 .400000 -7.100000
.317381 10.249487 5.602516
.351619 4.978801 .000000
.016395 .029171
K 1 .950000
.955364 .914612 .287551 -.300224
1.086411 .315462 .068194
-.004343 .010261
.720606 -1.529514
.000354
K.sc 9 .400000 -4.989348 -.756048
.294826 11.238705 7.067779
.322359 5.256702 .938947
.015795 .048923
Ca 2 .800000
.669737 1.645014 1.523491 .295996
.946474 .585479 .126329
-.003362 .012779
.526550 -3.032321
.000814
Ca.sc 10 .390000 -4.928146 -1.232854
.281909 12.352340 7.657455
.310345 5.722423 .923591
.021701 .056661
.904330 .016806
.000371
Sc 3 .750000
.597079 1.835768 1.734309 1.418483
.847994 .784127 .246733
-.008463 .020913
.454653 -3.859241
.001430
Sc.sc 11 .385000 7.425036 -.489852
.359707 6.119585 -2.563453
.243234 6.376618 -6.016415
.083053 .093017
.252945 -8.020892
.004812
Ti 4 .720000
.528411 1.866613 1.440233 3.658172
.791146 .967916 .260687
-.009333 .025291
.408712 -4.826456
.002010
Ti.sc 12 .380000 7.548789 -.588377
.334235 6.925740 -3.142005
.242416 5.079086 -6.284281
.122395 .057447
.242947 -9.125896
.005822
V 5 .690000
.514704 2.208670 1.896763 3.076377
.743504 1.115751 .286649
-.010973 .030816
.374890 -5.841633
.002717
V.sc 13 .375000 4.941291 -.096443
.326651 7.659390 -3.892229
.246407 4.256230 -5.941212
.156408 .008030
.240792 -8.828518
.006548
Cr 6 .660000
.498578 2.400756 2.072337 2.952179
.719768 1.145557 .278236
-.013176 .035625
.354341 -6.615878
.003514
Cr.sc 14 .370000 5.113362 -.646819
.306011 8.617835 -4.137695
.241090 3.161588 -5.032906
.169781 .000411
.219577 -11.157868
.009007
Mn 7 .640000
.481246 2.799031 2.486101 2.565630
.669304 1.368776 .316763
-.013685 .042938
.327763 -7.995418
.004536
Mn.sc 15 .365000 6.748683 -.576569
.280753 9.379532 -5.575280
.254536 .371176 -4.229057
.164188 -.039396
.221422 -12.115385
.009590
Fe 8 .610000
.454482 3.016640 2.583038 3.257635
.638903 1.499642 .326874
-.014909 .049793
.308732 -9.145354
.005722
Fe.sc 16 .360000 5.392507 -.030066
.269268 10.193723 -6.834982
.247686 .145613 -5.234954
.201450 -.075829
.223021 -12.026941
.010322
Co 9 .580000
.440457 3.334978 2.873150 3.091028
.610048 1.634005 .356083
-.017521 .058766
.291661 -10.358800
.007137
Co.sc 17 .355000 3.418391 .482078
.259140 11.195226 -7.845825
.251425 -.551464 -4.639237
.207915 -.108249
.221665 -12.075354
.011475
Ni 10 .560000
.425399 3.619651 3.088965 3.058598
.584081 1.742220 .386341
-.020384 .068770
.278113 -11.608428
.008708
Ni.sc 18 .350000 3.610311 .449638
.245105 12.161131 -9.078929
.234741 -.820624 -6.029071
.269572 -.143442
.214950 -13.395062
.013538
Cu 1 .580000
.843283 .975787 -.822070 -.133237
1.089543 .024580 -.249001
.010792 -.006734
1.291602 -.065292
-.000730
Cu.sc 11 .530000
.423734 3.888050 3.276584 2.290091
.572177 1.751272 .374943
-.024067 .076481
.266143 -12.676957
.010489
Zn 2 .570000
.640712 2.088557 -.218270 -.941317
.967605 .163546 -.227086
.012139 -.004876
1.330352 .010486
.000225
Zn.sc 12 .510000
.400866 4.278710 3.627342 2.849567
.539618 2.023884 .431742
-.025759 .090915
.252151 -14.338368
.012767
Ga 3 .560000
.610791 2.369325 -.249015 -.551796
.704596 .746305 -.513132
.029607 -.000873
.982580 .075437
.001486
Ga.sc 13 .490000
.384713 4.831779 4.238168 2.833238
.586130 1.940527 -.299738
.026949 .031400
.240803 -15.795675
.015503
Ge 4 .540000
.493743 3.826891 1.100231 -1.344218
.601064 1.362518 -.627370
.043981 .009802
.788369 .191205
.002918
As 5 .520000
.456400 4.560761 1.692389 -1.373804
.550562 1.812247 -.646727
.052466 .020562
.685283 .312373
.004273
Se 6 .510000
.432531 5.145131 2.052009 -1.369203
.472473 2.858806 -.590671
.062196 .064907
.613420 .434829
.005784
Br 7 .500000
.428207 5.398837 1.820292 -1.323974
.455323 3.108823 -.632202
.074007 .068787
.557847 .555903
.007144
Kr 8 .500000
.410759 5.911194 1.967372 -1.458069
.430256 3.524357 -.691198
.087011 .086008
.517120 .629228
.009267
Rb 1 1.096207 .847333 -.748120
.955699 .887460 .903088 -.006750
1.156681 .461734 .336113
-.043443 .057876
.664323 -1.362938
.003708
Rb.sc 9 .490000 4.504151 -.741018
.282301 9.536329 9.486634
.301886 2.209592 5.475249
-.867379 1.237532
.514895 .449376
.008685
Sr 2 1.010000 .684749 -.062125
.837564 1.200395 .926675 -.315858
1.174178 .439983 .018267
.004022 .022207
.743175 -1.386990
.002846
Sr.sc 10 .480000 5.571455 -1.079963
.275441 9.995135 9.336679
.302243 3.169126 4.049231
-.576265 .990062
.502045 .438728
.008991
Y 3 .900000 -.343891
.782457 1.520655 1.484368 -.189013
.949864 .780950 .368739
-.043336 .079989
.653851 -1.256930 -.075368
.009198 -.011657
Y.sc 11 .475000 13.217914 1.353178
.414360 2.522621 -4.363769
.406442 -.569552 -3.020044
.251526 -.077005
.513304 -1.571003 .627616
.012450 -.007507
Zr 4 .750000 -.782611
.649998 1.739877 2.388208 1.205349
.874408 1.018294 .528223
-.057486 .104495
.630668 -1.173911 .212179
.009380 -.011973
Zr.sc 12 .470000 15.782342 .433648
.396540 2.571767 -4.714509
.388558 -.794123 -3.172114
.301247 -.098654
.520496 -1.548402 .826127
.013187 -.010136
Nb 5 .724000 4.021058
.699708 1.532651 1.428264
.846672 .609675 .596788
-.080816 .125243
.516072 -2.696830 -1.694967
.025653 -.031541
Nb.sc 13 .460000 13.505394 .752434
.393708 3.222025 -4.599342
.403626 -.822037 -2.247366
.246821 -.086659
.513644 -1.489848 .823817
.014064 -.012055
Mo 6 .699000 7.995868
.678126 1.289607 .998113
.800771 .301412 .741615
-.104124 .153906
.453384 -2.809708 -6.820946
.068972 -.075591
Mo.sc 14 .430000 16.237452 1.496536
.376255 3.362426 -5.289276
.361734 -.379571 -4.067713
.378681 -.124561
.525828 -1.543211 1.074388
.014460 -.014769
Tc 7 .673000 13.315381
.677612 .819218 .348460
.784275 .028673 .658363
-.080760 .140668
.519890 -5.984224 .721822
.026025 -.041776
Tc.sc 15 .430000 14.910011 1.046381
.369721 3.917408 -5.268399
.357772 -.270000 -3.737771
.340791 -.065948
.510487 -1.586709 1.132307
.015790 -.016485
Ru 8 .647214 8.687723
.625656 1.637866 1.329335
.746425 .639012 .650376
-.095454 .164257
.440358 -4.883365 -3.063746
.046652 -.061808
Ru.sc 16 .430000 13.582571 .596227
.364084 4.480632 -5.268679
.364053 -.320372 -3.059714
.337322 -.103467
.495850 -1.597870 1.165495
.017773 -.019725
Rh 9 .621429 5.397962
.598079 2.242111 2.151597
.709586 1.155278 .704846
-.114357 .193923
.369207 -1.053058 -10.923960
.135036 -.127750
Rh.sc 17 .420000 15.225012 .415911
.350052 4.715292 -5.805525
.350253 -.504694 -3.373040
.389629 -.122856
.496950 -1.685594 1.387707
.018875 -.022837
Pd 10 .596000 5.209665
.582204 2.411076 2.318920
.688787 1.227253 .758021
-.136909 .220805
.442835 -4.377131 .413271
.033797 -.047798
Pd.sc 18 .410000 15.720259 .140765
.342151 5.177686 -5.852819
.343111 -.372561 -3.258728
.406984 -.110764
.494916 -1.608273 1.446609
.020374 -.026732
Ag 1 .650000 -2.376061
1.012705 .897931 -.748323 .029787
1.235842 .130081 -.277495
.019692 -.006821
1.016159 -.038842
.009455
Ag.sc 11 .570000 1.017053
.498900 2.990284 3.912395 2.205847
.630009 1.813968 1.304450
-.201869 .319708
.387660 -3.420076 -1.019949
.045193 -.051565
Cd 2 .625000 -1.796838
.828465 1.485292 -.424753 -.407986
.972873 .469208 -.448111
.037714 -.002009
1.240949 .065412
.003109
Cd.sc 12 .550000 2.382713
.491505 3.207932 4.140963 1.584234
.598565 1.940150 1.515892
-.241409 .376830
.377874 -4.190072 -.770156
.049329 -.058835
In 3 .610000 2.865777
.770602 1.256194 -.397255 -.278329
.858132 .494459 -.380789
.066367 -.005563
1.088691 .129208
.004448
In.sc 13 .530000 2.395404
.474081 3.554411 4.754135 1.565040
.559819 2.223664 2.035278
-.306488 .479435
.360488 -4.566414 -.773785
.058765 -.073414
Sn 4 .605000 4.610912
.663544 1.648791 -.141974 -.576546
.745865 .769355 -.445070
.103931 .005057
.944459 .225115
.007066
Sb 5 .590000 6.680228
.597684 1.951477 .037537 -.786631
.672122 .970313 -.466731
.139222 .023513
.856557 .300103
.009432
Te 6 .575000 9.387085
.556456 2.046890 -.029333 -.881119
.615262 1.033478 -.481172
.172997 .050641
.805101 .317411
.010809
I 7 .560000 14.661825
.552830 1.338054 -.834851 -.467438
.562251 .674496 -.577787
.213967 .093313
.794325 .224345
.010180
Xe 8 .560000 12.734280
.507371 2.236451 -.403551 -1.132507
.541024 1.130043 -.752764
.236603 .108473
.729821 .280131
.013362
Cs 1 1.200000
1.224737 .611527 .239830 -.294024
1.280478 .244893 .227279
-.107627 .138132
1.107522 -.542163
.003259
Cs.sc 9 .540000 35.234438 -3.318070
.456821 -.282378 -2.780956
.362467 -2.696733 -2.290940 .000000
-2.748528 1.815069 1.204825
.761462 .183754
.010841
.333507 -17.948259
.004760
Ba 2 1.200000
1.016187 .922593 .763495 -.333465
1.249880 .447168 .151081
-.041017 .088800
.937158 -.718934
.005321
Ba.sc 10 .540000 24.478653 -2.500850
.514776 1.046729 -.977217
.375190 -.202439 .680331 .000000
-.415083 .599763 .927065
.665403 .378419
.017660
.304920 -18.795208
.006151
La.sc 11 .535000 19.909308 -1.474830
.551775 1.293272 -1.121819
.476308 1.172527 -.828810 .029857
.524623 -.030901 .142077
.626672 .328377
.020900
.299310 -18.269439
.007193
Ce.sc 12 .535000 18.847470 -.765636
.521790 1.321616 -1.700444
.470324 .972641 -1.451337 .000000
.463710 .090257 .012566
.703593 .074241
.013265
.306717 -17.214790
.007568
Pr.sc 13 .532083 18.424739 -.657669
.526850 1.012621 -1.717982
.458897 1.117060 -1.852109 .000000
.314280 .350982 -.165254
.747610 .017571
.010905
.300773 -17.897119
.008547
Nd.sc 14 .529167 17.815030 -.594798
.503000 1.529110 -2.153732
.467013 .721553 -1.647499 .000000
-.214396 1.100446 -.832670
.325290 -.543240
.611413
.294743 -18.520228
.009598
Pm.sc 15 .526250 18.251723 -.492107
.489879 1.308978 -2.507751
.472260 .160512 -1.565305 .000000
-.339955 1.359017 -1.145883
.473709 -.429952
.064044
.291527 -19.305057
.010619
Sm.sc 16 .523333 17.206792 -.532803
.479677 1.723635 -2.659367
.490598 -.082403 -1.111009 .000000
-.240300 1.200867 -1.054041
.470840 -.410630
.063352
.284040 -19.984292
.011924
Eu.sc 17 .520417 17.373516 -.648468
.469043 1.763638 -2.916932
.445907 .518046 -2.135186 .000000
.252258 .584324 -.480586
.490038 -.426120
.051028
.278401 -20.946528
.013267
Gd.sc 18 .517500 17.512556 -.719534
.462014 1.551856 -3.068703
.456953 -.058347 -1.697711 .000000
.535540 .022024 -.054301
.482368 -.562601
.053128
.273390 -21.923490
.014666
Tb.sc 19 .514583 17.603616 -.828080
.448694 1.718481 -3.435239
.424220 .562400 -2.781827 .000000
-.008725 1.144007 -.860425
.482809 -.625802
.051754
.268260 -22.911697
.016197
Dy.sc 20 .511667 16.994331 -.955298
.440590 1.940320 -3.559798
.434642 .014315 -2.046238 .000000
-.124371 1.327404 -1.092142
.467229 -.668924
.058286
.261670 -23.922358
.017938
Ho.sc 21 .508750 16.781570 -1.173514
.432212 2.052797 -3.674534
.420138 .253295 -2.355289 .000000
.895947 -.275149 .205729
.447131 -.742863
.069483
.254992 -25.197211
.019830
Er.sc 22 .505833 17.105293 -1.430953
.419948 2.144503 -3.984203
.414455 .054087 -2.294477 .000000
1.255135 -.891960 .749717
.418385 -.999006
.091862
.249126 -26.696809
.021783
Tm.sc 23 .502917 17.247293 -1.627697
.413373 1.947196 -4.121556
.409923 -.094493 -2.224087 .000000
2.045370 -2.347237 1.902736
.392870 -1.353308
.119299
.243917 -28.104159
.023833
Yb.sc 24 .500000 17.357144 -1.773916
.402309 2.120771 -4.802990
.414358 -.923212 -1.678540 .000000
-.349470 2.074295 -1.814297
.444025 -.889967
.070076
.238298 -29.932854
.025718
Lu.sc 25 .497000 17.037053 -1.661610
.391206 2.184678 -5.432346
.393896 -.719819 -2.723799 .000000
.152450 1.395416 -1.238744
.436518 -1.173245
.072130
.232629 -31.852262
.028006
Hf.sc 12 .560000 5.134801 .529191
.422810 2.564442 -6.013732 1.109760
.472681 -1.025275 -1.872548 .000000
.607504 -.331637 -.121021
.426388 1.459363 -5.282764
.222119 -.121283
Ta 5 .744000 3.623116
.581801 2.005338 3.027036
.770646 .518567 1.185378
-.485635 .695148
.534370 -2.202200 -1.666675
.086716 -.094635
Ta.sc 13 .550000 4.546236 .779422
.421853 2.708136 -5.790959 .947663
.461345 -.724853 -2.215211 .000000
.649992 -.336371 -.101322
.410994 1.348495 -5.386947
.205344 -.102353
W 6 .719000 4.058450
.582463 2.161166 2.741500
.742307 .600973 1.299943
-.509800 .751739
.534959 -2.517063 -.789137
.075772 -.086193
W.sc 14 .540000 4.800251 .901544
.418570 2.692204 -6.022637 1.218316
.449555 -.702084 -2.451680 .000000
.715480 -.385339 -.077093
.399602 1.177436 -5.553621
.205860 -.100046
Re 7 .693000 8.180816
.509816 2.269379 3.528529
.745839 .496693 .925829
-.370589 .616765
.500954 -3.689630 -1.894601
.111557 -.131595
Re.sc 15 .530000 5.592660 .943957
.403252 2.760720 -6.396415 .868732
.440951 -.900546 -2.511211 .000000
.788715 -.489984 -.017012
.390395 .875251 -5.672543
.209737 -.102862
Os 8 .667000 9.440459
.510307 2.402367 3.046706
.717553 .499523 1.053284
-.430746 .701752
.487586 -4.142035 -1.666100
.116941 -.139761
Os.sc 16 .520000 5.613073 .921955
.410578 2.785758 -6.692130 2.247034
.422395 -.590006 -3.018323 .000000
.870817 -.412886 -.139506
.380252 .880133 -5.732892
.216440 -.103221
Ir 9 .641000 10.720016
.509960 2.445999 2.811037
.684971 .461792 1.304726
-.565347 .859620
.471745 -4.545484 -1.635428
.127199 -.151950
Ir.sc 17 .510000 4.904509 1.313786
.404469 3.243278 -7.315509 2.956978
.411426 -.380574 -3.504403 .000000
.930121 -.379865 -.262716
.376428 .754315 -5.875580
.219517 -.112145
Pt 10 .616000 11.027417
.520132 2.447430 2.640360
.658976 .408453 1.647716
-.763296 1.065883
.451243 -4.552295 -2.102396
.146912 -.169306
Pt.sc 18 .500000 5.445832 1.156382
.409942 2.994366 -7.448772 4.243095
.398652 -.225181 -3.776974 .000000
1.017060 -.348213 -.331919
.367964 .632067 -5.755431
.226472 -.114346
Au 1 .650000 -1.963712 -1.698123
.919308 1.539599 -.468779 -.792039
1.140351 .471229 -.497538 -.209758
.039349 .132970 -.153427
Au.sc 11 .590000 11.604428
.521180 2.538614 2.701113
.630613 .394853 2.057831
-.960055 1.296571
.440706 -4.719070 -1.650429
.148484 -.169493
Hg 2 .640000 -3.296329
.812108 1.765041 -.466127 -.799941
1.053714 .474056 -.531816
.092330 -.001118
1.100000 .120638
.020931
Hg.sc 12 .570000 2.134572
.521802 3.293920 4.661001
.621648 2.100960 1.689988 .000000
.084989 .072771 .653348
.401894 -1.669886 -2.473265
.155759 -.122282
Tl 3 .630000 -1.235846
.754005 1.875766 -.303680 -.781337
.903742 .759668 -.586721
.168641 .004459
1.063512 .247614
.022941
Tl.sc 13 .550000 7.301886
.502423 3.326560 4.341390
.572016 1.272807 2.992206 .000000
.012233 .031664 1.019164
.393185 -3.200652 -3.008296
.186849 -.170651
Pb 4 .617500 .753143
.705259 1.979927 -.164960 -.806060
.846641 .864420 -.540969
.207711 .012948
.971939 .374967
.029256
Bi 5 .605000 6.679437
.678858 1.377634 -.513697 -.471028
.798673 .655578 -.402932
.305314 -.023134
.934683 .378476
.029217
Po 6 .592500 10.411731
.647950 1.144203 -.735851 -.339386
.748947 .594562 -.353595
.396354 -.031462
.880468 .433232
.033886
At 7 .580000 13.520411
.627827 .945557 -.965903 -.190429
.709823 .527078 -.318821
.480774 -.034954
.838365 .468948
.037544
Rn 8 .570000 14.629185
.615182 .981832 -1.038963 -.120456
.676697 .612279 -.344122
.549896 -.023760
.788337 .557746
.045488
"""
gpaw-0.11.0.13004/gpaw/lcao/ 0000775 0001750 0001750 00000000000 12553644063 015327 5 ustar jensj jensj 0000000 0000000 gpaw-0.11.0.13004/gpaw/lcao/tools.py 0000664 0001750 0001750 00000053755 12553643472 017063 0 ustar jensj jensj 0000000 0000000 from time import localtime
import pickle
import numpy as np
from gpaw.utilities import pack
from gpaw.utilities.tools import tri2full
from gpaw.utilities.blas import rk, gemm
from gpaw.basis_data import Basis
from gpaw.setup import types2atomtypes
from gpaw.coulomb import CoulombNEW as Coulomb
from gpaw.mpi import world, rank, MASTER, serial_comm
from gpaw import GPAW
from ase.units import Hartree
from ase.calculators.singlepoint import SinglePointCalculator
def get_bf_centers(atoms, basis=None):
calc = atoms.get_calculator()
if calc is None or isinstance(calc, SinglePointCalculator):
symbols = atoms.get_chemical_symbols()
basis_a = types2atomtypes(symbols, basis, 'dzp')
nao_a = [Basis(symbol, type).nao
for symbol, type in zip(symbols, basis_a)]
else:
if not calc.initialized:
calc.initialize(atoms)
nao_a = [calc.wfs.setups[a].nao for a in range(len(atoms))]
pos_ic = []
for pos, nao in zip(atoms.get_positions(), nao_a):
pos_ic.extend(pos[None].repeat(nao, 0))
return np.array(pos_ic)
def get_bfi(calc, a_list):
"""basis function indices from a list of atom indices.
a_list: atom indices
Use: get_bfi(calc, [0, 4]) gives the functions indices
corresponding to atom 0 and 4"""
bfs_list = []
for a in a_list:
M = calc.wfs.basis_functions.M_a[a]
bfs_list += range(M, M + calc.wfs.setups[a].nao)
return bfs_list
def get_bfi2(symbols, basis, a_list):
"""Same as get_bfi, but does not require an LCAO calc"""
basis = types2atomtypes(symbols, basis, default='dzp')
bfs_list = []
i = 0
for a, symbol in enumerate(symbols):
nao = Basis(symbol, basis[a]).nao
if a in a_list:
bfs_list += range(i, i + nao)
i += nao
return bfs_list
def get_mulliken(calc, a_list):
"""Mulliken charges from a list of atom indices (a_list)."""
Q_a = {}
for a in a_list:
Q_a[a] = 0.0
for kpt in calc.wfs.kpt_u:
S_MM = calc.wfs.S_qMM[kpt.q]
nao = S_MM.shape[0]
rho_MM = np.empty((nao, nao), calc.wfs.dtype)
calc.wfs.calculate_density_matrix(kpt.f_n, kpt.C_nM, rho_MM)
Q_M = np.dot(rho_MM, S_MM).diagonal()
for a in a_list:
M1 = calc.wfs.basis_functions.M_a[a]
M2 = M1 + calc.wfs.setups[a].nao
Q_a[a] += np.sum(Q_M[M1:M2])
return Q_a
def get_realspace_hs(h_skmm, s_kmm, bzk_kc, weight_k,
R_c=(0, 0, 0), direction='x',
symmetry={'enabled': False}):
from gpaw.symmetry import Symmetry
from ase.dft.kpoints import get_monkhorst_pack_size_and_offset, \
monkhorst_pack
if symmetry['point_group'] is True:
raise NotImplementedError('Point group symmetry not implemented')
nspins, nk, nbf = h_skmm.shape[:3]
dir = 'xyz'.index(direction)
transverse_dirs = np.delete([0, 1, 2], [dir])
dtype = float
if len(bzk_kc) > 1 or np.any(bzk_kc[0] != [0, 0, 0]):
dtype = complex
kpts_grid = get_monkhorst_pack_size_and_offset(bzk_kc)[0]
# kpts in the transport direction
nkpts_p = kpts_grid[dir]
bzk_p_kc = monkhorst_pack((nkpts_p,1,1))[:, 0]
weight_p_k = 1. / nkpts_p
# kpts in the transverse directions
bzk_t_kc = monkhorst_pack(tuple(kpts_grid[transverse_dirs]) + (1, ))
if not 'time_reversal' in symmetry:
symmetry['time_reversal'] = True
if symmetry['time_reversal'] is True:
#XXX a somewhat ugly hack:
# By default GPAW reduces inversion sym in the z direction. The steps
# below assure reduction in the transverse dirs.
# For now this part seems to do the job, but it may be written
# in a smarter way in the future.
symmetry = Symmetry([1], np.eye(3))
symmetry.prune_symmetries_atoms(np.zeros((1, 3)))
ibzk_kc, ibzweight_k = symmetry.reduce(bzk_kc)[:2]
ibzk_t_kc, weights_t_k = symmetry.reduce(bzk_t_kc)[:2]
ibzk_t_kc = ibzk_t_kc[:, :2]
nkpts_t = len(ibzk_t_kc)
else:
ibzk_kc = bzk_kc.copy()
ibzk_t_kc = bzk_t_kc
nkpts_t = len(bzk_t_kc)
weights_t_k = [1. / nkpts_t for k in range(nkpts_t)]
h_skii = np.zeros((nspins, nkpts_t, nbf, nbf), dtype)
if s_kmm is not None:
s_kii = np.zeros((nkpts_t, nbf, nbf), dtype)
tol = 7
for j, k_t in enumerate(ibzk_t_kc):
for k_p in bzk_p_kc:
k = np.zeros((3,))
k[dir] = k_p
k[transverse_dirs] = k_t
kpoint_list = [list(np.round(k_kc, tol)) for k_kc in ibzk_kc]
if list(np.round(k, tol)) not in kpoint_list:
k = -k # inversion
index = kpoint_list.index(list(np.round(k,tol)))
h = h_skmm[:, index].conjugate()
if s_kmm is not None:
s = s_kmm[index].conjugate()
k=-k
else: # kpoint in the ibz
index = kpoint_list.index(list(np.round(k, tol)))
h = h_skmm[:, index]
if s_kmm is not None:
s = s_kmm[index]
c_k = np.exp(2.j * np.pi * np.dot(k, R_c)) * weight_p_k
h_skii[:, j] += c_k * h
if s_kmm is not None:
s_kii[j] += c_k * s
if s_kmm is None:
return ibzk_t_kc, weights_t_k, h_skii
else:
return ibzk_t_kc, weights_t_k, h_skii, s_kii
def remove_pbc(atoms, h, s=None, d=0, centers_ic=None, cutoff=None):
if h.ndim > 2:
raise KeyError('You have to run remove_pbc for each '
'spin/kpoint seperately.')
L = atoms.cell[d, d]
nao = len(h)
dtype = h.dtype
if centers_ic is None:
centers_ic = get_bf_centers(atoms) # requires an attached LCAO calc
ni = len(centers_ic)
if nao != ni:
assert nao == 2 * ni
centers_ic = np.vstack((centers_ic, centers_ic))
centers_ic[ni:, d] += L
if cutoff is None:
cutoff = L - 1e-3
elif cutoff is None:
cutoff = 0.5 * L - 1e-3
pos_i = centers_ic[:, d]
for i in range(nao):
dpos_i = abs(pos_i - pos_i[i])
mask_i = (dpos_i < cutoff).astype(dtype)
h[i, :] *= mask_i
h[:, i] *= mask_i
if s is not None:
s[i, :] *= mask_i
s[:, i] *= mask_i
def dump_hamiltonian(filename, atoms, direction=None, Ef=None):
h_skmm, s_kmm = get_hamiltonian(atoms)
if direction is not None:
d = 'xyz'.index(direction)
for s in range(atoms.calc.nspins):
for k in range(atoms.calc.nkpts):
if s==0:
remove_pbc(atoms, h_skmm[s, k], s_kmm[k], d)
else:
remove_pbc(atoms, h_skmm[s, k], None, d)
if atoms.calc.master:
fd = open(filename, 'wb')
pickle.dump((h_skmm, s_kmm), fd, 2)
atoms_data = {'cell':atoms.cell, 'positions':atoms.positions,
'numbers':atoms.numbers, 'pbc':atoms.pbc}
pickle.dump(atoms_data, fd, 2)
calc_data ={'weight_k':atoms.calc.weight_k,
'ibzk_kc':atoms.calc.ibzk_kc}
pickle.dump(calc_data, fd, 2)
fd.close()
world.barrier()
def dump_hamiltonian_parallel(filename, atoms, direction=None, Ef=None):
"""
Dump the lcao representation of H and S to file(s) beginning
with filename. If direction is x, y or z, the periodic boundary
conditions will be removed in the specified direction.
If the Fermi temperature is different from zero, the
energy zero-point is taken as the Fermi level.
Note:
H and S are parallized over spin and k-points and
is for now dumped into a number of pickle files. This
may be changed into a dump to a single file in the future.
"""
if direction is not None:
d = 'xyz'.index(direction)
calc = atoms.calc
wfs = calc.wfs
nao = wfs.setups.nao
nq = len(wfs.kpt_u) // wfs.nspins
H_qMM = np.empty((wfs.nspins, nq, nao, nao), wfs.dtype)
calc_data = {'k_q':{},
'skpt_qc':np.empty((nq, 3)),
'weight_q':np.empty(nq)}
S_qMM = wfs.S_qMM
for kpt in wfs.kpt_u:
calc_data['skpt_qc'][kpt.q] = calc.wfs.kd.ibzk_kc[kpt.k]
calc_data['weight_q'][kpt.q] = calc.wfs.kd.weight_k[kpt.k]
calc_data['k_q'][kpt.q] = kpt.k
## print ('Calc. H matrix on proc. %i: '
## '(rk, rd, q, k) = (%i, %i, %i, %i)') % (
## wfs.world.rank, wfs.kd.comm.rank,
## wfs.gd.domain.comm.rank, kpt.q, kpt.k)
H_MM = wfs.eigensolver.calculate_hamiltonian_matrix(calc.hamiltonian,
wfs,
kpt)
H_qMM[kpt.s, kpt.q] = H_MM
tri2full(H_qMM[kpt.s, kpt.q])
if kpt.s==0:
tri2full(S_qMM[kpt.q])
if direction is not None:
remove_pbc(atoms, H_qMM[kpt.s, kpt.q], S_qMM[kpt.q], d)
else:
if direction is not None:
remove_pbc(atoms, H_qMM[kpt.s, kpt.q], None, d)
if calc.occupations.width > 0:
if Ef is None:
Ef = calc.occupations.get_fermi_level()
else:
Ef = Ef / Hartree
H_qMM[kpt.s, kpt.q] -= S_qMM[kpt.q] * Ef
if wfs.gd.comm.rank == 0:
fd = file(filename+'%i.pckl' % wfs.kd.comm.rank, 'wb')
H_qMM *= Hartree
pickle.dump((H_qMM, S_qMM),fd , 2)
pickle.dump(calc_data, fd, 2)
fd.close()
def get_lcao_hamiltonian(calc):
"""Return H_skMM, S_kMM on master, (None, None) on slaves. H is in eV."""
if calc.wfs.S_qMM is None:
calc.wfs.set_positions(calc.get_atoms().get_scaled_positions() % 1)
dtype = calc.wfs.dtype
NM = calc.wfs.eigensolver.nao
Nk = calc.wfs.kd.nibzkpts
Ns = calc.wfs.nspins
S_kMM = np.zeros((Nk, NM, NM), dtype)
H_skMM = np.zeros((Ns, Nk, NM, NM), dtype)
for kpt in calc.wfs.kpt_u:
H_MM = calc.wfs.eigensolver.calculate_hamiltonian_matrix(
calc.hamiltonian, calc.wfs, kpt)
if kpt.s == 0:
S_kMM[kpt.k] = calc.wfs.S_qMM[kpt.q]
tri2full(S_kMM[kpt.k])
H_skMM[kpt.s, kpt.k] = H_MM * Hartree
tri2full(H_skMM[kpt.s, kpt.k])
calc.wfs.kd.comm.sum(S_kMM, MASTER)
calc.wfs.kd.comm.sum(H_skMM, MASTER)
if rank == MASTER:
return H_skMM, S_kMM
else:
return None, None
def get_lead_lcao_hamiltonian(calc, direction='x'):
H_skMM, S_kMM = get_lcao_hamiltonian(calc)
if rank == MASTER:
return lead_kspace2realspace(H_skMM, S_kMM,
bzk_kc=calc.wfs.kd.bzk_kc,
weight_k=calc.wfs.kd.weight_k,
direction=direction,
symmetry=calc.input_parameters['symmetry'])
else:
return None, None, None, None
def lead_kspace2realspace(h_skmm, s_kmm, bzk_kc, weight_k, direction='x',
symmetry={'point_group': False}):
"""Convert a k-dependent Hamiltonian to tight-binding onsite and coupling.
For each transverse k-point:
Convert k-dependent (in transport direction) Hamiltonian
representing a lead to a real space tight-binding Hamiltonian
of double size representing two principal layers and the coupling between.
"""
dir = 'xyz'.index(direction)
if symmetry['point_group'] is True:
raise NotImplementedError
R_c = [0, 0, 0]
ibz_t_kc, weight_t_k, h_skii, s_kii = get_realspace_hs(
h_skmm, s_kmm, bzk_kc, weight_k, R_c, direction, symmetry)
R_c[dir] = 1
h_skij, s_kij = get_realspace_hs(
h_skmm, s_kmm, bzk_kc, weight_k, R_c, direction, symmetry)[-2:]
nspins, nk, nbf = h_skii.shape[:-1]
h_skmm = np.zeros((nspins, nk, 2 * nbf, 2 * nbf), h_skii.dtype)
s_kmm = np.zeros((nk, 2 * nbf, 2 * nbf), h_skii.dtype)
h_skmm[:, :, :nbf, :nbf] = h_skmm[:, :, nbf:, nbf:] = h_skii
h_skmm[:, :, :nbf, nbf:] = h_skij
h_skmm[:, :, nbf:, :nbf] = h_skij.swapaxes(2, 3).conj()
s_kmm[:, :nbf, :nbf] = s_kmm[:, nbf:, nbf:] = s_kii
s_kmm[:, :nbf, nbf:] = s_kij
s_kmm[:, nbf:, :nbf] = s_kij.swapaxes(1,2).conj()
return ibz_t_kc, weight_t_k, h_skmm, s_kmm
def zeta_pol(basis):
"""Get number of zeta func. and polarization func. indices in Basis."""
zeta = []
pol = []
for bf in basis.bf_j:
if 'polarization' in bf.type:
pol.append(2 * bf.l + 1)
else:
zeta.append(2 * bf.l + 1)
zeta = sum(zeta)
pol = sum(pol)
assert zeta + pol == basis.nao
return zeta, pol
def basis_subset(symbol, largebasis, smallbasis):
"""Title.
Determine which basis function indices from ``largebasis`` are also
present in smallbasis.
"""
blarge = Basis(symbol, largebasis)
zeta_large, pol_large = zeta_pol(blarge)
bsmall = Basis(symbol, smallbasis)
zeta_small, pol_small = zeta_pol(bsmall)
assert zeta_small <= zeta_large
assert pol_small <= pol_large
insmall = np.zeros(blarge.nao, bool)
insmall[:zeta_small] = True
insmall[zeta_large:zeta_large + pol_small] = True
return insmall
def basis_subset2(symbols, largebasis='dzp', smallbasis='sz'):
"""Same as basis_subset, but for an entire list of atoms."""
largebasis = types2atomtypes(symbols, largebasis, default='dzp')
smallbasis = types2atomtypes(symbols, smallbasis, default='sz')
mask = []
for symbol, large, small in zip(symbols, largebasis, smallbasis):
mask.extend(basis_subset(symbol, large, small))
return np.asarray(mask, bool)
def collect_orbitals(a_xo, coords, root=0):
"""Collect array distributed over orbitals to root-CPU.
Input matrix has last axis distributed amongst CPUs,
return is None on slaves, and the collected array on root.
The distribution can be uneven amongst CPUs. The list coords gives the
number of values for each CPU.
"""
a_xo = np.ascontiguousarray(a_xo)
if world.size == 1:
return a_xo
# All slaves send their piece to ``root``:
# There can be several sends before the corresponding receives
# are posted, so use syncronous send here
if world.rank != root:
world.ssend(a_xo, root, 112)
return None
# On root, put the subdomains from the slaves into the big array
# for the whole domain on root:
xshape = a_xo.shape[:-1]
Norb2 = sum(coords) # total number of orbital indices
a_xO = np.empty(xshape + (Norb2,), a_xo.dtype)
o = 0
for rank, norb in enumerate(coords):
if rank != root:
tmp_xo = np.empty(xshape + (norb,), a_xo.dtype)
world.receive(tmp_xo, rank, 112)
a_xO[..., o:o + norb] = tmp_xo
else:
a_xO[..., o:o + norb] = a_xo
o += norb
return a_xO
def makeU(gpwfile='grid.gpw', orbitalfile='w_wG__P_awi.pckl',
rotationfile='eps_q__U_pq.pckl', tolerance=1e-5,
writeoptimizedpairs=False, dppname='D_pp.pckl', S_w=None):
# S_w: None or diagonal of overlap matrix. In the latter case
# the optimized and truncated pair orbitals are obtained from
# normalized (to 1) orbitals.
#
# Tolerance is used for truncation of optimized pairorbitals
#calc = GPAW(gpwfile, txt=None)
from gpaw import GPAW
from gpaw.mpi import world, MASTER
calc = GPAW(gpwfile, txt='pairorb.txt') # XXX
gd = calc.wfs.gd
setups = calc.wfs.setups
myatoms = calc.density.D_asp.keys()
del calc
# Load orbitals on master and distribute to slaves
if world.rank == MASTER:
wglobal_wG, P_awi = pickle.load(open(orbitalfile, 'rb'))
Nw = len(wglobal_wG)
print('Estimated total (serial) mem usage: %0.3f GB' % (
np.prod(gd.N_c) * Nw**2 * 8 / 1024.**3))
else:
wglobal_wG = None
Nw = 0
Nw = gd.comm.sum(Nw) #distribute Nw to all nodes
w_wG = gd.empty(n=Nw)
gd.distribute(wglobal_wG, w_wG)
del wglobal_wG
# Make pairorbitals
f_pG = gd.zeros(n=Nw**2)
Np = len(f_pG)
for p, (w1, w2) in enumerate(np.ndindex(Nw, Nw)):
np.multiply(w_wG[w1], w_wG[w2], f_pG[p])
del w_wG
assert f_pG.flags.contiguous
# Make pairorbital overlap (lower triangle only)
D_pp = np.zeros((Nw**2, Nw**2))
rk(gd.dv, f_pG, 0., D_pp)
# Add atomic corrections to pairorbital overlap
for a in myatoms:
if setups[a].type != 'ghost':
P_pp = np.array([pack(np.outer(P_awi[a][w1], P_awi[a][w2]))
for w1, w2 in np.ndindex(Nw, Nw)])
I4_pp = setups[a].four_phi_integrals()
A = np.zeros((len(I4_pp), len(P_pp)))
gemm(1.0, P_pp, I4_pp, 0.0, A, 't')
gemm(1.0, A, P_pp, 1.0, D_pp)
#D_pp += np.dot(P_pp, np.dot(I4_pp, P_pp.T))
# Summ all contributions to master
gd.comm.sum(D_pp, MASTER)
if world.rank == MASTER:
if S_w is not None:
print('renormalizing pairorb overlap matrix (D_pp)')
S2 = np.sqrt(S_w)
for pa, (wa1, wa2) in enumerate(np.ndindex(Nw, Nw)):
for pb, (wb1, wb2) in enumerate(np.ndindex(Nw, Nw)):
D_pp[pa, pb] /= S2[wa1] * S2[wa2] * S2[wb1] * S2[wb2]
D_pp.dump(dppname) # XXX if the diagonalization below (on MASTER only)
# fails, then one can always restart the stuff
# below using only the stored D_pp matrix
# Determine eigenvalues and vectors on master only
eps_q, U_pq = np.linalg.eigh(D_pp, UPLO='L')
del D_pp
indices = np.argsort(-eps_q.real)
eps_q = np.ascontiguousarray(eps_q.real[indices])
U_pq = np.ascontiguousarray(U_pq[:, indices])
# Truncate
indices = eps_q > tolerance
U_pq = np.ascontiguousarray(U_pq[:, indices])
eps_q = np.ascontiguousarray(eps_q[indices])
# Dump to file
pickle.dump((eps_q, U_pq), open(rotationfile, 'wb'), 2)
if writeoptimizedpairs is not False:
assert world.size == 1 # works in parallel if U and eps are broadcast
Uisq_qp = (U_pq / np.sqrt(eps_q)).T.copy()
g_qG = gd.zeros(n=len(eps_q))
gemm(1.0, f_pG, Uisq_qp, 0.0, g_qG)
g_qG = gd.collect(g_qG)
if world.rank == MASTER:
P_app = dict([(a, np.array([pack(np.outer(P_wi[w1], P_wi[w2]),
tolerance=1e3)
for w1, w2 in np.ndindex(Nw, Nw)]))
for a, P_wi in P_awi.items()])
P_aqp = dict([(a, np.dot(Uisq_qp, P_pp))
for a, P_pp in P_app.items()])
pickle.dump((g_qG, P_aqp), open(writeoptimizedpairs, 'wb'), 2)
def makeV(gpwfile='grid.gpw', orbitalfile='w_wG__P_awi.pckl',
rotationfile='eps_q__U_pq.pckl', coulombfile='V_qq.pckl',
log='V_qq.log', fft=False):
if isinstance(log, str) and world.rank == MASTER:
log = open(log, 'w')
# Extract data from files
calc = GPAW(gpwfile, txt=None, communicator=serial_comm)
spos_ac = calc.get_atoms().get_scaled_positions() % 1.0
coulomb = Coulomb(calc.wfs.gd, calc.wfs.setups, spos_ac, fft)
w_wG, P_awi = pickle.load(open(orbitalfile, 'rb'))
eps_q, U_pq = pickle.load(open(rotationfile, 'rb'))
del calc
# Make rotation matrix divided by sqrt of norm
Nq = len(eps_q)
Np = len(U_pq)
Ni = len(w_wG)
Uisq_iqj = (U_pq/np.sqrt(eps_q)).reshape(Ni, Ni, Nq).swapaxes(1, 2).copy()
del eps_q, U_pq
# Determine number of opt. pairorb on each cpu
Ncpu = world.size
nq, R = divmod(Nq, Ncpu)
nq_r = nq * np.ones(Ncpu, int)
if R > 0:
nq_r[-R:] += 1
# Determine number of opt. pairorb on this cpu
nq1 = nq_r[world.rank]
q1end = nq_r[:world.rank + 1].sum()
q1start = q1end - nq1
V_qq = np.zeros((Nq, nq1), float)
def make_optimized(qstart, qend):
g_qG = np.zeros((qend - qstart,) + w_wG.shape[1:], float)
P_aqp = {}
for a, P_wi in P_awi.items():
ni = P_wi.shape[1]
nii = ni * (ni + 1) // 2
P_aqp[a] = np.zeros((qend - qstart, nii), float)
for w1, w1_G in enumerate(w_wG):
U = Uisq_iqj[w1, qstart: qend].copy()
gemm(1., w1_G * w_wG, U, 1.0, g_qG)
for a, P_wi in P_awi.items():
P_wp = np.array([pack(np.outer(P_wi[w1], P_wi[w2]))
for w2 in range(Ni)])
gemm(1., P_wp, U, 1.0, P_aqp[a])
return g_qG, P_aqp
g1_qG, P1_aqp = make_optimized(q1start, q1end)
for block, nq2 in enumerate(nq_r):
if block == world.rank:
g2_qG, P2_aqp = g1_qG, P1_aqp
q2start, q2end = q1start, q1end
else:
q2end = nq_r[:block + 1].sum()
q2start = q2end - nq2
g2_qG, P2_aqp = make_optimized(q2start, q2end)
for q1, q2 in np.ndindex(nq1, nq2):
P1_ap = dict([(a, P_qp[q1]) for a, P_qp in P1_aqp.items()])
P2_ap = dict([(a, P_qp[q2]) for a, P_qp in P2_aqp.items()])
V_qq[q2 + q2start, q1] = coulomb.calculate(g1_qG[q1], g2_qG[q2],
P1_ap, P2_ap)
if q2 == 0 and world.rank == MASTER:
T = localtime()
log.write(
'Block %i/%i is %4.1f percent done at %02i:%02i:%02i\n' % (
block + 1, world.size, 100.0 * q1 / nq1, T[3], T[4], T[5]))
log.flush()
# Collect V_qq array on master node
if world.rank == MASTER:
T = localtime()
log.write('Starting collect at %02i:%02i:%02i\n' % (
T[3], T[4], T[5]))
log.flush()
V_qq = collect_orbitals(V_qq, coords=nq_r, root=MASTER)
if world.rank == MASTER:
# V can be slightly asymmetric due to numerics
V_qq = 0.5 * (V_qq + V_qq.T)
V_qq.dump(coulombfile)
T = localtime()
log.write('Finished at %02i:%02i:%02i\n' % (
T[3], T[4], T[5]))
log.flush()
gpaw-0.11.0.13004/gpaw/lcao/newoverlap.py 0000664 0001750 0001750 00000011741 12553643472 020072 0 ustar jensj jensj 0000000 0000000 import numpy as np
from ase import Atoms
from ase.calculators.neighborlist import NeighborList
from gpaw.lcao.overlap import AtomicDisplacement, TwoCenterIntegralCalculator
from gpaw.utilities.partition import EvenPartitioning
class DistsAndOffsets:
def __init__(self, nl, spos_ac, cell_cv):
#assert nl.bothways
r_and_offset_aao = {}
def add(a1, a2, R_c, offset):
r_and_offset_aao.setdefault((a1, a2), []).append((R_c, offset))
for a1, spos1_c in enumerate(spos_ac):
a2_a, offsets = nl.get_neighbors(a1)
for a2, offset in zip(a2_a, offsets):
spos2_c = spos_ac[a2] + offset
R_c = np.dot(spos2_c - spos1_c, cell_cv)
add(a1, a2, R_c, offset)
if a1 != a2 or offset.any():
add(a2, a1, -R_c, -offset)
self.r_and_offset_aao = r_and_offset_aao
def get(self, a1, a2):
R_ca_and_offset_a = self.r_and_offset_aao.get((a1, a2))
return R_ca_and_offset_a
def newoverlap(wfs, spos_ac):
assert wfs.ksl.block_comm.size == wfs.gd.comm.size * wfs.bd.comm.size
even_part = EvenPartitioning(wfs.gd.comm, #wfs.ksl.block_comm,
len(wfs.atom_partition.rank_a))
atom_partition = even_part.as_atom_partition()
tci = wfs.tci
gd = wfs.gd
kd = wfs.kd
nq = len(kd.ibzk_qc)
# New neighbor list because we want it "both ways", heh. Or do we?
neighbors = NeighborList(tci.cutoff_a, skin=0,
sorted=True, self_interaction=True,
bothways=False)
atoms = Atoms('X%d' % len(tci.cutoff_a), cell=gd.cell_cv, pbc=gd.pbc_c)
atoms.set_scaled_positions(spos_ac)
neighbors.update(atoms)
# XXX
pcutoff_a = []
phicutoff_a = []
for setup in wfs.setups:
if setup.pt_j:
pcutoff = max([pt.get_cutoff() for pt in setup.pt_j])
else:
pcutoff = 0.0
if setup.phit_j:
phicutoff = max([phit.get_cutoff() for phit in setup.phit_j])
else:
phicutoff = 0.0
pcutoff_a.append(pcutoff)
phicutoff_a.append(phicutoff)
# Calculate the projector--basis function overlaps:
#
# a1 ~a1
# P = < p | Phi > ,
# i mu i mu
#
# i.e. projector is on a1 and basis function is on what we will call a2.
overlapcalc = TwoCenterIntegralCalculator(wfs.kd.ibzk_qc,
derivative=False)
P_aaqim = {} # keys: (a1, a2). Values: matrix blocks
dists_and_offsets = DistsAndOffsets(neighbors, spos_ac, gd.cell_cv)
#ng = 2**extra_parameters.get('log2ng', 10)
#transformer = FourierTransformer(rcmax, ng)
#tsoc = TwoSiteOverlapCalculator(transformer)
#msoc = ManySiteOverlapCalculator(tsoc, I_a, I_a)
msoc = wfs.tci.msoc
phit_Ij = [setup.phit_j for setup in tci.setups_I]
l_Ij = []
for phit_j in phit_Ij:
l_Ij.append([phit.get_angular_momentum_number()
for phit in phit_j])
pt_l_Ij = [setup.l_j for setup in tci.setups_I]
pt_Ij = [setup.pt_j for setup in tci.setups_I]
phit_Ijq = msoc.transform(phit_Ij)
pt_Ijq = msoc.transform(pt_Ij)
#self.Theta_expansions = msoc.calculate_expansions(l_Ij, phit_Ijq,
# l_Ij, phit_Ijq)
#self.T_expansions = msoc.calculate_kinetic_expansions(l_Ij, phit_Ijq)
P_expansions = msoc.calculate_expansions(pt_l_Ij, pt_Ijq,
l_Ij, phit_Ijq)
P_neighbors_a = {}
for a1 in atom_partition.my_indices:
for a2 in range(len(wfs.setups)):
R_ca_and_offset_a = dists_and_offsets.get(a1, a2)
if R_ca_and_offset_a is None: # No overlap between a1 and a2
continue
maxdistance = pcutoff_a[a1] + phicutoff_a[a2]
expansion = P_expansions.get(a1, a2)
P_qim = expansion.zeros((nq,), dtype=wfs.dtype)
disp = None
for R_c, offset in R_ca_and_offset_a:
r = np.linalg.norm(R_c)
if r > maxdistance:
continue
# Below lines are meant to make use of symmetry. Will not
# be relevant for P.
#remainder = (a1 + a2) % 2
#if a1 < a2 and not remainder:
# continue
# if a1 > a2 and remainder:
# continue
phases = overlapcalc.phaseclass(overlapcalc.ibzk_qc, offset)
disp = AtomicDisplacement(None, a1, a2, R_c, offset, phases)
disp.evaluate_overlap(expansion, P_qim)
if disp is not None: # there was at least one non-zero overlap
assert (a1, a2) not in P_aaqim
P_aaqim[(a1, a2)] = P_qim
P_neighbors_a.setdefault(a1, []).append(a2)
return P_neighbors_a, P_aaqim
gpaw-0.11.0.13004/gpaw/lcao/generate_ngto_augmented.py 0000664 0001750 0001750 00000012657 12553643472 022571 0 ustar jensj jensj 0000000 0000000 from __future__ import print_function
import os
import re
import numpy as np
from gpaw.atom.basis import BasisMaker
from gpaw.atom.basis import QuasiGaussian
from gpaw.atom.configurations import parameters, parameters_extra
from gpaw.basis_data import BasisFunction
from gpaw.mpi import world
# Module for generating basis sets that compose of usual basis sets
# augmented with Gaussian type orbital (GTO).
#
# GTOs are truncated and represented numerically.
def read_gbs(fname):
"""Read gbs file.
This reads only the first element/atom from the file
as separated with line beginning with '*'.
"""
gto_k = []
description = ''
f = open(fname, 'r')
line_i = f.readlines()
f.close()
i = 0
Ni = len(line_i)
while True:
line = line_i[i].strip()
if line == '' or line[0] == '*':
pass
elif line[0] == '!':
description += '%s\n' % line[1:].strip()
else:
break
i += 1
description = description.strip()
atom = line_i[i].strip().split()[0]
i += 1
while i < Ni:
line = line_i[i]
if line[0] == '*':
break
i += 1
d = line.split()
l = 'spdfghi'.index(d[0].lower())
Nj = int(d[1])
alpha_j = []
coeff_j = []
for _ in range(Nj):
line = line_i[i]
d = line.split()
alpha = float(d[0])
coeff = float(d[1])
alpha_j.append(alpha)
coeff_j.append(coeff)
i += 1
gto_k.append({'l': l, 'alpha_j': alpha_j, 'coeff_j': coeff_j})
return atom, description, gto_k
def get_ngto(rgd, l, alpha, rcut):
gaussian = QuasiGaussian(alpha, rcut)
psi_g = gaussian(rgd.r_g) * rgd.r_g**l
norm = np.sum(rgd.dr_g * (rgd.r_g * psi_g) **2) ** .5
psi_g /= norm
return psi_g
def add_ngto(basis, l, alpha, tol, label):
rgd = basis.get_grid_descriptor()
rmax = rgd.r_g[-1]
# Get NGTO with the initial (large) rcut=rmax
psiref_g = get_ngto(rgd, l, alpha, rmax)
# Make rcut smaller
# Guess initial rcut where we are close to the tolerance
i = np.where(psiref_g > tol)[0][-1]
rcut = rgd.r_g[i]
psi_g = get_ngto(rgd, l, alpha, rcut)
err = np.max(np.absolute(psi_g - psiref_g))
# Increase/decrease rcut to find the smallest rcut
# that yields error within the tolerance
if err > tol:
# Increase rcut -> decrease err
for i in range(i, basis.ng):
rcut = rgd.r_g[i]
psi_g = get_ngto(rgd, l, alpha, rcut)
err = np.max(np.absolute(psi_g - psiref_g))
if err < tol:
break
else:
# Decrease rcut -> increase err
for i in range(i, 0, -1):
rcut = rgd.r_g[i]
psi_g = get_ngto(rgd, l, alpha, rcut)
err = np.max(np.absolute(psi_g - psiref_g))
if err > tol:
i += 1
break
# Construct NGTO with the found rcut
rcut = rgd.r_g[i]
psi_g = get_ngto(rgd, l, alpha, rcut)
# Change norm (maybe unnecessary)
psi_g = psi_g[:(i + 1)] * 0.5
# Create associated basis function
bf = BasisFunction(l, rcut, psi_g, label)
basis.bf_j.append(bf)
def do_nao_ngto_basis(atom, xc, naobasis, gbsfname, label):
# Read Gaussians
atomgbs, descriptiongbs, gto_k = read_gbs(gbsfname)
assert atom == atomgbs
# Generate nao basis
assert naobasis == 'sz'
# Choose basis sets without semi-core states XXXXXX
if atom == 'Ag':
label = '11.%s' % label
p = parameters_extra
else:
p = parameters
bm = BasisMaker(atom, label, run=False, gtxt=None, xc=xc)
bm.generator.run(write_xml=False, use_restart_file=False, **p[atom])
basis = bm.generate(1, 0, txt=None)
# Increase basis function max radius
rmax = 100.0
basis.ng = int(rmax / basis.d) + 1
# Add NGTOs
tol = 0.001
description = []
msg = 'Augmented with NGTOs'
description.append(msg)
description.append('=' * len(msg))
description.append('')
msg = 'GTOs from file %s' % os.path.basename(gbsfname)
description.append(msg)
description.append('-' * len(msg))
description.append(descriptiongbs)
description.append('')
description.append('NGTO truncation tolerance: %f' % tol)
description.append('Functions: NGTO(l,alpha)')
for gto in gto_k:
l = gto['l']
assert len(gto['alpha_j']) == 1, \
'Only non-contracted GTOs supported'
alpha = gto['alpha_j'][0]
ngtolabel = 'NGTO(%s,%.7f)' % ('spdfghi'[l], alpha)
description.append(' ' + ngtolabel)
add_ngto(basis, l, alpha, tol, ngtolabel)
basis.generatordata += '\n\n' + '\n'.join(description)
basis.write_xml()
def main():
xc = 'PBE'
# Process all gbs files
fname_i = [fname for fname in sorted(os.listdir('.'))
if fname.endswith('.gbs')]
for i, fname in enumerate(fname_i):
if i % world.size != world.rank:
continue
m = re.match('(?P\w+)-(?P