def dip_moment(cell,
dm_kpts,
unit='Debye',
verbose=logger.NOTE,
grids=None,
rho=None,
kpts=np.zeros((1, 3))):
''' Dipole moment in the unit cell (is it well defined)?
Args:
cell : an instance of :class:`Cell`
dm_kpts (a list of ndarrays) : density matrices of k-points
Return:
A list: the dipole moment on x, y and z components
'''
from pyscf.pbc.dft import gen_grid
from pyscf.pbc.dft import numint
if grids is None:
grids = gen_grid.UniformGrids(cell)
if rho is None:
rho = numint.KNumInt().get_rho(cell, dm_kpts, grids, kpts,
cell.max_memory)
return pbchf.dip_moment(cell, dm_kpts, unit, verbose, grids, rho, kpts)
def get_j_kpts(mf, cell, dm_kpts, kpts, kpts_band=None):
coords = gen_grid.gen_uniform_grids(cell)
nkpts = len(kpts)
ngrids = len(coords)
dm_kpts = np.asarray(dm_kpts)
nao = dm_kpts.shape[-1]
ni = numint.KNumInt(kpts)
aoR_kpts = ni.eval_ao(cell, coords, kpts)
if kpts_band is not None:
aoR_kband = numint.eval_ao(cell, coords, kpts_band)
dms = dm_kpts.reshape(-1,nkpts,nao,nao)
nset = dms.shape[0]
vjR = [get_vjR(cell, dms[i], aoR_kpts) for i in range(nset)]
if kpts_band is not None:
vj_kpts = [cell.vol/ngrids * lib.dot(aoR_kband.T.conj()*vjR[i], aoR_kband)
for i in range(nset)]
if dm_kpts.ndim == 3: # One set of dm_kpts for KRHF
vj_kpts = vj_kpts[0]
return lib.asarray(vj_kpts)
else:
vj_kpts = []
for i in range(nset):
vj = [cell.vol/ngrids * lib.dot(aoR_k.T.conj()*vjR[i], aoR_k)
for aoR_k in aoR_kpts]
vj_kpts.append(lib.asarray(vj))
return lib.asarray(vj_kpts).reshape(dm_kpts.shape)
def test_eval_ao_kpts(self):
cell = pbcgto.Cell()
cell.verbose = 5
cell.output = '/dev/null'
cell.a = np.eye(3) * 2.5
cell.mesh = [21] * 3
cell.atom = [
['He', (1., .8, 1.9)],
['He', (.1, .2, .3)],
]
cell.basis = 'ccpvdz'
cell.build(False, False)
grids = gen_grid.UniformGrids(cell)
grids.build()
np.random.seed(1)
kpts = np.random.random((4, 3))
ni = numint.KNumInt(kpts)
ao1 = ni.eval_ao(cell, grids.coords, kpts)
self.assertAlmostEqual(finger(ao1[0]),
(-2.4066959390326477 - 0.98044994099240701j), 8)
self.assertAlmostEqual(finger(ao1[1]),
(-0.30643153325360639 + 0.1571658820483913j), 8)
self.assertAlmostEqual(finger(ao1[2]),
(-1.1937974302337684 - 0.39039259235266233j), 8)
self.assertAlmostEqual(finger(ao1[3]),
(0.17701966968272009 - 0.20232879692603079j), 8)
def get_jk_kpts(mf, cell, dm_kpts, kpts, kpts_band=None):
coords = gen_grid.gen_uniform_grids(cell)
nkpts = len(kpts)
ngrids = len(coords)
dm_kpts = np.asarray(dm_kpts)
nao = dm_kpts.shape[-1]
dms = dm_kpts.reshape(-1,nkpts,nao,nao)
nset = dms.shape[0]
ni = numint.KNumInt(kpts)
aoR_kpts = ni.eval_ao(cell, coords, kpts)
if kpts_band is not None:
aoR_kband = numint.eval_ao(cell, coords, kpts_band)
# J
vjR = [get_vjR_kpts(cell, dms[i], aoR_kpts) for i in range(nset)]
if kpts_band is not None:
vj_kpts = [cell.vol/ngrids * lib.dot(aoR_kband.T.conj()*vjR[i], aoR_kband)
for i in range(nset)]
else:
vj_kpts = []
for i in range(nset):
vj = [cell.vol/ngrids * lib.dot(aoR_k.T.conj()*vjR[i], aoR_k)
for aoR_k in aoR_kpts]
vj_kpts.append(lib.asarray(vj))
vj_kpts = lib.asarray(vj_kpts)
vjR = None
# K
weight = 1./nkpts * (cell.vol/ngrids)
vk_kpts = np.zeros_like(vj_kpts)
if kpts_band is not None:
for k2, kpt2 in enumerate(kpts):
aoR_dms = [lib.dot(aoR_kpts[k2], dms[i,k2]) for i in range(nset)]
vkR_k1k2 = get_vkR(mf, cell, aoR_kband, aoR_kpts[k2],
kpts_band, kpt2)
#:vk_kpts = 1./nkpts * (cell.vol/ngrids) * np.einsum('rs,Rp,Rqs,Rr->pq',
#: dm_kpts[k2], aoR_kband.conj(),
#: vkR_k1k2, aoR_kpts[k2])
for i in range(nset):
tmp_Rq = np.einsum('Rqs,Rs->Rq', vkR_k1k2, aoR_dms[i])
vk_kpts[i] += weight * lib.dot(aoR_kband.T.conj(), tmp_Rq)
vkR_k1k2 = None
if dm_kpts.ndim == 3:
vj_kpts = vj_kpts[0]
vk_kpts = vk_kpts[0]
return lib.asarray(vj_kpts), lib.asarray(vk_kpts)
else:
for k2, kpt2 in enumerate(kpts):
aoR_dms = [lib.dot(aoR_kpts[k2], dms[i,k2]) for i in range(nset)]
for k1, kpt1 in enumerate(kpts):
vkR_k1k2 = get_vkR(mf, cell, aoR_kpts[k1], aoR_kpts[k2],
kpt1, kpt2)
for i in range(nset):
tmp_Rq = np.einsum('Rqs,Rs->Rq', vkR_k1k2, aoR_dms[i])
vk_kpts[i,k1] += weight * lib.dot(aoR_kpts[k1].T.conj(), tmp_Rq)
vkR_k1k2 = None
return vj_kpts.reshape(dm_kpts.shape), vk_kpts.reshape(dm_kpts.shape)
def write_esh5_orbitals(cell,
name,
kpts=numpy.zeros((1, 3), dtype=numpy.float64)):
"""Writes periodic AO basis to hdf5 file.
Parameters
----------
cell: PySCF get.Cell object
PySCF cell object which contains information of the system, including
AO basis set, FFT mesh, unit cell information, etc.
name: string
Name of hdf5 file.
kpts: array. Default: numpy.zeros((1,3)
K-point array of dimension (nkpts, 3)
dtype: datatype. Default: numpy.float64
Datatype of orbitals in file.
"""
def to_qmcpack_complex(array):
shape = array.shape
return array.view(numpy.float64).reshape(shape + (2, ))
nao = cell.nao_nr()
fh5 = File(name, 'w')
coords = cell.gen_uniform_grids(cell.mesh)
kpts = numpy.asarray(kpts)
nkpts = len(kpts)
norbs = numpy.zeros((nkpts, ), dtype=int)
norbs[:] = nao
grp = fh5.create_group("OrbsG")
dset = grp.create_dataset("reciprocal_vectors",
data=cell.reciprocal_vectors())
dset = grp.create_dataset("number_of_kpoints", data=len(kpts))
dset = grp.create_dataset("kpoints", data=kpts)
dset = grp.create_dataset("number_of_orbitals", data=norbs)
dset = grp.create_dataset("fft_grid", data=cell.mesh)
dset = grp.create_dataset("grid_type", data=int(0))
nnr = cell.mesh[0] * cell.mesh[1] * cell.mesh[2]
# loop over kpoints later
for (ik, k) in enumerate(kpts):
ao = numint.KNumInt().eval_ao(cell, coords, k)[0]
fac = numpy.exp(-1j * numpy.dot(coords, k))
for i in range(norbs[ik]):
aoi = fac * numpy.asarray(ao[:, i].T, order='C')
aoi_G = tools.fft(aoi, cell.mesh)
aoi_G = aoi_G.reshape(cell.mesh).transpose(2, 1, 0).reshape(nnr)
dset = grp.create_dataset('kp' + str(ik) + '_b' + str(i),
data=to_qmcpack_complex(aoi_G))
fh5.close()
def _dft_common_init_(mf):
mf.xc = 'LDA,VWN'
mf.grids = gen_grid.UniformGrids(mf.cell)
# Use rho to filter grids
mf.small_rho_cutoff = getattr(__config__,
'pbc_dft_rks_RKS_small_rho_cutoff', 1e-7)
##################################################
# don't modify the following attributes, they are not input options
# Note Do not refer to .with_df._numint because mesh/coords may be different
if isinstance(mf, khf.KSCF):
mf._numint = numint.KNumInt(mf.kpts)
else:
mf._numint = numint.NumInt()
mf._keys = mf._keys.union(['xc', 'grids', 'small_rho_cutoff'])
def get_rho(mf, dm=None, grids=None, kpts=None):
'''Compute density in real space
'''
from pyscf.pbc.dft import gen_grid
from pyscf.pbc.dft import numint
if dm is None:
dm = mf.make_rdm1()
if getattr(dm[0], 'ndim', None) != 2: # KUHF
dm = dm[0] + dm[1]
if grids is None:
grids = gen_grid.UniformGrids(mf.cell)
if kpts is None:
kpts = mf.kpts
ni = numint.KNumInt()
return ni.get_rho(mf.cell, dm, grids, kpts, mf.max_memory)
def test_nr_rks(self):
cell = pbcgto.Cell()
cell.verbose = 5
cell.output = '/dev/null'
cell.a = np.eye(3) * 2.5
cell.mesh = [21] * 3
cell.atom = [
['He', (1., .8, 1.9)],
['He', (.1, .2, .3)],
]
cell.basis = 'ccpvdz'
cell.build(False, False)
grids = gen_grid.UniformGrids(cell)
grids.build()
nao = cell.nao_nr()
np.random.seed(1)
kpts = np.random.random((2, 3))
dms = np.random.random((2, nao, nao))
dms = (dms + dms.transpose(0, 2, 1)) * .5
ni = numint.NumInt()
with lib.temporary_env(pbcgto.eval_gto, EXTRA_PREC=1e-5):
ne, exc, vmat = ni.nr_rks(cell, grids, 'blyp', dms[0], 1, kpts[0])
self.assertAlmostEqual(ne, 5.0499199224525153, 8)
self.assertAlmostEqual(exc, -3.8870579114663886, 8)
self.assertAlmostEqual(lib.fp(vmat),
0.42538491159934377 + 0.14139753327162483j, 8)
ni = numint.KNumInt()
with lib.temporary_env(pbcgto.eval_gto, EXTRA_PREC=1e-5):
ne, exc, vmat = ni.nr_rks(cell, grids, 'blyp', dms, 1, kpts)
self.assertAlmostEqual(ne, 6.0923292346269742, 8)
self.assertAlmostEqual(exc, -3.9899423803106466, 8)
self.assertAlmostEqual(lib.fp(vmat[0]),
-2348.9577179701278 - 60.733087913116719j, 7)
self.assertAlmostEqual(lib.fp(vmat[1]),
-2353.0350086740673 - 117.74811536967495j, 7)
with lib.temporary_env(pbcgto.eval_gto, EXTRA_PREC=1e-5):
ne, exc, vmat = ni.nr_rks(cell, grids, 'blyp', [dms, dms], 1, kpts)
self.assertAlmostEqual(ne[1], 6.0923292346269742, 8)
self.assertAlmostEqual(exc[1], -3.9899423803106466, 8)
self.assertAlmostEqual(lib.fp(vmat[1][0]),
-2348.9577179701278 - 60.733087913116719j, 7)
self.assertAlmostEqual(lib.fp(vmat[1][1]),
-2353.0350086740673 - 117.74811536967495j, 7)
def __init__(self, cell, kpts=numpy.zeros((1, 3))):
from pyscf.pbc.dft import gen_grid
from pyscf.pbc.dft import numint
self.cell = cell
self.stdout = cell.stdout
self.verbose = cell.verbose
self.max_memory = cell.max_memory
self.low_dim_ft_type = cell.low_dim_ft_type
self.kpts = kpts
self.grids = gen_grid.UniformGrids(cell)
# to mimic molecular DF object
self.blockdim = getattr(__config__, 'pbc_df_df_DF_blockdim', 240)
# Not input options
self.exxdiv = None # to mimic KRHF/KUHF object in function get_coulG
self._numint = numint.KNumInt()
self._keys = set(self.__dict__.keys())
def __init__(self, cell, kpts=numpy.zeros((1, 3))):
from pyscf.pbc.dft import gen_grid
from pyscf.pbc.dft import numint
self.cell = cell
self.stdout = cell.stdout
self.verbose = cell.verbose
self.max_memory = cell.max_memory
self.kpts = kpts
self.grids = gen_grid.UniformGrids(cell)
# to mimic molecular DF object
self.blockdim = getattr(__config__, 'pbc_df_df_DF_blockdim', 240)
# The following attributes are not input options.
# self.exxdiv has no effects. It was set in the get_k_kpts function to
# mimic the KRHF/KUHF object in the call to tools.get_coulG.
self.exxdiv = None
self._numint = numint.KNumInt()
self._keys = set(self.__dict__.keys())
def test_pbc_cgto_eval_dm(pbc_h1):
torch.manual_seed(123)
h_dqc, df_scf = pbc_h1
nkpts = h_dqc.kpts.shape[0]
nao = h_dqc.nao
# generate random hermitian density matrix
dm = torch.rand((nkpts, nao, nao), dtype=cdtype)
dm = dm + dm.conj().transpose(-2, -1)
npts = 100
xcoords = torch.linspace(-3, 3, npts)[:,None].to(dtype)
ycoords = torch.zeros(npts)[:,None].to(dtype)
zcoords = torch.zeros(npts)[:,None].to(dtype)
xyz = torch.cat((xcoords, ycoords, zcoords), dim=-1)
# xyz = torch.rand((10, 3), dtype=dtype)
dens = h_dqc.aodm2dens(dm, xyz)
assert dens.dtype == dtype
kpts_np = h_dqc.kpts.numpy()
knumint = pbc_numint.KNumInt(kpts=kpts_np)
cell = df_scf.cell
ao = knumint.eval_ao(cell, xyz.numpy(), kpts=kpts_np)
dens_scf = knumint.eval_rho(cell, ao, dm.numpy())
dens_scf = torch.as_tensor(dens_scf, dtype=dens.dtype)
# print("dens pyscf:")
# print(dens_scf)
# print("dens dqc:")
# print(dens)
# print(dens / dens_scf)
#
# import matplotlib.pyplot as plt
# plt.plot(xcoords.view(-1), dens)
# plt.plot(xcoords.view(-1), dens_scf)
# plt.show()
assert torch.allclose(dens, dens_scf)
