def test_analyze(self):
f = td_hf.oscillator_strength(gauge='length')
self.assertAlmostEqual(lib.fp(f), 0.16147450863004867, 7)
f = td_hf.oscillator_strength(gauge='velocity', order=2)
self.assertAlmostEqual(lib.fp(f), 0.19750347627735745, 6)
note_args = []
def temp_logger_note(rec, msg, *args):
note_args.append(args)
with lib.temporary_env(lib.logger.Logger, note=temp_logger_note):
td_hf.analyze()
ref = [(),
(1, 2.057393343331977, 602.6275818634069, 0.1605980834206071),
(2, 2.280659766638949, 543.6330282886508, 0.0016221163442707552),
(3, 6.37244518162562, 194.5629880048233, 9.923201744400984e-31)]
self.assertAlmostEqual(abs(numpy.hstack(ref) -
numpy.hstack(note_args)).max(), 0, 7)
def test_get_eri_1111_1(self):
eri1111 = kmdf1.get_eri((kpts[1],kpts[1],kpts[1],kpts[1]))
self.assertTrue(eri1111.dtype == numpy.complex128)
self.assertAlmostEqual(eri1111.real.sum(), 44.106518037762719, 6)
self.assertAlmostEqual(abs(eri1111.imag).sum(), 11.560980263508144, 5)
self.assertAlmostEqual(lib.fp(eri1111),
(5.8655421128841088+0.034457178081070433j), 6)
check2 = kmdf1.get_eri((kpts[1]+5e-9,kpts[1]+5e-9,kpts[1],kpts[1]))
self.assertTrue(numpy.allclose(eri1111, check2, atol=1e-7))
def test_optimize(self):
conv_params = {
'convergence_grms': 1e-5,
'convergence_gmax': 1e-5,
}
mol1 = scf.RHF(mol).Gradients().optimizer(solver='geometric').kernel(
params=conv_params)
self.assertAlmostEqual(lib.fp(mol1.atom_coords()), 2.19943732625887, 3)
self.assertEqual(mol1.symmetry, 'C2v')
def test_init_guess_chk(self):
dm = mol.GHF(
chkfile=tempfile.NamedTemporaryFile().name).get_init_guess(
mol, key='chkfile')
self.assertEqual(dm.shape, (48, 48))
self.assertAlmostEqual(lib.fp(dm), 1.8117584283411752, 9)
dm = mf.get_init_guess(mol, key='chkfile')
self.assertEqual(dm.shape, (48, 48))
self.assertAlmostEqual(lib.fp(dm), 1.3594274771226789, 9)
dm = scf.ghf.init_guess_by_chkfile(mol1, mf_r.chkfile, project=True)
self.assertEqual(dm.shape, (26, 26))
self.assertAlmostEqual(lib.fp(dm), -3.742519160521582, 9)
dm = scf.ghf.init_guess_by_chkfile(mol1, mf_u.chkfile)
self.assertEqual(dm.shape, (26, 26))
self.assertAlmostEqual(lib.fp(dm), -3.742519160521582, 9)
def test_get_veff(self):
mf = pscf.RHF(cell)
numpy.random.seed(1)
nao = cell.nao_nr()
dm = numpy.random.random((nao, nao)) + numpy.random.random(
(nao, nao)) * 1j
dm = dm + dm.conj().T
v11 = mf.get_veff(cell, dm, kpt=cell.get_abs_kpts([.25, .25, .25]))
v12 = mf.get_veff(cell,
dm,
kpts_band=cell.get_abs_kpts([.25, .25, .25]))
v13 = mf.get_veff(cell,
dm,
kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
kpts_band=cell.get_abs_kpts([.25, .25, .25]))
v14 = mf.get_veff(cell,
dm,
kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
kpts_band=cell.make_kpts([2, 1, 1]))
self.assertTrue(v11.dtype == numpy.complex128)
self.assertTrue(v12.dtype == numpy.complex128)
mf = pscf.UHF(cell)
v21 = mf.get_veff(cell, dm, kpt=cell.get_abs_kpts([.25, .25, .25]))
dm = [dm * .5, dm * .5]
v22 = mf.get_veff(cell,
dm,
kpts_band=cell.get_abs_kpts([.25, .25, .25]))
v23 = mf.get_veff(cell,
dm,
kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
kpts_band=cell.get_abs_kpts([.25, .25, .25]))
v24 = mf.get_veff(cell,
dm,
kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
kpts_band=cell.make_kpts([2, 1, 1]))
self.assertAlmostEqual(abs(v11 - v21).max(), 0, 9)
self.assertAlmostEqual(abs(v12 - v22).max(), 0, 9)
self.assertAlmostEqual(abs(v13 - v23).max(), 0, 9)
self.assertAlmostEqual(abs(v14 - v24).max(), 0, 9)
self.assertAlmostEqual(lib.fp(v11),
-0.30110964334164825 + 0.81409418199767414j, 9)
self.assertAlmostEqual(lib.fp(v12),
-2.1601376488983997 - 9.4070613374115908j, 9)
def test_olvp(self):
cell = make_cell1(4, 41)
s0 = get_ovlp(cell)
s1 = scfint.get_ovlp(cell)
self.assertAlmostEqual(numpy.linalg.norm(s0 - s1), 0, 8)
self.assertAlmostEqual(lib.fp(s1), 1.3229918679678208, 10)
s0 = get_ovlp(cell, kpt=k)
s1 = scfint.get_ovlp(cell, kpt=k)
self.assertAlmostEqual(numpy.linalg.norm(s0 - s1), 0, 8)
def test_tda_m06l(self):
td = mf_m06l.TDA()
es = td.kernel(nstates=5)[0] * 27.2114
self.assertAlmostEqual(lib.fp(es), -20.70191947889884, 6)
ref = [
2.74346804, 3.10082138, 6.87321246, 12.8332282, 14.30085068,
14.61913328
]
self.assertAlmostEqual(abs(es[:4] - ref[:4]).max(), 0, 6)
self.assertAlmostEqual(abs(es[4] - ref[5]), 0, 6)
def test_hcore(self):
h1ref = pbchf.get_hcore(cell)
h1 = pbchf.RHF(cell).get_hcore()
self.assertAlmostEqual(abs(h1 - h1ref).max(), 0, 9)
self.assertAlmostEqual(lib.fp(h1), 0.14116483012673137, 9)
cell1 = cell.copy()
cell1.ecp = {'He': (2, ((-1, (((7.2, .3), ), )), ))}
cell1.build(0, 0)
kpt = numpy.ones(3) * .5
h1ref = pbchf.get_hcore(cell1, kpt)
h1 = pbchf.RHF(cell1).get_hcore(kpt=kpt)
self.assertAlmostEqual(abs(h1 - h1ref).max(), 0, 9)
self.assertAlmostEqual(lib.fp(h1),
-2.708431894877279 - 0.395390980665125j, 9)
h1 = pscf.KRHF(cell1).get_hcore(kpts=[kpt])
self.assertEqual(h1.ndim, 3)
self.assertAlmostEqual(abs(h1[0] - h1ref).max(), 0, 9)
def test_complex_dm(self):
mf = dft.RKS(h2o)
mf.xc = 'b3lyp'
nao = h2o.nao
numpy.random.seed(1)
dm = (numpy.random.random((nao,nao)) +
numpy.random.random((nao,nao))*1j)
dm = dm + dm.conj().T
v = mf.get_veff(h2o, dm)
self.assertAlmostEqual(lib.fp(v), 30.543789621782576-0.23207622637751305j, 9)
def test_rotate_mo(self):
numpy.random.seed(4)
def occarray(nmo, nocc):
occ = numpy.zeros(nmo)
occ[:nocc] = 2
return occ
mo_coeff = [
numpy.random.random((8, 8)),
numpy.random.random((8, 7)),
numpy.random.random((8, 8))
]
mo_occ = [occarray(8, 3), occarray(7, 3), occarray(8, 2)]
dx = numpy.random.random(15 + 12 + 12)
mo1 = stability._rotate_mo(mo_coeff, mo_occ, dx)
self.assertAlmostEqual(lib.fp(mo1[0]), 1.1090134286653903, 12)
self.assertAlmostEqual(lib.fp(mo1[1]), 1.0665953580532537, 12)
self.assertAlmostEqual(lib.fp(mo1[2]), -5.008202013953201, 12)
def test_tda_m06l(self):
mf = dft.UKS(mol1)
mf.xc = 'm06l'
mf.grids.prune = None
mf.scf()
td = mf.TDA()
es = td.kernel(nstates=5)[0] * 27.2114
self.assertAlmostEqual(lib.fp(es), -8.943196581335487, 6)
ref = [8.18683464, 8.77581263, 10.20108589, 10.55440239, 10.98105145]
self.assertAlmostEqual(abs(es - ref).max(), 0, 6)
def test_aft_get_ao_eri_high_cost(self):
df0 = fft.FFTDF(cell)
df = aft.AFTDF(cell)
eri0 = df0.get_ao_eri(compact=True)
eri1 = df.get_ao_eri(compact=True)
self.assertTrue(np.allclose(eri0, eri1, atol=1e-5, rtol=1e-5))
self.assertAlmostEqual(lib.fp(eri1), 0.80425361966560172, 8)
eri0 = df0.get_ao_eri(kpts[0])
eri1 = df.get_ao_eri(kpts[0])
self.assertTrue(np.allclose(eri0, eri1, atol=1e-5, rtol=1e-5))
self.assertAlmostEqual(lib.fp(eri1),
(2.9346374476387949 - 0.20479054936779137j), 8)
eri0 = df0.get_ao_eri(kpts)
eri1 = df.get_ao_eri(kpts)
self.assertTrue(np.allclose(eri0, eri1, atol=1e-5, rtol=1e-5))
self.assertAlmostEqual(lib.fp(eri1),
(0.33709287302019619 - 0.94185725020966538j), 8)
def test_tda_lda_xcfun(self):
mf = dft.RKS(mol)
mf.xc = 'lda,vwn'
mf.grids.prune = None
mf._numint.libxc = dft.xcfun
mf.scf()
td = rks.TDA(mf)
es = td.kernel(nstates=5)[0] * 27.2114
dft.numint.NumInt.libxc = dft.libxc
self.assertAlmostEqual(lib.fp(es), -41.201828219760415, 6)
def test_get_eri_0110(self):
eri0110 = kmdf.get_eri((kpts[0], kpts[1], kpts[1], kpts[0]))
self.assertTrue(eri0110.dtype == numpy.complex128)
self.assertAlmostEqual(eri0110.real.sum(), 83.10554333963026, 7)
self.assertAlmostEqual(abs(eri0110.imag).sum(), 5.018709716490495, 7)
self.assertAlmostEqual(lib.fp(eri0110),
0.9492917585299039 - 0.32856082029420147j, 7)
check2 = kmdf.get_eri(
(kpts[0] + 5e-8, kpts[1] + 5e-8, kpts[1], kpts[0]))
self.assertTrue(numpy.allclose(eri0110, check2, atol=1e-7))
def test_tda_m06l_singlet(self):
mf = dft.RKS(mol)
mf.xc = 'm06l'
mf.grids.prune = None
mf.scf()
td = mf.TDA()
es = td.kernel(nstates=5)[0] * 27.2114
self.assertAlmostEqual(lib.fp(es), -42.506737955524784, 6)
ref = [10.82697357, 10.82697357, 16.73026277]
self.assertAlmostEqual(abs(es[:3] - ref).max(), 0, 6)
def test_get_eri_0110_high_cost(self):
eri0110 = kmdf.get_eri((kpts[0], kpts[1], kpts[1], kpts[0]))
self.assertTrue(eri0110.dtype == numpy.complex128)
self.assertAlmostEqual(eri0110.real.sum(), 411.86033298299179, 6)
self.assertAlmostEqual(abs(eri0110.imag).sum(), 136.58633427242452, 6)
self.assertAlmostEqual(lib.fp(eri0110),
1.3767132918850329 + 0.12378724026874122j, 6)
check2 = kmdf.get_eri(
(kpts[0] + 5e-9, kpts[1] + 5e-9, kpts[1], kpts[0]))
self.assertTrue(numpy.allclose(eri0110, check2, atol=1e-7))
def test_get_eri_0110_1(self):
eri0110 = kmdf1.get_eri((kpts[0], kpts[1], kpts[1], kpts[0]))
self.assertTrue(eri0110.dtype == numpy.complex128)
self.assertAlmostEqual(eri0110.real.sum(), 89.922543439119721, 6)
self.assertAlmostEqual(abs(eri0110.imag).sum(), 67.573338930409079, 6)
self.assertAlmostEqual(lib.fp(eri0110),
(7.3778033770176341 - 4.0951535119430975j), 6)
check2 = kmdf1.get_eri(
(kpts[0] + 5e-9, kpts[1] + 5e-9, kpts[1], kpts[0]))
self.assertTrue(numpy.allclose(eri0110, check2, atol=1e-7))
def test_get_eri_0110(self):
eri0110 = kmdf.get_eri((kpts[0], kpts[1], kpts[1], kpts[0]))
self.assertTrue(eri0110.dtype == numpy.complex128)
self.assertAlmostEqual(eri0110.real.sum(), 83.11379784456005, 9)
self.assertAlmostEqual(abs(eri0110.imag).sum(), 5.083432749354445, 9)
self.assertAlmostEqual(lib.fp(eri0110),
0.9700096733262158 - 0.3318635561567801j, 9)
check2 = kmdf.get_eri(
(kpts[0] + 5e-8, kpts[1] + 5e-8, kpts[1], kpts[0]))
self.assertTrue(numpy.allclose(eri0110, check2, atol=1e-7))
def test_get_eri_1111_high_cost(self):
eri1111 = kmdf.get_eri((kpts[1], kpts[1], kpts[1], kpts[1]))
self.assertTrue(eri1111.dtype == numpy.complex128)
self.assertAlmostEqual(eri1111.real.sum(), 258.81872464108312, 6)
self.assertAlmostEqual(abs(eri1111.imag).sum(), 16.275864968641145, 6)
self.assertAlmostEqual(lib.fp(eri1111),
2.2339104732873363 + 0.10954687420327755j, 7)
check2 = kmdf.get_eri(
(kpts[1] + 5e-9, kpts[1] + 5e-9, kpts[1], kpts[1]))
self.assertTrue(numpy.allclose(eri1111, check2, atol=1e-7))
def test_ipsp_spinor(self):
ao = eval_gto(mol, 'GTOval_ipsp_spinor', coords, comp=3)
self.assertAlmostEqual(lib.fp(ao), -159.94403505490939+400.80148912086418j, 9)
numpy.random.seed(1)
rs = numpy.random.random((213,3))
rs = (rs-.5)**2 * 30
ao1 = eval_gto(mol1, 'GTOval_ip_spinor', rs, comp=3, shls_slice=(0,mol1.nbas//2))
ao2 = eval_gto(mol1, 'GTOval_ipsp_spinor', rs, comp=3, shls_slice=(mol1.nbas//2,mol1.nbas))
self.assertAlmostEqual(abs(ao1-ao2*1j).sum(), 0, 9)
def test_sp_spinor(self):
ao = eval_gto(mol, 'GTOval_sp_spinor', coords)
self.assertAlmostEqual(lib.fp(ao), 26.212937567473656-68.970076521029782j, 9)
numpy.random.seed(1)
rs = numpy.random.random((213,3))
rs = (rs-.5)**2 * 30
ao1 = eval_gto(mol1, 'GTOval_spinor', rs, shls_slice=(0,mol1.nbas//2))
ao2 = eval_gto(mol1, 'GTOval_sp_spinor', rs, shls_slice=(mol1.nbas//2,mol1.nbas))
self.assertAlmostEqual(abs(ao1-ao2*1j).sum(), 0, 9)
def test_nto(self):
mf = scf.RHF(mol).run()
td = rks.TDA(mf).run()
w, nto = td.get_nto(state=3)
self.assertAlmostEqual(w[0], 0.98655300613468389, 9)
self.assertAlmostEqual(lib.fp(w), 0.98625701534112464, 9)
w, nto = td.get_nto(state=0)
self.assertAlmostEqual(w[0], 0.99997335352278072, 9)
self.assertAlmostEqual(lib.fp(w), 0.99998775067586554, 9)
pmol = copy.copy(mol)
pmol.symmetry = True
pmol.build(0, 0)
mf = scf.RHF(pmol).run()
td = rks.TDA(mf).run(nstates=3)
w, nto = td.get_nto(state=-1)
self.assertAlmostEqual(w[0], 0.98655300613468389, 9)
self.assertAlmostEqual(lib.fp(w), 0.98625701534112464, 9)
def test_optimize(self):
conv_params = {
'gradientmax': 0.1e-3,
'gradientrms': 0.1e-3,
}
mf = scf.RHF(mol)
mol_eq = mf.Gradients().optimizer(solver='berny').kernel(
params=conv_params)
self.assertAlmostEqual(lib.fp(mol_eq.atom_coords()), 2.19943732625887,
4)
def test_check_mp2_high_cost(self):
mol = gto.Mole()
mol.atom = [
['C', (0.0, 0.0, 0.0)],
['O', (0.0, r_CO, 0.0)],
['H', (0.0, -x, y)],
['H', (0.0, -x, -y)],
]
mol.basis = {
'H': 'aug-cc-pVQZ',
'C': 'aug-cc-pVQZ',
'O': 'aug-cc-pVQZ',
}
mol.verbose = 7
mol.output = '/dev/null'
mol.build()
mf = scf.RHF(mol)
mf.conv_tol = 1e-12
mf.kernel()
# Ensure phase
mf.mo_coeff[:, mf.mo_coeff.sum(axis=0) < 0] *= -1
mp2 = mp.MP2(mf)
e_mp2 = mp2.kernel()[0]
myadc = adc.ADC(mf)
myadc.max_memory = 20
e_adc_mp2, t_amp1, t_amp2 = myadc.kernel_gs()
diff_mp2 = e_adc_mp2 - e_mp2
self.assertAlmostEqual(diff_mp2, 0.0000000000000, 6)
t_amp1_n = numpy.linalg.norm(t_amp1[0])
t_amp2_n = numpy.linalg.norm(t_amp2[0])
self.assertAlmostEqual(t_amp1_n, 0.0456504320024, 6)
self.assertAlmostEqual(t_amp2_n, 0.2977897530749, 6)
self.assertAlmostEqual(lib.fp(t_amp1[0]), -0.008983054536, 6)
self.assertAlmostEqual(lib.fp(t_amp2[0]), -0.639727653133, 6)
def test_get_jk_kpts(self):
df = fft.FFTDF(cell)
dm = mf0.get_init_guess()
nkpts = len(kpts)
dms = [dm] * nkpts
vj0, vk0 = get_jk_kpts(mf0, cell, dms, kpts=kpts)
vj1, vk1 = df.get_jk(dms, kpts=kpts, exxdiv=None)
self.assertTrue(vj1.dtype == numpy.complex128)
self.assertTrue(vk1.dtype == numpy.complex128)
self.assertTrue(np.allclose(vj0, vj1, atol=1e-9, rtol=1e-9))
self.assertTrue(np.allclose(vk0, vk1, atol=1e-9, rtol=1e-9))
ej1 = numpy.einsum('xij,xji->', vj1, dms) / len(kpts)
ek1 = numpy.einsum('xij,xji->', vk1, dms) / len(kpts)
self.assertAlmostEqual(ej1,
2.3163352969873445 * (6 / 6.82991739766009)**2,
9)
self.assertAlmostEqual(ek1,
7.7311228144548600 * (6 / 6.82991739766009)**2,
9)
numpy.random.seed(1)
kpts_band = numpy.random.random((2, 3))
vj1, vk1 = df.get_jk(dms, kpts=kpts, kpts_band=kpts_band, exxdiv=None)
self.assertAlmostEqual(
lib.fp(vj1),
6 / 6.82991739766009 * (3.437188138446714 + 0.1360466492092307j),
9)
self.assertAlmostEqual(
lib.fp(vk1),
6 / 6.82991739766009 * (7.479986541097368 + 1.1980593415201204j),
9)
nao = dm.shape[0]
mo_coeff = numpy.random.random((nkpts, nao, nao))
mo_occ = numpy.array(numpy.random.random((nkpts, nao)) > .6,
dtype=numpy.double)
dms = numpy.einsum('kpi,ki,kqi->kpq', mo_coeff, mo_occ, mo_coeff)
dms = lib.tag_array(lib.asarray(dms), mo_coeff=mo_coeff, mo_occ=mo_occ)
vk1 = df.get_jk(dms, kpts=kpts, kpts_band=kpts_band, exxdiv=None)[1]
self.assertAlmostEqual(lib.fp(vk1),
10.239828255099447 + 2.1190549216896182j, 9)
def test_get_vk_lr(self):
numpy.random.seed(1)
nao = mol.nao
dm = numpy.random.random((nao, nao))
vk1 = mf.get_k(mol, dm, hermi=0, omega=1.5)
mf1 = scf.RHF(mol)
mf1.max_memory = 0
vk2 = mf1.get_k(mol, dm, hermi=0, omega=1.5)
self.assertAlmostEqual(abs(vk1 - vk2).max(), 0, 12)
self.assertAlmostEqual(lib.fp(vk1), -11.399103957754445, 12)
def test_get_vj_lr(self):
numpy.random.seed(1)
nao = mol.nao
dm = numpy.random.random((nao, nao))
vj1 = mf.get_j(mol, dm, omega=1.5)
mf1 = scf.RHF(mol)
mf1.max_memory = 0
vj2 = mf1.get_j(mol, dm, omega=1.5)
self.assertAlmostEqual(abs(vj1 - vj2).max(), 0, 12)
self.assertAlmostEqual(lib.fp(vj1), -10.015956161068031, 12)
def test_get_vk_direct_scf(self):
numpy.random.seed(1)
nao = mol.nao
dm = numpy.random.random((nao, nao))
vk1 = mf.get_k(mol, dm, hermi=0)
mf1 = scf.RHF(mol)
mf1.max_memory = 0
vk2 = mf1.get_k(mol, dm, hermi=0)
self.assertAlmostEqual(abs(vk1 - vk2).max(), 0, 12)
self.assertAlmostEqual(lib.fp(vk1), -12.365527167710301, 12)
def test_make_mask(self):
grid = gen_grid.Grids(h2o)
grid.atom_grid = {
"H": (10, 110),
"O": (10, 110),
}
grid.build()
coords = grid.coords * 10.
non0 = gen_grid.make_mask(h2o, coords)
self.assertEqual(non0.sum(), 122)
self.assertAlmostEqual(lib.fp(non0), 0.554275491306796, 9)
def test_nr_uks_vv10(self):
method = dft.UKS(h2o)
dm = method.get_init_guess()
dm = (dm[0], dm[0])
method.xc = 'wB97M_V'
method.nlc = 'vv10'
method.grids.prune = None
method.grids.atom_grid = {"H": (30, 86), "O": (30, 86),}
method.nlcgrids.prune = None
method.nlcgrids.atom_grid = {"H": (20, 50), "O": (20, 50),}
method.dump_flags()
vxc = method.get_veff(h2o, dm)
self.assertAlmostEqual(lib.fp(vxc[0]), 22.767504283729778, 8)
self.assertAlmostEqual(lib.fp(vxc[1]), 22.767504283729778, 8)
method._eri = None
method.max_memory = 0
vxc = method.get_veff(h2o, dm)
self.assertAlmostEqual(lib.fp(vxc[0]), 22.767504283729778, 8)
self.assertAlmostEqual(lib.fp(vxc[1]), 22.767504283729778, 8)
