def check_frozen(frozen):
myci = ci.UCISD(mf)
myci.frozen = frozen
myci.nroots = 2
myci.kernel()
nocc = myci.nocc
nmo = myci.nmo
norb = mf.mo_coeff[0].shape[1]
nfroz = len(frozen[0])
cibra = (myci.ci[0] + myci.ci[1]) * numpy.sqrt(.5)
fcibra = ucisd.to_fcivec(cibra, norb, mol.nelec, myci.frozen)
fciket = ucisd.to_fcivec(myci.ci[1], norb, mol.nelec, myci.frozen)
fcidm1 = fci.direct_spin1.trans_rdm1s(fcibra, fciket, norb, mol.nelec)
cidm1 = myci.trans_rdm1(cibra, myci.ci[1], nmo, nocc)
self.assertAlmostEqual(abs(fcidm1[0]-cidm1[0]).max(), 0, 12)
self.assertAlmostEqual(abs(fcidm1[1]-cidm1[1]).max(), 0, 12)
def test_contract(self):
'''cross check with UCISD'''
mol = gto.M()
mol.nelectron = 6
nocc, nvir = mol.nelectron // 2, 4
nmo = nocc + nvir
nmo_pair = nmo * (nmo + 1) // 2
mf = scf.UHF(mol)
numpy.random.seed(12)
mf._eri = numpy.random.random(nmo_pair * (nmo_pair + 1) // 2) * .2
mf.mo_coeff = numpy.random.random((2, nmo, nmo))
mf.mo_energy = [numpy.arange(0., nmo)] * 2
mf.mo_occ = numpy.zeros((2, nmo))
mf.mo_occ[:, :nocc] = 1
h1 = numpy.random.random((nmo, nmo)) * .1
h1 = h1 + h1.T + numpy.diag(numpy.arange(nmo))
mf.get_hcore = lambda *args: h1
mf1 = scf.addons.convert_to_ghf(mf)
mf1.get_hcore = lambda *args: scipy.linalg.block_diag(h1, h1)
gci = ci.GCISD(mf1)
c2 = numpy.random.random(
(nocc * 2, nocc * 2, nvir * 2, nvir * 2)) * .1 - .1
c2 = c2 - c2.transpose(0, 1, 3, 2)
c2 = c2 - c2.transpose(1, 0, 2, 3)
c1 = numpy.random.random((nocc * 2, nvir * 2)) * .1
c0 = .5
civec = gci.amplitudes_to_cisdvec(c0, c1, c2)
civecref = gci.contract(civec, gci.ao2mo())
c0ref, c1ref, c2ref = gci.cisdvec_to_amplitudes(civecref)
c1ref = gci.spin2spatial(c1ref)
c2ref = gci.spin2spatial(c2ref)
c1 = gci.spin2spatial(c1)
c2 = gci.spin2spatial(c2)
myci = ci.UCISD(mf)
civec = myci.amplitudes_to_cisdvec(c0, c1, c2)
cinew = myci.contract(civec, myci.ao2mo())
c0new, c1new, c2new = myci.cisdvec_to_amplitudes(cinew)
self.assertAlmostEqual(abs(c0new - c0ref).max(), 0, 12)
self.assertAlmostEqual(abs(c1new[0] - c1ref[0]).max(), 0, 12)
self.assertAlmostEqual(abs(c1new[1] - c1ref[1]).max(), 0, 12)
self.assertAlmostEqual(abs(c2new[0] - c2ref[0]).max(), 0, 12)
self.assertAlmostEqual(abs(c2new[1] - c2ref[1]).max(), 0, 12)
self.assertAlmostEqual(abs(c2new[2] - c2ref[2]).max(), 0, 12)
self.assertAlmostEqual(lib.finger(cinew), -102.17887236599671, 9)
def test_trans_rdm1(self):
numpy.random.seed(1)
norb = 4
nocc = 2
nvir = norb - nocc
c2 = numpy.random.random((nocc, nocc, nvir, nvir))
c2 = c2 + c2.transpose(1, 0, 3, 2)
cibra = numpy.hstack(
(numpy.random.random(1 + nocc * nvir), c2.ravel()))
c2 = numpy.random.random((nocc, nocc, nvir, nvir))
c2 = c2 + c2.transpose(1, 0, 3, 2)
ciket = numpy.hstack(
(numpy.random.random(1 + nocc * nvir), c2.ravel()))
cibra /= ci.cisd.dot(cibra, cibra, norb, nocc)**.5
ciket /= ci.cisd.dot(ciket, ciket, norb, nocc)**.5
fcibra = ci.cisd.to_fcivec(cibra, norb, nocc * 2)
fciket = ci.cisd.to_fcivec(ciket, norb, nocc * 2)
fcidm1 = fci.direct_spin1.trans_rdm1s(fcibra, fciket, norb, nocc * 2)
myci1 = ci.GCISD(scf.GHF(gto.M()))
myci1.nmo = norb = 8
myci1.nocc = nocc = 4
orbspin = numpy.zeros(norb, dtype=int)
orbspin[1::2] = 1
myci1.mo_coeff = lib.tag_array(numpy.eye(norb), orbspin=orbspin)
myci1.mo_occ = numpy.zeros(norb)
myci1.mo_occ[:nocc] = 1
cibra = myci1.from_rcisdvec(cibra, (nocc // 2, nocc // 2), orbspin)
ciket = myci1.from_rcisdvec(ciket)
cidm1 = myci1.trans_rdm1(cibra, ciket, norb, nocc)
self.assertAlmostEqual(abs(cidm1[0::2, 0::2] - fcidm1[0]).max(), 0, 12)
self.assertAlmostEqual(abs(cidm1[1::2, 1::2] - fcidm1[1]).max(), 0, 12)
cibra = myci1.to_ucisdvec(cibra, orbspin)
ciket = myci1.to_ucisdvec(ciket)
myci2 = ci.UCISD(scf.UHF(gto.M()))
cidm1 = myci2.trans_rdm1(cibra, ciket, (norb // 2, norb // 2),
(nocc // 2, nocc // 2))
self.assertAlmostEqual(abs(cidm1[0] - fcidm1[0]).max(), 0, 12)
self.assertAlmostEqual(abs(cidm1[1] - fcidm1[1]).max(), 0, 12)
ci2 = ci.CISD(myhf2).run()
print('CISD energy of mol2', ci2.e_tot)
s12 = gto.intor_cross('cint1e_ovlp_sph', myhf1.mol, myhf2.mol)
s12 = reduce(numpy.dot, (myhf1.mo_coeff.T, s12, myhf2.mo_coeff))
nmo = myhf2.mo_energy.size
nocc = myhf2.mol.nelectron // 2
print('<CISD-mol1|CISD-mol2> = ',
ci.cisd.overlap(ci1.ci, ci2.ci, nmo, nocc, s12))
#
# UCISD wavefunction overlap
#
myhf1 = gto.M(atom='H 0 0 0; F 0 0 1.1', basis='6-31g', spin=2,
verbose=0).apply(scf.UHF).run()
ci1 = ci.UCISD(myhf1).run()
print('CISD energy of mol1', ci1.e_tot)
myhf2 = gto.M(atom='H 0 0 0; F 0 0 1.2', basis='6-31g', spin=2,
verbose=0).apply(scf.UHF).run()
ci2 = ci.UCISD(myhf2).run()
print('CISD energy of mol2', ci2.e_tot)
s12 = gto.intor_cross('cint1e_ovlp_sph', myhf1.mol, myhf2.mol)
mo1a, mo1b = myhf1.mo_coeff
mo2a, mo2b = myhf2.mo_coeff
s12 = (reduce(numpy.dot,
(mo1a.T, s12, mo2a)), reduce(numpy.dot, (mo1b.T, s12, mo2b)))
nmo = (myhf2.mo_energy[0].size, myhf2.mo_energy[1].size)
nocc = myhf2.nelec
print('<CISD-mol1|CISD-mol2> = ',
mol.verbose = 0
# UHF for UNOs
mf = scf.UHF(mol).run(max_cycle=100)
mo_new = mf.stability()[0]
while mo_new is not mf.mo_coeff:
mf.kernel(dm0=mf.make_rdm1(mo_coeff=mo_new))
mo_new = mf.stability()[0]
no, occ = UNOs(mf)
# UHF UMP2
mp2 = mp.UMP2(mf).run()
no, occ = nat_orbs_obj(mp2)
# UHF UCISD
mci = ci.UCISD(mf).run()
no, occ = nat_orbs_obj(mci)
# RHF UCCSD
dm0 = mf.make_rdm1()
mf = scf.RHF(mol)
mf.kernel(dm0=dm0)
mcc = cc.UCCSD(mf).run()
no, occ = nat_orbs_obj(mcc)
# Run a symmetric CASCI to test symmetric natural orbitals.
mc = mcscf.CASCI(mf, 6, 6)
solver1 = fci.direct_spin0_symm.FCI(mol)
solver1.spin = final_spin
solver1.wfnsym = 'A1g'
solver1 = fci.addons.fix_spin(solver1,
