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))