def test_ccsd_t(self):
mol = gto.M()
numpy.random.seed(12)
nocc, nvir = 5, 12
nmo = nocc + nvir
eris = cc.rccsd._ChemistsERIs()
eri1 = numpy.random.random((nmo,nmo,nmo,nmo)) - .5
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
t2 = numpy.random.random((nocc,nocc,nvir,nvir)) * .1
t2 = t2 + t2.transpose(1,0,3,2)
mf = scf.RHF(mol)
mycc = cc.CCSD(mf)
mycc.incore_complete = True
mycc.mo_energy = mycc._scf.mo_energy = numpy.arange(0., nocc+nvir)
f = numpy.random.random((nmo,nmo)) * .1
eris.fock = f+f.T + numpy.diag(numpy.arange(nmo))
eris.mo_energy = eris.fock.diagonal()
e = ccsd_t.kernel(mycc, eris, t1, t2)
self.assertAlmostEqual(e, -45.96028705175308, 9)
mycc.max_memory = 0
e = ccsd_t.kernel(mycc, eris, t1, t2)
self.assertAlmostEqual(e, -45.96028705175308, 9)
def test_ccsd_t(self):
mol = gto.M()
numpy.random.seed(12)
nocc, nvir = 5, 12
nmo = nocc + nvir
eris = cc.rccsd._ChemistsERIs()
eri1 = numpy.random.random((nmo, nmo, nmo, nmo)) - .5
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
t2 = numpy.random.random((nocc, nocc, nvir, nvir)) * .1
t2 = t2 + t2.transpose(1, 0, 3, 2)
mf = scf.RHF(mol)
mycc = cc.CCSD(mf)
mycc.incore_complete = True
mycc.mo_energy = mycc._scf.mo_energy = numpy.arange(0., nocc + nvir)
f = numpy.random.random((nmo, nmo)) * .1
eris.fock = f + f.T + numpy.diag(numpy.arange(nmo))
eris.mo_energy = eris.fock.diagonal()
e = ccsd_t.kernel(mycc, eris, t1, t2)
self.assertAlmostEqual(e, -45.96028705175308, 9)
mycc.max_memory = 0
e = ccsd_t.kernel(mycc, eris, t1, t2)
self.assertAlmostEqual(e, -45.96028705175308, 9)
def test_ccsd_t_symm(self):
e3a = ccsd_t.kernel(mcc, mcc.ao2mo())
self.assertAlmostEqual(e3a, -0.003060022611584471, 9)
mcc.mol.symmetry = False
e3a = ccsd_t.kernel(mcc, mcc.ao2mo())
self.assertAlmostEqual(e3a, -0.003060022611584471, 9)
def test_ccsd_t_symm(self):
e3a = ccsd_t.kernel(mcc, mcc.ao2mo())
self.assertAlmostEqual(e3a, -0.003060022611584471, 9)
mcc.mol.symmetry = False
e3a = ccsd_t.kernel(mcc, mcc.ao2mo())
self.assertAlmostEqual(e3a, -0.003060022611584471, 9)
mcc.mol.symmetry = True
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 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.complex)
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.complex)
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 test_ccsd_t(self):
mol = gto.M()
numpy.random.seed(12)
nocc, nvir = 5, 12
eris = lambda :None
eris.ovvv = numpy.random.random((nocc*nvir,nvir*(nvir+1)//2)) * .1
eris.ovoo = numpy.random.random((nocc,nvir,nocc,nocc)) * .1
eris.ovov = numpy.random.random((nocc*nvir,nocc*nvir)) * .1
t1 = numpy.random.random((nocc,nvir)) * .1
t2 = numpy.random.random((nocc,nocc,nvir,nvir)) * .1
t2 = t2 + t2.transpose(1,0,3,2)
mf = scf.RHF(mol)
mycc = cc.CCSD(mf)
mycc.mo_energy = mycc._scf.mo_energy = numpy.arange(0., nocc+nvir)
e = ccsd_t.kernel(mycc, eris, t1, t2)
self.assertAlmostEqual(e, -8.4953387936460398, 9)
def test_ccsd_t(self):
mol = gto.M()
numpy.random.seed(12)
nocc, nvir = 5, 12
eris = lambda :None
eris.ovvv = numpy.random.random((nocc*nvir,nvir*(nvir+1)//2)) * .1
eris.ovoo = numpy.random.random((nocc,nvir,nocc,nocc)) * .1
eris.ovov = numpy.random.random((nocc*nvir,nocc*nvir)) * .1
t1 = numpy.random.random((nocc,nvir)) * .1
t2 = numpy.random.random((nocc,nocc,nvir,nvir)) * .1
t2 = t2 + t2.transpose(1,0,3,2)
mf = scf.RHF(mol)
mycc = cc.CCSD(mf)
mycc.mo_energy = mycc._scf.mo_energy = numpy.arange(0., nocc+nvir)
eris.fock = numpy.diag(mycc.mo_energy)
e = ccsd_t.kernel(mycc, eris, t1, t2)
self.assertAlmostEqual(e, -8.4953387936460398, 9)
from pyscf import gto, scf, cc mol = gto.M(verbose=4, atom='H 0 0 0; F 0 0 1.1', basis='ccpvdz') mf = scf.RHF(mol).run() mycc = cc.CCSD(mf) # # CCSD module allows you feed MO integrals # eris = mycc.ao2mo() mycc.kernel(eris=eris) # # The same MO integrals can be used in CCSD lambda equation # mycc.solve_lambda(eris=eris) # # CCSD(T) module requires the same integrals used by CCSD module # from pyscf.cc import ccsd_t ccsd_t.kernel(mycc, eris=eris) # # CCSD gradients need zeroth order MO integrals when solving the "relaxed" # 1-particle density matrix. # from pyscf.grad.ccsd import Gradients grad_e = Gradients(mycc).kernel(eris=eris) # The electronic part only
'''
from pyscf import gto, scf, lib
from pyscf import cc
from pyscf.cc import ccsd_t
mol = gto.M(atom=[('H', 0, 0, i) for i in range(4)],
basis='ccpvdz')
#
# Run HF and CCSD and save results in file h10.chk
#
mf = scf.RHF(mol).set(chkfile='h10.chk').run()
mycc = cc.CCSD(mf).run()
lib.chkfile.save('h10.chk', 'cc/t1', mycc.t1)
lib.chkfile.save('h10.chk', 'cc/t2', mycc.t2)
#
# The following code can be executed in an independent script. One can
# restore the old HF and CCSD results from chkfile then call a standalone
# CCSD(T) calculation.
#
mol = lib.chkfile.load_mol('h10.chk')
mf = scf.RHF(mol)
mf.__dict__.update(lib.chkfile.load('h10.chk', 'scf'))
mycc = cc.CCSD(mf)
mycc.__dict__.update(scf.chkfile.load('h10.chk', 'cc'))
eris = mycc.ao2mo()
ccsd_t.kernel(mycc, eris)
def main(filename):
#uses the parameters specified in the inp object to optimize the geometry of the given molecule and outputs a file with the updated geometry
#TO PARAMATERIZE
min_grad = (1 * 10 ^ (-6))
# initialize and print header
pstr("", delim="*", addline=False)
pstr(" FREEZE-AND-THAW GEOMETRY CALCULATION ",
delim="*",
fill=False,
addline=False)
pstr("", delim="*", addline=False)
# print input options to stdout
pstr("Input File")
[
print(i[:-1]) for i in open(filename).readlines()
if ((i[0] not in ['#', '!']) and (i[0:2] not in ['::', '//']))
]
pstr("End Input", addline=False)
# read input file
inp = read_input(filename)
inp.timer = simple_timer.timer()
nsub = inp.nsubsys
inp.DIIS = None
inp.ndiags = [0 for i in range(nsub)]
# use supermolecular grid for all subsystem grids
inp.grids = gen_grids(inp)
sna = inp.smol.nao_nr()
na = [inp.mol[i].nao_nr() for i in range(nsub)]
# initialize 1e matrices from supermolecular system
inp.timer.start("OVERLAP INTEGRALS")
pstr("Getting subsystem overlap integrals", delim=" ")
inp.sSCF = get_scf(inp, inp.smol)
Hcore = inp.sSCF.get_hcore()
Smat = inp.sSCF.get_ovlp()
Fock = np.zeros((sna, sna))
Dmat = [None for i in range(nsub)]
inp.timer.end("OVERLAP INTEGRALS")
# get initial density for each subsystem
inp.timer.start("INITIAL SUBSYSTEMS")
inp.mSCF = [None for i in range(nsub)] # SCF objects
pstr('Initial subsystem densities', delim=' ')
for i in range(nsub):
inp.mSCF[i] = get_scf(inp, inp.mol[i])
# read density from file
if inp.read and os.path.isfile(inp.read + '.dm{0}'.format(i)):
print("Reading initial densities from file: {0}".format(
inp.read + '.dm{0}'.format(i)))
Dmat[i] = pickle.load(open(inp.read + '.dm{0}'.format(i), 'rb'))
# guess density
else:
print("Guessing initial subsystem densities")
Dmat[i] = inp.mSCF[i].init_guess_by_atom()
#Dmat[i] = inp.mSCF[i].init_guess_by_minao()
inp.sub2sup = get_sub2sup(inp, inp.mSCF)
inp.timer.end("INITIAL SUBSYSTEMS")
# start with supermolecule calculation
if inp.embed.localize:
pstr("Supermolecular DFT")
inp.sSCF = do_supermol_scf(inp, Dmat, Smat)
from localize import localize
pstr("Localizing Orbitals", delim="=")
Dmat = localize(inp, inp.sSCF, inp.mSCF, Dmat, Smat)
# do freeze-and-thaw cycles
inp.timer.start("FREEZE AND THAW")
if inp.embed.cycles == 1:
smethod = "SCF"
else:
smethod = "Freeze-and-Thaw"
if inp.embed.cycles > 0:
pstr("Starting " + smethod)
inp.error = 1.
inp.ift = 0
while ((inp.error > inp.embed.conv) and (inp.ift < inp.embed.cycles)):
inp.ift += 1
inp.prev_error = copy(inp.error)
inp.error = 0.
# cycle over active subsystems
for a in range(nsub):
if inp.embed.freezeb and a > 0: continue
# perform embedding of this subsystem
inp.timer.start("TOT. EMBED. OF {0}".format(a + 1))
Fock, inp.mSCF[a], Dnew, eproj, err = do_embedding(
a,
inp,
inp.mSCF,
Hcore,
Dmat,
Smat,
Fock,
cycles=inp.embed.subcycles,
conv=inp.embed.conv,
llast=False)
er = sp.linalg.norm(Dnew - Dmat[a])
Dmat[a] = np.copy(Dnew)
print(' iter: {0:>3d}:{1:<2d} |ddm|: {2:12.6e} '
'Tr[DP] {3:13.6e}'.format(inp.ift, a + 1, er, eproj))
inp.error += er
inp.timer.end("TOT. EMBED. OF {0}".format(a + 1))
print("FOCK")
print(Fock)
# print whether freeze-and-thaw has converged
if ((inp.embed.cycles > 1 and inp.error < inp.embed.conv)
or (inp.embed.cycles == 1 and err < inp.embed.conv)):
pstr(smethod + " converged!", delim=" ", addline=False)
elif inp.embed.cycles == 0:
pass
else:
pstr(smethod + " NOT converged!", delim=" ", addline=False)
#DFT in DFT Breakdown
superMol = concatenate_mols(inp.mol[0], inp.mol[1])
# do final embedded cycle at high level of theory
if inp.embed.cycles > -1:
inp.timer.start("TOT. EMBED. OF 1")
maxiter = inp.embed.subcycles
conv = inp.embed.conv
if inp.embed.method != inp.method:
pstr("Subsystem 1 at higher mean-field method", delim="=")
maxiter = inp.maxiter
conv = inp.conv
Fock, mSCF_A, DA, eproj, err = do_embedding(0,
inp,
inp.mSCF,
Hcore,
Dmat,
Smat,
Fock,
cycles=maxiter,
conv=conv,
llast=True)
er = sp.linalg.norm(DA - Dmat[0])
print(' iter: {0:>3d}:{1:<2d} |ddm|: {2:12.6e} '
'Tr[DP] {3:13.6e}'.format(inp.ift + 1, 1, er, eproj))
inp.timer.end("TOT. EMBED. OF 1")
if inp.embed.method != inp.method:
inp.eHI = mSCF_A.e_tot
else:
inp.eHI = None
inp.timer.end("FREEZE AND THAW")
# if WFT-in-(DFT/HF), do WFT theory calculation here
if inp.method == 'ccsd' or inp.method == 'ccsd(t)':
inp.timer.start("CCSD")
pstr("Doing CCSD Calculation on Subsystem 1")
mCCSD = cc.CCSD(mSCF_A)
ecc, t1, t2 = mCCSD.kernel()
inp.eHI = mSCF_A.e_tot + ecc
inp.timer.end("CCSD")
print("Hartree-Fock Energy: {0:19.14f}".format(mSCF_A.e_tot))
print("CCSD Correlation: {0:19.14f}".format(ecc))
print("CCSD Energy: {0:19.14f}".format(mSCF_A.e_tot + ecc))
if inp.method == 'ccsd(t)':
from pyscf.cc import ccsd_t, ccsd_t_lambda_slow, ccsd_t_rdm_slow
inp.timer.start("CCSD(T)")
pstr("Doing CCSD(T) Calculation on Subsystem 1")
ecc += ccsd_t.kernel(mCCSD, mCCSD.ao2mo())
inp.eHI = mSCF_A.e_tot + ecc
inp.timer.end("CCSD(T)")
print("Hartree-Fock Energy: {0:19.14f}".format(mSCF_A.e_tot))
print("CCSD(T) Correlation: {0:19.14f}".format(ecc))
print("CCSD(T) Energy: {0:19.14f}".format(mSCF_A.e_tot + ecc))
if inp.method == 'fci':
from pyscf import fci
inp.timer.start("FCI")
pstr("Doing FCI Calculation on Subsystem 1")
#Found here: https://github.com/sunqm/pyscf/blob/master/examples/fci/00-simple_fci.py
cisolver = fci.FCI(inp.mol[0], mSCF_A.mo_coeff)
efci = cisolver.kernel()[0]
inp.eHI = efci
inp.timer.end("FCI")
print("Hartree-Fock Energy: {0:19.14f}".format(mSCF_A.e_tot))
print("FCI Correlation: {0:19.14f}".format(efci - mSCF_A.e_tot))
print("FCI Energy: {0:19.14f}".format(efci))
# get interaction energy
inp.timer.start("INTERACTION ENERGIES")
ldosup = not inp.embed.localize
if ldosup: pstr("Supermolecular DFT")
Etot, EA = get_interaction_energy(inp, Dmat, Smat, ldosup=ldosup)
inp.timer.end("INTERACTION ENERGIES")
if inp.gencube == "final":
inp.timer.start("Generate Cube file")
molA_cubename = filename.split(".")[0] + "_A.cube"
molB_cubename = filename.split(".")[0] + "_B.cube"
cubegen.density(inp.mol[0], molA_cubename, Dmat[0])
cubegen.density(inp.mol[1], molB_cubename, Dmat[1])
inp.timer.end("Generate Cube file")
pstr("Embedding Energies", delim="=")
Eint = Etot - EA
Ediff = inp.Esup - Etot
print("Subsystem DFT {0:19.14f}".format(EA))
print("Interaction {0:19.14f}".format(Eint))
print("DFT-in-DFT {0:19.14f}".format(Etot))
print("Supermolecular DFT {0:19.14f}".format(inp.Esup))
print("Difference {0:19.14f}".format(Ediff))
print("Corrected DFT-in-DFT {0:19.14f}".format(Etot + Ediff))
if inp.eHI is not None:
print("WF-in-DFT {0:19.14f}".format(inp.eHI + Eint))
print("Corrected WF-in-DFT {0:19.14f}".format(inp.eHI + Eint +
Ediff))
# close and print timings
inp.timer.close()
# print end of file
pstr("", delim="*")
pstr("END OF CYCLE", delim="*", fill=False, addline=False)
pstr("", delim="*", addline=False)
G_tot = grad.rks.Gradient(inp.sSCF)
G_tot_mat = G_tot.grad()
print(G_tot_mat)
atom = [
["O" , (0. , 0. , 0. )],
[1 , (0. ,-0.757 ,-0.587)],
[1 , (0. , 0.757 ,-0.587)]],
basis = '631g'
)
mf = scf.RHF(mol)
mf.conv_tol = 1e-14
ehf = mf.scf()
mycc = cc.CCSD(mf)
mycc.conv_tol = 1e-10
mycc.conv_tol_normt = 1e-10
ecc, t1, t2 = mycc.kernel()
eris = mycc.ao2mo()
e3ref = ccsd_t.kernel(mycc, eris, t1, t2)
print(ehf+ecc+e3ref)
eris = mycc.ao2mo(mf.mo_coeff)
conv, l1, l2 = ccsd_t_lambda.kernel(mycc, eris, t1, t2)
g1 = Gradients(mycc).kernel(t1, t2, l1, l2, eris=eris)
print(g1)
myccs = mycc.as_scanner()
mol.atom[0] = ["O" , (0., 0., 0.001)]
mol.build(0, 0)
e1 = myccs(mol)
e1 += myccs.ccsd_t()
mol.atom[0] = ["O" , (0., 0.,-0.001)]
mol.build(0, 0)
e2 = myccs(mol)
e2 += myccs.ccsd_t()
def do_scf(inp):
'''Do the requested SCF.'''
from pyscf import gto, scf, dft, cc, fci, ci, ao2mo, mcscf, mrpt, lib, mp, tdscf
from pyscf.cc import ccsd_t, uccsd_t
import numpy as np
from .fcidump import fcidump
# sort out the method
mol = inp.mol
method = inp.scf.method.lower()
# UHF
if method == 'uhf':
ehf, mSCF = do_hf(inp, unrestricted=True)
print_energy('UHF', ehf)
if inp.scf.exci is not None:
inp.timer.start('TDHF')
mtd = do_TDDFT(inp, mSCF)
inp.timer.end('TDHF')
# RHF
elif method in ('rhf', 'hf'):
ehf, mSCF = do_hf(inp)
print_energy('RHF', ehf)
if inp.scf.exci is not None:
inp.timer.start('TDHF')
mtd = do_TDDFT(inp, mSCF)
inp.timer.end('TDHF')
# CCSD and CCSD(T)
elif method in ('ccsd', 'ccsd(t)', 'uccsd', 'uccsd(t)', 'eomccsd'):
if 'u' in method:
ehf, tSCF = do_hf(inp, unrestricted=True)
print_energy('UHF', ehf)
else:
ehf, tSCF = do_hf(inp)
print_energy('RHF', ehf)
inp.timer.start('ccsd')
frozen = 0
if inp.scf.freeze is not None: frozen = inp.scf.freeze
if 'u' in method:
mSCF = cc.UCCSD(tSCF, frozen=frozen)
else:
mSCF = cc.CCSD(tSCF, frozen=frozen)
mSCF.max_cycle = inp.scf.maxiter
eccsd, t1, t2 = mSCF.kernel()
print_energy('CCSD', ehf + eccsd)
inp.timer.end('ccsd')
if method == 'eomccsd':
inp.timer.start('eomccsd')
ee = mSCF.eomee_ccsd_singlet(nroots=4)[0]
inp.timer.end('eomccsd')
for i in range(len(ee)):
print_energy('EOM-CCSD {0} (eV)'.format(i+1), ee[i] * 27.2114)
if method in ('ccsd(t)', 'uccsd(t)'):
inp.timer.start('ccsd(t)')
eris = mSCF.ao2mo()
if method == 'ccsd(t)':
e3 = ccsd_t.kernel(mSCF, eris)
else:
e3 = uccsd_t.kernel(mSCF, eris)
print_energy('CCSD(T)', ehf + eccsd + e3)
inp.timer.end('ccsd(t)')
# MP2
elif method == 'mp2':
ehf, tSCF = do_hf(inp)
print_energy('RHF', ehf)
inp.timer.start('mp2')
frozen = 0
if inp.scf.freeze is not None: frozen = inp.scf.freeze
mSCF = mp.MP2(tSCF, frozen=frozen)
emp2, t2 = mSCF.kernel()
print_energy('MP2', ehf+emp2)
inp.timer.end('mp2')
# CISD
elif method == 'cisd' or method == 'cisd(q)':
ehf, tSCF = do_hf(inp)
print_energy('RHF', ehf)
inp.timer.start('cisd')
frozen = 0
if inp.scf.freeze is not None: frozen = inp.scf.freeze
mSCF = ci.CISD(tSCF, frozen=frozen)
ecisd = mSCF.kernel()[0]
print_energy('CISD', ehf + ecisd)
inp.timer.end('cisd')
# perform Davison quadruples correction
c0 = np.max(np.abs(mSCF.ci))
c02 = c0**2
ne = mSCF.mol.nelectron
eq = ( 1.0 - c02 ) * ecisd
print_energy('CISD(Q) Davidson', ehf + ecisd + eq)
eq = ( 1.0 - c02 ) / c02 * ecisd
print_energy('CISD(Q) Renomalized-Davidson', ehf + ecisd + eq)
eq = ( 1.0 - c02 ) / ( 2.0 * c02 - 1.0 ) * ecisd
print_energy('CISD(Q) Davison-Silver', ehf + ecisd + eq)
eq = (( 2.0 * c02 ) / ((2.0*c02-1.0)*(1.0 + np.sqrt(1.0 + (8.0*c02*(1.0-c02))
/ ( ne * (2.0*c02-1.0)**2 )))) - 1.0 ) * ecisd
print_energy('CISD(Q) PC', ehf + ecisd + eq)
eq = ( 1.0 - c02 ) / c02 * ((ne-2)*(ne-3.0)) / (ne*(ne-1.0)) * ecisd
print_energy('CISD(Q) MC', ehf + ecisd + eq)
if ne > 2:
eq = ( 2.0 - c02 ) / (2.0 * (ne-1.0)/(ne-2.0) * c02 - 1.0)
else:
eq = 0.0
print_energy('CISD(Q) DD', ehf + ecisd + eq)
# UKS
elif method in ('uks' or 'udft'):
inp.timer.start('uks')
inp.timer.start('grids')
grids = dft.gen_grid.Grids(mol)
grids.level = inp.scf.grid
grids.build()
inp.timer.end('grids')
mSCF = dft.UKS(mol)
mSCF.grids = grids
mSCF.xc = inp.scf.xc
mSCF.conv_tol = inp.scf.conv
mSCF.conv_tol_grad = inp.scf.grad
mSCF.max_cycle = inp.scf.maxiter
mSCF.init_guess = inp.scf.guess
mSCF.small_rho_cutoff = 1e-20
eks = mSCF.kernel()
print_energy('UKS', eks)
inp.timer.end('uks')
if inp.scf.exci is not None:
inp.timer.start('TDDFT')
mtd = do_TDDFT(inp, mSCF)
inp.timer.end('TDDFT')
# RKS
elif method in ('rks', 'ks', 'rdft', 'dft'):
inp.timer.start('ks')
inp.timer.start('grids')
grids = dft.gen_grid.Grids(mol)
grids.level = inp.scf.grid
grids.build()
inp.timer.end('grids')
if mol.nelectron%2 == 0:
mSCF = dft.RKS(mol)
else:
mSCF = dft.ROKS(mol)
mSCF.grids = grids
mSCF.xc = inp.scf.xc
mSCF.conv_tol = inp.scf.conv
mSCF.conv_tol_grad = inp.scf.grad
mSCF.max_cycle = inp.scf.maxiter
mSCF.init_guess = inp.scf.guess
mSCF.small_rho_cutoff = 1e-20
mSCF.damp = inp.scf.damp
mSCF.level_shift = inp.scf.shift
eks = mSCF.kernel()
print_energy('RKS', eks)
inp.timer.end('ks')
if inp.scf.exci is not None:
inp.timer.start('TDDFT')
mtd = do_TDDFT(inp, mSCF)
inp.timer.end('TDDFT')
# Unrestricted FCI
elif method == 'ufci':
ehf, mSCF = do_hf(inp, unrestricted=True)
print_energy('UHF', ehf)
inp.timer.start('fci')
cis = fci.direct_uhf.FCISolver(mol)
norb = mSCF.mo_energy[0].size
nea = (mol.nelectron+mol.spin) // 2
neb = (mol.nelectron-mol.spin) // 2
nelec = (nea, neb)
mo_a = mSCF.mo_coeff[0]
mo_b = mSCF.mo_coeff[1]
h1e_a = reduce(np.dot, (mo_a.T, mSCF.get_hcore(), mo_a))
h1e_b = reduce(np.dot, (mo_b.T, mSCF.get_hcore(), mo_b))
g2e_aa = ao2mo.incore.general(mSCF._eri, (mo_a,)*4, compact=False)
g2e_aa = g2e_aa.reshape(norb,norb,norb,norb)
g2e_ab = ao2mo.incore.general(mSCF._eri, (mo_a,mo_a,mo_b,mo_b), compact=False)
g2e_ab = g2e_ab.reshape(norb,norb,norb,norb)
g2e_bb = ao2mo.incore.general(mSCF._eri, (mo_b,)*4, compact=False)
g2e_bb = g2e_bb.reshape(norb,norb,norb,norb)
h1e = (h1e_a, h1e_b)
eri = (g2e_aa, g2e_ab, g2e_bb)
eci = fci.direct_uhf.kernel(h1e, eri, norb, nelec)[0]
print_energy('FCI', eci)
inp.timer.end('fci')
# FCI
elif method in ('fci'):
ehf, mSCF = do_hf(inp)
print_energy('RHF', ehf)
inp.timer.start('fci')
if inp.scf.freeze is None:
mCI = fci.FCI(mSCF)
if inp.scf.roots is not None:
mCI.nroots = inp.scf.roots
mCI.kernel()[0]
eci = mCI.eci
else:
nel = mol.nelectron - inp.scf.freeze * 2
ncas = mol.nao_nr() - inp.scf.freeze
if mol.spin == 0:
nelecas = nel
mCI = mcscf.CASCI(mSCF, ncas, nelecas)
mCI.fcisolver = fci.solver(mol)
else:
if mol.spin%2 == 0:
nelecas = (nel//2+mol.spin//2, nel//2-mol.spin//2)
else:
nelecas = (nel//2+mol.spin//2+1, nel//2-mol.spin//2)
mCI = mcscf.CASCI(mSCF, ncas, nelecas)
mCI.fcisolver = fci.direct_spin1.FCISolver(mol)
eci = mCI.kernel()[0]
dm = mCI.make_rdm1()
dip = mSCF.dip_moment(dm=dm)
if inp.scf.roots is None:
print_energy('FCI', eci)
else:
for i in range(inp.scf.roots):
print_energy('FCI {0}'.format(i), eci[i])
inp.timer.end('fci')
# CASCI
elif method == 'casci':
if inp.scf.cas is None and inp.scf.casorb is None:
print ('ERROR: Must specify CAS space or CASORB')
return inp
ehf, mSCF = do_hf(inp)
print_energy('RHF', ehf)
# get cas space
if inp.scf.cas is not None:
if mol.spin == 0:
nelecas = inp.scf.cas[0]
else:
nelecas = (inp.scf.cas[0]//2 + mol.spin//2,
inp.scf.cas[0]//2 - mol.spin//2)
ncasorb = inp.scf.cas[1]
elif inp.scf.casorb is not None:
ncasorb = len(inp.scf.casorb)
nelecas = int(np.sum(mSCF.mo_occ[inp.scf.casorb]))
if inp.scf.casspin is not None:
nelecas = (nelecas//2 + inp.scf.casspin//2,
nelecas//2 - inp.scf.casspin//2)
inp.timer.start('casci')
mCI = mcscf.CASCI(mSCF, ncasorb, nelecas)
if inp.scf.casorb is not None:
mo = mcscf.addons.sort_mo(mCI, np.copy(mSCF.mo_coeff), inp.scf.casorb, 0)
else:
mo = np.copy(mSCF.mo_coeff)
eci = mCI.kernel(mo)[0]
print_energy('CASCI', eci)
inp.timer.end('casci')
# CASSCF
elif method == 'casscf' or method == 'ucasscf':
if inp.scf.cas is None and inp.scf.casorb is None:
print ('ERROR: Must specify CAS space or CASORB')
return inp
lunrestricted = (method == 'ucasscf')
ehf, mSCF = do_hf(inp, unrestricted=lunrestricted)
print_energy('HF', ehf)
# get cas space
if inp.scf.cas is not None:
if mol.spin == 0:
nelecas = inp.scf.cas[0]
else:
nelecas = (inp.scf.cas[0]//2 + mol.spin//2,
inp.scf.cas[0]//2 - mol.spin//2)
ncasorb = inp.scf.cas[1]
elif inp.scf.casorb is not None:
ncasorb = len(inp.scf.casorb)
nelecas = int(np.sum(mSCF.mo_occ[inp.scf.casorb]))
if inp.scf.casspin is not None:
nelecas = (nelecas//2 + inp.scf.casspin//2,
nelecas//2 - inp.scf.casspin//2)
inp.timer.start('casscf')
mCI = mcscf.CASSCF(mSCF, ncasorb, nelecas)
if inp.scf.casorb is not None:
mo = mcscf.addons.sort_mo(mCI, np.copy(mSCF.mo_coeff), inp.scf.casorb, 0)
else:
mo = np.copy(mSCF.mo_coeff)
eci = mCI.kernel(mo)[0]
print_energy('CASSCF', eci)
inp.timer.end('casscf')
# NEVPT2
elif method == 'nevpt2' or method == 'unevpt2':
if inp.scf.cas is None and inp.scf.casorb is None:
print ('ERROR: Must specify CAS space or CASORB')
return inp
ehf, mSCF = do_hf(inp)
print_energy('RHF', ehf)
inp.timer.start('casscf')
# get cas space
if inp.scf.cas is not None:
if mol.spin == 0:
nelecas = inp.scf.cas[0]
else:
nelecas = (inp.scf.cas[0]//2 + mol.spin//2,
inp.scf.cas[0]//2 - mol.spin//2)
ncasorb = inp.scf.cas[1]
elif inp.scf.casorb is not None:
ncasorb = len(inp.scf.casorb)
nelecas = int(np.sum(mSCF.mo_occ[inp.scf.casorb]))
if inp.scf.casspin is not None:
nelecas = (nelecas//2 + inp.scf.casspin//2,
nelecas//2 - inp.scf.casspin//2)
mCI = mcscf.CASSCF(mSCF, ncasorb, nelecas, frozen=inp.scf.freeze)
if inp.scf.casorb is not None:
mo = mcscf.addons.sort_mo(mCI, np.copy(mSCF.mo_coeff), inp.scf.casorb, 0)
else:
mo = np.copy(mSCF.mo_coeff)
eci = mCI.kernel(mo)[0]
print_energy('CASSCF', eci)
inp.timer.end('casscf')
inp.timer.start('nevpt2')
mpt2 = mrpt.NEVPT(mCI)
ept2 = mpt2.kernel() + eci
print_energy('NEVPT2', ept2)
inp.timer.end('nevpt2')
else:
print ('ERROR: Unrecognized SCF method!')
raise SystemExit
# dump fcidump file if needed
if inp.fcidump:
if inp.filename[-4:].lower() == '.inp':
fcifile = inp.filename[:-4] + '.fcidump'
else:
fcifile = inp.filename + '.fcidump'
fcidump(mSCF, filename=fcifile, tol=1e-6)
# plot MOs if needed
if inp.mo2cube:
from .mo_2_cube import save_MOs
save_MOs(inp, mSCF, mSCF.mo_coeff)
# save molden file if needed
if inp.molden:
from pyscf.tools import molden
molden_file = inp.filename[:-4] + '.molden'
molden.from_mo(inp.mol, molden_file, mSCF.mo_coeff, ene=mSCF.mo_energy)
# save and return
inp.mf = mSCF
return inp
atom = [
["O" , (0. , 0. , 0. )],
[1 , (0. ,-0.757 ,-0.587)],
[1 , (0. , 0.757 ,-0.587)]],
basis = '631g'
)
mf = scf.RHF(mol)
mf.conv_tol = 1e-14
ehf = mf.scf()
mycc = cc.CCSD(mf)
mycc.conv_tol = 1e-10
mycc.conv_tol_normt = 1e-10
ecc, t1, t2 = mycc.kernel()
eris = mycc.ao2mo()
e3ref = ccsd_t.kernel(mycc, eris, t1, t2)
print(ehf+ecc+e3ref)
eris = mycc.ao2mo(mf.mo_coeff)
conv, l1, l2 = ccsd_t_lambda.kernel(mycc, eris, t1, t2)
g1 = kernel(mycc, t1, t2, l1, l2, eris=eris)
print(g1)
myccs = mycc.as_scanner()
mol.atom[0] = ["O" , (0., 0., 0.001)]
mol.build(0, 0)
e1 = myccs(mol)
e1 += myccs.ccsd_t()
mol.atom[0] = ["O" , (0., 0.,-0.001)]
mol.build(0, 0)
e2 = myccs(mol)
e2 += myccs.ccsd_t()
results.multiplicity) if results.multiplicity is not None else 1
spin = (multiplicity - 1) / 2
num_frozen_cores = int(
results.frozen_cores) if results.frozen_cores is not None else 0
sys.argv = [sys.argv[0]]
# -----------------------
# PYSCF
# -----------------------
mol = gto.M(atom=atomic_coords,
basis=basis_set,
spin=spin,
charge=charge,
verbose=5)
mf = scf.RHF(mol)
if density_fit:
mf = mf.density_fit()
mf.with_df.auxbasis = aux_basis_set
mf.run()
my_cc = cc.CCSD(mf)
ccsd_corr_energy = my_cc.kernel()[0]
ccsdt_corr_energy = ccsd_t.kernel(my_cc, my_cc.ao2mo())
ccsdt_energy = mf.e_tot + ccsd_corr_energy + ccsdt_corr_energy
print("E(CCSD(T)) = {0}".format(ccsdt_energy))
#
mo_vir = cv
coeff = numpy.hstack([mo_core, mo_occ, mo_vir])
nao, nmo = coeff.shape
nocc = mol.nelectron // 2
occ = numpy.zeros(nmo)
for i in range(nocc):
occ[i] = 2.0
#
mycc = cc.CCSD(mf, mo_coeff=coeff, mo_occ=occ)
mycc.diis_space = 10
mycc.frozen = ncore
mycc.conv_tol = 1e-6
mycc.conv_tol_normt = 1e-6
mycc.max_cycle = 150
ecc, t1, t2 = mycc.kernel()
nao, nmo = coeff.shape
eris = mycc.ao2mo()
e3 = ccsd_t.kernel(mycc, eris, t1, t2)
lib.logger.info(mycc, "* CCSD(T) energy : %12.6f" % (ehf + ecc + e3))
l1, l2 = ccsd_t_lambda.kernel(mycc, eris, t1, t2)[1:]
rdm1 = ccsd_t_rdm.make_rdm1(mycc, t1, t2, l1, l2, eris=eris)
rdm2 = ccsd_t_rdm.make_rdm2(mycc, t1, t2, l1, l2, eris=eris)
#
eri_mo = ao2mo.kernel(mf._eri, coeff[:, :nmo], compact=False)
eri_mo = eri_mo.reshape(nmo, nmo, nmo, nmo)
h1 = reduce(numpy.dot, (coeff[:, :nmo].T, mf.get_hcore(), coeff[:, :nmo]))
ecc = (numpy.einsum('ij,ji->', h1, rdm1) +
numpy.einsum('ijkl,ijkl->', eri_mo, rdm2) * .5 + mf.mol.energy_nuc())
lib.logger.info(mycc, "* Energy with 1/2-RDM : %.8f" % ecc)
#!/usr/bin/env python
from pyscf import gto, scf, cc
from pyscf.cc import ccsd_t
mol = gto.Mole()
mol.basis = 'aug-cc-pvdz'
mol.atom = (('Ne', 0, 0, 0), )
mol.verbose = 4
mol.build()
mf = scf.RHF(mol)
mf.chkfile = 'scf.chk'
ehf = mf.kernel()
ccsd = cc.CCSD(mf)
eccsd = ccsd.kernel()[0]
ecorr_ccsdt = ccsd_t.kernel(ccsd, ccsd.ao2mo())
print("E(CCSD(T)) = {}".format(ehf + eccsd + ecorr_ccsdt))
sub1_trans_mol.atom = sub1_trans
sub1_trans_mol.basis = basis_to_use
sub1_trans_mol.charge = -2
sub1_trans_mol.build()
sub2_trans_mol = gto.Mole()
sub2_trans_mol.atom = sub2_trans
sub2_trans_mol.basis = basis_to_use
sub2_trans_mol.charge = 1
sub2_trans_mol.build()
react_mf = scf.RHF(react_mol)
react_total_energy = react_mf.kernel()
react_cc = cc.CCSD(react_mf)
react_total_energy += react_cc.kernel()[0]
react_total_energy += ccsd_t.kernel(react_cc, react_cc.ao2mo())
trans_mf = scf.RHF(trans_mol)
trans_total_energy = trans_mf.kernel()
trans_cc = cc.CCSD(trans_mf)
trans_total_energy += trans_cc.kernel()[0]
trans_total_energy += ccsd_t.kernel(trans_cc, trans_cc.ao2mo())
print("Canonical Difference")
print(trans_total_energy - react_total_energy)
sub1_react = cluster_subsystem.ClusterActiveSubSystem(sub1_react_mol,
dft_method,
active_method)
sub2_react = cluster_subsystem.ClusterEnvSubSystem(sub2_react_mol, dft_method)
sup_react = cluster_supersystem.ClusterSuperSystem([sub1_react, sub2_react],
