def setUpModule():
global mol, mf, molsym, mfsym, mol1, mf_r, mf_u
mol = gto.M(
verbose=5,
output='/dev/null',
atom='''
O 0 0 0
H 0 -0.757 0.587
H 0 0.757 0.587''',
basis='cc-pvdz',
)
mf = scf.GHF(mol)
mf.conv_tol = 1e-12
mf.chkfile = tempfile.NamedTemporaryFile().name
mf.kernel()
molsym = gto.M(verbose=5,
output='/dev/null',
atom='''
O 0 0 0
H 0 -0.757 0.587
H 0 0.757 0.587''',
basis='cc-pvdz',
symmetry='c2v')
mfsym = scf.GHF(molsym).run()
mol1 = gto.M(atom=mol.atom, basis='631g', spin=2, verbose=0)
mf_r = scf.RHF(mol1).run(chkfile=tempfile.NamedTemporaryFile().name)
mf_u = scf.RHF(mol1).run(chkfile=tempfile.NamedTemporaryFile().name)
def test_get_occ_extreme_case(self):
mol = gto.M(atom='He', verbose=7, output='/dev/null')
mf = scf.GHF(mol).run()
self.assertAlmostEqual(mf.e_tot, -2.8077839575399737, 12)
mol.charge = 2
mf = scf.GHF(mol).run()
self.assertAlmostEqual(mf.e_tot, 0, 12)
mol.stdout.close()
def test_gccsd_t_complex(self):
nocc, nvir = 4, 6
nmo = nocc + nvir
numpy.random.seed(1)
eris = cc.gccsd._PhysicistsERIs()
h = (numpy.random.random((nmo,nmo)) +
numpy.random.random((nmo,nmo)) * .6j - .5-.3j)
eris.fock = h + h.T.conj() + numpy.diag(numpy.arange(nmo)) * 2
eri1 = (numpy.random.random((nmo,nmo,nmo,nmo)) +
numpy.random.random((nmo,nmo,nmo,nmo))*.8j - .5-.4j)
eri1 = eri1 - eri1.transpose(0,1,3,2)
eri1 = eri1 - eri1.transpose(1,0,2,3)
eri1 = eri1 + eri1.transpose(2,3,0,1).conj()
eris.ovvv = eri1[:nocc,nocc:,nocc:,nocc:]
eris.oovv = eri1[:nocc,:nocc,nocc:,nocc:]
eris.ooov = eri1[:nocc,:nocc,:nocc,nocc:]
t2 = (numpy.random.random((nocc,nocc,nvir,nvir)) +
numpy.random.random((nocc,nocc,nvir,nvir))*.8j - .5-.4j)
t2 = t2 - t2.transpose(0,1,3,2)
t2 = t2 - t2.transpose(1,0,2,3)
t1 = (numpy.random.random((nocc,nvir)) +
numpy.random.random((nocc,nvir))*.8j - .5-.4j)
eris.mo_energy = eris.fock.diagonal().real
gcc = cc.gccsd.GCCSD(scf.GHF(gto.M()))
self.assertAlmostEqual(gccsd_t.kernel(gcc, eris, t1, t2),
(-104.15886718888137+0.30739952563327672j), 9)
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 test_tdhf_with_wfnsym(self):
mf_ghf = scf.GHF(molsym).run()
td = mf_ghf.TDHF()
td.wfnsym = 'B1'
td.nroots = 3
es = td.kernel()[0]
self.assertAlmostEqual(lib.fp(es), 0.48380638923581476, 6)
def test_init(self):
self.assertTrue(isinstance(cc.CCSD(mf), ccsd.CCSD))
self.assertTrue(isinstance(cc.CCSD(mf.density_fit()), dfccsd.RCCSD))
self.assertTrue(isinstance(cc.CCSD(mf.newton()), ccsd.CCSD))
self.assertTrue(isinstance(cc.CCSD(mf.density_fit().newton()), dfccsd.RCCSD))
self.assertTrue(isinstance(cc.CCSD(mf.newton().density_fit()), ccsd.CCSD))
self.assertTrue(not isinstance(cc.CCSD(mf.newton().density_fit()), dfccsd.RCCSD))
self.assertTrue(isinstance(cc.CCSD(mf.density_fit().newton().density_fit()), dfccsd.RCCSD))
self.assertTrue(isinstance(cc.UCCSD(mf), uccsd.UCCSD))
# self.assertTrue(isinstance(cc.UCCSD(mf.density_fit()), dfccsd.UCCSD))
self.assertTrue(isinstance(cc.UCCSD(mf.newton()), uccsd.UCCSD))
# self.assertTrue(isinstance(cc.UCCSD(mf.density_fit().newton()), dfccsd.UCCSD))
self.assertTrue(isinstance(cc.UCCSD(mf.newton().density_fit()), uccsd.UCCSD))
# self.assertTrue(not isinstance(cc.UCCSD(mf.newton().density_fit()), dfccsd.UCCSD))
# self.assertTrue(isinstance(cc.UCCSD(mf.density_fit().newton().density_fit()), dfccsd.UCCSD))
self.assertTrue(isinstance(cc.CCSD(scf.GHF(mol)), gccsd.GCCSD))
umf = scf.convert_to_uhf(mf, scf.UHF(mol))
self.assertTrue(isinstance(cc.CCSD(umf), uccsd.UCCSD))
# self.assertTrue(isinstance(cc.CCSD(umf.density_fit()), dfccsd.UCCSD))
self.assertTrue(isinstance(cc.CCSD(umf.newton()), uccsd.UCCSD))
# self.assertTrue(isinstance(cc.CCSD(umf.density_fit().newton()), dfccsd.UCCSD))
self.assertTrue(isinstance(cc.CCSD(umf.newton().density_fit()), uccsd.UCCSD))
# self.assertTrue(not isinstance(cc.CCSD(umf.newton().density_fit()), dfccsd.UCCSD))
# self.assertTrue(isinstance(cc.CCSD(umf.density_fit().newton().density_fit()), dfccsd.UCCSD))
self.assertTrue(isinstance(cc.CCSD(mf, mo_coeff=mf.mo_coeff*1j), rccsd.RCCSD))
def doGHF(mol): gmf = scf.GHF(mol) gmf.max_cycle = 200 dm = gmf.get_init_guess() norb = mol.nao dm = dm + np.random.rand(2*norb, 2*norb) / 3 print gmf.kernel(dm0 = dm) return gmf
def doGHF(mol, dm=None):
gmf = scf.GHF(mol)
gmf.max_cycle = 200
if dm is None:
dm = gmf.get_init_guess()
norb = mol.nao
dm = dm + np.random.rand(2 * norb, 2 * norb) / 3
print(gmf.kernel(dm0=dm))
return gmf
def test_ghf_complex(self):
mf1 = scf.GHF(mol)
dm = mf1.init_guess_by_1e(mol) + 0j
nao = dm.shape[0] // 2
numpy.random.seed(12)
dm[:nao, nao:] = numpy.random.random((nao, nao)) * .1j
dm[nao:, :nao] = dm[:nao, nao:].T.conj()
mf1.kernel(dm)
self.assertAlmostEqual(mf1.e_tot, mf.e_tot, 9)
def test_ccsd_t_complex(self):
mol = gto.M()
numpy.random.seed(12)
nocc, nvir = 3, 4
nmo = nocc + nvir
eris = cc.rccsd._ChemistsERIs()
eri1 = (numpy.random.random(
(nmo, nmo, nmo, nmo)) + numpy.random.random(
(nmo, nmo, nmo, nmo)) * .8j - .5 - .4j)
eri1 = eri1 + eri1.transpose(1, 0, 2, 3)
eri1 = eri1 + eri1.transpose(0, 1, 3, 2)
eri1 = eri1 + eri1.transpose(2, 3, 0, 1)
eri1 *= .1
eris.ovvv = eri1[:nocc, nocc:, nocc:, nocc:]
eris.ovoo = eri1[:nocc, nocc:, :nocc, :nocc]
eris.ovov = eri1[:nocc, nocc:, :nocc, nocc:]
t1 = (numpy.random.random((nocc, nvir)) * .1 + numpy.random.random(
(nocc, nvir)) * .1j)
t2 = (numpy.random.random(
(nocc, nocc, nvir, nvir)) * .1 + numpy.random.random(
(nocc, nocc, nvir, nvir)) * .1j)
t2 = t2 + t2.transpose(1, 0, 3, 2)
mf = scf.RHF(mol)
mcc = cc.CCSD(mf)
f = (numpy.random.random((nmo, nmo)) * .1 + numpy.random.random(
(nmo, nmo)) * .1j)
eris.fock = f + f.T.conj() + numpy.diag(numpy.arange(nmo))
eris.mo_energy = eris.fock.diagonal().real
e0 = ccsd_t.kernel(mcc, eris, t1, t2)
eri2 = numpy.zeros((nmo * 2, nmo * 2, nmo * 2, nmo * 2),
dtype=numpy.complex128)
orbspin = numpy.zeros(nmo * 2, dtype=int)
orbspin[1::2] = 1
eri2[0::2, 0::2, 0::2, 0::2] = eri1
eri2[1::2, 1::2, 0::2, 0::2] = eri1
eri2[0::2, 0::2, 1::2, 1::2] = eri1
eri2[1::2, 1::2, 1::2, 1::2] = eri1
eri2 = eri2.transpose(0, 2, 1, 3) - eri2.transpose(0, 2, 3, 1)
fock = numpy.zeros((nmo * 2, nmo * 2), dtype=numpy.complex128)
fock[0::2, 0::2] = eris.fock
fock[1::2, 1::2] = eris.fock
eris1 = gccsd._PhysicistsERIs()
eris1.ovvv = eri2[:nocc * 2, nocc * 2:, nocc * 2:, nocc * 2:]
eris1.oovv = eri2[:nocc * 2, :nocc * 2, nocc * 2:, nocc * 2:]
eris1.ooov = eri2[:nocc * 2, :nocc * 2, :nocc * 2, nocc * 2:]
eris1.fock = fock
eris1.mo_energy = fock.diagonal().real
t1 = gccsd.spatial2spin(t1, orbspin)
t2 = gccsd.spatial2spin(t2, orbspin)
gcc = gccsd.GCCSD(scf.GHF(gto.M()))
e1 = gccsd_t.kernel(gcc, eris1, t1, t2)
self.assertAlmostEqual(e0, e1.real, 9)
self.assertAlmostEqual(e1,
-0.98756910139720788 - 0.0019567929592079489j,
9)
def to_ghf(self):
'''Convert the input mean-field object to a GHF object.
Note this conversion only changes the class of the mean-field object.
The total energy and wave-function are the same as them in the input
mean-field object.
'''
mf = _update_keys_(scf.GHF(self.mol), self.to_gks())
mf.converged = False
return mf
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_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
eri0 = eri
erip = eri - eri.transpose(0, 3, 2, 1)
eris = lambda: None
eris.oovv = erip[:nocc, nocc:, :nocc, nocc:].transpose(0, 2, 1, 3)
mo_energy = numpy.arange(nmo)
mo_occ = numpy.zeros(nmo)
mo_occ[:nocc] = 1
dm = numpy.diag(mo_occ)
vhf = numpy.einsum('ijkl,lk->ij', erip, dm)
hcore = numpy.diag(mo_energy) - vhf
mf.get_hcore = lambda *args: hcore
mf.get_ovlp = lambda *args: numpy.eye(nmo)
eris.mo_energy = mf.mo_energy = mo_energy
mf.mo_coeff = numpy.eye(nmo)
mf.mo_occ = mo_occ
mf.e_tot = numpy.einsum('ij,ji', hcore,
dm) + numpy.einsum('ij,ji', vhf, dm) * .5
mf.converged = True
pt = mp.GMP2(mf)
pt.ao2mo = lambda *args, **kwargs: eris
pt.kernel(eris=eris)
dm1 = pt.make_rdm1()
dm2 = pt.make_rdm2()
e1 = numpy.einsum('ij,ji', hcore, dm1)
e1 += numpy.einsum('ijkl,ijkl', eri0, dm2) * .5
self.assertAlmostEqual(e1, pt.e_tot, 12)
#self.assertAlmostEqual(abs(numpy.einsum('ijkk->ji', dm2)/(nocc-1) - dm1).max(), 0, 9)
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 test_update_amps(self):
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(
(nmo, nmo)) + 1j
vhf = vhf + vhf.conj().T
mf.get_veff = lambda *args: vhf
cinv = numpy.linalg.inv(mf.mo_coeff)
mf.get_hcore = lambda *args: (reduce(numpy.dot, (cinv.T * mf.mo_energy,
cinv)) - vhf)
nmo_pair = nmo * (nmo // 2 + 1) // 4
mf._eri = numpy.random.random(nmo_pair * (nmo_pair + 1) // 2)
mycc = gccsd.GCCSD(mf)
eris = mycc.ao2mo()
eris.oooo = eris.oooo + numpy.sin(eris.oooo) * 1j
eris.oooo = eris.oooo + eris.oooo.conj().transpose(2, 3, 0, 1)
eris.ooov = eris.ooov + numpy.sin(eris.ooov) * 1j
eris.oovv = eris.oovv + numpy.sin(eris.oovv) * 1j
eris.ovov = eris.ovov + numpy.sin(eris.ovov) * 1j
eris.ovov = eris.ovov + eris.ovov.conj().transpose(2, 3, 0, 1)
eris.ovvv = eris.ovvv + numpy.sin(eris.ovvv) * 1j
eris.vvvv = eris.vvvv + numpy.sin(eris.vvvv) * 1j
eris.vvvv = eris.vvvv + eris.vvvv.conj().transpose(2, 3, 0, 1)
a = numpy.random.random((nmo, nmo)) * .1
eris.fock += a + a.T
t1 = numpy.random.random((nocc, nvir)) * .1 + numpy.random.random(
(nocc, nvir)) * .1j
t2 = (numpy.random.random(
(nocc, nocc, nvir, nvir)) * .1 + numpy.random.random(
(nocc, nocc, nvir, nvir)) * .1j)
t2 = t2 - t2.transpose(0, 1, 3, 2)
t2 = t2 - t2.transpose(1, 0, 2, 3)
r1, r2 = mycc.vector_to_amplitudes(mycc.amplitudes_to_vector(t1, t2))
self.assertAlmostEqual(abs(t1 - r1).max(), 0, 14)
self.assertAlmostEqual(abs(t2 - r2).max(), 0, 14)
t1a, t2a = mycc.update_amps(t1, t2, eris)
self.assertAlmostEqual(lib.finger(t1a),
20.805393111419136 - 300.1138026015621j, 9)
self.assertAlmostEqual(lib.finger(t2a),
-313.54117398035567 + 8.3700078645035205j, 9)
def test_cisdvec_to_amplitudes_overwritten(self):
mol = gto.M()
myci = scf.GHF(mol).apply(ci.GCISD)
nelec = (3,3)
nocc, nvir = sum(nelec), 4
nmo = nocc + nvir
myci.nocc = nocc
myci.nmo = nmo
vec = numpy.zeros(myci.vector_size())
vec_orig = vec.copy()
c0, c1, c2 = myci.cisdvec_to_amplitudes(vec)
c1[:] = 1
c2[:] = 1
self.assertAlmostEqual(abs(vec - vec_orig).max(), 0, 15)
def prepValence(mol,
ncore,
nact,
occ=None,
loc="iao",
dm=None,
writeFcidump=True,
writeMolden=False,
writeBestDet=True,
writeMOs=True):
mf = doRHF(mol)
mo = mf.mo_coeff
lmo = localizeValence(mf, mo[:, ncore:ncore + nact], loc)
if writeMolden:
tools.molden.from_mo(mol, 'valenceOrbs.molden', lmo)
nelec = mol.nelectron - 2 * ncore
mc = mcscf.CASSCF(mf, nact, nelec)
h1cas, energy_core = mcscf.casci.h1e_for_cas(mc, mf.mo_coeff, nact, ncore)
mo_core = mc.mo_coeff[:, :ncore]
core_dm = 2 * mo_core.dot(mo_core.T)
corevhf = mc.get_veff(mol, core_dm)
h1eff = lmo.T.dot(mc.get_hcore() + corevhf).dot(lmo)
eri = ao2mo.kernel(mol, lmo)
if writeFcidump:
tools.fcidump.from_integrals('FCIDUMP', h1eff, eri, nact, nelec,
energy_core)
if occ is not None:
bestDetValence(mol, lmo, occ, eri, writeBestDet)
# make fictitious valence only molecule and perform ghf
norb = nact
molA = gto.M()
molA.nelectron = nelec
molA.verbose = 4
molA.incore_anyway = True
gmf = scf.GHF(molA)
gmf.get_hcore = lambda *args: la.block_diag(h1eff, h1eff)
gmf.get_ovlp = lambda *args: np.identity(2 * norb)
gmf.energy_nuc = lambda *args: energy_core
gmf._eri = eri
if dm is None:
dm = gmf.get_init_guess()
dm = dm + 2 * np.random.rand(2 * norb, 2 * norb)
gmf.level_shift = 0.1
gmf.max_cycle = 500
print(gmf.kernel(dm0=dm))
if writeMOs:
writeMat(gmf.mo_coeff, "hf.txt", False)
def test_multi_roots(self):
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. )],
]
mol.basis = '3-21g'
mol.build()
mf = scf.GHF(mol).run()
myci = ci.GCISD(mf)
myci.nroots = 3
myci.run()
self.assertAlmostEqual(myci.e_tot[2], -1.9802158893844912, 8)
def setUpModule():
global mol, mf, gmf
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.spin = 2
mol.build()
mf = scf.UHF(mol)
mf.conv_tol = 1e-14
mf.scf()
gmf = scf.GHF(mol)
gmf.conv_tol = 1e-14
gmf.scf()
def test_rdm_real(self):
mol = gto.M()
mol.verbose = 0
nocc = 6
nvir = 10
mf = scf.GHF(mol)
nmo = nocc + nvir
npair = nmo * (nmo // 2 + 1) // 4
numpy.random.seed(12)
mf._eri = numpy.random.random(npair * (npair + 1) // 2) * .3
hcore = numpy.random.random((nmo, nmo)) * .5
hcore = hcore + hcore.T + numpy.diag(range(nmo)) * 2
mf.get_hcore = lambda *args: hcore
mf.get_ovlp = lambda *args: numpy.eye(nmo)
mf.mo_coeff = numpy.eye(nmo)
mf.mo_occ = numpy.zeros(nmo)
mf.mo_occ[:nocc] = 1
dm1 = mf.make_rdm1()
mf.e_tot = mf.energy_elec()[0]
myci = gcisd.GCISD(mf).run()
dm1 = myci.make_rdm1()
dm2 = myci.make_rdm2()
nao = nmo // 2
mo_a = mf.mo_coeff[:nao]
mo_b = mf.mo_coeff[nao:]
eri = ao2mo.kernel(mf._eri, mo_a)
eri += ao2mo.kernel(mf._eri, mo_b)
eri1 = ao2mo.kernel(mf._eri, (mo_a, mo_a, mo_b, mo_b))
eri += eri1
eri += eri1.T
eri = ao2mo.restore(1, eri, nmo)
h1 = reduce(numpy.dot, (mf.mo_coeff.T.conj(), hcore, mf.mo_coeff))
e1 = numpy.einsum('ij,ji', h1, dm1)
e1 += numpy.einsum('ijkl,ijkl', eri, dm2) * .5
self.assertAlmostEqual(e1, myci.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 test_rdm_real(self):
nocc = 6
nvir = 10
mf = scf.GHF(mol)
nmo = nocc + nvir
npair = nmo * (nmo // 2 + 1) // 4
numpy.random.seed(12)
mf._eri = numpy.random.random(npair * (npair + 1) // 2) * .3
hcore = numpy.random.random((nmo, nmo)) * .5
hcore = hcore + hcore.T + numpy.diag(range(nmo)) * 2
mf.get_hcore = lambda *args: hcore
mf.get_ovlp = lambda *args: numpy.eye(nmo)
mf.mo_coeff = numpy.eye(nmo)
mf.mo_occ = numpy.zeros(nmo)
mf.mo_occ[:nocc] = 1
mycc = gccsd.GCCSD(mf)
ecc, t1, t2 = mycc.kernel()
l1, l2 = mycc.solve_lambda()
dm1 = gccsd_rdm.make_rdm1(mycc, t1, t2, l1, l2)
dm2 = gccsd_rdm.make_rdm2(mycc, t1, t2, l1, l2)
nao = nmo // 2
mo_a = mf.mo_coeff[:nao]
mo_b = mf.mo_coeff[nao:]
eri = ao2mo.kernel(mf._eri, mo_a)
eri += ao2mo.kernel(mf._eri, mo_b)
eri1 = ao2mo.kernel(mf._eri, (mo_a, mo_a, mo_b, mo_b))
eri += eri1
eri += eri1.T
eri = ao2mo.restore(1, eri, nmo)
h1 = reduce(numpy.dot, (mf.mo_coeff.T.conj(), hcore, mf.mo_coeff))
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)
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 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(
(nmo, nmo)) + 1j
vhf = vhf + vhf.conj().T
mf.get_veff = lambda *args: vhf
cinv = numpy.linalg.inv(mf.mo_coeff)
mf.get_hcore = lambda *args: (reduce(numpy.dot,
(cinv.T * mf.mo_energy, cinv)) - vhf)
nmo_pair = nmo * (nmo // 2 + 1) // 4
mf._eri = numpy.random.random(nmo_pair * (nmo_pair + 1) // 2)
mycc1 = gccsd.GCCSD(mf)
eris1 = mycc1.ao2mo()
eris1.oooo = eris1.oooo + numpy.sin(eris1.oooo) * 1j
eris1.oooo = eris1.oooo + eris1.oooo.conj().transpose(2, 3, 0, 1)
eris1.ooov = eris1.ooov + numpy.sin(eris1.ooov) * 1j
eris1.oovv = eris1.oovv + numpy.sin(eris1.oovv) * 1j
eris1.ovov = eris1.ovov + numpy.sin(eris1.ovov) * 1j
eris1.ovvv = eris1.ovvv + numpy.sin(eris1.ovvv) * 1j
eris1.vvvv = eris1.vvvv + numpy.sin(eris1.vvvv) * 1j
eris1.vvvv = eris1.vvvv + eris1.vvvv.conj().transpose(2, 3, 0, 1)
a = numpy.random.random((nmo, nmo)) * .1
eris1.fock += a + a.T
t1 = numpy.random.random((nocc, nvir)) * .1 + numpy.random.random(
(nocc, nvir)) * .1j
t2 = (numpy.random.random(
(nocc, nocc, nvir, nvir)) * .1 + numpy.random.random(
(nocc, nocc, nvir, nvir)) * .1j)
t2 = t2 - t2.transpose(0, 1, 3, 2)
t2 = t2 - t2.transpose(1, 0, 2, 3)
mycc1.t1 = t1
mycc1.t2 = t2
return mycc1, eris1
def test_vector_to_amplitudes_overwritten(self):
mol = gto.M()
mycc = scf.GHF(mol).apply(cc.GCCSD)
nelec = (3, 3)
nocc, nvir = nelec[0] * 2, 4
nmo = nocc + nvir
mycc.nocc = nocc
mycc.nmo = nmo
def check_overwritten(method):
vec = numpy.zeros(method.vector_size())
vec_orig = vec.copy()
t1, t2 = method.vector_to_amplitudes(vec)
t1[:] = 1
t2[:] = 1
self.assertAlmostEqual(abs(vec - vec_orig).max(), 0, 15)
check_overwritten(mycc)
check_overwritten(mycc.EOMIP())
check_overwritten(mycc.EOMEA())
check_overwritten(mycc.EOMEE())
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)
def setUpClass(cls):
cls.mol = gto.Mole()
cls.mol.verbose = 0
cls.mol.atom = "H 0 0 0; H 0.74 0 0"
cls.mol.basis = 'ccpvdz'
cls.mol.build()
cls.mf = scf.GHF(cls.mol)
cls.mf.kernel()
cls.ccsd = gccsd.GCCSD(cls.mf)
cls.ccsd.kernel()
cls.ccsd.conv_tol_normt = 1e-8
cls.ccsd.solve_lambda()
cls.nroots = 2
cls.eomip = eom_gccsd.EOMIP(cls.ccsd)
cls.eomip.conv_tol = 1e-12
cls.eomip.kernel(nroots=cls.nroots)
cls.eomea = eom_gccsd.EOMEA(cls.ccsd)
cls.eomea.conv_tol = 1e-12
cls.eomea.kernel(nroots=cls.nroots)
def setUpClass(cls):
"""
H20 molecule test vs ORCA-MRCC data.
ORCA reference energies:
HF -75.97354725
CCS --
CCSD -76.185805898396
CCSDT -76.189327633478
"""
cls.mol = gto.Mole()
cls.mol.verbose = 0
cls.mol.atom = "O 0 0 0; H 0.758602 0.000000 0.504284; H 0.758602 0.000000 -0.504284"
cls.mol.unit = "angstrom"
cls.mol.basis = 'cc-pvdz'
cls.mol.build()
cls.mf = scf.GHF(cls.mol)
cls.mf.conv_tol = 1e-11
cls.mf.kernel()
testing.assert_allclose(cls.mf.e_tot, -75.97354725, atol=1e-4)
cls.ccsd = gccsd.GCCSD(cls.mf, frozen=2)
cls.ccsd.kernel()
cls.ccsd.conv_tol_normt = 1e-8
cls.ccsd.solve_lambda()
cls.nroots = 4
cls.eomip = eom_gccsd.EOMIP(cls.ccsd)
cls.eomip.conv_tol = 1e-12
cls.eomip.kernel(nroots=cls.nroots)
cls.eomea = eom_gccsd.EOMEA(cls.ccsd)
cls.eomea.conv_tol = 1e-12
cls.eomea.kernel(nroots=cls.nroots)
def test_init_guess_huckel(self):
dm = scf.GHF(mol).get_init_guess(mol, key='huckel')
self.assertAlmostEqual(lib.fp(dm), 1.0574099243527206, 9)
"""
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)
def test_uccsd_t_complex(self):
mol = gto.M()
numpy.random.seed(12)
nocca, noccb, nvira, nvirb = 3, 2, 4, 5
nmo = nocca + nvira
eris = cc.uccsd._ChemistsERIs()
eris.nocca = nocca
eris.noccb = noccb
eris.nocc = (nocca, noccb)
eri1 = (numpy.random.random((3,nmo,nmo,nmo,nmo)) +
numpy.random.random((3,nmo,nmo,nmo,nmo)) * .8j - .5-.4j)
eri1 = eri1 + eri1.transpose(0,2,1,4,3).conj()
eri1[0] = eri1[0] + eri1[0].transpose(2,3,0,1)
eri1[2] = eri1[2] + eri1[2].transpose(2,3,0,1)
eri1 *= .1
eris.ovvv = eri1[0,:nocca,nocca:,nocca:,nocca:]
eris.ovov = eri1[0,:nocca,nocca:,:nocca,nocca:]
eris.ovoo = eri1[0,:nocca,nocca:,:nocca,:nocca]
eris.OVVV = eri1[2,:noccb,noccb:,noccb:,noccb:]
eris.OVOV = eri1[2,:noccb,noccb:,:noccb,noccb:]
eris.OVOO = eri1[2,:noccb,noccb:,:noccb,:noccb]
eris.voVP = eri1[1,nocca:,:nocca,noccb:,: ]
eris.ovVV = eri1[1,:nocca,nocca:,noccb:,noccb:]
eris.ovOV = eri1[1,:nocca,nocca:,:noccb,noccb:]
eris.ovOO = eri1[1,:nocca,nocca:,:noccb,:noccb]
eris.OVvv = eri1[1,nocca:,nocca:,:noccb,noccb:].transpose(2,3,0,1)
eris.OVoo = eri1[1,:nocca,:nocca,:noccb,noccb:].transpose(2,3,0,1)
t1a = .1 * numpy.random.random((nocca,nvira)) + numpy.random.random((nocca,nvira))*.1j
t1b = .1 * numpy.random.random((noccb,nvirb)) + numpy.random.random((noccb,nvirb))*.1j
t2aa = .1 * numpy.random.random((nocca,nocca,nvira,nvira)) + numpy.random.random((nocca,nocca,nvira,nvira))*.1j
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)) + numpy.random.random((noccb,noccb,nvirb,nvirb))*.1j
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)) + numpy.random.random((nocca,noccb,nvira,nvirb))*.1j
f = (numpy.random.random((2,nmo,nmo)) * .4 +
numpy.random.random((2,nmo,nmo)) * .4j)
eris.focka = f[0]+f[0].T.conj() + numpy.diag(numpy.arange(nmo))
eris.fockb = f[1]+f[1].T.conj() + numpy.diag(numpy.arange(nmo))
eris.mo_energy = (eris.focka.diagonal().real,
eris.fockb.diagonal().real)
t1 = t1a, t1b
t2 = t2aa, t2ab, t2bb
mcc = cc.UCCSD(scf.UHF(mol))
mcc.nocc = eris.nocc
e0 = uccsd_t.kernel(mcc, eris, t1, t2)
eri2 = numpy.zeros((nmo*2,nmo*2,nmo*2,nmo*2), dtype=eri1.dtype)
orbspin = numpy.zeros(nmo*2,dtype=int)
orbspin[1::2] = 1
eri2[0::2,0::2,0::2,0::2] = eri1[0]
eri2[1::2,1::2,0::2,0::2] = eri1[1].transpose(2,3,0,1)
eri2[0::2,0::2,1::2,1::2] = eri1[1]
eri2[1::2,1::2,1::2,1::2] = eri1[2]
eri2 = eri2.transpose(0,2,1,3) - eri2.transpose(0,2,3,1)
fock = numpy.zeros((nmo*2,nmo*2), dtype=eris.focka.dtype)
fock[0::2,0::2] = eris.focka
fock[1::2,1::2] = eris.fockb
eris1 = gccsd._PhysicistsERIs()
nocc = nocca + noccb
eris1.ovvv = eri2[:nocc,nocc:,nocc:,nocc:]
eris1.oovv = eri2[:nocc,:nocc,nocc:,nocc:]
eris1.ooov = eri2[:nocc,:nocc,:nocc,nocc:]
eris1.fock = fock
eris1.mo_energy = fock.diagonal().real
t1 = gccsd.spatial2spin(t1, orbspin)
t2 = gccsd.spatial2spin(t2, orbspin)
gcc = gccsd.GCCSD(scf.GHF(gto.M()))
e1 = gccsd_t.kernel(gcc, eris1, t1, t2)
self.assertAlmostEqual(e0, e1.real, 9)
self.assertAlmostEqual(e1, -0.056092415718338388-0.011390417704868244j, 9)
def test_init(self):
from pyscf import dft
from pyscf import x2c
mol_r = mol
mol_u = gto.M(atom='Li', spin=1, verbose=0)
mol_r1 = gto.M(atom='H', spin=1, verbose=0)
sym_mol_r = molsym
sym_mol_u = gto.M(atom='Li', spin=1, symmetry=1, verbose=0)
sym_mol_r1 = gto.M(atom='H', spin=1, symmetry=1, verbose=0)
self.assertTrue(isinstance(scf.RKS(mol_r), dft.rks.RKS))
self.assertTrue(isinstance(scf.RKS(mol_u), dft.roks.ROKS))
self.assertTrue(isinstance(scf.UKS(mol_r), dft.uks.UKS))
self.assertTrue(isinstance(scf.ROKS(mol_r), dft.roks.ROKS))
self.assertTrue(isinstance(scf.GKS(mol_r), dft.gks.GKS))
self.assertTrue(isinstance(scf.KS(mol_r), dft.rks.RKS))
self.assertTrue(isinstance(scf.KS(mol_u), dft.uks.UKS))
self.assertTrue(isinstance(scf.RHF(mol_r), scf.hf.RHF))
self.assertTrue(isinstance(scf.RHF(mol_u), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.RHF(mol_r1), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.UHF(mol_r), scf.uhf.UHF))
self.assertTrue(isinstance(scf.UHF(mol_u), scf.uhf.UHF))
self.assertTrue(isinstance(scf.UHF(mol_r1), scf.uhf.HF1e))
self.assertTrue(isinstance(scf.ROHF(mol_r), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.ROHF(mol_u), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.ROHF(mol_r1), scf.rohf.HF1e))
self.assertTrue(isinstance(scf.HF(mol_r), scf.hf.RHF))
self.assertTrue(isinstance(scf.HF(mol_u), scf.uhf.UHF))
self.assertTrue(isinstance(scf.HF(mol_r1), scf.rohf.HF1e))
self.assertTrue(isinstance(scf.GHF(mol_r), scf.ghf.GHF))
self.assertTrue(isinstance(scf.GHF(mol_u), scf.ghf.GHF))
self.assertTrue(isinstance(scf.GHF(mol_r1), scf.ghf.HF1e))
#TODO: self.assertTrue(isinstance(scf.DHF(mol_r), scf.dhf.RHF))
self.assertTrue(isinstance(scf.DHF(mol_u), scf.dhf.UHF))
self.assertTrue(isinstance(scf.DHF(mol_r1), scf.dhf.HF1e))
self.assertTrue(isinstance(scf.RHF(sym_mol_r), scf.hf_symm.RHF))
self.assertTrue(isinstance(scf.RHF(sym_mol_u), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.RHF(sym_mol_r1), scf.hf_symm.HF1e))
self.assertTrue(isinstance(scf.UHF(sym_mol_r), scf.uhf_symm.UHF))
self.assertTrue(isinstance(scf.UHF(sym_mol_u), scf.uhf_symm.UHF))
self.assertTrue(isinstance(scf.UHF(sym_mol_r1), scf.uhf_symm.HF1e))
self.assertTrue(isinstance(scf.ROHF(sym_mol_r), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.ROHF(sym_mol_u), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.ROHF(sym_mol_r1), scf.hf_symm.HF1e))
self.assertTrue(isinstance(scf.HF(sym_mol_r), scf.hf_symm.RHF))
self.assertTrue(isinstance(scf.HF(sym_mol_u), scf.uhf_symm.UHF))
self.assertTrue(isinstance(scf.HF(sym_mol_r1), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.GHF(sym_mol_r), scf.ghf_symm.GHF))
self.assertTrue(isinstance(scf.GHF(sym_mol_u), scf.ghf_symm.GHF))
self.assertTrue(isinstance(scf.GHF(sym_mol_r1), scf.ghf_symm.HF1e))
self.assertTrue(isinstance(scf.X2C(mol_r), x2c.x2c.UHF))
self.assertTrue(isinstance(scf.sfx2c1e(scf.HF(mol_r)), scf.rhf.RHF))
self.assertTrue(isinstance(scf.sfx2c1e(scf.HF(mol_u)), scf.uhf.UHF))
self.assertTrue(isinstance(scf.sfx2c1e(scf.HF(mol_r1)), scf.rohf.ROHF))
self.assertTrue(
isinstance(scf.sfx2c1e(scf.HF(sym_mol_r)), scf.rhf_symm.RHF))
self.assertTrue(
isinstance(scf.sfx2c1e(scf.HF(sym_mol_u)), scf.uhf_symm.UHF))
self.assertTrue(
isinstance(scf.sfx2c1e(scf.HF(sym_mol_r1)), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.density_fit(scf.HF(mol_r)),
scf.rhf.RHF))
self.assertTrue(isinstance(scf.density_fit(scf.HF(mol_u)),
scf.uhf.UHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(mol_r1)), scf.rohf.ROHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(sym_mol_r)), scf.rhf_symm.RHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(sym_mol_u)), scf.uhf_symm.UHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(sym_mol_r1)), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.newton(scf.HF(mol_r)), scf.rhf.RHF))
self.assertTrue(isinstance(scf.newton(scf.HF(mol_u)), scf.uhf.UHF))
self.assertTrue(isinstance(scf.newton(scf.HF(mol_r1)), scf.rohf.ROHF))
self.assertTrue(
isinstance(scf.newton(scf.HF(sym_mol_r)), scf.rhf_symm.RHF))
self.assertTrue(
isinstance(scf.newton(scf.HF(sym_mol_u)), scf.uhf_symm.UHF))
self.assertTrue(
isinstance(scf.newton(scf.HF(sym_mol_r1)), scf.hf_symm.ROHF))
m = scf.UHF(mol)
m.max_cycle = 1
#m.verbose = 5
m.scf()
nrmf = scf.density_fit(newton(m), 'weigend')
nrmf.max_cycle = 50
nrmf.conv_tol = 1e-8
nrmf.conv_tol_grad = 1e-5
#nrmf.verbose = 5
e4 = nrmf.kernel()
m = scf.density_fit(scf.UHF(mol), 'weigend')
m.max_cycle = 1
#m.verbose = 5
m.scf()
nrmf = scf.density_fit(newton(m), 'weigend')
nrmf.max_cycle = 50
nrmf.conv_tol_grad = 1e-5
e5 = nrmf.kernel()
m = newton(scf.GHF(mol))
e6 = m.kernel()
print(e0 - -2.93707955256)
print(e1 - -2.99456398848)
print(e2 - -2.99663808314)
print(e4 - -2.99663808186)
print(e5 - -2.99634506072)
print(e6 - -3.002844505604826)
