def test_gccsd_t(self):
mf1 = copy.copy(mf)
nao, nmo = mf.mo_coeff[0].shape
numpy.random.seed(10)
mf1.mo_coeff = numpy.random.random((2,nao,nmo))
numpy.random.seed(12)
nocca, noccb = mol.nelec
nmo = mf1.mo_occ[0].size
nvira = nmo - nocca
nvirb = nmo - noccb
t1a = .1 * numpy.random.random((nocca,nvira))
t1b = .1 * numpy.random.random((noccb,nvirb))
t2aa = .1 * numpy.random.random((nocca,nocca,nvira,nvira))
t2aa = t2aa - t2aa.transpose(0,1,3,2)
t2aa = t2aa - t2aa.transpose(1,0,2,3)
t2bb = .1 * numpy.random.random((noccb,noccb,nvirb,nvirb))
t2bb = t2bb - t2bb.transpose(0,1,3,2)
t2bb = t2bb - t2bb.transpose(1,0,2,3)
t2ab = .1 * numpy.random.random((nocca,noccb,nvira,nvirb))
mycc = cc.GCCSD(mf1)
t1 = mycc.spatial2spin((t1a, t1b ))
t2 = mycc.spatial2spin((t2aa, t2ab, t2bb))
eris = mycc.ao2mo()
e3a = gccsd_t.kernel(mycc, eris, t1, t2)
self.assertAlmostEqual(e3a, 9877.2780859693339, 6)
def test_rdm_complex(self):
mol = gto.M()
mol.verbose = 0
nocc = 6
nvir = 8
mf = scf.GHF(mol)
nmo = nocc + nvir
numpy.random.seed(1)
eri = (numpy.random.random((nmo, nmo, nmo, nmo)) + numpy.random.random(
(nmo, nmo, nmo, nmo)) * 1j - (.5 + .5j))
eri = eri + eri.transpose(1, 0, 3, 2).conj()
eri = eri + eri.transpose(2, 3, 0, 1)
eri *= .1
def get_jk(mol, dm, *args, **kwargs):
vj = numpy.einsum('ijkl,lk->ij', eri, dm)
vk = numpy.einsum('ijkl,jk->il', eri, dm)
return vj, vk
def get_veff(mol, dm, *args, **kwargs):
vj, vk = get_jk(mol, dm)
return vj - vk
def ao2mofn(mos):
return eri
mf.get_jk = get_jk
mf.get_veff = get_veff
hcore = numpy.random.random((nmo, nmo)) * .2 + numpy.random.random(
(nmo, nmo)) * .2j
hcore = hcore + hcore.T.conj() + numpy.diag(range(nmo)) * 2
mf.get_hcore = lambda *args: hcore
mf.get_ovlp = lambda *args: numpy.eye(nmo)
orbspin = numpy.zeros(nmo, dtype=int)
orbspin[1::2] = 1
mf.mo_coeff = lib.tag_array(numpy.eye(nmo) + 0j, orbspin=orbspin)
mf.mo_occ = numpy.zeros(nmo)
mf.mo_occ[:nocc] = 1
mf.e_tot = mf.energy_elec(mf.make_rdm1(), hcore)[0]
mycc = cc.GCCSD(mf)
eris = gccsd._make_eris_incore(mycc, mf.mo_coeff, ao2mofn)
mycc.ao2mo = lambda *args, **kwargs: eris
mycc.kernel(eris=eris)
mycc.solve_lambda(eris=eris)
dm1 = mycc.make_rdm1()
dm2 = mycc.make_rdm2()
e1 = numpy.einsum('ij,ji', hcore, dm1)
e1 += numpy.einsum('ijkl,ijkl', eri, dm2) * .5
self.assertAlmostEqual(e1, mycc.e_tot, 7)
self.assertAlmostEqual(
abs(dm2 - dm2.transpose(1, 0, 3, 2).conj()).max(), 0, 9)
self.assertAlmostEqual(
abs(dm2 - dm2.transpose(2, 3, 0, 1)).max(), 0, 9)
self.assertAlmostEqual(
abs(dm2 + dm2.transpose(2, 1, 0, 3)).max(), 0, 9)
self.assertAlmostEqual(
abs(dm2 + dm2.transpose(0, 3, 2, 1)).max(), 0, 9)
def setUpModule():
global mol, mf, mycc, eris1, mycc1, nocc, nvir
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '6-31g'
mol.verbose = 7
mol.output = '/dev/null'
mol.build()
mf = scf.RHF(mol).run()
mycc = cc.GCCSD(mf).run()
mycc1, eris1 = make_mycc1()
nocc, nvir = mycc1.t1.shape
def test_convert_to_gccsd(self):
mygcc = addons.convert_to_uccsd(myrcc)
mygcc = addons.convert_to_gccsd(myrcc)
self.assertTrue(mygcc.t1.shape, (10, 16))
self.assertTrue(mygcc.t2.shape, (10, 10, 16, 16))
myucc = addons.convert_to_uccsd(myrcc)
mygcc = addons.convert_to_gccsd(myucc)
self.assertTrue(mygcc.t1.shape, (10, 16))
self.assertTrue(mygcc.t2.shape, (10, 10, 16, 16))
mygcc = addons.convert_to_gccsd(cc.GCCSD(gmf))
self.assertTrue(isinstance(mygcc, cc.gccsd.GCCSD))
def setUpModule():
global mol, mol1, mf, myucc, mygcc
mol = gto.Mole()
mol.verbose = 5
mol.output = '/dev/null'
mol.atom = [[8, (0., 0., 0.)], [1, (0., -.757, .587)],
[1, (0., .757, .587)]]
mol.spin = 2
mol.basis = '3-21g'
mol.symmetry = 'C2v'
mol.build()
mol1 = copy.copy(mol)
mol1.symmetry = False
mf = scf.UHF(mol1).run(conv_tol=1e-14)
myucc = cc.UCCSD(mf).run()
mygcc = cc.GCCSD(mf).run()
def test_h2o_star(self):
mol_h2o = gto.Mole()
mol_h2o.atom = [
[8, [0.000000000000000, -0.000000000000000, -0.124143731294022]],
[1, [0.000000000000000, -1.430522735894536, 0.985125550040314]],
[1, [0.000000000000000, 1.430522735894536, 0.985125550040314]]
]
mol_h2o.unit = 'B'
mol_h2o.basis = {
'H': [[0, [5.4471780, 0.156285], [0.8245472, 0.904691]],
[0, [0.1831916, 1.0]]],
'O':
'3-21G'
}
mol_h2o.verbose = 9
mol_h2o.output = '/dev/null'
mol_h2o.build()
mf_h2o = scf.RHF(mol_h2o)
mf_h2o.conv_tol_grad = 1e-12
mf_h2o.conv_tol = 1e-12
mf_h2o.kernel()
mycc_h2o = cc.GCCSD(mf_h2o).run()
mycc_h2o.conv_tol_normt = 1e-12
mycc_h2o.conv_tol = 1e-12
mycc_h2o.kernel()
myeom = eom_gccsd.EOMIP(mycc_h2o)
e = myeom.ipccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.410661965883, 6)
myeom = eom_gccsd.EOMIP_Ta(mycc_h2o)
e = myeom.ipccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.411695647736, 6)
myeom = eom_gccsd.EOMEA(mycc_h2o)
e = myeom.eaccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.250589854185, 6)
myeom = eom_gccsd.EOMEA_Ta(mycc_h2o)
e = myeom.eaccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.250720295150, 6)
def test_update_amps(self):
mf = scf.UHF(mol).run()
numpy.random.seed(21)
mycc = cc.GCCSD(mf)
eris = mycc.ao2mo()
orbspin = eris.orbspin
nocc = mol.nelectron
nvir = mol.nao_nr() * 2 - nocc
t1 = numpy.random.random((nocc, nvir)) * .1
t2 = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
t2 = t2 - t2.transpose(1, 0, 2, 3)
t2 = t2 - t2.transpose(0, 1, 3, 2)
l1 = numpy.random.random((nocc, nvir)) * .1
l2 = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
l2 = l2 - l2.transpose(1, 0, 2, 3)
l2 = l2 - l2.transpose(0, 1, 3, 2)
l1ref, l2ref = update_l1l2(mf, t1, t2, l1, l2, orbspin)
imds = gccsd_lambda.make_intermediates(mycc, t1, t2, eris)
l1, l2 = gccsd_lambda.update_lambda(mycc, t1, t2, l1, l2, eris, imds)
self.assertAlmostEqual(abs(l1 - l1ref).max(), 0, 8)
self.assertAlmostEqual(abs(l2 - l2ref).max(), 0, 8)
t1a = .1 * numpy.random.random((nocca,nvira))
t1b = .1 * numpy.random.random((noccb,nvirb))
t2aa = .1 * numpy.random.random((nocca,nocca,nvira,nvira))
t2aa = t2aa - t2aa.transpose(0,1,3,2)
t2aa = t2aa - t2aa.transpose(1,0,2,3)
t2bb = .1 * numpy.random.random((noccb,noccb,nvirb,nvirb))
t2bb = t2bb - t2bb.transpose(0,1,3,2)
t2bb = t2bb - t2bb.transpose(1,0,2,3)
t2ab = .1 * numpy.random.random((nocca,noccb,nvira,nvirb))
t1 = t1a, t1b
t2 = t2aa, t2ab, t2bb
mcc = uccsd.UCCSD(scf.addons.convert_to_uhf(mf))
e3a = kernel(mcc, mcc.ao2mo(), [t1a,t1b], [t2aa, t2ab, t2bb])
print(e3a - 9877.2780859693339)
mycc = cc.GCCSD(scf.addons.convert_to_ghf(mf))
eris = mycc.ao2mo()
t1 = mycc.spatial2spin(t1, eris.orbspin)
t2 = mycc.spatial2spin(t2, eris.orbspin)
from pyscf.cc import gccsd_t
et = gccsd_t.kernel(mycc, eris, t1, t2)
print(et - 9877.2780859693339)
mol = gto.M()
numpy.random.seed(12)
nocca, noccb, nvira, nvirb = 3, 2, 4, 5
nmo = nocca + nvira
eris = cc.uccsd._ChemistsERIs()
eri1 = (numpy.random.random((3,nmo,nmo,nmo,nmo)) +
numpy.random.random((3,nmo,nmo,nmo,nmo)) * .8j - .5-.4j)
from pyscf import lib
from pyscf import gto
from pyscf import scf
from pyscf import cc
from pyscf import ao2mo
from pyscf.cc import gccsd, eom_gccsd
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '6-31g'
mol.verbose = 7
mol.output = '/dev/null'
mol.build()
mf = scf.RHF(mol).run()
mycc = cc.GCCSD(mf).run()
def make_mycc1():
mol = gto.M()
nocc, nvir = 8, 14
nmo = nocc + nvir
nmo_pair = nmo * (nmo + 1) // 2
mf = scf.GHF(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] = 1
vhf = numpy.random.random((nmo, nmo)) + numpy.random.random(
"""
nocc, _, nvirt, _ = t2.shape
hamiltonian = eris_hamiltonian(cc.ao2mo())
hamiltonian.update(dict(
t2=t2,
))
initial_guess_ea = list(
koopmans_guess_ea(nocc, nvirt, OrderedDict((("r_ea2", 2))), i, dtype=float)
for i in range(nroots)
)
return kernel_eig(hamiltonian, eq_ea_d, initial_guess_ea, tolerance=tolerance)
if __name__ == "__main__":
from pyscf import scf, gto, cc
mol = gto.Mole()
mol.atom = "O 0 0 0; H 0.758602 0.000000 0.504284; H 0.758602 0.000000 -0.504284"
mol.unit = "angstrom"
mol.basis = 'cc-pvdz'
mol.build()
mf = scf.GHF(mol)
mf.conv_tol = 1e-11
mf.kernel()
ccsd = cc.GCCSD(mf, frozen=2)
ccsd.kernel()
e, t1, t2 = kernel_ground_state_sd(ccsd)
print(e)
mf0 = mf = scf.RHF(mol).run(conv_tol=1.)
mf = scf.addons.convert_to_ghf(mf)
from pyscf.cc import ccsd_t_lambda_slow as ccsd_t_lambda
from pyscf.cc import ccsd_t_rdm_slow as ccsd_t_rdm
mycc0 = cc.CCSD(mf0)
eris0 = mycc0.ao2mo()
mycc0.kernel(eris=eris0)
t1 = mycc0.t1
t2 = mycc0.t2
imds = ccsd_t_lambda.make_intermediates(mycc0, t1, t2, eris0)
l1, l2 = ccsd_t_lambda.update_lambda(mycc0, t1, t2, t1, t2, eris0, imds)
dm1ref = ccsd_t_rdm.make_rdm1(mycc0, t1, t2, l1, l2, eris0)
dm2ref = ccsd_t_rdm.make_rdm2(mycc0, t1, t2, l1, l2, eris0)
mycc = cc.GCCSD(mf)
eris = mycc.ao2mo()
t1 = mycc.spatial2spin(t1, mycc.mo_coeff.orbspin)
t2 = mycc.spatial2spin(t2, mycc.mo_coeff.orbspin)
l1 = mycc.spatial2spin(l1, mycc.mo_coeff.orbspin)
l2 = mycc.spatial2spin(l2, mycc.mo_coeff.orbspin)
gdm1 = make_rdm1(mycc, t1, t2, l1, l2, eris)
gdm2 = make_rdm2(mycc, t1, t2, l1, l2, eris)
idxa = numpy.where(mycc.mo_coeff.orbspin == 0)[0]
idxb = numpy.where(mycc.mo_coeff.orbspin == 1)[0]
trdm1 = gdm1[idxa[:, None], idxa]
trdm1 += gdm1[idxb[:, None], idxb]
trdm2 = gdm2[idxa[:, None, None, None], idxa[:, None, None], idxa[:, None],
idxa]
trdm2 += gdm2[idxb[:, None, None, None], idxb[:, None, None],
assert t1_diff < 1e-7 # genrate reference values mol = gto.M(atom='H 0 0 0; F 0 0 1.1', basis='321g', spin=2) mol.verbose = 5 mf = mol.GHF() hcoreX = mf.get_hcore() # a small random potential to break the Sz symmetry: pot = (np.random.random(hcoreX.shape) - 0.5) * 3e-2 pot = pot + pot.T hcoreX += pot mf.get_hcore = lambda *args: hcoreX mf.kernel() mycc_ref = serial_cc.GCCSD(mf) mycc_ref.conv_tol = 1e-8 mycc_ref.conv_tol_normt = 1e-6 eris_ref = mycc_ref.ao2mo() # initial MP2 emp2_ref, t1_mp2_ref, t2_mp2_ref = mycc_ref.init_amps() # 1st step Ecc ecc_0_ref = mycc_ref.energy(t1_mp2_ref, t2_mp2_ref, eris_ref) # converged Ecc ecc_ref, t1_cc_ref, t2_cc_ref = mycc_ref.kernel() # converged lambda mycc_ref.max_cycle = 50
# return et
t3d = numpy.einsum('ia,bcjk->ijkabc', t1, bcjk)
t3d += numpy.einsum('ai,jkbc->ijkabc', eris.fock[nocc:,:nocc], t2)
t3d = t3d - t3d.transpose(0,1,2,4,3,5) - t3d.transpose(0,1,2,5,4,3)
t3d = t3d - t3d.transpose(1,0,2,3,4,5) - t3d.transpose(2,1,0,3,4,5)
t3d /= d3
et = numpy.einsum('ijkabc,ijkabc,ijkabc', (t3c+t3d).conj(), d3, t3c) / 36
return et
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import cc
mol = gto.Mole()
mol.atom = [
[8 , (0. , 0. , 0.)],
[1 , (0. , -.957 , .587)],
[1 , (0.2, .757 , .487)]]
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run(conv_tol=1e-1)
mycc = cc.CCSD(mf).set(conv_tol=1e-11).run()
et = mycc.ccsd_t()
mycc = cc.GCCSD(scf.addons.convert_to_ghf(mf)).set(conv_tol=1e-11).run()
eris = mycc.ao2mo()
print(kernel(mycc, eris) - et)
mol.verbose = 5
mol.output = '/dev/null'
mol.atom = [
[8 , (0. , 0. , 0.)],
[1 , (0. , -.757 , .587)],
[1 , (0. , .757 , .587)]]
mol.spin = 2
mol.basis = '3-21g'
mol.symmetry = 'C2v'
mol.build()
mol1 = copy.copy(mol)
mol1.symmetry = False
mf = scf.UHF(mol1).run(conv_tol=1e-14)
myucc = cc.UCCSD(mf).run()
mygcc = cc.GCCSD(mf).run()
def tearDownModule():
global mol, mol1, mf, myucc, mygcc
mol.stdout.close()
del mol, mol1, mf, myucc, mygcc
class KnownValues(unittest.TestCase):
def test_gccsd_t_compare_uccsd_t(self):
self.assertAlmostEqual(myucc.ccsd_t(), mygcc.ccsd_t(t1=None), 7)
def test_gccsd_t(self):
mf1 = copy.copy(mf)
nao, nmo = mf.mo_coeff[0].shape
numpy.random.seed(10)
mf1.mo_coeff = numpy.random.random((2,nao,nmo))
