def test_update_amps(self):
mf = scf.UHF(mol).run()
numpy.random.seed(21)
mf.mo_coeff = [numpy.random.random(mf.mo_coeff[0].shape) * .1] * 2
mycc = uccsd.UCCSD(mf)
eris = mycc.ao2mo()
nocc = mol.nelectron // 2
nvir = mol.nao_nr() - nocc
numpy.random.seed(1)
t1r = numpy.random.random((nocc, nvir)) * .1
t2r = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
t2r = t2r + t2r.transpose(1, 0, 3, 2)
t1 = addons.spatial2spin(t1r)
t2 = addons.spatial2spin(t2r)
l1r = numpy.random.random((nocc, nvir)) * .1
l2r = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
l2r = l2r + l2r.transpose(1, 0, 3, 2)
l1 = addons.spatial2spin(l1r)
l2 = addons.spatial2spin(l2r)
l1ref, l2ref = update_l1l2(mf, t1, t2, l1, l2, eris.orbspin)
eris = uccsd_lambda._eris_spatial2spin(mycc, eris)
imds = uccsd_lambda.make_intermediates(mycc, t1, t2, eris)
l1, l2 = uccsd_lambda.update_amps(mycc, t1, t2, l1, l2, eris, imds)
self.assertAlmostEqual(abs(l1 - l1ref).max(), 0, 8)
self.assertAlmostEqual(abs(l2 - l2ref).max(), 0, 8)
def test_rdm(self):
nocc = 5
nvir = 7
mol = gto.M()
mf = scf.UHF(mol)
mf.mo_occ = numpy.zeros((2, nocc + nvir))
mf.mo_occ[:, :nocc] = 1
mycc = uccsd.UCCSD(mf)
def antisym(t2):
t2 = t2 - t2.transpose(0, 1, 3, 2)
t2 = t2 - t2.transpose(1, 0, 2, 3)
return t2
orbspin = numpy.zeros((nocc + nvir) * 2, dtype=int)
orbspin[1::2] = 1
numpy.random.seed(1)
t1 = numpy.random.random((2, nocc, nvir)) * .1 - .1
t2ab = numpy.random.random((nocc, nocc, nvir, nvir)) * .1 - .1
t2aa = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1 - .1)
t2bb = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1 - .1)
t2 = (t2aa, t2ab, t2bb)
l1 = numpy.random.random((2, nocc, nvir)) * .1 - .1
l2ab = numpy.random.random((nocc, nocc, nvir, nvir)) * .1 - .1
l2aa = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1 - .1)
l2bb = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1 - .1)
l2 = (l2aa, l2ab, l2bb)
dm1a, dm1b = mycc.make_rdm1(t1, t2, l1, l2)
dm2aa, dm2ab, dm2bb = mycc.make_rdm2(t1, t2, l1, l2)
ia = orbspin == 0
ib = orbspin == 1
oa = orbspin[:nocc * 2] == 0
ob = orbspin[:nocc * 2] == 1
va = orbspin[nocc * 2:] == 0
vb = orbspin[nocc * 2:] == 1
t1 = addons.spatial2spin(t1, orbspin)
t2 = addons.spatial2spin(t2, orbspin)
l1 = addons.spatial2spin(l1, orbspin)
l2 = addons.spatial2spin(l2, orbspin)
mf1 = scf.GHF(mol)
mf1.mo_occ = numpy.zeros((nocc + nvir) * 2)
mf.mo_occ[:, :nocc * 2] = 1
mycc1 = gccsd.GCCSD(mf1)
dm1 = mycc1.make_rdm1(t1, t2, l1, l2)
dm2 = mycc1.make_rdm2(t1, t2, l1, l2)
self.assertAlmostEqual(abs(dm1[ia][:, ia] - dm1a).max(), 0, 9)
self.assertAlmostEqual(abs(dm1[ib][:, ib] - dm1b).max(), 0, 9)
self.assertAlmostEqual(
abs(dm2[ia][:, ia][:, :, ia][:, :, :, ia] - dm2aa).max(), 0, 9)
self.assertAlmostEqual(
abs(dm2[ia][:, ia][:, :, ib][:, :, :, ib] - dm2ab).max(), 0, 9)
self.assertAlmostEqual(
abs(dm2[ib][:, ib][:, :, ib][:, :, :, ib] - dm2bb).max(), 0, 9)
def test_spin2spatial(self):
t1g = addons.spatial2spin(myrcc.t1)
t2g = addons.spatial2spin(myrcc.t2)
orbspin = gmf.mo_coeff.orbspin
t1a, t1b = addons.spin2spatial(t1g, orbspin)
t2aa, t2ab, t2bb = addons.spin2spatial(t2g, orbspin)
self.assertAlmostEqual(abs(myrcc.t1 - t1a).max(), 0, 12)
self.assertAlmostEqual(abs(myrcc.t2 - t2ab).max(), 0, 12)
self.assertAlmostEqual(abs(t1g - addons.spatial2spin((t1a,t1b), orbspin)).max(), 0, 12)
self.assertAlmostEqual(abs(t2g - addons.spatial2spin((t2aa,t2ab,t2bb), orbspin)).max(), 0, 12)
def kernel(mycc,
eris,
t1=None,
t2=None,
l1=None,
l2=None,
max_cycle=50,
tol=1e-8,
verbose=logger.INFO):
cput0 = (time.clock(), time.time())
if isinstance(verbose, logger.Logger):
log = verbose
else:
log = logger.Logger(mycc.stdout, verbose)
eris = _eris_spatial2spin(mycc, eris)
if t1 is None: t1 = mycc.t1
if t2 is None: t2 = mycc.t2
if not isinstance(t1, numpy.ndarray):
t1 = spatial2spin(t1, eris.orbspin)
t2 = spatial2spin(t2, eris.orbspin)
if l1 is None: l1 = t1
if l2 is None: l2 = t2
imds = make_intermediates(mycc, t1, t2, eris)
if mycc.diis:
adiis = lib.diis.DIIS(mycc, mycc.diis_file)
adiis.space = mycc.diis_space
else:
adiis = lambda t1, t2, *args: (t1, t2)
cput0 = log.timer('UCCSD lambda initialization', *cput0)
conv = False
for istep in range(max_cycle):
l1new, l2new = update_amps(mycc, t1, t2, l1, l2, eris, imds)
normt = numpy.linalg.norm(l1new - l1) + numpy.linalg.norm(l2new - l2)
l1, l2 = l1new, l2new
l1new = l2new = None
if mycc.diis:
l1 = spin2spatial(l1, eris.orbspin)
l2 = spin2spatial(l2, eris.orbspin)
l1, l2 = mycc.diis(l1, l2, istep, normt, 0, adiis)
l1 = spatial2spin(l1, eris.orbspin)
l2 = spatial2spin(l2, eris.orbspin)
log.info('cycle = %d norm(lambda1,lambda2) = %.6g', istep + 1, normt)
cput0 = log.timer('UCCSD iter', *cput0)
if normt < tol:
conv = True
break
l1 = spin2spatial(l1, eris.orbspin)
l2 = spin2spatial(l2, eris.orbspin)
return conv, l1, l2
def test_rdm(self):
nocc = 5
nvir = 7
mol = gto.M()
mf = scf.UHF(mol)
mf.mo_occ = numpy.zeros((2,nocc+nvir))
mf.mo_occ[:,:nocc] = 1
mycc = uccsd.UCCSD(mf)
def antisym(t2):
t2 = t2 - t2.transpose(0,1,3,2)
t2 = t2 - t2.transpose(1,0,2,3)
return t2
orbspin = numpy.zeros((nocc+nvir)*2, dtype=int)
orbspin[1::2] = 1
numpy.random.seed(1)
t1 = numpy.random.random((2,nocc,nvir))*.1 - .1
t2ab = numpy.random.random((nocc,nocc,nvir,nvir))*.1 - .1
t2aa = antisym(numpy.random.random((nocc,nocc,nvir,nvir))*.1 - .1)
t2bb = antisym(numpy.random.random((nocc,nocc,nvir,nvir))*.1 - .1)
t2 = (t2aa,t2ab,t2bb)
l1 = numpy.random.random((2,nocc,nvir))*.1 - .1
l2ab = numpy.random.random((nocc,nocc,nvir,nvir))*.1 - .1
l2aa = antisym(numpy.random.random((nocc,nocc,nvir,nvir))*.1 - .1)
l2bb = antisym(numpy.random.random((nocc,nocc,nvir,nvir))*.1 - .1)
l2 = (l2aa,l2ab,l2bb)
dm1a, dm1b = mycc.make_rdm1(t1, t2, l1, l2)
dm2aa, dm2ab, dm2bb = mycc.make_rdm2(t1, t2, l1, l2)
ia = orbspin == 0
ib = orbspin == 1
oa = orbspin[:nocc*2] == 0
ob = orbspin[:nocc*2] == 1
va = orbspin[nocc*2:] == 0
vb = orbspin[nocc*2:] == 1
t1 = addons.spatial2spin(t1, orbspin)
t2 = addons.spatial2spin(t2, orbspin)
l1 = addons.spatial2spin(l1, orbspin)
l2 = addons.spatial2spin(l2, orbspin)
mf1 = scf.GHF(mol)
mf1.mo_occ = numpy.zeros((nocc+nvir)*2)
mf.mo_occ[:,:nocc*2] = 1
mycc1 = gccsd.GCCSD(mf1)
dm1 = mycc1.make_rdm1(t1, t2, l1, l2)
dm2 = mycc1.make_rdm2(t1, t2, l1, l2)
self.assertAlmostEqual(abs(dm1[ia][:,ia]-dm1a).max(), 0, 9)
self.assertAlmostEqual(abs(dm1[ib][:,ib]-dm1b).max(), 0, 9)
self.assertAlmostEqual(abs(dm2[ia][:,ia][:,:,ia][:,:,:,ia]-dm2aa).max(), 0, 9)
self.assertAlmostEqual(abs(dm2[ia][:,ia][:,:,ib][:,:,:,ib]-dm2ab).max(), 0, 9)
self.assertAlmostEqual(abs(dm2[ib][:,ib][:,:,ib][:,:,:,ib]-dm2bb).max(), 0, 9)
def test_spin2spatial(self):
t1g = addons.spatial2spin(myrcc.t1)
t2g = addons.spatial2spin(myrcc.t2)
orbspin = gmf.mo_coeff.orbspin
t1a, t1b = addons.spin2spatial(t1g, orbspin)
t2aa, t2ab, t2bb = addons.spin2spatial(t2g, orbspin)
self.assertAlmostEqual(abs(myrcc.t1 - t1a).max(), 0, 12)
self.assertAlmostEqual(abs(myrcc.t2 - t2ab).max(), 0, 12)
self.assertAlmostEqual(
abs(t1g - addons.spatial2spin((t1a, t1b), orbspin)).max(), 0, 12)
self.assertAlmostEqual(
abs(t2g - addons.spatial2spin((t2aa, t2ab, t2bb), orbspin)).max(),
0, 12)
def from_ucisdvec(civec, nocc, orbspin):
'''Convert the (spin-separated) CISD coefficient vector to GCISD
coefficient vector'''
nmoa = numpy.count_nonzero(orbspin == 0)
nmob = numpy.count_nonzero(orbspin == 1)
if isinstance(nocc, int):
nocca = numpy.count_nonzero(orbspin[:nocc] == 0)
noccb = numpy.count_nonzero(orbspin[:nocc] == 1)
else:
nocca, noccb = nocc
nvira, nvirb = nmoa-nocca, nmob-noccb
if civec.size == nocca*nvira + (nocca*nvira)**2 + 1: # RCISD
c0, c1, c2 = cisd.cisdvec_to_amplitudes(civec, nmoa, nocca)
else: # UCISD
c0, c1, c2 = ucisd.cisdvec_to_amplitudes(civec, (nmoa,nmob), (nocca,noccb))
c1 = spatial2spin(c1, orbspin)
c2 = spatial2spin(c2, orbspin)
return amplitudes_to_cisdvec(c0, c1, c2)
def from_ucisdvec(civec, nocc, orbspin):
'''Convert the (spin-separated) CISD coefficient vector to GCISD
coefficient vector'''
nmoa = numpy.count_nonzero(orbspin == 0)
nmob = numpy.count_nonzero(orbspin == 1)
if isinstance(nocc, int):
nocca = numpy.count_nonzero(orbspin[:nocc] == 0)
noccb = numpy.count_nonzero(orbspin[:nocc] == 1)
else:
nocca, noccb = nocc
nvira, nvirb = nmoa-nocca, nmob-noccb
if civec.size == nocca*nvira + (nocca*nvira)**2 + 1: # RCISD
c0, c1, c2 = cisd.cisdvec_to_amplitudes(civec, nmoa, nocca)
else: # UCISD
c0, c1, c2 = ucisd.cisdvec_to_amplitudes(civec, (nmoa,nmob), (nocca,noccb))
c1 = spatial2spin(c1, orbspin)
c2 = spatial2spin(c2, orbspin)
return amplitudes_to_cisdvec(c0, c1, c2)
def from_fci(ci0, nelec, orbspin):
from pyscf.cc.addons import spatial2spin
nocc = nelec
oidxa = orbspin[:nocc] == 0
oidxb = orbspin[:nocc] == 1
vidxa = orbspin[nocc:] == 0
vidxb = orbspin[nocc:] == 1
nocca = numpy.count_nonzero(oidxa)
noccb = numpy.count_nonzero(oidxb)
nvira = numpy.count_nonzero(vidxa)
nvirb = numpy.count_nonzero(vidxb)
norba = nocca + nvira
norbb = noccb + nvirb
t1addra, t1signa = t1strs(norba, nocca)
t1addrb, t1signb = t1strs(norbb, noccb)
na = fci.cistring.num_strings(norba, nocca)
nb = fci.cistring.num_strings(norbb, noccb)
ci0 = ci0.reshape(na, nb)
c0 = ci0[0, 0]
c1a = ((ci0[t1addra, 0] * t1signa).reshape(nvira, nocca).T)[::-1]
c1b = ((ci0[0, t1addrb] * t1signb).reshape(nvirb, noccb).T)[::-1]
c1 = spatial2spin((c1a, c1b), orbspin)
c2ab = numpy.einsum('i,j,ij->ij', t1signa, t1signb, ci0[t1addra][:,
t1addrb])
c2ab = c2ab.reshape(nvira, nocca, nvirb, noccb).transpose(1, 3, 0, 2)
c2ab = c2ab[::-1, ::-1]
t2addra, t2signa = t2strs(norba, nocca)
c2aa = (ci0[t2addra, 0] * t2signa).reshape(nvira * (nvira - 1) // 2, -1).T
c2aa = _unpack_4fold(c2aa[::-1], nocca, nvira)
t2addrb, t2signb = t2strs(norbb, noccb)
c2bb = (ci0[0, t2addrb] * t2signb).reshape(nvirb * (nvirb - 1) // 2, -1).T
c2bb = _unpack_4fold(c2bb[::-1], noccb, nvirb)
c2 = spatial2spin((c2aa, c2ab, c2bb), orbspin)
cisdvec = amplitudes_to_cisdvec(c0, c1, c2)
return cisdvec
def ccsd_single_amps(self):
r"""A 2-dimension array t[a,i] for CCSD single excitation amplitudes
where a is virtual index and i is occupied index.
"""
if self._ccsd_single_amps is None:
ccsd = self._pyscf_data.get('ccsd', None)
if ccsd is None:
return None
t1 = spatial2spin(ccsd.t1)
no, nv = t1.shape
nmo = no + nv
self._ccsd_single_amps = numpy.zeros((nmo, nmo))
self._ccsd_single_amps[no:, :no] = t1.T
return self._ccsd_single_amps
def ccsd_double_amps(self):
r"""A 4-dimension array t[a,i,b,j] for CCSD double excitation amplitudes
where a, b are virtual indices and i, j are occupied indices.
"""
if self._ccsd_double_amps is None:
ccsd = self._pyscf_data.get('ccsd', None)
if ccsd is None:
return None
t2 = spatial2spin(ccsd.t2)
no, nv = t2.shape[1:3]
nmo = no + nv
self._ccsd_double_amps = numpy.zeros((nmo, nmo, nmo, nmo))
self._ccsd_double_amps[no:, :no,
no:, :no] = .5 * t2.transpose(2, 0, 3, 1)
return self._ccsd_double_amps
def test_update_lambda_real(self):
numpy.random.seed(21)
eris = mycc.ao2mo()
gcc1 = gccsd.GCCSD(scf.addons.convert_to_ghf(mf))
eri1 = gcc1.ao2mo()
orbspin = eri1.orbspin
nocc = mol.nelectron
nvir = mol.nao_nr() * 2 - nocc
t1r = numpy.random.random((nocc, nvir)) * .1
t2r = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
t2r = t2r - t2r.transpose(1, 0, 2, 3)
t2r = t2r - t2r.transpose(0, 1, 3, 2)
l1r = numpy.random.random((nocc, nvir)) * .1
l2r = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
l2r = l2r - l2r.transpose(1, 0, 2, 3)
l2r = l2r - l2r.transpose(0, 1, 3, 2)
t1r = addons.spin2spatial(t1r, orbspin)
t2r = addons.spin2spatial(t2r, orbspin)
t1r = addons.spatial2spin(t1r, orbspin)
t2r = addons.spatial2spin(t2r, orbspin)
l1r = addons.spin2spatial(l1r, orbspin)
l2r = addons.spin2spatial(l2r, orbspin)
l1r = addons.spatial2spin(l1r, orbspin)
l2r = addons.spatial2spin(l2r, orbspin)
imds = gccsd_lambda.make_intermediates(gcc1, t1r, t2r, eri1)
l1ref, l2ref = gccsd_lambda.update_lambda(gcc1, t1r, t2r, l1r, l2r,
eri1, imds)
t1 = addons.spin2spatial(t1r, orbspin)
t2 = addons.spin2spatial(t2r, orbspin)
l1 = addons.spin2spatial(l1r, orbspin)
l2 = addons.spin2spatial(l2r, orbspin)
imds = uccsd_lambda.make_intermediates(mycc, t1, t2, eris)
l1, l2 = uccsd_lambda.update_lambda(mycc, t1, t2, l1, l2, eris, imds)
self.assertAlmostEqual(
float(abs(addons.spatial2spin(l1, orbspin) - l1ref).max()), 0, 8)
self.assertAlmostEqual(
float(abs(addons.spatial2spin(l2, orbspin) - l2ref).max()), 0, 8)
l1ref = addons.spin2spatial(l1ref, orbspin)
l2ref = addons.spin2spatial(l2ref, orbspin)
self.assertAlmostEqual(abs(l1[0] - l1ref[0]).max(), 0, 8)
self.assertAlmostEqual(abs(l1[1] - l1ref[1]).max(), 0, 8)
self.assertAlmostEqual(abs(l2[0] - l2ref[0]).max(), 0, 8)
self.assertAlmostEqual(abs(l2[1] - l2ref[1]).max(), 0, 8)
self.assertAlmostEqual(abs(l2[2] - l2ref[2]).max(), 0, 8)
def test_update_lambda_real(self):
numpy.random.seed(21)
eris = mycc.ao2mo()
gcc1 = gccsd.GCCSD(scf.addons.convert_to_ghf(mf))
eri1 = gcc1.ao2mo()
orbspin = eri1.orbspin
nocc = mol.nelectron
nvir = mol.nao_nr()*2 - nocc
t1r = numpy.random.random((nocc,nvir))*.1
t2r = numpy.random.random((nocc,nocc,nvir,nvir))*.1
t2r = t2r - t2r.transpose(1,0,2,3)
t2r = t2r - t2r.transpose(0,1,3,2)
l1r = numpy.random.random((nocc,nvir))*.1
l2r = numpy.random.random((nocc,nocc,nvir,nvir))*.1
l2r = l2r - l2r.transpose(1,0,2,3)
l2r = l2r - l2r.transpose(0,1,3,2)
t1r = addons.spin2spatial(t1r, orbspin)
t2r = addons.spin2spatial(t2r, orbspin)
t1r = addons.spatial2spin(t1r, orbspin)
t2r = addons.spatial2spin(t2r, orbspin)
l1r = addons.spin2spatial(l1r, orbspin)
l2r = addons.spin2spatial(l2r, orbspin)
l1r = addons.spatial2spin(l1r, orbspin)
l2r = addons.spatial2spin(l2r, orbspin)
imds = gccsd_lambda.make_intermediates(gcc1, t1r, t2r, eri1)
l1ref, l2ref = gccsd_lambda.update_lambda(gcc1, t1r, t2r, l1r, l2r, eri1, imds)
t1 = addons.spin2spatial(t1r, orbspin)
t2 = addons.spin2spatial(t2r, orbspin)
l1 = addons.spin2spatial(l1r, orbspin)
l2 = addons.spin2spatial(l2r, orbspin)
imds = uccsd_lambda.make_intermediates(mycc, t1, t2, eris)
l1, l2 = uccsd_lambda.update_lambda(mycc, t1, t2, l1, l2, eris, imds)
self.assertAlmostEqual(float(abs(addons.spatial2spin(l1, orbspin)-l1ref).max()), 0, 8)
self.assertAlmostEqual(float(abs(addons.spatial2spin(l2, orbspin)-l2ref).max()), 0, 8)
l1ref = addons.spin2spatial(l1ref, orbspin)
l2ref = addons.spin2spatial(l2ref, orbspin)
self.assertAlmostEqual(abs(l1[0]-l1ref[0]).max(), 0, 8)
self.assertAlmostEqual(abs(l1[1]-l1ref[1]).max(), 0, 8)
self.assertAlmostEqual(abs(l2[0]-l2ref[0]).max(), 0, 8)
self.assertAlmostEqual(abs(l2[1]-l2ref[1]).max(), 0, 8)
self.assertAlmostEqual(abs(l2[2]-l2ref[2]).max(), 0, 8)
def spatial2spin(self, tx, orbspin=None):
if orbspin is None:
orbspin = getattr(self.mo_coeff, 'orbspin', None)
if orbspin is not None:
orbspin = orbspin[self.get_frozen_mask()]
return spatial2spin(tx, orbspin)
def spatial2spin(self, tx, orbspin=None):
if orbspin is None:
orbspin = getattr(self.mo_coeff, 'orbspin', None)
if orbspin is not None:
orbspin = orbspin[self.get_frozen_mask()]
return spatial2spin(tx, orbspin)
def amplitudes_from_rccsd(t1, t2, orbspin=None):
'''Convert spatial orbital T1,T2 to spin-orbital T1,T2'''
return spatial2spin(t1, orbspin), spatial2spin(t2, orbspin)
def amplitudes_from_rccsd(t1, t2, orbspin=None):
'''Convert spatial orbital T1,T2 to spin-orbital T1,T2'''
return spatial2spin(t1, orbspin), spatial2spin(t2, orbspin)
def gamma2_intermediates(cc, t1, t2, l1, l2):
t1a, t1b = t1
t2aa, t2ab, t2bb = t2
l1a, l1b = l1
l2aa, l2ab, l2bb = l2
nocca, nvira = t1a.shape
noccb, nvirb = t1b.shape
# tauaa = t2aa*.5 + numpy.einsum('ia,jb->ijab', t1a, t1a)
# tauab = t2ab + numpy.einsum('ia,jb->ijab', t1a, t1b)
# taubb = t2bb*.5 + numpy.einsum('ia,jb->ijab', t1b, t1b)
# gvvvv = numpy.einsum('ijab,ijcd->abcd', l2aa, tauaa) * .25
# gvVvV = numpy.einsum('ijab,ijcd->abcd', l2ab, tauab) * .25
# gVVVV = numpy.einsum('ijab,ijcd->abcd', l2bb, taubb) * .25
#
# goooo = numpy.einsum('ijab,klab->klij', l2aa, tauaa) * .25
# goOoO = numpy.einsum('ijab,klab->klij', l2ab, tauab) * .25
# gOOOO = numpy.einsum('ijab,klab->klij', l2bb, taubb) * .25
t1 = addons.spatial2spin(t1, cc.orbspin)
t2 = addons.spatial2spin(t2, cc.orbspin)
l1 = addons.spatial2spin(l1, cc.orbspin)
l2 = addons.spatial2spin(l2, cc.orbspin)
tau = t2 + einsum('ia,jb->ijab', t1, t1) * 2
miajb = einsum('ikac,kjcb->iajb', l2, t2)
goovv = 0.25 * (l2 + tau)
tmp = einsum('kc,kica->ia', l1, t2)
goovv += einsum('ia,jb->ijab', tmp, t1)
tmp = einsum('kc,kb->cb', l1, t1)
goovv += 0.5 * einsum('cb,ijca->ijab', tmp, t2)
tmp = einsum('kc,jc->kj', l1, t1)
goovv += 0.5 * einsum('kiab,kj->ijab', tau, tmp)
tmp = numpy.einsum('ldjd->lj', miajb)
goovv -= einsum('lj,liba->ijab', tmp, t2) * .25
goovv -= einsum('li,la,jb->ijab', tmp, t1, t1) * .5
tmp = numpy.einsum('ldlb->db', miajb)
goovv -= einsum('db,jida->ijab', tmp, t2) * .25
goovv -= einsum('da,id,jb->ijab', tmp, t1, t1) * .5
goovv -= einsum('ldia,ljbd->ijab', miajb, tau) * .5
tmp = einsum('klcd,ijcd->ijkl', l2, tau) * .25**2
goovv += einsum('ijkl,klab->ijab', tmp, tau)
gvvvv = 0.125 * einsum('ijab,ijcd->abcd', l2, tau)
goooo = 0.125 * einsum('klab,ijab->klij', tau, l2)
gooov = -0.5 * einsum('jkba,ib->jkia', tau, l1)
gooov += einsum('jkil,la->jkia', goooo, t1) * 2
tmp = numpy.einsum('icjc->ij', miajb)
gooov -= einsum('ij,ka->jkia', tmp, t1) * .5
gooov += einsum('icja,kc->jkia', miajb, t1)
gooov += einsum('jkab,ib->jkia', l2, t1) * .5
govvo = einsum('ia,jb->jabi', l1, t1)
govvo += numpy.einsum('iajb->jabi', miajb)
govvo -= einsum('ikac,jc,kb->jabi', l2, t1, t1)
gvovv = 0.5 * einsum('ja,jibc->aibc', l1, tau)
gvovv -= einsum('adbc,id->aibc', gvvvv, t1) * 2
tmp = numpy.einsum('kakb->ab', miajb)
gvovv += einsum('ab,ic->aibc', tmp, t1) * .5
gvovv -= einsum('kaib,kc->aibc', miajb, t1)
gvovv -= 0.5 * einsum('ijbc,ja->aibc', l2, t1)
dovov = goovv.transpose(0, 2, 1, 3) - goovv.transpose(0, 3, 1, 2)
dvvvv = gvvvv.transpose(0, 2, 1, 3) - gvvvv.transpose(0, 3, 1, 2)
doooo = goooo.transpose(0, 2, 1, 3) - goooo.transpose(0, 3, 1, 2)
dvvov = gvovv.transpose(0, 2, 1, 3) - gvovv.transpose(0, 3, 1, 2)
dooov = gooov.transpose(0, 2, 1, 3) - gooov.transpose(1, 2, 0, 3)
dovvo = govvo.transpose(0, 2, 1, 3)
doovv = -numpy.einsum('jabi->jiab', govvo)
return (dovov, dvvvv, doooo, doovv, dovvo, dvvov, None, dooov)
mf.mo_occ = [occ] * 2
mycc = uccsd.UCCSD(mf)
def antisym(t2):
t2 = t2 - t2.transpose(0, 1, 3, 2)
t2 = t2 - t2.transpose(1, 0, 2, 3)
return t2
numpy.random.seed(1)
t1r = numpy.random.random((nocc, nvir)) * .1
t1 = (t1r, t1r)
t2r = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
t2aa = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1)
t2bb = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1)
t2 = (t2aa, t2r, t2bb)
t1spin = addons.spatial2spin(t1)
t2spin = addons.spatial2spin(t2)
l1r = numpy.random.random((nocc, nvir)) * .1
l1 = (l1r, l1r)
l2r = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
l2aa = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1)
l2bb = antisym(numpy.random.random((nocc, nocc, nvir, nvir)) * .1)
l2 = (l2aa, l2r, l2bb)
l1spin = addons.spatial2spin(l1)
l2spin = addons.spatial2spin(l2)
# import cclambda_rsp
# mycc.t1 = t1spin
# mycc.t2 = t2spin
# mycc.L1 = l1spin
# mycc.L2 = l2spin
from pyscf import scf
from pyscf import fci
from pyscf.cc.addons import spatial2spin
numpy.random.seed(12)
nocc = 3
nvir = 5
nmo = nocc + nvir
orbspin = numpy.zeros(nmo * 2, dtype=int)
orbspin[1::2] = 1
c1a = numpy.random.random((nocc, nvir))
c1b = numpy.random.random((nocc, nvir))
c2aa = numpy.random.random((nocc, nocc, nvir, nvir))
c2bb = numpy.random.random((nocc, nocc, nvir, nvir))
c2ab = numpy.random.random((nocc, nocc, nvir, nvir))
c1 = spatial2spin((c1a, c1b), orbspin)
c2 = spatial2spin((c2aa, c2ab, c2bb), orbspin)
cisdvec = amplitudes_to_cisdvec(1., c1, c2)
fcivec = to_fci(cisdvec, nocc * 2, orbspin)
cisdvec1 = from_fci(fcivec, nocc * 2, orbspin)
print(abs(cisdvec - cisdvec1).sum())
ci1 = to_fci(cisdvec1, nocc * 2, orbspin)
print(abs(fcivec - ci1).sum())
mol = gto.Mole()
mol.verbose = 0
mol.atom = [
['H', (1., -1., 0.)],
['H', (0., -1., -1.)],
['H', (1., -0.5, 0.)],
['H', (0., -1., 1.)],
