def test_rand_ccsd_frozen1(self):
'''Single (eom-)ccsd iteration with random t1/t2 and single frozen occupied
orbital.'''
kmf = pbcscf.addons.convert_to_ghf(rand_kmf)
# Round to make this insensitive to small changes between PySCF versions
mat_veff = kmf.get_veff().round(4)
mat_hcore = kmf.get_hcore().round(4)
kmf.get_veff = lambda *x: mat_veff
kmf.get_hcore = lambda *x: mat_hcore
frozen = [[0,],[],[]]
rand_cc = pbcc.KGCCSD(kmf, frozen=frozen)
eris = rand_cc.ao2mo(rand_cc.mo_coeff)
eris.mo_energy = [eris.fock[k].diagonal() for k in range(rand_cc.nkpts)]
t1, t2 = rand_t1_t2(kmf, rand_cc)
# Manually zero'ing out the frozen elements of the t1/t2
# N.B. the 0'th element frozen means we are freezing the 1'th
# element in the current padding scheme
t1[0, 1] = 0.0
t2[0, :, :, 1, :] = 0.0
t2[:, 0, :, :, 1] = 0.0
Ht1, Ht2 = rand_cc.update_amps(t1, t2, eris)
self.assertAlmostEqual(finger(Ht1), (-15.7950827762+31.0483053388j), 6)
self.assertAlmostEqual(finger(Ht2), (263.884192539+96.7615664563j), 6)
def test_init_guess_minao(self):
mol = gto.M(
verbose = 7,
output = '/dev/null',
atom = '''
O 0 0 0
H1 0 -0.757 0.587
H2 0 0.757 0.587''',
basis = 'ccpvdz',
)
dm = scf.hf.get_init_guess(mol, key='minao')
self.assertAlmostEqual(lib.finger(dm), 2.5912875957299684, 9)
mol1 = gto.M(atom='Mo', basis='lanl2dz', ecp='lanl2dz',
verbose=7, output='/dev/null')
dm = scf.hf.get_init_guess(mol1, key='minao')
self.assertAlmostEqual(lib.finger(dm), 1.5371195992125495, 9)
self.assertAlmostEqual(numpy.einsum('ij,ji->', dm, mol1.intor('int1e_ovlp')), 14, 9)
mol1.basis = 'sto3g'
mol1.build(0, 0)
dm = scf.hf.get_init_guess(mol1, key='minao')
self.assertAlmostEqual(lib.finger(dm), 1.8936729909734513, 9)
self.assertAlmostEqual(numpy.einsum('ij,ji->', dm, mol1.intor('int1e_ovlp')), 13.4787347477, 7)
mol1.stdout.close()
def test_rand_ccsd_frozen2(self):
'''Single (eom-)ccsd iteration with random t1/t2 and full occupied frozen
at a single k-point.'''
kmf = pbcscf.addons.convert_to_ghf(rand_kmf)
# Round to make this insensitive to small changes between PySCF versions
mat_veff = kmf.get_veff().round(4)
mat_hcore = kmf.get_hcore().round(4)
kmf.get_veff = lambda *x: mat_veff
kmf.get_hcore = lambda *x: mat_hcore
frozen = [[],[0,1,2,3],[]]
rand_cc = pbcc.KGCCSD(kmf, frozen=frozen)
eris = rand_cc.ao2mo(rand_cc.mo_coeff)
eris.mo_energy = [eris.fock[k].diagonal() for k in range(rand_cc.nkpts)]
t1, t2 = rand_t1_t2(kmf, rand_cc)
# Manually zero'ing out the frozen elements of the t1/t2
# N.B. the 0'th element frozen means we are freezing the 1'th
# element in the current padding scheme
t1[1, [0,1,2,3]] = 0.0
t2[1, :, :, [0,1,2,3], :] = 0.0
t2[:, 1, :, :, [0,1,2,3]] = 0.0
Ht1, Ht2 = rand_cc.update_amps(t1, t2, eris)
self.assertAlmostEqual(finger(Ht1), (-19.2772171332-10.5977304455j), 6)
self.assertAlmostEqual(finger(Ht2), (227.434582141+298.826965082j), 6)
def test_rand_ccsd_frozen3(self):
'''Single (eom-)ccsd iteration with random t1/t2 and single frozen virtual
orbital.'''
kconserv = kpts_helper.get_kconserv(rand_kmf.cell, rand_kmf.kpts)
kmf = pbcscf.addons.convert_to_ghf(rand_kmf)
# Round to make this insensitive to small changes between PySCF versions
mat_veff = kmf.get_veff().round(4)
mat_hcore = kmf.get_hcore().round(4)
kmf.get_veff = lambda *x: mat_veff
kmf.get_hcore = lambda *x: mat_hcore
frozen = [[],[],[5]] # freezing one virtual
rand_cc = pbcc.KGCCSD(kmf, frozen=frozen)
eris = rand_cc.ao2mo(rand_cc.mo_coeff)
eris.mo_energy = [eris.fock[k].diagonal() for k in range(rand_cc.nkpts)]
t1, t2 = rand_t1_t2(kmf, rand_cc)
# Manually zero'ing out the frozen elements of the t1/t2
t1[2, :, 0] = 0.0
for ki in range(rand_cc.nkpts):
for kj in range(rand_cc.nkpts):
for ka in range(rand_cc.nkpts):
kb = kconserv[ki, ka, kj]
if ka == 2:
t2[ki, kj, ka, :, :, 0] = 0.0
if kb == 2:
t2[ki, kj, ka, :, :, :, 0] = 0.0
Ht1, Ht2 = rand_cc.update_amps(t1, t2, eris)
self.assertAlmostEqual(finger(Ht1), (-19.6637196882-16.2773841431j), 6)
self.assertAlmostEqual(finger(Ht2), (881.655146297+1283.71020059j), 6)
def test_eris_contract_vvvv_t2(self):
mol = gto.Mole()
nocca, noccb, nvira, nvirb = 5, 4, 12, 13
nvira_pair = nvira*(nvira+1)//2
nvirb_pair = nvirb*(nvirb+1)//2
numpy.random.seed(9)
t2 = numpy.random.random((nocca,noccb,nvira,nvirb))
eris = uccsd._ChemistsERIs()
eris.vvVV = numpy.random.random((nvira_pair,nvirb_pair))
eris.mol = mol
myucc.max_memory, bak = 0, myucc.max_memory
vt2 = eris._contract_vvVV_t2(myucc, t2, eris.vvVV)
myucc.max_memory = bak
self.assertAlmostEqual(lib.finger(vt2), 12.00904827896089, 11)
idxa = lib.square_mat_in_trilu_indices(nvira)
idxb = lib.square_mat_in_trilu_indices(nvirb)
vvVV = eris.vvVV[:,idxb][idxa]
ref = lib.einsum('acbd,ijcd->ijab', vvVV, t2)
self.assertAlmostEqual(abs(vt2 - ref).max(), 0, 11)
# _contract_VVVV_t2, testing complex and real mixed contraction
VVVV =(numpy.random.random((nvirb,nvirb,nvirb,nvirb)) +
numpy.random.random((nvirb,nvirb,nvirb,nvirb))*1j - (.5+.5j))
VVVV = VVVV + VVVV.transpose(1,0,3,2).conj()
VVVV = VVVV + VVVV.transpose(2,3,0,1)
eris.VVVV = VVVV
t2 = numpy.random.random((noccb,noccb,nvirb,nvirb))
t2 = t2 - t2.transpose(0,1,3,2)
t2 = t2 - t2.transpose(1,0,3,2)
myucc.max_memory, bak = 0, myucc.max_memory
vt2 = eris._contract_VVVV_t2(myucc, t2, eris.VVVV)
myucc.max_memory = bak
self.assertAlmostEqual(lib.finger(vt2), 47.903883794299404-50.501573400833429j, 11)
ref = lib.einsum('acbd,ijcd->ijab', eris.VVVV, t2)
self.assertAlmostEqual(abs(vt2 - ref).max(), 0, 11)
def test_define_xc(self):
def eval_xc(xc_code, rho, spin=0, relativity=0, deriv=1, verbose=None):
# A fictitious XC functional to demonstrate the usage
rho0, dx, dy, dz = rho[:4]
gamma = (dx**2 + dy**2 + dz**2)
exc = .01 * rho0**2 + .02 * (gamma+.001)**.5
vrho = .01 * 2 * rho0
vgamma = .02 * .5 * (gamma+.001)**(-.5)
vlapl = None
vtau = None
vxc = (vrho, vgamma, vlapl, vtau)
fxc = None # 2nd order functional derivative
kxc = None # 3rd order functional derivative
return exc, vxc, fxc, kxc
mf = dft.RKS(mol)
ni = dft.libxc.define_xc(mf._numint, eval_xc, 'GGA', hyb=0.2)
numpy.random.seed(1)
rho = numpy.random.random((4,10))
exc, vxc = ni.eval_xc(None, rho, 0, deriv=1)[:2]
self.assertAlmostEqual(lib.finger(exc), 0.0012441814416833327, 9)
self.assertAlmostEqual(lib.finger(vxc[0]), 0.0065565189784811129, 9)
self.assertAlmostEqual(lib.finger(vxc[1]), 0.0049270110162854116, 9)
mf = mf.define_xc_('0.5*B3LYP+0.5*B3LYP')
exc0, vxc0 = mf._numint.eval_xc(None, rho, 0, deriv=1)[:2]
exc1, vxc1 = dft.libxc.eval_xc('0.5*B3LYP+0.5*B3LYP', rho, 0, deriv=1)[:2]
self.assertAlmostEqual(abs(exc0-exc1).max(), 0, 9)
self.assertAlmostEqual(abs(vxc0[0]-vxc1[0]).max(), 0, 9)
self.assertAlmostEqual(abs(vxc0[1]-vxc1[1]).max(), 0, 9)
self.assertRaises(ValueError, dft.libxc.define_xc, mf._numint, 0.1)
def test_make_rdm1(self):
dm1 = mc.make_rdm1()
self.assertAlmostEqual(lib.finger(dm1), -5.0290089869374492, 5)
dm1 = mc.analyze(with_meta_lowdin=False)
self.assertAlmostEqual(lib.finger(dm1[0]), -5.7326112327013377, 5)
self.assertAlmostEqual(lib.finger(dm1[1]), 0.70360224576388797, 5)
self.assertAlmostEqual(lib.finger(dm1[0]+dm1[1]), -5.0290089869374492, 5)
def test_coulG(self):
numpy.random.seed(19)
kpt = numpy.random.random(3)
cell = pbcgto.Cell()
cell.unit = 'A'
cell.atom = 'C 0., 0., 0.; C 0.8917, 0.8917, 0.8917'
cell.a = numpy.array(((0. , 1.7834, 1.7834),
(1.7834, 0. , 1.7834),
(1.7834, 1.7834, 0. ),)) + numpy.random.random((3,3)).T
cell.basis = 'gth-szv'
cell.pseudo = 'gth-pade'
cell.mesh = [11,9,7]
cell.verbose = 5
cell.output = '/dev/null'
cell.build()
coulG = tools.get_coulG(cell, kpt)
self.assertAlmostEqual(lib.finger(coulG), 62.75448804333378, 9)
cell.a = numpy.eye(3)
cell.unit = 'B'
coulG = tools.get_coulG(cell, numpy.array([0, numpy.pi, 0]))
self.assertAlmostEqual(lib.finger(coulG), 4.6737453679713905, 9)
coulG = tools.get_coulG(cell, numpy.array([0, numpy.pi, 0]),
wrap_around=False)
self.assertAlmostEqual(lib.finger(coulG), 4.5757877990664744, 9)
coulG = tools.get_coulG(cell, exx='ewald')
self.assertAlmostEqual(lib.finger(coulG), 4.888843468914021, 9)
def test_canonicalize1(self):
numpy.random.seed(1)
f1 = numpy.random.random(mcr.mo_coeff.shape)
u1 = numpy.linalg.svd(f1)[0]
mo1 = numpy.dot(mcr.mo_coeff, u1)
mo1 = lib.tag_array(mo1, orbsym=mcr.mo_coeff.orbsym)
mo, ci, mo_e = mcr.canonicalize(mo1)
e1 = numpy.einsum('ji,jk,ki', mo, f1, mo)
self.assertAlmostEqual(e1, 44.2658681077, 7)
self.assertAlmostEqual(lib.finger(mo_e), 5.1364166175063097, 7)
mo, ci, mo_e = mcr.canonicalize(mo1, eris=mcr.ao2mo(mcr.mo_coeff))
e1 = numpy.einsum('ji,jk,ki', mo, f1, mo)
self.assertAlmostEqual(e1, 44.2658681077, 7)
self.assertAlmostEqual(lib.finger(mo_e), 4.1206025804989173, 7)
mcr1 = copy.copy(mcr)
mcr1.frozen = 2
mo, ci, mo_e = mcr1.canonicalize(mo1)
self.assertAlmostEqual(lib.finger(mo_e), 6.6030999409178577, 7)
mcr1.frozen = [0,1]
mo, ci, mo_e = mcr1.canonicalize(mo1)
self.assertAlmostEqual(lib.finger(mo_e), 6.6030999409178577, 7)
mcr1.frozen = [1,12]
mo, ci, mo_e = mcr1.canonicalize(mo1)
self.assertAlmostEqual(lib.finger(mo_e), 5.2182584355788162, 7)
def test_rand_ccsd_frozen0(self):
'''Single (eom-)ccsd iteration with random t1/t2 and lowest lying orbital
at multiple k-points frozen.'''
kmf = pbcscf.addons.convert_to_ghf(rand_kmf)
# Round to make this insensitive to small changes between PySCF versions
mat_veff = kmf.get_veff().round(4)
mat_hcore = kmf.get_hcore().round(4)
kmf.get_veff = lambda *x: mat_veff
kmf.get_hcore = lambda *x: mat_hcore
# frozen = 1
rand_cc = pbcc.KGCCSD(kmf, frozen=1)
eris = rand_cc.ao2mo(rand_cc.mo_coeff)
eris.mo_energy = [eris.fock[k].diagonal() for k in range(rand_cc.nkpts)]
t1, t2 = rand_t1_t2(kmf, rand_cc)
Ht1, Ht2 = rand_cc.update_amps(t1, t2, eris)
self.assertAlmostEqual(finger(Ht1), (12.6235870016-0.263432509044j), 6)
self.assertAlmostEqual(finger(Ht2), (94.8802678168+910.369938369j), 6)
# frozen = [[0,],[0,],[0,]], should be same as above
frozen = [[0,],[0,],[0,]]
rand_cc = pbcc.KGCCSD(kmf, frozen=frozen)
eris = rand_cc.ao2mo(rand_cc.mo_coeff)
eris.mo_energy = [eris.fock[k].diagonal() for k in range(rand_cc.nkpts)]
t1, t2 = rand_t1_t2(rand_kmf, rand_cc)
Ht1, Ht2 = rand_cc.update_amps(t1, t2, eris)
self.assertAlmostEqual(finger(Ht1), (12.6235870016-0.263432509044j), 6)
self.assertAlmostEqual(finger(Ht2), (94.8802678168+910.369938369j), 6)
def test_eris_contract_vvvv_t2(self):
mol = gto.Mole()
nocc, nvir = 5, 12
nvir_pair = nvir*(nvir+1)//2
numpy.random.seed(9)
t2 = numpy.random.random((nocc,nocc,nvir,nvir)) - .5
t2 = t2 + t2.transpose(1,0,3,2)
eris = ccsd._ChemistsERIs()
vvvv = numpy.random.random((nvir_pair,nvir_pair)) - .5
eris.vvvv = vvvv + vvvv.T
eris.mol = mol
mycc.max_memory, bak = 0, mycc.max_memory
vt2 = eris._contract_vvvv_t2(mycc, t2, eris.vvvv)
mycc.max_memory = bak
self.assertAlmostEqual(lib.finger(vt2), -39.572579908080087, 11)
vvvv = ao2mo.restore(1, eris.vvvv, nvir)
ref = lib.einsum('acbd,ijcd->ijab', vvvv, t2)
self.assertAlmostEqual(abs(vt2 - ref).max(), 0, 11)
# _contract_s1vvvv_t2, testing complex and real mixed contraction
vvvv =(numpy.random.random((nvir,nvir,nvir,nvir)) +
numpy.random.random((nvir,nvir,nvir,nvir))*1j - (.5+.5j))
vvvv = vvvv + vvvv.transpose(1,0,3,2).conj()
vvvv = vvvv + vvvv.transpose(2,3,0,1)
eris.vvvv = vvvv
eris.mol = mol
mycc.max_memory, bak = 0, mycc.max_memory
vt2 = eris._contract_vvvv_t2(mycc, t2, eris.vvvv)
mycc.max_memory = bak
self.assertAlmostEqual(lib.finger(vt2), 23.502736435296871+113.90422480013488j, 11)
ref = lib.einsum('acbd,ijcd->ijab', eris.vvvv, t2)
self.assertAlmostEqual(abs(vt2 - ref).max(), 0, 11)
def test_init_guess_by_1e(self):
dm = mf.get_init_guess(key='1e')
self.assertAlmostEqual(lib.finger(dm), 0.025922864381755062, 9)
dm = kmf.get_init_guess(key='1e')
self.assertEqual(dm.ndim, 3)
self.assertAlmostEqual(lib.finger(dm), 0.025922864381755062, 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.finger(v11), -0.30110964334164825+0.81409418199767414j, 9)
self.assertAlmostEqual(lib.finger(v12), -2.1601376488983997-9.4070613374115908j, 9)
def test_p(self):
numpy.random.seed(2)
a = numpy.random.random((3,3,3))
self.assertAlmostEqual(lib.finger(cc.p('a.c', a)), -1.1768882755852079, 12)
self.assertAlmostEqual(lib.finger(cc.p('.ab', a)), -1.9344875839983993, 12)
self.assertAlmostEqual(lib.finger(cc.p('abc', a)), -0.0055534783760265282, 14)
self.assertAlmostEqual(abs(cc.p('a.a', a) - a).max(), 0, 12)
def test_aux_e2(self):
nao = mol.nao_nr()
naoaux = auxmol.nao_nr()
eri0 = numpy.empty((nao,nao,naoaux))
pi = 0
for i in range(mol.nbas):
pj = 0
for j in range(mol.nbas):
pk = 0
for k in range(mol.nbas, mol.nbas+auxmol.nbas):
shls = (i, j, k)
buf = gto.moleintor.getints_by_shell('int3c2e_sph',
shls, atm, bas, env)
di, dj, dk = buf.shape
eri0[pi:pi+di,pj:pj+dj,pk:pk+dk] = buf
pk += dk
pj += dj
pi += di
j3c = df.incore.aux_e2(mol, auxmol, intor='int3c2e_sph', aosym='s1')
self.assertTrue(numpy.allclose(eri0, j3c.reshape(nao,nao,naoaux)))
self.assertAlmostEqual(lib.finger(j3c), 48.11812978990752, 9)
idx = numpy.tril_indices(nao)
j3c = df.incore.aux_e2(mol, auxmol, intor='int3c2e_sph', aosym='s2ij')
self.assertTrue(numpy.allclose(eri0[idx], j3c))
self.assertAlmostEqual(lib.finger(j3c), 4.6774743051154459, 9)
def test_analyze(self):
f = td_hf.oscillator_strength(gauge='length')
self.assertAlmostEqual(lib.finger(f), -0.13908774016795605, 7)
f = td_hf.oscillator_strength(gauge='velocity', order=2)
self.assertAlmostEqual(lib.finger(f), -0.096991134490587522, 7)
td_hf.analyze()
self.assertEqual(td_hf.nroots, td_hf.nstates)
self.assertAlmostEqual(lib.finger(td_hf.e_tot-mf.e_tot), 0.41508325757603637, 6)
def test_nr_s8(self):
mol = gto.M(atom="He 0 0 0; Ne 3 0 0", basis='ccpvdz')
eri0 = mol.intor('int2e_sph', aosym='s8')
self.assertAlmostEqual(lib.finger(eri0), -10.685918926843847, 9)
eri1 = mol.intor('int2e_yp_sph', aosym=8)
self.assertAlmostEqual(lib.finger(eri1), -10.685918926843847, 9)
self.assertAlmostEqual(abs(eri0-eri1).max(), 0, 9)
def test_khf_stability(self):
kmf = pscf.KRHF(cell, kpts, exxdiv='ewald').run(conv_tol=1e-12)
mo_i, mo_e = kmf.stability(internal=True, external=True)
self.assertAlmostEqual(abs(kmf.mo_coeff[0]-mo_i[0]).max(), 0, 9)
hop2, hdiag2 = stability._gen_hop_rhf_external(kmf)
self.assertAlmostEqual(lib.finger(hdiag2), 18.528134783454508, 7)
self.assertAlmostEqual(lib.finger(hop2(hdiag2)), 108.99683506471919, 5)
def test_fast_iao_mulliken_pop(self):
mf = scf.RHF(mol).run()
a = iao.iao(mol, mf.mo_coeff[:,mf.mo_occ>0])
p,chg = iao.fast_iao_mullikan_pop(mol, mf.make_rdm1(), a)
self.assertAlmostEqual(lib.finger(p), 0.56812564587009806, 5)
mf = scf.UHF(mol).run()
p,chg = iao.fast_iao_mullikan_pop(mol, mf.make_rdm1(), a)
self.assertAlmostEqual(lib.finger(p[0]+p[1]), 0.56812564587009806, 5)
def test_kuhf_stability(self):
kumf = pscf.KUHF(cell, kpts, exxdiv='ewald').run(conv_tol=1e-12)
mo_i, mo_e = kumf.stability(internal=True, external=True)
self.assertAlmostEqual(abs(kumf.mo_coeff[0][0]-mo_i[0][0]).max(), 0, 9)
self.assertAlmostEqual(abs(kumf.mo_coeff[1][0]-mo_i[1][0]).max(), 0, 9)
hop2, hdiag2 = stability._gen_hop_uhf_external(kumf)
self.assertAlmostEqual(lib.finger(hdiag2), 10.977759629315884, 7)
self.assertAlmostEqual(lib.finger(hop2(hdiag2)), 86.425042652868, 5)
def test_init_guess_by_atom(self):
with lib.temporary_env(cell, dimension=1):
dm = mf.get_init_guess(key='minao')
kdm = kmf.get_init_guess(key='minao')
self.assertAlmostEqual(lib.finger(dm), -1.714952331211208, 8)
self.assertEqual(kdm.ndim, 3)
self.assertAlmostEqual(lib.finger(dm), -1.714952331211208, 8)
def test_r_get_jk(self):
numpy.random.seed(1)
dfobj = df.df.DF4C(mol)
n2c = mol.nao_2c()
n4c = n2c * 2
dms = numpy.random.random((2,n4c,n4c))
vj, vk = dfobj.get_jk(dms, hermi=0)
self.assertAlmostEqual(lib.finger(vj), 12.961687328405461+55.686811159338134j, 9)
self.assertAlmostEqual(lib.finger(vk), 41.984238099875462+12.870888901217896j, 9)
def test_bands(self):
np.random.seed(1)
kpts_bands = np.random.random((1,3))
e = mf.get_bands(kpts_bands)[0]
self.assertAlmostEqual(lib.finger(e), 0.9038555558945438, 6)
e = kmf.get_bands(kpts_bands)[0]
self.assertAlmostEqual(lib.finger(e), -0.3020614, 6)
def test_multi_roots(self):
mc1 = mcscf.CASCI(m, 4, 4)
mc1.fcisolver.nroots = 2
mc1.natorb = True
mc1.kernel()
self.assertAlmostEqual(mc1.e_tot[0], -108.83741684447352, 9)
self.assertAlmostEqual(mc1.e_tot[1], -108.72522194135604, 9)
dm1 = mc1.analyze()
self.assertAlmostEqual(lib.finger(dm1[0]), 2.6252082970845532, 7)
self.assertAlmostEqual(lib.finger(dm1[1]), 2.6252082970845532, 7)
def test_state_average(self):
mc1 = mcscf.CASSCF(m, 4, 4).state_average_((0.5,0.5))
mc1.natorb = True
mc1.kernel()
self.assertAlmostEqual(numpy.dot(mc1.e_tot, [.5,.5]), -108.80445340617777, 8)
mo_occ = lib.chkfile.load(mc1.chkfile, 'mcscf/mo_occ')[5:9]
self.assertAlmostEqual(lib.finger(mo_occ), 1.8748844779923917, 4)
dm1 = mc1.analyze()
self.assertAlmostEqual(lib.finger(dm1[0]), 2.6993157521103779, 4)
self.assertAlmostEqual(lib.finger(dm1[1]), 2.6993157521103779, 4)
def test_ao2mo_with_mol_cart(self):
pmol = mol.copy()
pmol.cart = True
nao = pmol.nao_nr()
numpy.random.seed(1)
mo = numpy.random.random((nao,4))
eri = ao2mo.kernel(pmol, mo)
self.assertAlmostEqual(lib.finger(eri), -977.99841341828437, 9)
eri = ao2mo.kernel(mol, mo, intor='int2e_cart')
self.assertAlmostEqual(lib.finger(eri), -977.99841341828437, 9)
def test_contract(self):
mol = gto.M()
mol.nelectron = 6
nocc, nvir = mol.nelectron//2, 4
nmo = nocc + nvir
nmo_pair = nmo*(nmo+1)//2
mf = scf.RHF(mol)
numpy.random.seed(12)
mf._eri = numpy.random.random(nmo_pair*(nmo_pair+1)//2)
mf.mo_coeff = numpy.random.random((nmo,nmo))
mf.mo_energy = numpy.arange(0., nmo)
mf.mo_occ = numpy.zeros(nmo)
mf.mo_occ[:nocc] = 2
dm = mf.make_rdm1()
vhf = mf.get_veff(mol, dm)
h1 = numpy.random.random((nmo,nmo)) * .1
h1 = h1 + h1.T
mf.get_hcore = lambda *args: h1
myci = ci.CISD(mf)
eris = myci.ao2mo(mf.mo_coeff)
eris.ehf = (h1*dm).sum() + (vhf*dm).sum()*.5
c2 = numpy.random.random((nocc,nocc,nvir,nvir)) * .1
c2 = c2 + c2.transpose(1,0,3,2)
c1 = numpy.random.random(nocc*nvir+1) * .1
c0, c1 = c1[0], c1[1:].reshape(nocc,nvir)
civec = myci.amplitudes_to_cisdvec(c0, c1, c2)
hcivec = ci.cisd.contract(myci, civec, eris)
self.assertAlmostEqual(lib.finger(hcivec), 2059.5730673341673, 9)
e2 = ci.cisd.dot(civec, hcivec+eris.ehf*civec, nmo, nocc)
self.assertAlmostEqual(e2, 7226.7494656749295, 9)
rdm2 = myci.make_rdm2(civec, nmo, nocc)
self.assertAlmostEqual(lib.finger(rdm2), 2.0492023431953221, 9)
def fcicontract(h1, h2, norb, nelec, ci0):
g2e = fci.direct_spin1.absorb_h1e(h1, h2, norb, nelec, .5)
ci1 = fci.direct_spin1.contract_2e(g2e, ci0, norb, nelec)
return ci1
ci0 = myci.to_fcivec(civec, nmo, mol.nelec)
self.assertAlmostEqual(abs(civec-myci.from_fcivec(ci0, nmo, nocc*2)).max(), 0, 9)
h2e = ao2mo.kernel(mf._eri, mf.mo_coeff)
h1e = reduce(numpy.dot, (mf.mo_coeff.T, h1, mf.mo_coeff))
ci1 = fcicontract(h1e, h2e, nmo, mol.nelec, ci0)
ci2 = myci.to_fcivec(hcivec, nmo, mol.nelec)
e1 = numpy.dot(ci1.ravel(), ci0.ravel())
e2 = ci.cisd.dot(civec, hcivec+eris.ehf*civec, nmo, nocc)
self.assertAlmostEqual(e1, e2, 9)
dovov, dvvvv, doooo, doovv, dovvo, dvvov, dovvv, dooov = \
ci.cisd._gamma2_intermediates(myci, civec, nmo, nocc)
self.assertAlmostEqual(lib.finger(numpy.array(dovov)), 0.02868859991188923, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dvvvv)),-0.05524957311823144, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doooo)), 0.01014399192065793, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doovv)), 0.02761239887072825, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvo)), 0.09971200182238759, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvv)), 0.12777531252787638, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dooov)), 0.18667669732858014, 9)
def test_get_init_guess(self):
cell1 = cell.copy()
cell1.dimension = 1
cell1.build(0, 0)
mf = pscf.ROHF(cell1)
dm = mf.get_init_guess(key='minao')
self.assertAlmostEqual(lib.finger(dm), -0.06586028869608128, 8)
mf = pscf.KROHF(cell1)
dm = mf.get_init_guess(key='minao')
self.assertAlmostEqual(lib.finger(dm), -0.06586028869608128, 8)
def test_df_eomsf_ccsd_matvec(self):
numpy.random.seed(10)
r1 = numpy.random.random((no,nv)) - .9
r2 = numpy.random.random((2,no,no,nv,nv)) - .9
myeom = eom_rccsd.EOMEESpinFlip(mycc1)
vec = myeom.amplitudes_to_vector(r1,r2)
imds = myeom.make_imds(eris1)
vec1 = myeom.matvec(vec, imds)
r1, r2 = myeom.vector_to_amplitudes(vec1)
self.assertAlmostEqual(lib.finger(r1 ), 1929.9270950777639, 8)
self.assertAlmostEqual(lib.finger(r2[0]), 15571.714806853948, 8)
self.assertAlmostEqual(lib.finger(r2[1]),-12949.619613624538, 8)
def test_gen_g_hop(self):
numpy.random.seed(1)
mo = numpy.random.random(mf.mo_coeff.shape)
ci0 = numpy.random.random((6,6))
ci0/= numpy.linalg.norm(ci0)
gall, gop, hop, hdiag = newton_casscf.gen_g_hop(mc, mo, ci0, mc.ao2mo(mo))
self.assertAlmostEqual(lib.finger(gall), 21.288022525148595, 8)
self.assertAlmostEqual(lib.finger(hdiag), -4.6864640132374618, 8)
x = numpy.random.random(gall.size)
u, ci1 = newton_casscf.extract_rotation(mc, x, 1, ci0)
self.assertAlmostEqual(lib.finger(gop(u, ci1)), -412.9441873541524, 8)
self.assertAlmostEqual(lib.finger(hop(x)), 73.358310983341198, 8)
def test_ucc_eomsf_ccsd_matvec(self):
numpy.random.seed(10)
myeom = eom_uccsd.EOMEESpinFlip(ucc1)
vec = numpy.random.random(myeom.vector_size()) - .9
vec1 = eom_uccsd.eomsf_ccsd_matvec(myeom, vec)
self.assertAlmostEqual(lib.finger(vec1), -588.66159772500009, 8)
mf.mo_occ[:nocc] = 2
vhf = mf.get_veff(mol, mf.make_rdm1())
cinv = np.linalg.inv(mf.mo_coeff)
mf.get_hcore = lambda *args: (reduce(np.dot,
(cinv.T * mf.mo_energy, cinv)) - vhf)
mycc = RCCSD(mf)
eris = mycc.ao2mo()
a = np.random.random((nmo, nmo)) * .1
eris.fock += a + a.T.conj()
t1 = np.random.random((nocc, nvir)) * .1
t2 = np.random.random((nocc, nocc, nvir, nvir)) * .1
t2 = t2 + t2.transpose(1, 0, 3, 2)
mycc.cc2 = False
t1a, t2a = update_amps(mycc, t1, t2, eris)
print(lib.finger(t1a) - -106360.5276951083)
print(lib.finger(t2a) - 66540.100267798145)
mycc.cc2 = True
t1a, t2a = update_amps(mycc, t1, t2, eris)
print(lib.finger(t1a) - -106360.5276951083)
print(lib.finger(t2a) - -1517.9391800662809)
eri1 = np.random.random((nmo, nmo, nmo, nmo)) + np.random.random(
(nmo, nmo, nmo, nmo)) * 1j
eri1 = eri1.transpose(0, 2, 1, 3)
eri1 = eri1 + eri1.transpose(1, 0, 3, 2).conj()
eri1 = eri1 + eri1.transpose(2, 3, 0, 1)
eri1 *= .1
eris.oooo = eri1[:nocc, :nocc, :nocc, :nocc].copy()
eris.ooov = eri1[:nocc, :nocc, :nocc, nocc:].copy()
eris.ovoo = eri1[:nocc, nocc:, :nocc, :nocc].copy()
def test_t3p2_imds_complex_against_so(self):
'''Test t3[2] implementation against spin-orbital implmentation.'''
from pyscf.pbc.scf.addons import convert_to_ghf
kmf = copy.copy(rand_kmf2)
# Round to make this insensitive to small changes between PySCF versions
mat_veff = kmf.get_veff().round(4)
mat_hcore = kmf.get_hcore().round(4)
kmf.get_veff = lambda *x: mat_veff
kmf.get_hcore = lambda *x: mat_hcore
rand_cc = pbcc.kccsd_rhf.RCCSD(kmf)
eris = rand_cc.ao2mo(kmf.mo_coeff)
eris.mo_energy = [
eris.fock[k].diagonal() for k in range(rand_cc.nkpts)
]
t1, t2 = rand_t1_t2(kmf, rand_cc)
rand_cc.t1, rand_cc.t2, rand_cc.eris = t1, t2, eris
e, pt1, pt2, Wmcik, Wacek = kintermediates_rhf.get_t3p2_imds(
rand_cc, t1, t2)
self.assertAlmostEqual(lib.finger(e), 3867.812511518491, 6)
self.assertAlmostEqual(lib.finger(pt1),
(179.0050003787795 + 521.7529255474592j), 6)
self.assertAlmostEqual(lib.finger(pt2),
(361.4902731606503 + 1079.5387279755082j), 6)
self.assertAlmostEqual(lib.finger(Wmcik),
(34.9811459194098 - 86.93467379996585j), 6)
self.assertAlmostEqual(lib.finger(Wacek),
(183.86684834783233 + 179.66583663669644j), 6)
gkmf = convert_to_ghf(rand_kmf2)
# Round to make this insensitive to small changes between PySCF versions
mat_veff = gkmf.get_veff().round(4)
mat_hcore = gkmf.get_hcore().round(4)
gkmf.get_veff = lambda *x: mat_veff
gkmf.get_hcore = lambda *x: mat_hcore
rand_gcc = pbcc.KGCCSD(gkmf)
eris = rand_gcc.ao2mo(rand_gcc.mo_coeff)
eris.mo_energy = [
eris.fock[k].diagonal() for k in range(rand_gcc.nkpts)
]
gt1 = rand_gcc.spatial2spin(t1)
gt2 = rand_gcc.spatial2spin(t2)
rand_gcc.t1, rand_gcc.t2, rand_gcc.eris = gt1, gt2, eris
ge, gpt1, gpt2, gWmcik, gWacek = kintermediates.get_t3p2_imds_slow(
rand_gcc, gt1, gt2)
self.assertAlmostEqual(lib.finger(ge), lib.finger(e), 8)
self.assertAlmostEqual(lib.finger(gpt1[:, ::2, ::2]), lib.finger(pt1),
8)
self.assertAlmostEqual(lib.finger(gpt2[:, :, :, ::2, 1::2, ::2, 1::2]),
lib.finger(pt2), 8)
self.assertAlmostEqual(
lib.finger(gWmcik[:, :, :, ::2, 1::2, ::2, 1::2]),
lib.finger(Wmcik), 8)
self.assertAlmostEqual(
lib.finger(gWacek[:, :, :, ::2, 1::2, ::2, 1::2]),
lib.finger(Wacek), 8)
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = 'cc-pvdz'
#mol.basis = '3-21G'
mol.verbose = 0
mol.spin = 0
mol.build()
mf = scf.RHF(mol).run(conv_tol=1e-14)
mycc = RCCSD(mf)
mycc.max_memory = 0
eris = mycc.ao2mo()
emp2, t1, t2 = mycc.init_amps(eris)
print(lib.finger(t2) - 0.044540097905897198)
np.random.seed(1)
t1 = np.random.random(t1.shape) * .1
t2 = np.random.random(t2.shape) * .1
t2 = t2 + t2.transpose(1, 0, 3, 2)
t1, t2 = update_amps(mycc, t1, t2, eris)
print(lib.finger(t1) - 0.25118555558133576)
print(lib.finger(t2) - 0.02352137419932243)
ecc, t1, t2 = mycc.kernel()
print(ecc - -0.21334326214236796)
e, v = mycc.ipccsd(nroots=3)
print(e[0] - 0.43356041409195489)
print(e[1] - 0.51876598058509493)
print(e[2] - 0.6782879569941862)
if __name__ == '__main__':
import numpy
from pyscf import lib
from pyscf import gto
from pyscf import scf, dft
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [[1, (1., 0., 0.000)], [1, (0., 1., 0.000)],
[1, (0., -1.517, 1.177)], [1, (0., 1.517, 1.177)]]
mol.basis = '631g'
mol.unit = 'B'
mol.build()
mf = dft.RKS(mol)
mf.conv_tol = 1e-14
mf.scf()
n3 = mol.natm * 3
hobj = rks_hess.Hessian(mf)
e2 = hobj.kernel()
numpy.random.seed(1)
x = numpy.random.random((mol.natm, 3))
e2x = numpy.einsum('abxy,ax->by', e2, x)
print(lib.finger(e2x) - -0.20252942721146411)
hop = Freq(mf).gen_hop()[0]
print(lib.finger(hop(x)) - -0.20252942721146411)
print(abs(e2x - hop(x).reshape(mol.natm, 3)).sum())
print(Freq(mf).set(nroots=1).kernel()[0])
print(numpy.linalg.eigh(e2.transpose(0, 2, 1, 3).reshape(n3, n3))[0])
verbose=3)
mf = scf.UHF(mol).run()
gobj = GTensor(mf)
#print(gobj.kernel())
gobj.para_soc2e = 'SSO+SOO'
gobj.dia_soc2e = None
gobj.so_eff_charge = False
nao, nmo = mf.mo_coeff[0].shape
nelec = mol.nelec
numpy.random.seed(1)
mo10 = [
numpy.random.random((3, nmo, nelec[0])),
numpy.random.random((3, nmo, nelec[1]))
]
print(
lib.finger(para(gobj, mo10, mf.mo_coeff, mf.mo_occ)) -
4.3706065384682997e-05)
print(
lib.finger(para_for_debug(gobj, mo10, mf.mo_coeff, mf.mo_occ)) -
4.3706065384682997e-05)
numpy.random.seed(1)
dm0 = numpy.random.random((2, nao, nao))
dm0 = dm0 + dm0.transpose(0, 2, 1)
dm10 = numpy.random.random((2, 3, nao, nao))
dm10 = dm10 - dm10.transpose(0, 1, 3, 2)
print(lib.finger(make_para_soc2e(gobj, dm0, dm10)) - 0.011068947999868441)
print(
lib.finger(make_dia_gc2e(gobj, dm0, (.5, 1, 2))) -
-0.0058333522256648652)
print(lib.finger(make_dia_gc2e(gobj, dm0, None)) - 0.0015992772016390443)
def test_rdm_trace(self):
mycc = rccsd.RCCSD(mf)
numpy.random.seed(2)
nocc = 5
nmo = 12
nvir = nmo - nocc
eri0 = numpy.random.random((nmo, nmo, nmo, nmo))
eri0 = ao2mo.restore(1, ao2mo.restore(8, eri0, nmo), nmo)
fock0 = numpy.random.random((nmo, nmo))
fock0 = fock0 + fock0.T + numpy.diag(range(nmo)) * 2
t1 = numpy.random.random((nocc, nvir))
t2 = numpy.random.random((nocc, nocc, nvir, nvir))
t2 = t2 + t2.transpose(1, 0, 3, 2)
l1 = numpy.random.random((nocc, nvir))
l2 = numpy.random.random((nocc, nocc, nvir, nvir))
l2 = l2 + l2.transpose(1, 0, 3, 2)
h1 = fock0 - (numpy.einsum('kkpq->pq', eri0[:nocc, :nocc]) * 2 -
numpy.einsum('pkkq->pq', eri0[:, :nocc, :nocc]))
eris = lambda: None
eris.oooo = eri0[:nocc, :nocc, :nocc, :nocc].copy()
eris.ooov = eri0[:nocc, :nocc, :nocc, nocc:].copy()
eris.ovoo = eri0[:nocc, nocc:, :nocc, :nocc].copy()
eris.oovv = eri0[:nocc, :nocc, nocc:, nocc:].copy()
eris.ovov = eri0[:nocc, nocc:, :nocc, nocc:].copy()
eris.ovvo = eri0[:nocc, nocc:, nocc:, :nocc].copy()
eris.ovvv = eri0[:nocc, nocc:, nocc:, nocc:].copy()
eris.vvvv = eri0[nocc:, nocc:, nocc:, nocc:].copy()
eris.fock = fock0
doo, dov, dvo, dvv = ccsd_rdm._gamma1_intermediates(
mycc, t1, t2, l1, l2)
self.assertAlmostEqual(
(numpy.einsum('ij,ij', doo, fock0[:nocc, :nocc])) * 2,
-20166.329861034799, 8)
self.assertAlmostEqual(
(numpy.einsum('ab,ab', dvv, fock0[nocc:, nocc:])) * 2,
58078.964019246778, 8)
self.assertAlmostEqual(
(numpy.einsum('ai,ia', dvo, fock0[:nocc, nocc:])) * 2,
-74994.356886784764, 8)
self.assertAlmostEqual(
(numpy.einsum('ia,ai', dov, fock0[nocc:, :nocc])) * 2,
34.010188025702391, 9)
fdm2 = lib.H5TmpFile()
dovov, dvvvv, doooo, doovv, dovvo, dvvov, dovvv, dooov = \
ccsd_rdm._gamma2_outcore(mycc, t1, t2, l1, l2, fdm2, True)
self.assertAlmostEqual(lib.finger(numpy.array(dovov)),
-14384.907042073517, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dvvvv)),
-25.374007033024839, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doooo)),
60.114594698129963, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doovv)),
-79.176348067958401, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvo)),
9.864134457251815, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvv)),
-421.90333700061342, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dooov)),
-592.66863759586136, 9)
fdm2 = None
dovov, dvvvv, doooo, doovv, dovvo, dvvov, dovvv, dooov = \
ccsd_rdm._gamma2_intermediates(mycc, t1, t2, l1, l2)
self.assertAlmostEqual(lib.finger(numpy.array(dovov)),
-14384.907042073517, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dvvvv)),
45.872344902116758, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doooo)),
60.114594698129963, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doovv)),
-79.176348067958401, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvo)),
9.864134457251815, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvv)),
-421.90333700061342, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dooov)),
-592.66863759586136, 9)
self.assertAlmostEqual(
numpy.einsum('kilj,kilj', doooo, eris.oooo) * 2, 15939.9007625418,
7)
self.assertAlmostEqual(
numpy.einsum('acbd,acbd', dvvvv, eris.vvvv) * 2, 37581.823919588,
7)
self.assertAlmostEqual(
numpy.einsum('jkia,jkia', dooov, eris.ooov) * 2, 128470.009687716,
7)
self.assertAlmostEqual(
numpy.einsum('icba,icba', dovvv, eris.ovvv) * 2, -166794.225195056,
7)
self.assertAlmostEqual(
numpy.einsum('iajb,iajb', dovov, eris.ovov) * 2, -719279.812916893,
7)
self.assertAlmostEqual(
numpy.einsum('jbai,jbia', dovvo, eris.ovov) * 2 +
numpy.einsum('jiab,jiba', doovv, eris.oovv) * 2, -53634.0012286654,
7)
dm1 = ccsd_rdm.make_rdm1(mycc, t1, t2, l1, l2)
dm2 = ccsd_rdm.make_rdm2(mycc, t1, t2, l1, l2)
e2 = (
numpy.einsum('ijkl,ijkl', doooo, eris.oooo) * 2 +
numpy.einsum('acbd,acbd', dvvvv, eris.vvvv) * 2 +
numpy.einsum('jkia,jkia', dooov, eris.ooov) * 2 +
numpy.einsum('icba,icba', dovvv, eris.ovvv) * 2 +
numpy.einsum('iajb,iajb', dovov, eris.ovov) * 2 +
numpy.einsum('jbai,jbia', dovvo, eris.ovov) * 2 +
numpy.einsum('ijab,ijab', doovv, eris.oovv) * 2 +
numpy.einsum('ij,ij', doo, fock0[:nocc, :nocc]) * 2 +
numpy.einsum('ai,ia', dvo, fock0[:nocc, nocc:]) * 2 +
numpy.einsum('ia,ai', dov, fock0[nocc:, :nocc]) * 2 +
numpy.einsum('ab,ab', dvv, fock0[nocc:, nocc:]) * 2 +
fock0[:nocc].trace() * 2 - numpy.einsum(
'kkpq->pq', eri0[:nocc, :nocc, :nocc, :nocc]).trace() * 2 +
numpy.einsum('pkkq->pq', eri0[:nocc, :nocc, :nocc, :nocc]).trace())
self.assertAlmostEqual(e2, -794721.197459942, 8)
self.assertAlmostEqual(
numpy.einsum('pqrs,pqrs', dm2, eri0) * .5 +
numpy.einsum('pq,qp', dm1, h1), e2, 9)
self.assertAlmostEqual(
abs(dm2 - dm2.transpose(1, 0, 3, 2)).max(), 0, 9)
self.assertAlmostEqual(
abs(dm2 - dm2.transpose(2, 3, 0, 1)).max(), 0, 9)
d1 = numpy.einsum('kkpq->qp', dm2) / 9
self.assertAlmostEqual(abs(d1 - dm1).max(), 0, 9)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
['Ne', (0., 0., 0.)],
]
mol.basis = '631g'
mol.build()
mf = dft.RKS(mol).run()
mag = Magnetizability(mf).kernel()
print(lib.finger(mag) - -0.30375149255154221)
mf.set(xc='b3lyp').run()
mag = Magnetizability(mf).kernel()
print(lib.finger(mag) - -0.3022331813238171)
mol.atom = [
[1, (0., 0., .917)],
['F', (0., 0., 0.)],
]
mol.basis = '6-31g'
mol.build()
mf = dft.RKS(mol).set(xc='lda,vwn').run()
mag = Magnetizability(mf).kernel()
print(lib.finger(mag) - -0.4313210213418015)
def test_contract(self):
mol = gto.M()
mol.nelectron = 6
nocc, nvir = mol.nelectron // 2, 4
nmo = nocc + nvir
nmo_pair = nmo * (nmo + 1) // 2
mf = scf.RHF(mol)
numpy.random.seed(12)
mf._eri = numpy.random.random(nmo_pair * (nmo_pair + 1) // 2)
mf.mo_coeff = numpy.random.random((nmo, nmo))
mf.mo_energy = numpy.arange(0., nmo)
mf.mo_occ = numpy.zeros(nmo)
mf.mo_occ[:nocc] = 2
dm = mf.make_rdm1()
vhf = mf.get_veff(mol, dm)
h1 = numpy.random.random((nmo, nmo)) * .1
h1 = h1 + h1.T
mf.get_hcore = lambda *args: h1
myci = ci.CISD(mf)
eris = myci.ao2mo(mf.mo_coeff)
eris.ehf = (h1 * dm).sum() + (vhf * dm).sum() * .5
c2 = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
c2 = c2 + c2.transpose(1, 0, 3, 2)
c1 = numpy.random.random(nocc * nvir + 1) * .1
c0, c1 = c1[0], c1[1:].reshape(nocc, nvir)
civec = myci.amplitudes_to_cisdvec(c0, c1, c2)
hcivec = ci.cisd.contract(myci, civec, eris)
self.assertAlmostEqual(lib.finger(hcivec), 2059.5730673341673, 9)
e2 = ci.cisd.dot(civec, hcivec + eris.ehf * civec, nmo, nocc)
self.assertAlmostEqual(e2, 7226.7494656749295, 9)
rdm2 = myci.make_rdm2(civec, nmo, nocc)
self.assertAlmostEqual(lib.finger(rdm2), 2.0492023431953221, 9)
def fcicontract(h1, h2, norb, nelec, ci0):
g2e = fci.direct_spin1.absorb_h1e(h1, h2, norb, nelec, .5)
ci1 = fci.direct_spin1.contract_2e(g2e, ci0, norb, nelec)
return ci1
ci0 = myci.to_fcivec(civec, nmo, mol.nelec)
self.assertAlmostEqual(
abs(civec - myci.from_fcivec(ci0, nmo, nocc * 2)).max(), 0, 9)
h2e = ao2mo.kernel(mf._eri, mf.mo_coeff)
h1e = reduce(numpy.dot, (mf.mo_coeff.T, h1, mf.mo_coeff))
ci1 = fcicontract(h1e, h2e, nmo, mol.nelec, ci0)
ci2 = myci.to_fcivec(hcivec, nmo, mol.nelec)
e1 = numpy.dot(ci1.ravel(), ci0.ravel())
e2 = ci.cisd.dot(civec, hcivec + eris.ehf * civec, nmo, nocc)
self.assertAlmostEqual(e1, e2, 9)
dovov, dvvvv, doooo, doovv, dovvo, dvvov, dovvv, dooov = \
ci.cisd._gamma2_intermediates(myci, civec, nmo, nocc)
self.assertAlmostEqual(lib.finger(numpy.array(dovov)),
0.02868859991188923, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dvvvv)),
-0.05524957311823144, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doooo)),
0.01014399192065793, 9)
self.assertAlmostEqual(lib.finger(numpy.array(doovv)),
0.02761239887072825, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvo)),
0.09971200182238759, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dovvv)),
0.12777531252787638, 9)
self.assertAlmostEqual(lib.finger(numpy.array(dooov)),
0.18667669732858014, 9)
def test_different_grids_for_grad(self):
grids1 = dft.gen_grid.Grids(mol)
grids1.level = 1
g = mf.nuc_grad_method().set(grids=grids1).kernel()
self.assertAlmostEqual(lib.finger(g), -0.12085837432386037, 6)
atom = [
["O" , (0. , 0. , 0.)],
[1 , (0. ,-0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)]],
basis = '631g'
)
mf = scf.RHF(mol)
ehf = mf.scf()
myci = cisd.CISD(mf)
myci.kernel()
g1 = myci.Gradients().kernel()
# O 0.0000000000 -0.0000000000 0.0065498854
# H -0.0000000000 0.0208760610 -0.0032749427
# H -0.0000000000 -0.0208760610 -0.0032749427
print(lib.finger(g1) - -0.032562200777204092)
mcs = myci.as_scanner()
mol.set_geom_([
["O" , (0. , 0. , 0.001)],
[1 , (0. ,-0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)]])
e1 = mcs(mol)
mol.set_geom_([
["O" , (0. , 0. ,-0.001)],
[1 , (0. ,-0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)]])
e2 = mcs(mol)
print(g1[0,2] - (e1-e2)/0.002*lib.param.BOHR)
print('-----------------------------------')
make_pso_soc = make_pso_soc
solve_mo1 = solve_mo1_soc
make_h1_soc2e = make_h1_soc2e
HFC = HyperfineCoupling
if __name__ == '__main__':
from pyscf import gto, scf
mol = gto.M(atom='Ne 0 0 0', basis='ccpvdz', spin=1, charge=-1, verbose=3)
mf = scf.UHF(mol).run()
hfc = HFC(mf)
#hfc.verbose = 4
hfc.para_soc2e = 'SSO+SOO'
hfc.so_eff_charge = False
print(lib.finger(hfc.kernel()) - -2050.5830130636241)
mol = gto.M(atom='C 0 0 0; O 0 0 1.12',
basis='ccpvdz',
spin=1,
charge=1,
verbose=3)
mf = scf.UHF(mol).run()
hfc = HFC(mf)
#hfc.verbose = 4
hfc.para_soc2e = 'SSO+SOO'
hfc.so_eff_charge = False
print(lib.finger(hfc.kernel()) - 323.96293610190781)
mol = gto.M(atom='H 0 0 0; H 0 0 1.',
basis='ccpvdz',
return v1mo.ravel()
return vind
SSC = SpinSpinCoupling
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom.extend([
[1 , (0. , 0. , .917)],
['F' , (0. , 0. , 0.)], ])
mol.nucmod = {'F': 2} # gaussian nuclear model
mol.basis = {'H': '6-31g',
'F': '6-31g',}
mol.build()
mf = scf.UHF(mol).run()
ssc = SSC(mf)
ssc.verbose = 4
ssc.cphf = True
ssc.with_fc = True
ssc.with_fcsd = True
jj = ssc.kernel()
print(jj)
print(lib.finger(jj)*1e8 - 0.12374695912503765)
def test_scanner(self):
mc = mcscf.CASSCF(mf, 4, 4)
gs = mc.nuc_grad_method().as_scanner().as_scanner()
e, g1 = gs(mol.atom, atmlst=range(4))
self.assertAlmostEqual(e, -108.39289688030243, 9)
self.assertAlmostEqual(lib.finger(g1), -0.065094188906156134, 7)
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [[1, (1., 0., 0.000)], [1, (0., 1., 0.000)],
[1, (0., -1.517, 1.177)], [1, (0., 1.517, 1.177)]]
mol.basis = '631g'
mol.unit = 'B'
mol.build()
mf = scf.UHF(mol)
mf.conv_tol = 1e-14
mf.scf()
n3 = mol.natm * 3
hobj = mf.Hessian()
e2 = hobj.kernel().transpose(0, 2, 1, 3).reshape(n3, n3)
print(lib.finger(e2) - -0.50693144355876429)
mol.spin = 2
mf = scf.UHF(mol)
mf.conv_tol = 1e-14
mf.scf()
n3 = mol.natm * 3
hobj = Hessian(mf)
e2 = hobj.kernel().transpose(0, 2, 1, 3).reshape(n3, n3)
def grad_full(ia, inc):
coord = mol.atom_coord(ia).copy()
ptr = mol._atm[ia, gto.PTR_COORD]
de = []
for i in range(3):
mol._env[ptr + i] = coord[i] + inc
Grad = Gradients
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import mcscf
mol = gto.Mole()
mol.atom = 'N 0 0 0; N 0 0 1.2; H 1 1 0; H 1 1 1.2'
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run()
mc = mcscf.CASSCF(mf, 4, 4).run()
de = Grad(mc).kernel()
print(lib.finger(de) - 0.019602220578635747)
mol = gto.Mole()
mol.verbose = 0
mol.atom = 'N 0 0 0; N 0 0 1.2'
mol.basis = 'sto3g'
mol.build()
mf = scf.RHF(mol).run()
mc = mcscf.CASSCF(mf, 4, 4).run()
de = kernel(mc)
mcs = mc.as_scanner()
mol.set_geom_('N 0 0 0; N 0 0 1.201')
e1 = mcs(mol)
mol.set_geom_('N 0 0 0; N 0 0 1.199')
e2 = mcs(mol)
mol.atom = [
[1 , (1. , 0. , 0.000)],
[1 , (0. , 1. , 0.000)],
[1 , (0. , -1.517 , 1.177)],
[1 , (0. , 1.517 , 1.177)] ]
mol.basis = '631g'
mol.unit = 'B'
mol.build()
mf = dft.UKS(mol)
mf.xc = xc_code
mf.conv_tol = 1e-14
mf.kernel()
n3 = mol.natm * 3
hobj = mf.Hessian()
e2 = hobj.kernel().transpose(0,2,1,3).reshape(n3,n3)
print(lib.finger(e2) - -0.42286407986042956)
print(lib.finger(e2) - -0.45453541215680582)
print(lib.finger(e2) - -0.41385170026016327)
mol.spin = 2
mf = dft.UKS(mol)
mf.conv_tol = 1e-14
mf.xc = xc_code
mf.scf()
n3 = mol.natm * 3
hobj = Hessian(mf)
e2 = hobj.kernel().transpose(0,2,1,3).reshape(n3,n3)
def grad_full(ia, inc):
coord = mol.atom_coord(ia).copy()
ptr = mol._atm[ia,gto.PTR_COORD]
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = '''h , 0. 0. 0.
F , 0. 0. .917'''
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run()
mag = Magnetizability(mf)
mag.cphf = True
m = mag.kernel()
print(lib.finger(m) - -0.43596639996758657)
mag.gauge_orig = (0, 0, 1)
m = mag.kernel()
print(lib.finger(m) - -0.76996086788058238)
mag.gauge_orig = (0, 0, 1)
mag.cphf = False
m = mag.kernel()
print(lib.finger(m) - -0.7973915717274408)
mol = gto.M(atom='''O 0. 0. 0.
H 0. -0.757 0.587
H 0. 0.757 0.587''',
basis='ccpvdz')
mf = scf.RHF(mol).run()
['H', (0., 0., 1.804)],
['F', (0., 0., 0.)],
]
mol.unit = 'B'
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run(conv_tol=1e-14)
td = tddft.TDA(mf)
td.nstates = 3
e, z = td.kernel()
tdg = td.Gradients()
#tdg.verbose = 5
g1 = tdg.kernel(z[0])
print(g1)
print(lib.finger(g1) - 0.18686561181358813)
#[[ 0 0 -2.67023832e-01]
# [ 0 0 2.67023832e-01]]
td_solver = td.as_scanner()
e1 = td_solver(mol.set_geom_('H 0 0 1.805; F 0 0 0', unit='B'))
e2 = td_solver(mol.set_geom_('H 0 0 1.803; F 0 0 0', unit='B'))
print(abs((e1[0] - e2[0]) / .002 - g1[0, 2]).max())
mol.set_geom_('H 0 0 1.804; F 0 0 0', unit='B')
td = tddft.TDDFT(mf)
td.nstates = 3
e, z = td.kernel()
tdg = td.Gradients()
g1 = tdg.kernel(state=1)
print(g1)
print(lib.finger(g1) - 0.18967687762609461)
[1 , (0. , 0. , .917)],
['F' , (0. , 0. , 0.)], ])
mol.nucmod = {'F': 2} # gaussian nuclear model
mol.basis = {'H': '6-31g',
'F': '6-31g',}
mol.build()
mf = scf.RHF(mol).run()
ssc = mf.SSC()
ssc.verbose = 4
ssc.cphf = True
ssc.with_fc = True
ssc.with_fcsd = True
jj = ssc.kernel()
print(jj)
print(lib.finger(jj)*1e8 - 0.12374812977885304)
mol = gto.M(atom='''
O 0 0 0
H 0 -0.757 0.587
H 0 0.757 0.587''',
basis='ccpvdz')
mf = scf.RHF(mol).run()
ssc = SSC(mf)
ssc.with_fc = True
ssc.with_fcsd = True
jj = ssc.kernel()
print(lib.finger(jj)*1e8 - -0.11191697931377538)
ssc.with_fc = True
HFC = HyperfineCoupling
if __name__ == '__main__':
from pyscf import gto, scf, dft
mol = gto.M(atom='C 0 0 0; O 0 0 1.12',
basis='ccpvdz',
spin=1,
charge=1,
verbose=3)
mf = dft.UKS(mol).run()
hfc = HFC(mf)
hfc.verbose = 4
hfc.so_eff_charge = False
print(lib.finger(hfc.kernel()) - 255.92807696823797)
mol = gto.M(atom='H 0 0 0; H 0 0 1.',
basis='ccpvdz',
spin=1,
charge=-1,
verbose=3)
mf = scf.UKS(mol).run()
hfc = HFC(mf)
hfc.cphf = True
print(lib.finger(hfc.kernel()) - -25.896662045941071)
mol = gto.M(atom='''
Li 0 0 1
''',
basis='ccpvdz',
r = (((l + 2) * numpy.log(r) + numpy.log(cs) - log_prec) / es)**.5
rcut.append(r.max())
return numpy.array(rcut)
if __name__ == '__main__':
from pyscf.pbc import gto
cell = gto.M(a=numpy.eye(3) * 4,
atom='He 1 1 1',
basis=[[2, (1, .5), (.5, .5)]])
coords = cell.get_uniform_grids([10] * 3)
ao_value = eval_gto(cell,
"GTOval_sph",
coords,
kpts=cell.make_kpts([3] * 3))
print(
lib.finger(numpy.asarray(ao_value)) -
(-0.27594803231989179 + 0.0064644591759109114j))
cell = gto.M(a=numpy.eye(3) * 4,
atom='He 1 1 1',
basis=[[2, (1, .5), (.5, .5)]])
coords = cell.get_uniform_grids([10] * 3)
ao_value = eval_gto(cell,
"GTOval_ip_cart",
coords,
kpts=cell.make_kpts([3] * 3))
print(
lib.finger(numpy.asarray(ao_value)) -
(0.38051517609460028 + 0.062526488684770759j))
-1, 1)
Lpq = numpy.empty((self.blockdim, ao_pairs_G.shape[1]))
for p0, p1 in lib.prange(0, ngrids, blksize):
Lpq[:p1 - p0] = ao_pairs_G[p0:p1].real
yield Lpq[:p1 - p0]
Lpq[:p1 - p0] = ao_pairs_G[p0:p1].imag
yield Lpq[:p1 - p0]
def get_naoaux(self):
mesh = numpy.asarray(self.mesh)
ngrids = numpy.prod(mesh)
return ngrids * 2
if __name__ == '__main__':
from pyscf.pbc import gto as pbcgto
cell = pbcgto.Cell()
cell.verbose = 0
cell.atom = 'C 0 0 0; C 1 1 1; C 0 2 2; C 2 0 2'
cell.a = numpy.diag([4, 4, 4])
cell.basis = 'gth-szv'
cell.pseudo = 'gth-pade'
cell.mesh = [20] * 3
cell.build()
k = numpy.ones(3) * .25
df = FFTDF(cell)
v1 = get_pp(df, k)
print(lib.finger(v1) - (1.8428463642697195 - 0.10478381725330854j))
v1 = get_nuc(df, k)
print(lib.finger(v1) - (2.3454744614944714 - 0.12528407127454744j))
def test_symmetrize(self):
mol = gto.M(atom='N 0 0 0; N 0 0 1.2', basis='631g', symmetry=True)
g = mol.RHF.run().CCSD().run().Gradients().kernel()
self.assertAlmostEqual(lib.finger(g), 0.10105388861195158, 7)
gen_solver = as_solver = gen_ddpcm_solver
def regularize_xt(self, t, eta, scale=1):
return regularize_xt(t, eta, scale)
if __name__ == '__main__':
from pyscf import scf
mol = gto.M(atom='H 0 0 0; H 0 1 1.2; H 1. .1 0; H .5 .5 1')
numpy.random.seed(1)
nao = mol.nao_nr()
dm = numpy.random.random((nao, nao))
dm = dm + dm.T
#dm = scf.RHF(mol).run().make_rdm1()
e, vmat = DDPCM(mol).kernel(dm)
print(e + 1.2446306643473923)
print(lib.finger(vmat) - 0.77873361914445294)
mol = gto.Mole()
mol.atom = ''' O 0.00000000 0.00000000 -0.11081188
H -0.00000000 -0.84695236 0.59109389
H -0.00000000 0.89830571 0.52404783 '''
mol.basis = '3-21g' #cc-pvdz'
mol.build()
cm = DDPCM(mol)
cm.verbose = 4
mf = ddpcm_for_scf(scf.RHF(mol), cm) #.newton()
mf.verbose = 4
mf.kernel()
def test_ERIS(self):
ucc1 = cc.UCCSD(mf)
nao, nmo = mf.mo_coeff[0].shape
numpy.random.seed(1)
mo_coeff = numpy.random.random((2, nao, nmo))
eris = cc.uccsd._make_eris_incore(ucc1, mo_coeff)
self.assertAlmostEqual(lib.finger(eris.oooo), 4.9638849382825754, 11)
self.assertAlmostEqual(lib.finger(eris.ovoo), -1.3623681896983584, 11)
self.assertAlmostEqual(lib.finger(eris.ovov), 125.81550684442163, 11)
self.assertAlmostEqual(lib.finger(eris.oovv), 55.123681017639598, 11)
self.assertAlmostEqual(lib.finger(eris.ovvo), 133.48083527898248, 11)
self.assertAlmostEqual(lib.finger(eris.ovvv), 59.421927525288183, 11)
self.assertAlmostEqual(lib.finger(eris.vvvv), 43.556602622204778, 11)
self.assertAlmostEqual(lib.finger(eris.OOOO), -407.05319440524585, 11)
self.assertAlmostEqual(lib.finger(eris.OVOO), 56.284299937160796, 11)
self.assertAlmostEqual(lib.finger(eris.OVOV), -287.72899895597448, 11)
self.assertAlmostEqual(lib.finger(eris.OOVV), -85.484299959144522, 11)
self.assertAlmostEqual(lib.finger(eris.OVVO), -228.18996145476956, 11)
self.assertAlmostEqual(lib.finger(eris.OVVV), -10.715902258877399, 11)
self.assertAlmostEqual(lib.finger(eris.VVVV), -89.908425473958303, 11)
self.assertAlmostEqual(lib.finger(eris.ooOO), -336.65979260175226, 11)
self.assertAlmostEqual(lib.finger(eris.ovOO), -16.405125847288176, 11)
self.assertAlmostEqual(lib.finger(eris.ovOV), 231.59042209500075, 11)
self.assertAlmostEqual(lib.finger(eris.ooVV), 20.338077193028354, 11)
self.assertAlmostEqual(lib.finger(eris.ovVO), 206.48662856981386, 11)
self.assertAlmostEqual(lib.finger(eris.ovVV), -71.273249852220516, 11)
self.assertAlmostEqual(lib.finger(eris.vvVV), 172.47130671068496, 11)
self.assertAlmostEqual(lib.finger(eris.OVoo), -19.927660309103977, 11)
self.assertAlmostEqual(lib.finger(eris.OOvv), -27.761433381797019, 11)
self.assertAlmostEqual(lib.finger(eris.OVvo), -140.09648311337384, 11)
self.assertAlmostEqual(lib.finger(eris.OVvv), 40.700983950220547, 11)
uccsd.MEMORYMIN, bak = 0, uccsd.MEMORYMIN
ucc1.max_memory = 0
eris1 = ucc1.ao2mo(mo_coeff)
uccsd.MEMORYMIN = bak
self.assertAlmostEqual(
abs(numpy.array(eris1.oooo) - eris.oooo).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovoo) - eris.ovoo).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovov) - eris.ovov).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.oovv) - eris.oovv).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovvo) - eris.ovvo).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovvv) - eris.ovvv).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.vvvv) - eris.vvvv).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OOOO) - eris.OOOO).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OVOO) - eris.OVOO).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OVOV) - eris.OVOV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OOVV) - eris.OOVV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OVVO) - eris.OVVO).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OVVV) - eris.OVVV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.VVVV) - eris.VVVV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ooOO) - eris.ooOO).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovOO) - eris.ovOO).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovOV) - eris.ovOV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ooVV) - eris.ooVV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovVO) - eris.ovVO).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.ovVV) - eris.ovVV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.vvVV) - eris.vvVV).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OVoo) - eris.OVoo).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OOvv) - eris.OOvv).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OVvo) - eris.OVvo).max(), 0, 11)
self.assertAlmostEqual(
abs(numpy.array(eris1.OVvv) - eris.OVvv).max(), 0, 11)
# Testing the complex MO integrals
def ao2mofn(mos):
if isinstance(mos, numpy.ndarray) and mos.ndim == 2:
mos = [mos] * 4
nmos = [mo.shape[1] for mo in mos]
eri_mo = ao2mo.kernel(mf._eri, mos, compact=False).reshape(nmos)
return eri_mo * 1j
eris1 = cc.uccsd._make_eris_incore(ucc1, mo_coeff, ao2mofn=ao2mofn)
self.assertAlmostEqual(abs(eris1.oooo.imag - eris.oooo).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ovoo.imag - eris.ovoo).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ovov.imag - eris.ovov).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.oovv.imag - eris.oovv).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ovvo.imag - eris.ovvo).max(), 0, 11)
#self.assertAlmostEqual(abs(eris1.ovvv.imag-eris.ovvv).max(), 0, 11)
#self.assertAlmostEqual(abs(eris1.vvvv.imag-eris.vvvv).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OOOO.imag - eris.OOOO).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OVOO.imag - eris.OVOO).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OVOV.imag - eris.OVOV).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OOVV.imag - eris.OOVV).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OVVO.imag - eris.OVVO).max(), 0, 11)
#self.assertAlmostEqual(abs(eris1.OVVV.imag-eris.OVVV).max(), 0, 11)
#self.assertAlmostEqual(abs(eris1.VVVV.imag-eris.VVVV).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ooOO.imag - eris.ooOO).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ovOO.imag - eris.ovOO).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ovOV.imag - eris.ovOV).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ooVV.imag - eris.ooVV).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.ovVO.imag - eris.ovVO).max(), 0, 11)
#self.assertAlmostEqual(abs(eris1.ovVV.imag-eris.ovVV).max(), 0, 11)
#self.assertAlmostEqual(abs(eris1.vvVV.imag-eris.vvVV).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OVoo.imag - eris.OVoo).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OOvv.imag - eris.OOvv).max(), 0, 11)
self.assertAlmostEqual(abs(eris1.OVvo.imag - eris.OVvo).max(), 0, 11)
def test_ucc_eomee_ccsd_diag(self):
vec1, vec2 = eom_uccsd.EOMEE(ucc1).get_diag()
self.assertAlmostEqual(lib.finger(vec1), -36.776800901625307, 9)
self.assertAlmostEqual(lib.finger(vec2), 106.70096636265369, 9)
Gradients)
if __name__ == '__main__':
from pyscf import dft
mol = gto.Mole()
mol.atom = [['O', (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '631g'
mol.build()
mf = dft.RKS(mol)
mf.conv_tol = 1e-14
#mf.grids.atom_grid = (20,86)
e0 = mf.scf()
g = mf.Gradients()
print(lib.finger(g.kernel()) - -0.049887865971659243)
#[[ -4.20040265e-16 -6.59462771e-16 2.10150467e-02]
# [ 1.42178271e-16 2.81979579e-02 -1.05137653e-02]
# [ 6.34069238e-17 -2.81979579e-02 -1.05137653e-02]]
g.grid_response = True
print(lib.finger(g.kernel()) - -0.049891265876709084)
# O 0.0000000000 -0.0000000000 0.0210225191
# H 0.0000000000 0.0281984036 -0.0105112595
# H -0.0000000000 -0.0281984036 -0.0105112595
mf.xc = 'b88,p86'
e0 = mf.scf()
g = Gradients(mf)
print(lib.finger(g.kernel()) - -0.050382923259300716)
#[[ -8.20194970e-16 -2.04319288e-15 2.44405835e-02]
# [ 4.36709255e-18 2.73690416e-02 -1.22232039e-02]
def test_symmetrize(self):
mol = gto.M(atom='N 0 0 0; N 0 0 1.2', basis='631g', symmetry=True)
g = mol.RHF.run().CASSCF(4, 4).run().Gradients().kernel()
self.assertAlmostEqual(lib.finger(g), 0.12355818572359845, 7)
Freq = Frequency
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [[1, (1., 0., 0.000)], [1, (0., 1., 0.000)],
[1, (0., -1.517, 1.177)], [1, (0., 1.517, 1.177)]]
mol.basis = '631g'
mol.unit = 'B'
mol.build()
mf = scf.RHF(mol)
mf.conv_tol = 1e-14
mf.scf()
n3 = mol.natm * 3
hobj = rhf_hess.Hessian(mf)
e2 = hobj.kernel()
numpy.random.seed(1)
x = numpy.random.random((mol.natm, 3))
e2x = numpy.einsum('abxy,ax->by', e2, x)
print(lib.finger(e2x) - -0.19160804881270971)
hop = Freq(mf).gen_hop()[0]
print(lib.finger(hop(x)) - -0.19160804881270971)
print(abs(e2x - hop(x).reshape(mol.natm, 3)).sum())
print(Freq(mf).set(nroots=1).kernel()[0])
print(numpy.linalg.eigh(e2.transpose(0, 2, 1, 3).reshape(n3, n3))[0])
