def test_eval_ao(self):
cell = pbcgto.Cell()
cell.verbose = 5
cell.output = '/dev/null'
cell.a = np.eye(3) * 2.5
cell.mesh = [21]*3
cell.atom = [['C', (1., .8, 1.9)],
['C', (.1, .2, .3)],]
cell.basis = 'ccpvdz'
cell.build(False, False)
grids = gen_grid.UniformGrids(cell)
grids.build()
ni = numint.NumInt()
ao10 = eval_ao(cell, grids.coords, deriv=1)
ao0 = ao10[0]
ao1 = ni.eval_ao(cell, grids.coords)
self.assertTrue(numpy.allclose(ao0, ao1, atol=1e-9, rtol=1e-9))
self.assertAlmostEqual(finger(ao1), -0.54069672246407219, 8)
ao11 = ni.eval_ao(cell, grids.coords, deriv=1)
self.assertTrue(numpy.allclose(ao10, ao11, atol=1e-9, rtol=1e-9))
self.assertAlmostEqual(finger(ao11), 8.8004405892746433, 8)
ni.non0tab = ni.make_mask(cell, grids.coords)
ao1 = ni.eval_ao(cell, grids.coords)
self.assertTrue(numpy.allclose(ao0, ao1, atol=1e-9, rtol=1e-9))
self.assertAlmostEqual(finger(ao1), -0.54069672246407219, 8)
ao11 = ni.eval_ao(cell, grids.coords, deriv=1)
self.assertTrue(numpy.allclose(ao10, ao11, atol=1e-9, rtol=1e-9))
self.assertAlmostEqual(finger(ao11), 8.8004405892746433, 8)
ao11 = ni.eval_ao(cell, grids.coords, deriv=1, shls_slice=(3,7))
self.assertTrue(numpy.allclose(ao10[:,:,6:17], ao11, atol=1e-9, rtol=1e-9))
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, kpt=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, 'ndim', None) != 2: # UHF
dm = dm[0] + dm[1]
if grids is None:
grids = gen_grid.UniformGrids(mf.cell)
if kpt is None:
kpt = mf.kpt
ni = numint.NumInt()
return ni.get_rho(mf.cell, dm, grids, kpt, 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 test_1d_rho(self):
cell = pbcgto.Cell()
cell.a = '5 0 0; 0 1 0; 0 0 1'
cell.unit = 'B'
cell.atom = 'He 1. 0. 1.'
cell.basis = {'He': '321g'}
cell.dimension = 1
cell.verbose = 0
cell.mesh = [10, 30, 30]
cell.build()
grids = gen_grid.UniformGrids(cell)
grids.build()
numpy.random.seed(10)
nao = cell.nao_nr()
dm = numpy.random.random((nao, nao))
dm = dm + dm.T
ni = numint.NumInt()
rho = numint.get_rho(ni, cell, dm, grids)
self.assertAlmostEqual(lib.finger(rho), 1.1624587519868457, 9)
def test_2d_rho(self):
cell = pbcgto.Cell()
cell.a = '5 0 0; 0 5 0; 0 0 1'
cell.unit = 'B'
cell.atom = 'He 1. 0. 1.'
cell.basis = {'He': '321g'}
cell.dimension = 2
cell.low_dim_ft_type = 'inf_vacuum'
cell.verbose = 0
cell.mesh = [10,10,30]
cell.build()
grids = gen_grid.UniformGrids(cell)
grids.build()
numpy.random.seed(10)
nao = cell.nao_nr()
dm = numpy.random.random((nao,nao))
dm = dm + dm.T
ni = numint.NumInt()
rho = numint.get_rho(ni, cell, dm, grids)
self.assertAlmostEqual(lib.finger(rho), 7.2089907050590334, 9)
def test_eval_ao_kpt(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)
kpt = np.random.random(3)
ni = numint.NumInt()
ao0 = eval_ao(cell, grids.coords, kpt)
ao1 = ni.eval_ao(cell, grids.coords, kpt)
self.assertTrue(numpy.allclose(ao0, ao1, atol=1e-9, rtol=1e-9))
self.assertAlmostEqual(finger(ao1), (-2.4066959390326477-0.98044994099240701j), 8)
def dip_moment(cell,
dm,
unit='Debye',
verbose=logger.NOTE,
grids=None,
rho=None,
kpt=np.zeros(3),
origin=None):
''' Dipole moment in the unit cell (is it well defined)?
Args:
cell : an instance of :class:`Cell`
dm (ndarray) : density matrix
Return:
A list: the dipole moment on x, y and z components
'''
from pyscf.pbc import tools
from pyscf.pbc.dft import gen_grid
from pyscf.pbc.dft import numint
if cell.dimension != 3:
# raise NotImplementedError
logger.warn(
cell, 'Dipole moment for low-dimension system is not supported.')
return np.zeros(3)
log = logger.new_logger(cell, verbose)
a = cell.lattice_vectors()
b = np.linalg.inv(a).T
if grids is None:
grids = gen_grid.UniformGrids(cell)
#? FIXME: Less requirements on the density accuracy.
#ke_cutoff = gto.estimate_ke_cutoff(cell, 1e-5)
#grids.mesh = tools.cutoff_to_mesh(a, ke_cutoff)
if rho is None:
rho = numint.NumInt().get_rho(cell, dm, grids, kpt, cell.max_memory)
if origin is None:
origin = _search_dipole_gauge_origin(cell, grids, rho, log)
# Move the unit cell to the position around the origin.
def shift_grids(r):
r_frac = lib.dot(r - origin, b.T)
# Grids on the boundary (r_frac == +/-0.5) of the new cell may lead to
# unbalanced contributions to the dipole moment. Exclude them from the
# dipole and quadrupole
r_frac[r_frac == 0.5] = 0
r_frac[r_frac == -0.5] = 0
r_frac[r_frac > 0.5] -= 1
r_frac[r_frac < -0.5] += 1
r = lib.dot(r_frac, a)
return r
r = shift_grids(grids.coords)
e_dip = np.einsum('g,g,gx->x', rho, grids.weights, r)
charges = cell.atom_charges()
r = shift_grids(cell.atom_coords())
nuc_dip = np.einsum('g,gx->x', charges, r)
dip = nuc_dip - e_dip
if unit.upper() == 'DEBYE':
dip *= nist.AU2DEBYE
log.note('Dipole moment(X, Y, Z, Debye): %8.5f, %8.5f, %8.5f', *dip)
else:
log.note('Dipole moment(X, Y, Z, A.U.): %8.5f, %8.5f, %8.5f', *dip)
return dip
