def RCCSD(mf, frozen=None, mo_coeff=None, mo_occ=None):
__doc__ = ccsd.CCSD.__doc__
import numpy
from pyscf import lib
from pyscf.soscf import newton_ah
from pyscf.cc import dfccsd
if isinstance(mf, scf.uhf.UHF):
raise RuntimeError('RCCSD cannot be used with UHF method.')
elif isinstance(mf, scf.rohf.ROHF):
lib.logger.warn(mf, 'RCCSD method does not support ROHF method. ROHF object '
'is converted to UHF object and UCCSD method is called.')
mf = scf.addons.convert_to_uhf(mf)
return UCCSD(mf, frozen, mo_coeff, mo_occ)
if isinstance(mf, newton_ah._CIAH_SOSCF) or not isinstance(mf, scf.hf.RHF):
mf = scf.addons.convert_to_rhf(mf)
if getattr(mf, 'with_df', None):
return dfccsd.RCCSD(mf, frozen, mo_coeff, mo_occ)
elif numpy.iscomplexobj(mo_coeff) or numpy.iscomplexobj(mf.mo_coeff):
return rccsd.RCCSD(mf, frozen, mo_coeff, mo_occ)
else:
return ccsd.CCSD(mf, frozen, mo_coeff, mo_occ)
def make_mycc1():
mf1 = copy.copy(mf)
no = mol.nelectron // 2
n = mol.nao_nr()
nv = n - no
mf1.mo_occ = numpy.zeros(mol.nao_nr())
mf1.mo_occ[:no] = 2
numpy.random.seed(12)
mf1.mo_coeff = numpy.random.random((n, n))
dm = mf1.make_rdm1(mf1.mo_coeff, mf1.mo_occ)
fockao = mf1.get_hcore() + mf1.get_veff(mol, dm)
mf1.mo_energy = numpy.einsum('pi,pq,qi->i', mf1.mo_coeff, fockao,
mf1.mo_coeff)
idx = numpy.hstack(
[mf1.mo_energy[:no].argsort(), no + mf1.mo_energy[no:].argsort()])
mf1.mo_coeff = mf1.mo_coeff[:, idx]
mycc1 = rccsd.RCCSD(mf1)
eris1 = mycc1.ao2mo()
numpy.random.seed(12)
r1 = numpy.random.random((no, nv)) - .9
r2 = numpy.random.random((no, no, nv, nv)) - .9
r2 = r2 + r2.transpose(1, 0, 3, 2)
mycc1.t1 = r1 * 1e-5
mycc1.t2 = r2 * 1e-5
return mf1, mycc1, eris1
def test_rdm(self):
mycc = rccsd.RCCSD(mf)
mycc.frozen = 1
mycc.kernel()
dm1 = mycc.make_rdm1()
dm2 = mycc.make_rdm2()
h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff))
nmo = mf.mo_coeff.shape[1]
eri = ao2mo.restore(1, ao2mo.kernel(mf._eri, mf.mo_coeff), nmo)
e1 = numpy.einsum('ij,ji', h1, dm1)
e1 += numpy.einsum('ijkl,ijkl', eri, dm2) * .5
e1 += mol.energy_nuc()
self.assertAlmostEqual(e1, mycc.e_tot, 7)
d1 = ccsd_rdm._gamma1_intermediates(mycc, mycc.t1, mycc.t2, mycc.l1,
mycc.l2)
mycc1 = copy.copy(mycc)
mycc1.max_memory = 0
d2 = ccsd_rdm._gamma2_intermediates(mycc1, mycc.t1, mycc.t2, mycc.l1,
mycc.l2, True)
dm2 = ccsd_rdm._make_rdm2(mycc,
d1,
d2,
with_dm1=True,
with_frozen=True)
e1 = numpy.einsum('ij,ji', h1, dm1)
e1 += numpy.einsum('ijkl,ijkl', eri, dm2) * .5
e1 += mol.energy_nuc()
self.assertAlmostEqual(e1, mycc.e_tot, 7)
def setUpModule():
global mol, mf, mycc
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '631g'
mol.verbose = 5
mol.output = '/dev/null'
mol.build()
mf = scf.RHF(mol).run()
mycc = rccsd.RCCSD(mf)
def RCCSD(mf, frozen=[], mo_coeff=None, mo_occ=None):
from pyscf.cc import rccsd
from pyscf import lib
from pyscf import scf
if isinstance(mf, scf.uhf.UHF):
raise RuntimeError('RCCSD cannot be used with UHF method.')
elif isinstance(mf, scf.rohf.ROHF):
lib.logger.warn(
mf, 'RCCSD method does not support ROHF method. ROHF object '
'is converted to UHF object and UCCSD method is called.')
mf = scf.addons.convert_to_uhf(mf)
return UCCSD(mf, [frozen, frozen], mo_coeff, mo_occ)
else:
return rccsd.RCCSD(mf, frozen, mo_coeff, mo_occ)
def test_ERIS(self):
mycc = rccsd.RCCSD(mf)
numpy.random.seed(1)
mo_coeff = numpy.random.random(mf.mo_coeff.shape)
eris = rccsd._make_eris_incore(mycc, mo_coeff)
self.assertAlmostEqual(lib.finger(eris.oooo), 4.963884938282539, 11)
self.assertAlmostEqual(lib.finger(eris.ovoo), -1.362368189698315, 11)
self.assertAlmostEqual(lib.finger(eris.ovov), 125.815506844421580, 11)
self.assertAlmostEqual(lib.finger(eris.oovv), 55.123681017639463, 11)
self.assertAlmostEqual(lib.finger(eris.ovvo), 133.480835278982620, 11)
self.assertAlmostEqual(lib.finger(eris.ovvv), 95.756230114113222, 11)
self.assertAlmostEqual(lib.finger(eris.vvvv), -10.450387490987071, 11)
ccsd.MEMORYMIN, bak = 0, ccsd.MEMORYMIN
mycc.max_memory = 0
eris1 = mycc.ao2mo(mo_coeff)
ccsd.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)
# 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 = rccsd._make_eris_incore(mycc, 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)
def test_update_lambda_real(self):
mycc = rccsd.RCCSD(mf)
np.random.seed(12)
nocc = 5
nmo = 12
nvir = nmo - nocc
eri0 = np.random.random((nmo, nmo, nmo, nmo))
eri0 = ao2mo.restore(1, ao2mo.restore(8, eri0, nmo), nmo)
fock0 = np.random.random((nmo, nmo))
fock0 = fock0 + fock0.T + np.diag(range(nmo)) * 2
t1 = np.random.random((nocc, nvir))
t2 = np.random.random((nocc, nocc, nvir, nvir))
t2 = t2 + t2.transpose(1, 0, 3, 2)
l1 = np.random.random((nocc, nvir))
l2 = np.random.random((nocc, nocc, nvir, nvir))
l2 = l2 + l2.transpose(1, 0, 3, 2)
eris = rccsd._ChemistsERIs(mol)
eris.oooo = eri0[:nocc, :nocc, :nocc, :nocc].copy()
eris.ovoo = eri0[:nocc, nocc:, :nocc, :nocc].copy()
eris.oovv = eri0[:nocc, :nocc, nocc:, nocc:].copy()
eris.ovvo = eri0[:nocc, nocc:, nocc:, :nocc].copy()
eris.ovov = eri0[:nocc, nocc:, :nocc, nocc:].copy()
idx = np.tril_indices(nvir)
eris.ovvv = eri0[:nocc, nocc:, nocc:, nocc:].copy()
eris.vvvv = eri0[nocc:, nocc:, nocc:, nocc:].copy()
eris.fock = fock0
imds = rccsd_lambda.make_intermediates(mycc, t1, t2, eris)
l1new, l2new = rccsd_lambda.update_lambda(mycc, t1, t2, l1, l2, eris,
imds)
self.assertAlmostEqual(lib.finger(l1new), -6699.5335665027187, 9)
self.assertAlmostEqual(lib.finger(l2new), -514.7001243502192, 9)
self.assertAlmostEqual(
abs(l2new - l2new.transpose(1, 0, 3, 2)).max(), 0, 12)
mycc.max_memory = 0
imds = rccsd_lambda.make_intermediates(mycc, t1, t2, eris)
l1new, l2new = rccsd_lambda.update_lambda(mycc, t1, t2, l1, l2, eris,
imds)
self.assertAlmostEqual(lib.finger(l1new), -6699.5335665027187, 9)
self.assertAlmostEqual(lib.finger(l2new), -514.7001243502192, 9)
self.assertAlmostEqual(
abs(l2new - l2new.transpose(1, 0, 3, 2)).max(), 0, 12)
def setUpModule():
global mol, mf, eris, mycc
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol)
mf.chkfile = tempfile.NamedTemporaryFile().name
mf.conv_tol_grad = 1e-8
mf.kernel()
mycc = rccsd.RCCSD(mf)
mycc.conv_tol = 1e-10
eris = mycc.ao2mo()
mycc.kernel(eris=eris)
def RCCSD(mf, frozen=0, mo_coeff=None, mo_occ=None):
import numpy
from pyscf.cc import rccsd
from pyscf import lib
from pyscf import scf
if isinstance(mf, scf.uhf.UHF):
raise RuntimeError('RCCSD cannot be used with UHF method.')
elif isinstance(mf, scf.rohf.ROHF):
lib.logger.warn(
mf, 'RCCSD method does not support ROHF method. ROHF object '
'is converted to UHF object and UCCSD method is called.')
mf = scf.addons.convert_to_uhf(mf)
return UCCSD(mf, frozen, mo_coeff, mo_occ)
elif hasattr(mf, 'with_df') and 'pbc' in str(mf.__module__):
from pyscf.cc import dfccsd
return dfccsd.CCSD(mf, frozen, mo_coeff, mo_occ)
else:
return rccsd.RCCSD(mf, frozen, mo_coeff, mo_occ)
def test_update_amps(self):
mol = gto.M()
nocc, nvir = 5, 12
nmo = nocc + nvir
nmo_pair = nmo * (nmo + 1) // 2
mf = scf.RHF(mol)
np.random.seed(12)
mf._eri = np.random.random(nmo_pair * (nmo_pair + 1) // 2)
mf.mo_coeff = np.random.random((nmo, nmo))
mf.mo_energy = np.arange(0., nmo)
mf.mo_occ = np.zeros(nmo)
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)
mycc1 = rccsd.RCCSD(mf)
eris1 = mycc1.ao2mo()
mycc2 = ccsd.CCSD(mf)
eris2 = mycc2.ao2mo()
a = np.random.random((nmo, nmo)) * .1
eris1.fock += a + a.T.conj()
eris2.fock += a + a.T
t1 = np.random.random((nocc, nvir)) * .1
t2 = np.random.random((nocc, nocc, nvir, nvir)) * .1
t2 = t2 + t2.transpose(1, 0, 3, 2)
t1b, t2b = ccsd.update_amps(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(t1b), -106360.5276951083, 6)
self.assertAlmostEqual(lib.finger(t2b), 66540.100267798145, 6)
mycc2.max_memory = 0
t1a, t2a = ccsd.update_amps(mycc2, t1, t2, eris2)
self.assertAlmostEqual(abs(t1a - t1b).max(), 0, 9)
self.assertAlmostEqual(abs(t2a - t2b).max(), 0, 9)
t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(t2tril), 13306.139402693696, 8)
Ht2 = ccsd._add_vvvv_full(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(Ht2), 760.50164232208408, 9)
mycc1.cc2 = False
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a), -106360.5276951083, 7)
self.assertAlmostEqual(lib.finger(t2a), 66540.100267798145, 6)
self.assertAlmostEqual(abs(t1a - t1b).max(), 0, 6)
self.assertAlmostEqual(abs(t2a - t2b).max(), 0, 6)
mycc1.cc2 = True
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a), -106360.5276951083, 7)
self.assertAlmostEqual(lib.finger(t2a), -1517.9391800662809, 7)
mol = gto.Mole()
mol.verbose = 0
mol.atom = [[8, (0., 0., 0.)], [1, (1., 0., 0.)],
[1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]]
mol.basis = {
'H': 'sto3g',
'O': 'cc-pvdz',
}
mol.charge = 1
mol.build(0, 0)
mycc2.direct = True
eris2.vvvv = None
eris2.mol = mol
mycc2.mo_coeff, eris2.mo_coeff = eris2.mo_coeff, None
t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2, with_ovvv=True)
self.assertAlmostEqual(lib.finger(t2tril), 680.07199094501584, 9)
t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2, with_ovvv=False)
self.assertAlmostEqual(lib.finger(t2tril), 446.56702664171348, 9)
Ht2 = ccsd._add_vvvv_full(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(Ht2), 48.122317842230686, 9)
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
eris1.oooo = eri1[:nocc, :nocc, :nocc, :nocc].copy()
eris1.ovoo = eri1[:nocc, nocc:, :nocc, :nocc].copy()
eris1.ovov = eri1[:nocc, nocc:, :nocc, nocc:].copy()
eris1.oovv = eri1[:nocc, :nocc, nocc:, nocc:].copy()
eris1.ovvo = eri1[:nocc, nocc:, nocc:, :nocc].copy()
eris1.ovvv = eri1[:nocc, nocc:, nocc:, nocc:].copy()
eris1.vvvv = eri1[nocc:, nocc:, nocc:, nocc:].copy()
a = np.random.random((nmo, nmo)) * .1j
eris1.fock = eris1.fock + a + a.T.conj()
t1 = t1 + np.random.random((nocc, nvir)) * .1j
t2 = t2 + np.random.random((nocc, nocc, nvir, nvir)) * .1j
t2 = t2 + t2.transpose(1, 0, 3, 2)
mycc1.cc2 = False
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a),
-13.32050019680894 - 1.8825765910430254j, 9)
self.assertAlmostEqual(lib.finger(t2a),
9.2521062044785189 + 29.999480274811873j, 9)
mycc1.cc2 = True
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a),
-13.32050019680894 - 1.8825765910430254j, 9)
self.assertAlmostEqual(lib.finger(t2a),
-0.056223856104895858 + 0.025472249329733986j,
9)
from pyscf import lib
from pyscf import gto
from pyscf import scf
from pyscf import cc
from pyscf import ao2mo
from pyscf.cc import ccsd, rccsd, eom_rccsd
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.verbose = 0
mol.spin = 0
mol.build()
mf = scf.RHF(mol).run()
mycc = rccsd.RCCSD(mf).run()
def make_mycc1():
mf1 = copy.copy(mf)
no = mol.nelectron // 2
n = mol.nao_nr()
nv = n - no
mf1.mo_occ = numpy.zeros(mol.nao_nr())
mf1.mo_occ[:no] = 2
numpy.random.seed(12)
mf1.mo_coeff = numpy.random.random((n, n))
dm = mf1.make_rdm1(mf1.mo_coeff, mf1.mo_occ)
fockao = mf1.get_hcore() + mf1.get_veff(mol, dm)
mf1.mo_energy = numpy.einsum('pi,pq,qi->i', mf1.mo_coeff, fockao,
mf1.mo_coeff)
from pyscf.cc import ccsd
from pyscf.cc import rccsd
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol)
mf.conv_tol_grad = 1e-8
mf.kernel()
mycc = rccsd.RCCSD(mf)
mycc.conv_tol = 1e-10
eris = mycc.ao2mo()
mycc.kernel(eris=eris)
def tearDownModule():
global mol, mf, eris, mycc
mol.stdout.close()
del mol, mf, eris, mycc
class KnownValues(unittest.TestCase):
def test_roccsd(self):
mf = scf.ROHF(mol).run()
mycc = cc.RCCSD(mf).run()
def test_update_lambda_complex(self):
mo_coeff = mf.mo_coeff + np.sin(mf.mo_coeff) * .01j
nao = mo_coeff.shape[0]
eri = ao2mo.restore(1, mf._eri, nao)
eri0 = lib.einsum('pqrs,pi,qj,rk,sl->ijkl', eri, mo_coeff.conj(),
mo_coeff, mo_coeff.conj(), mo_coeff)
nocc, nvir = 5, nao - 5
eris = rccsd._ChemistsERIs(mol)
eris.oooo = eri0[:nocc, :nocc, :nocc, :nocc].copy()
eris.ovoo = eri0[:nocc, nocc:, :nocc, :nocc].copy()
eris.oovv = eri0[:nocc, :nocc, nocc:, nocc:].copy()
eris.ovvo = eri0[:nocc, nocc:, nocc:, :nocc].copy()
eris.ovov = eri0[:nocc, nocc:, :nocc, nocc:].copy()
eris.ovvv = eri0[:nocc, nocc:, nocc:, nocc:].copy()
eris.vvvv = eri0[nocc:, nocc:, nocc:, nocc:].copy()
eris.fock = np.diag(mf.mo_energy)
np.random.seed(1)
t1 = np.random.random((nocc, nvir)) + np.random.random(
(nocc, nvir)) * .1j - .5
t2 = np.random.random((nocc, nocc, nvir, nvir)) - .5
t2 = t2 + np.sin(t2) * .1j
t2 = t2 + t2.transpose(1, 0, 3, 2)
l1 = np.random.random((nocc, nvir)) + np.random.random(
(nocc, nvir)) * .1j - .5
l2 = np.random.random((nocc, nocc, nvir, nvir)) - .5
l2 = l2 + np.sin(l2) * .1j
l2 = l2 + l2.transpose(1, 0, 3, 2)
mycc = rccsd.RCCSD(mf)
imds = rccsd_lambda.make_intermediates(mycc, t1, t2, eris)
l1new_ref, l2new_ref = rccsd_lambda.update_lambda(
mycc, t1, t2, l1, l2, eris, imds)
orbspin = np.zeros(nao * 2, dtype=int)
orbspin[1::2] = 1
eri1 = np.zeros([nao * 2] * 4, dtype=np.complex128)
eri1[0::2,0::2,0::2,0::2] = \
eri1[0::2,0::2,1::2,1::2] = \
eri1[1::2,1::2,0::2,0::2] = \
eri1[1::2,1::2,1::2,1::2] = eri0
eri1 = eri1.transpose(0, 2, 1, 3) - eri1.transpose(0, 2, 3, 1)
erig = gccsd._PhysicistsERIs(mol)
nocc *= 2
nvir *= 2
erig.oooo = eri1[:nocc, :nocc, :nocc, :nocc].copy()
erig.ooov = eri1[:nocc, :nocc, :nocc, nocc:].copy()
erig.ovov = eri1[:nocc, nocc:, :nocc, nocc:].copy()
erig.ovvo = eri1[:nocc, nocc:, nocc:, :nocc].copy()
erig.oovv = eri1[:nocc, :nocc, nocc:, nocc:].copy()
erig.ovvv = eri1[:nocc, nocc:, nocc:, nocc:].copy()
erig.vvvv = eri1[nocc:, nocc:, nocc:, nocc:].copy()
mo_e = np.array([mf.mo_energy] * 2)
erig.fock = np.diag(mo_e.T.ravel())
erig.mo_energy = erig.fock.diagonal()
myccg = gccsd.GCCSD(scf.addons.convert_to_ghf(mf))
t1, t2 = myccg.amplitudes_from_ccsd(t1, t2)
l1, l2 = myccg.amplitudes_from_ccsd(l1, l2)
imds = gccsd_lambda.make_intermediates(myccg, t1, t2, erig)
l1new, l2new = gccsd_lambda.update_lambda(myccg, t1, t2, l1, l2, erig,
imds)
self.assertAlmostEqual(float(abs(l1new[0::2, 0::2] - l1new_ref).max()),
0, 9)
l2aa = l2new[0::2, 0::2, 0::2, 0::2]
l2ab = l2new[0::2, 1::2, 0::2, 1::2]
self.assertAlmostEqual(float(abs(l2ab - l2new_ref).max()), 0, 9)
self.assertAlmostEqual(
float(abs(l2ab - l2ab.transpose(1, 0, 2, 3) - l2aa).max()), 0, 9)
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)
def RCCSD(mf, frozen=[], mo_energy=None, mo_coeff=None, mo_occ=None):
from pyscf.cc import rccsd
return rccsd.RCCSD(mf, frozen, mo_energy, mo_coeff, mo_occ)
def RCCSD(mf, frozen=[], mo_coeff=None, mo_occ=None):
from pyscf.cc import rccsd
mf = _convert_to_rhf(mf)
return rccsd.RCCSD(mf, frozen, mo_coeff, mo_occ)
