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_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 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.)],