def test_denisty_fit_interface(self):
mydf = df.DF(mol)
mycc1 = ccsd.CCSD(mf).density_fit(auxbasis='ccpvdz-ri',
with_df=mydf).run()
self.assertAlmostEqual(mycc1.e_tot, -76.119348934346789, 7)
mycc = gccsd.GCCSD(mf)
eris = mycc.ao2mo()
mycc.kernel(eris=eris)
l1, l2 = mycc.solve_lambda(mycc.t1, mycc.t2, eris=eris)
l1 = mycc.spin2spatial(l1, mycc.mo_coeff.orbspin)
l2 = mycc.spin2spatial(l2, mycc.mo_coeff.orbspin)
print(lib.finger(l1[0]) - -0.0030030170069977758)
print(lib.finger(l1[1]) - -0.0030030170069977758)
print(lib.finger(l2[0]) - -0.041444910588788492)
print(lib.finger(l2[1]) - 0.1077575086912813)
print(lib.finger(l2[2]) - -0.041444910588788492)
print(abs(l2[1] - l2[1].transpose(1, 0, 2, 3) - l2[0]).max())
print(abs(l2[1] - l2[1].transpose(0, 1, 3, 2) - l2[0]).max())
from pyscf.cc import ccsd
mycc0 = ccsd.CCSD(mf0)
eris0 = mycc0.ao2mo()
mycc0.kernel(eris=eris0)
t1 = mycc0.t1
t2 = mycc0.t2
imds = ccsd_lambda.make_intermediates(mycc0, t1, t2, eris0)
l1, l2 = ccsd_lambda.update_lambda(mycc0, t1, t2, t1, t2, eris0, imds)
l1ref, l2ref = ccsd_lambda.update_lambda(mycc0, t1, t2, l1, l2, eris0,
imds)
t1 = mycc.spatial2spin(t1, mycc.mo_coeff.orbspin)
t2 = mycc.spatial2spin(t2, mycc.mo_coeff.orbspin)
l1 = mycc.spatial2spin(l1, mycc.mo_coeff.orbspin)
l2 = mycc.spatial2spin(l2, mycc.mo_coeff.orbspin)
imds = make_intermediates(mycc, t1, t2, eris)
l1, l2 = update_lambda(mycc, t1, t2, l1, l2, eris, imds)
l1 = mycc.spin2spatial(l1, mycc.mo_coeff.orbspin)
no, nv = mycc1.t1.shape mycci = copy.copy(mycc1) erisi = copy.copy(eris1) erisi.oooo = eris1.oooo + numpy.sin(eris1.oooo) * 1j erisi.oooo = erisi.oooo + erisi.oooo.conj().transpose(1, 0, 3, 2) erisi.ovoo = eris1.ovoo + numpy.sin(eris1.ovoo) * 1j erisi.ovvo = eris1.ovvo + numpy.sin(eris1.ovvo) * 1j erisi.oovv = eris1.oovv + numpy.sin(eris1.oovv) * 1j erisi.oovv = erisi.oovv + erisi.oovv.conj().transpose(1, 0, 3, 2) erisi.ovov = eris1.ovov + numpy.sin(eris1.ovov) * 1j erisi.ovvv = eris1.ovvv + numpy.sin(eris1.ovvv) * 1j erisi.vvvv = eris1.vvvv + numpy.sin(eris1.vvvv) * 1j erisi.vvvv = erisi.vvvv + erisi.vvvv.conj().transpose(1, 0, 3, 2) mycc2 = ccsd.CCSD(mf) mycc21 = ccsd.CCSD(mf1) mycc2.__dict__.update(mycc.__dict__) mycc21.__dict__.update(mycc1.__dict__) eris21 = mycc21.ao2mo() mycc3 = ccsd.CCSD(mf) mycc31 = ccsd.CCSD(mf1) mycc3.__dict__.update(mycc.__dict__) mycc31.__dict__.update(mycc1.__dict__) mycc3 = mycc3.set(max_memory=0, direct=True) mycc31 = mycc31.set(max_memory=0, direct=True) eris31 = mycc31.ao2mo() def tearDownModule():
def test_update_amps(self):
mol = gto.M()
nocc, nvir = 5, 12
nmo = nocc + nvir
nmo_pair = nmo * (nmo + 1) // 2
mf = scf.RHF(mol)
np.random.seed(12)
mf._eri = np.random.random(nmo_pair * (nmo_pair + 1) // 2)
mf.mo_coeff = np.random.random((nmo, nmo))
mf.mo_energy = np.arange(0., nmo)
mf.mo_occ = np.zeros(nmo)
mf.mo_occ[:nocc] = 2
vhf = mf.get_veff(mol, mf.make_rdm1())
cinv = np.linalg.inv(mf.mo_coeff)
mf.get_hcore = lambda *args: (reduce(np.dot, (cinv.T * mf.mo_energy,
cinv)) - vhf)
mycc1 = rccsd.RCCSD(mf)
eris1 = mycc1.ao2mo()
mycc2 = ccsd.CCSD(mf)
eris2 = mycc2.ao2mo()
a = np.random.random((nmo, nmo)) * .1
eris1.fock += a + a.T.conj()
eris2.fock += a + a.T
t1 = np.random.random((nocc, nvir)) * .1
t2 = np.random.random((nocc, nocc, nvir, nvir)) * .1
t2 = t2 + t2.transpose(1, 0, 3, 2)
t1b, t2b = ccsd.update_amps(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(t1b), -106360.5276951083, 6)
self.assertAlmostEqual(lib.finger(t2b), 66540.100267798145, 6)
mycc2.max_memory = 0
t1a, t2a = ccsd.update_amps(mycc2, t1, t2, eris2)
self.assertAlmostEqual(abs(t1a - t1b).max(), 0, 9)
self.assertAlmostEqual(abs(t2a - t2b).max(), 0, 9)
t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(t2tril), 13306.139402693696, 8)
Ht2 = ccsd._add_vvvv_full(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(Ht2), 760.50164232208408, 9)
mycc1.cc2 = False
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a), -106360.5276951083, 7)
self.assertAlmostEqual(lib.finger(t2a), 66540.100267798145, 6)
self.assertAlmostEqual(abs(t1a - t1b).max(), 0, 6)
self.assertAlmostEqual(abs(t2a - t2b).max(), 0, 6)
mycc1.cc2 = True
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a), -106360.5276951083, 7)
self.assertAlmostEqual(lib.finger(t2a), -1517.9391800662809, 7)
mol = gto.Mole()
mol.verbose = 0
mol.atom = [[8, (0., 0., 0.)], [1, (1., 0., 0.)],
[1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]]
mol.basis = {
'H': 'sto3g',
'O': 'cc-pvdz',
}
mol.charge = 1
mol.build(0, 0)
mycc2.direct = True
eris2.vvvv = None
eris2.mol = mol
mycc2.mo_coeff, eris2.mo_coeff = eris2.mo_coeff, None
t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2, with_ovvv=True)
self.assertAlmostEqual(lib.finger(t2tril), 680.07199094501584, 9)
t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2, with_ovvv=False)
self.assertAlmostEqual(lib.finger(t2tril), 446.56702664171348, 9)
Ht2 = ccsd._add_vvvv_full(mycc2, t1, t2, eris2)
self.assertAlmostEqual(lib.finger(Ht2), 48.122317842230686, 9)
eri1 = np.random.random((nmo, nmo, nmo, nmo)) + np.random.random(
(nmo, nmo, nmo, nmo)) * 1j
eri1 = eri1.transpose(0, 2, 1, 3)
eri1 = eri1 + eri1.transpose(1, 0, 3, 2).conj()
eri1 = eri1 + eri1.transpose(2, 3, 0, 1)
eri1 *= .1
eris1.oooo = eri1[:nocc, :nocc, :nocc, :nocc].copy()
eris1.ovoo = eri1[:nocc, nocc:, :nocc, :nocc].copy()
eris1.ovov = eri1[:nocc, nocc:, :nocc, nocc:].copy()
eris1.oovv = eri1[:nocc, :nocc, nocc:, nocc:].copy()
eris1.ovvo = eri1[:nocc, nocc:, nocc:, :nocc].copy()
eris1.ovvv = eri1[:nocc, nocc:, nocc:, nocc:].copy()
eris1.vvvv = eri1[nocc:, nocc:, nocc:, nocc:].copy()
a = np.random.random((nmo, nmo)) * .1j
eris1.fock = eris1.fock + a + a.T.conj()
t1 = t1 + np.random.random((nocc, nvir)) * .1j
t2 = t2 + np.random.random((nocc, nocc, nvir, nvir)) * .1j
t2 = t2 + t2.transpose(1, 0, 3, 2)
mycc1.cc2 = False
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a),
-13.32050019680894 - 1.8825765910430254j, 9)
self.assertAlmostEqual(lib.finger(t2a),
9.2521062044785189 + 29.999480274811873j, 9)
mycc1.cc2 = True
t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1)
self.assertAlmostEqual(lib.finger(t1a),
-13.32050019680894 - 1.8825765910430254j, 9)
self.assertAlmostEqual(lib.finger(t2a),
-0.056223856104895858 + 0.025472249329733986j,
9)
def test():
nao = 2
U = 2.
solver = 'cc' # 'scf', 'cc', 'fci'
if solver == 'fci':
assert (fci_)
htb = -1*_tb(nao)
htb[0,0]=0.0
eri = np.zeros([nao,nao,nao,nao])
for k in range(nao):
eri[k,k,k,k] = U
#delta = _get_delta(htb)
delta=0.01
mol = gto.M()
mol.build()
mol.nelectron = 2 #nao
mf = scf.RHF(mol)
mf.verbose = 0
# mf.verbose = 4
mf.max_memory = 1000
mf.get_hcore = lambda *args: htb
mf.get_ovlp = lambda *args: np.eye(nao)
mf._eri = ao2mo.restore(8, eri, nao)
mf.init_guess = '1e'
mf.scf()
print 'MF energy = %20.12f' % (mf.e_tot)
print 'MO energies :'
print mf.mo_energy
print '----\n'
HamCheMPS2, theFCI = None, None
if solver == 'cc':
cc = ccsd.CCSD(mf)
ecc = cc.ccsd()[0]
print "CCSD corr = %20.12f" % (ecc)
print "Solving lambda equations..."
cc.solve_lambda()
print "Repeating with EOM CCSD"
#cc_eom = eom_rccsd.RCCSD(mf)
# cc_eomip = eom_rccsd.EOMIP(cc)
# cc_eomea = eom_rccsd.EOMEA(cc)
#def ao2mofn_ (mol, bas, compact):
# return ao2mo.incore.general(mf._eri, bas, compact=compact)
#eri_eom = eom_rccsd._ERIS(cc_eom, ao2mofn=ao2mofn_)
#ecc_eom = cc_eom.ccsd(eris=eri_eom)[0]
#print "EOM-CCSD corr = %20.12f" % (ecc_eom)
#print '====\n'
#cc_eom.t1 = cc.t1
#cc_eom.t2 = cc.t2
#cc_eom.l1 = cc.l1
#cc_eom.l2 = cc.l2
e_vector = list()
b_vector = list()
for q in range(nao):
e_vector.append(greens_function.greens_e_vector_ip_rhf(cc,q))
b_vector.append(greens_function.greens_b_vector_ip_rhf(cc,q))
dm = np.zeros((nao,nao,), np.complex128)
for q in range(nao):
for p in range(nao):
dm[p,q] = -np.dot(e_vector[q], b_vector[p])
print dm.real
hc = np.dot(mf.mo_coeff.T, np.dot(mf.get_hcore(), mf.mo_coeff))
print 'CC IP evals'
eomip = eom_rccsd.EOMIP(cc)
evals, evecs = eomip.ipccsd(nroots=e_vector[0].shape[0])
print evals
# these are sums over principal poles
A = np.dot(evecs, np.dot(np.diag(evals), inv(evecs)))
dt = np.zeros((nao,nao,), np.complex128)
for q in range(nao):
for p in range(nao):
dt[p,q] = np.dot(e_vector[q], np.dot(A, b_vector[p]))
nn = 2*0.5*np.trace(dm).real
ee = 2*0.5*np.trace(np.dot(dm, hc)).real \
+ 2*0.5*np.trace(dt).real
print 'N = %16.8f' % (nn)
print 'E = %16.8f' % (ee)
elif solver == 'fci':
h0 = 0.
h1t = np.dot(mf.mo_coeff.T, np.dot(htb, mf.mo_coeff))
erit = ao2mo.incore.full(mf._eri, mf.mo_coeff, compact=False)
erit = erit.reshape([nao,nao,nao,nao])
HamCheMPS2, theFCI, GSvector, en_FCIgs = \
fci_sol (h0, h1t, erit, mol.nelectron)
print "FCI corr = %20.12f" % (en_FCIgs-mf.e_tot)
evals, evecs = scipy.linalg.eigh(htb)
mu = ( mf.mo_energy[mol.nelectron//2-1] + \
mf.mo_energy[mol.nelectron//2] )/2.
#mu += 0.05
def _gf (w, delta):
if solver == 'scf':
return mf_gf (w, delta, mf.mo_coeff, mf.mo_energy)
elif solver == 'cc':
return cc_gf (w, delta, cc, mf.mo_coeff)
elif solver == 'fci':
return fci_gf (w, delta, mf.mo_coeff, en_FCIgs, GSvector, \
HamCheMPS2, theFCI)
def _mf_gf (w, delta):
return mf_gf (w, delta, evecs, evals)
freqs_ = _get_linear_freqs(-6+U/2., 6+U/2., 64)[0]
gfx = _gf (freqs_, delta)
dos = np.zeros([freqs_.shape[0]])
for k in range(nao):
dos[:] += -1./np.pi * np.imag(gfx[k,k,:])
plt.plot(freqs_, dos)
plt.show()
def _eval_p(w, delta):
gf_ = _gf(np.array([w]), delta)
return gf_[:,:,0]
def _eval_n(w, delta):
return np.trace(_eval_p(w, delta))
powers = [10**i for i in range(7)]
for LARGE in powers:
#LARGE = 100000000
mf_infi = _mf_gf(np.array([1j*LARGE+mu]), delta_)
gf_infi = _gf(np.array([1j*LARGE+mu]), delta_)
sigma_infi = get_sigma(mf_infi, gf_infi)[:,:,0]
mf_infr = _mf_gf(np.array([LARGE]), delta_)
gf_infr = _gf(np.array([LARGE]), delta_)
sigma_infr = get_sigma(mf_infr, gf_infr)[:,:,0]
print LARGE, sigma_infi[0,0]
print LARGE, sigma_infr[0,0]
def _eval_en0(w, delta):
gf_ = _gf(np.array([w]), delta)
return np.trace(np.dot(htb, gf_[:,:,0]))
def _eval_en1(w, delta):
gf_ = _gf(np.array([w]), delta)
if np.iscomplex(w):
return np.trace(np.dot(sigma_infi, gf_[:,:,0]))
else:
return np.trace(np.dot(sigma_infr, gf_[:,:,0]))
def _eval_en2(w, delta):
mf_ = _mf_gf(np.array([w]), delta)
gf_ = _gf(np.array([w]), delta)
sigma = get_sigma(mf_, gf_)
if np.iscomplex(w):
return np.trace(np.dot(sigma[:,:,0]-sigma_infi, gf_[:,:,0]))
else:
return np.trace(np.dot(sigma[:,:,0]-sigma_infr, gf_[:,:,0]))
lplt = False
if lplt:
def real_fn(w, gf_fn):
return -1./np.pi * np.imag(gf_fn(w, delta_))
def imag_fn(w, gf_fn):
return -2./np.pi * np.real(gf_fn(1j*w+mu, delta_))
#fnr0 = np.zeros_like(freqs_)
#fnr1 = np.zeros_like(freqs_)
#fnr2 = np.zeros_like(freqs_)
#fnr3 = np.zeros_like(freqs_)
fni0 = np.zeros_like(freqs_)
fni1 = np.zeros_like(freqs_)
fni2 = np.zeros_like(freqs_)
fni3 = np.zeros_like(freqs_)
wmin = np.min(freqs_)
wmax = np.max(freqs_)
for iw, w in enumerate(freqs_):
#fnr0[iw] = real_fn(w+mu, _eval_n)
#fnr1[iw] = real_fn(w+mu, _eval_en0)
#fnr2[iw] = real_fn(w+mu, _eval_en1)
#fnr3[iw] = real_fn(w+mu, _eval_en2)
fni0[iw] = imag_fn(w, _eval_n)
fni1[iw] = imag_fn(w, _eval_en0)
fni2[iw] = imag_fn(w, _eval_en1)
fni3[iw] = imag_fn(w, _eval_en2)
#plt.plot(freqs_+mu, fnr0)
#plt.figure()
#plt.plot(freqs_+mu, fnr1)
#plt.figure()
#plt.plot(freqs_+mu, fnr2)
#plt.figure()
#plt.plot(freqs_+mu, fnr3)
#plt.figure()
plt.plot(freqs_, fni0)
plt.figure()
plt.plot(freqs_, fni1)
plt.figure()
plt.plot(freqs_, fni2)
plt.figure()
plt.plot(freqs_, fni3)
plt.show()
li = True
lr = False
# NL = # poles to left of mu, NR = # poles to right of mu
# nao = NL + NR
# integration gives NR - NL (factor of 2 in imag_fn)
INF=10000
if li:
print '\nnumber [imag]'
#nint_n = numint_.int_quad_imag (_eval_n, mu, \
# epsrel=1.0e-5, delta=delta_)
nint_n = numint_.int_quad_imag (_eval_n, mu, \
epsrel=1.0e-5, delta=delta_)
nint_n = 2*0.5*(nao-nint_n)
print 'nint_n [imag] = ', nint_n
print '----\n'
if lr:
print '\nnumber [real]'
nint_n = numint_.int_quad_real (_eval_n, mu, x0=-40., \
epsrel=1.0e-5, delta=delta_)
nint_n = numint_.int_quad_real (_eval_n, mu, x0=-40., \
epsrel=1.0e-5, delta=delta_)
print 'nint_n [real] = ', 2*nint_n
print '----\n'
if li:
print 'energy [imag]'
# trace of h with GF
#nint_e0 = numint_.int_quad_imag (_eval_en0, mu, \
# epsrel=1.0e-5, delta=delta_)
nint_e0 = numint_.int_quad_imag (_eval_en0, mu, \
epsrel=1.0e-5, delta=delta_)
print 'nint H_c [imag] = ', -nint_e0
# energy due to 1/w self-energy
#nint_e2 = numint_.int_quad_imag (_eval_en2, mu, \
# epsrel=1.0e-5, delta=delta_)
nint_e2 = numint_.int_quad_imag (_eval_en2, mu, \
epsrel=1.0e-5, delta=delta_)
print 'nint S[w] [imag] = ', -nint_e2/2.
# energy due to a constant self-energy
#nint_e1 = numint_.int_quad_imag (_eval_en1, mu, \
# epsrel=1.0e-5, delta=delta_)
nint_e1 = numint_.int_quad_imag (_eval_en1, mu, \
epsrel=1.0e-5, delta=delta_)
e1 = (np.real(np.trace(sigma_infi)) - nint_e1)
print 'nint S[inf] [imag] = ', e1/2
print 'nint_e = ', -nint_e0 + e1/2. -nint_e2/2.
print '----\n'
if lr:
print 'energy [real]'
# trace of h with GF
nint_e0 = numint_.int_quad_real (_eval_en0, mu, x0=-40., \
epsrel=1.0e-5, delta=delta_)
print 'nint H_c [real] = ', 2*nint_e0
# energy due to 1/w self-energy
nint_e2 = numint_.int_quad_real (_eval_en2, mu, x0=-40., \
epsrel=1.0e-5, delta=delta_)
print 'nint S[w] [real] = ', nint_e2
# energy due to a constant self-energy
nint_e1 = numint_.int_quad_real (_eval_en1, mu, x0=-40., \
epsrel=1.0e-5, delta=delta_)
print 'nint S[inf] [real] = ', nint_e1
print 'nint_e = ', 2*nint_e0 + nint_e1 + nint_e2
print '----\n'
def solve(CONST,
OEI,
FOCK,
TEI,
Norb,
Nel,
Nimp,
DMguessRHF,
energytype='LAMBDA',
chempot_imp=0.0,
printoutput=True):
assert ((energytype == 'LAMBDA') or (energytype == 'LAMBDA_AMP')
or (energytype == 'LAMBDA_ZERO') or (energytype == 'CASCI'))
# Killing output if necessary
if (printoutput == False):
sys.stdout.flush()
old_stdout = sys.stdout.fileno()
new_stdout = os.dup(old_stdout)
devnull = os.open('/dev/null', os.O_WRONLY)
os.dup2(devnull, old_stdout)
os.close(devnull)
# Augment the FOCK operator with the chemical potential
FOCKcopy = FOCK.copy()
if (chempot_imp != 0.0):
for orb in range(Nimp):
FOCKcopy[orb, orb] -= chempot_imp
# Get the RHF solution
mol = gto.Mole()
mol.build(verbose=0)
mol.atom.append(('C', (0, 0, 0)))
mol.nelectron = Nel
mol.incore_anyway = True
mf = scf.RHF(mol)
mf.get_hcore = lambda *args: FOCKcopy
mf.get_ovlp = lambda *args: np.eye(Norb)
mf._eri = ao2mo.restore(8, TEI, Norb)
mf.scf(DMguessRHF)
DMloc = np.dot(np.dot(mf.mo_coeff, np.diag(mf.mo_occ)), mf.mo_coeff.T)
if (mf.converged == False):
mf = rhf_newtonraphson.solve(mf, dm_guess=DMloc)
DMloc = np.dot(np.dot(mf.mo_coeff, np.diag(mf.mo_occ)), mf.mo_coeff.T)
# Check the RHF solution
assert (Nel % 2 == 0)
numPairs = Nel / 2
FOCKloc = FOCKcopy + np.einsum(
'ijkl,ij->kl', TEI, DMloc) - 0.5 * np.einsum('ijkl,ik->jl', TEI, DMloc)
eigvals, eigvecs = np.linalg.eigh(FOCKloc)
idx = eigvals.argsort()
eigvals = eigvals[idx]
eigvecs = eigvecs[:, idx]
print "psi4cc::solve : RHF h**o-lumo gap =", eigvals[numPairs] - eigvals[
numPairs - 1]
DMloc2 = 2 * np.dot(eigvecs[:, :numPairs], eigvecs[:, :numPairs].T)
print "Two-norm difference of 1-RDM(RHF) and 1-RDM(FOCK(RHF)) =", np.linalg.norm(
DMloc - DMloc2)
# Get the CC solution from pyscf
ccsolver = ccsd.CCSD(mf)
ccsolver.verbose = 5
ECORR, t1, t2 = ccsolver.ccsd()
ERHF = mf.hf_energy
ECCSD = ERHF + ECORR
# Compute the impurity energy
if (energytype == 'CASCI'):
# The 2-RDM is not required
# Active space energy is computed with the Fock operator of the core (not rescaled)
print "ECCSD =", ECCSD
ccsolver.solve_lambda()
pyscfRDM1 = ccsolver.make_rdm1() # MO space
pyscfRDM1 = 0.5 * (pyscfRDM1 + pyscfRDM1.T) # Symmetrize
pyscfRDM1 = np.dot(mf.mo_coeff,
np.dot(pyscfRDM1,
mf.mo_coeff.T)) # From MO to localized space
ImpurityEnergy = ECCSD
if (chempot_imp != 0.0):
# [FOCK - FOCKcopy]_{ij} = chempot_imp * delta(i,j) * delta(i \in imp)
ImpurityEnergy += np.einsum('ij,ij->', FOCK - FOCKcopy, pyscfRDM1)
else:
# Compute the DMET impurity energy based on the lambda equations
if (energytype == 'LAMBDA'):
ccsolver.solve_lambda()
pyscfRDM1 = ccsolver.make_rdm1() # MO space
pyscfRDM2 = ccsolver.make_rdm2() # MO space
if (energytype == 'LAMBDA_AMP'):
# Overwrite lambda tensors with t-amplitudes
pyscfRDM1 = ccsolver.make_rdm1(t1, t2, t1, t2) # MO space
pyscfRDM2 = ccsolver.make_rdm2(t1, t2, t1, t2) # MO space
if (energytype == 'LAMBDA_ZERO'):
# Overwrite lambda tensors with 0.0
fake_l1 = np.zeros(t1.shape, dtype=float)
fake_l2 = np.zeros(t2.shape, dtype=float)
pyscfRDM1 = ccsolver.make_rdm1(t1, t2, fake_l1,
fake_l2) # MO space
pyscfRDM2 = ccsolver.make_rdm2(t1, t2, fake_l1,
fake_l2) # MO space
pyscfRDM1 = 0.5 * (pyscfRDM1 + pyscfRDM1.T) # Symmetrize
# Print a few to things to double check
'''
print "Do we understand how the 1-RDM is stored?", np.linalg.norm( np.einsum('ii->', pyscfRDM1) - Nel )
print "Do we understand how the 2-RDM is stored?", np.linalg.norm( np.einsum('ijkk->ij', pyscfRDM2) / (Nel - 1.0) - pyscfRDM1 )
'''
# Change the pyscfRDM1/2 from MO space to localized space
pyscfRDM1 = np.dot(mf.mo_coeff, np.dot(pyscfRDM1, mf.mo_coeff.T))
pyscfRDM2 = np.einsum('ai,ijkl->ajkl', mf.mo_coeff, pyscfRDM2)
pyscfRDM2 = np.einsum('bj,ajkl->abkl', mf.mo_coeff, pyscfRDM2)
pyscfRDM2 = np.einsum('ck,abkl->abcl', mf.mo_coeff, pyscfRDM2)
pyscfRDM2 = np.einsum('dl,abcl->abcd', mf.mo_coeff, pyscfRDM2)
ECCSDbis = CONST + np.einsum(
'ij,ij->', FOCKcopy,
pyscfRDM1) + 0.5 * np.einsum('ijkl,ijkl->', TEI, pyscfRDM2)
print "ECCSD1 =", ECCSD
print "ECCSD2 =", ECCSDbis
# To calculate the impurity energy, rescale the JK matrix with a factor 0.5 to avoid double counting: 0.5 * ( OEI + FOCK ) = OEI + 0.5 * JK
ImpurityEnergy = CONST \
+ 0.25 * np.einsum('ij,ij->', pyscfRDM1[:Nimp,:], FOCK[:Nimp,:] + OEI[:Nimp,:]) \
+ 0.25 * np.einsum('ij,ij->', pyscfRDM1[:,:Nimp], FOCK[:,:Nimp] + OEI[:,:Nimp]) \
+ 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:Nimp,:,:,:], TEI[:Nimp,:,:,:]) \
+ 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:Nimp,:,:], TEI[:,:Nimp,:,:]) \
+ 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:,:Nimp,:], TEI[:,:,:Nimp,:]) \
+ 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:,:,:Nimp], TEI[:,:,:,:Nimp])
# Reviving output if necessary
if (printoutput == False):
sys.stdout.flush()
os.dup2(new_stdout, old_stdout)
os.close(new_stdout)
return (ImpurityEnergy, pyscfRDM1)
####################################
# Perform the RHF calculations #
####################################
mf1 = scf.RHF(mol1)
mf1.verbose = 4
mf1.scf()
mf2 = scf.RHF(mol2)
mf2.verbose = 4
mf2.scf()
######################
# CCSD reference #
######################
# Always calculate the CCSD energy of the small molecule (mol2)
ccsolver2 = ccsd.CCSD(mf2)
ccsolver2.verbose = 5
ECORR2, t1, t2 = ccsolver2.ccsd()
ERHF2 = mf2.hf_energy
ECCSD2 = ERHF2 + ECORR2
if (False):
ccsolver1 = ccsd.CCSD(mf1)
ccsolver1.verbose = 5
ECORR1, t1, t2 = ccsolver1.ccsd()
ECCSD1 = mf1.hf_energy + ECORR1
print "ERHF for structure", thestructure, "=", mf1.hf_energy + ERHF2
print "ECCSD for structure", thestructure, "=", ECCSD1 + ECCSD2
# ERHF (reactants) = -925.856396874
# ECCSD (reactants) = -927.858808954
# ERHF (products) = -925.964797448
as_scanner = as_scanner
Grad = Gradients
ccsd.CCSD.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.M(atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]],
basis='631g')
mf = scf.RHF(mol).run()
mycc = ccsd.CCSD(mf).run()
g1 = mycc.Gradients().kernel()
#[[ 0 0 1.00950925e-02]
# [ 0 2.28063426e-02 -5.04754623e-03]
# [ 0 -2.28063426e-02 -5.04754623e-03]]
print(lib.finger(g1) - -0.036999389889460096)
mcs = mycc.as_scanner()
mol.set_geom_([["O", (0., 0., 0.001)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]])
e1 = mcs(mol)
mol.set_geom_([["O", (0., 0., -0.001)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]])
e2 = mcs(mol)
print(g1[0, 2] - (e1 - e2) / 0.002 * lib.param.BOHR)
for i in range(nat / 2):
mol.atom.append(('C', (R * np.cos(angle), R * np.sin(angle), 0.0)))
mol.atom.append(
('C', (R * np.cos(angle + shift), R * np.sin(angle + shift), 0.0)))
angle += 4.0 * np.pi / nat
#mol.basis = 'cc-pvdz'
mol.basis = '6-31g'
mol.build()
mf = scf.RHF(mol)
mf.verbose = 3
mf.scf()
if (False):
ccsolver = ccsd.CCSD(mf)
ccsolver.verbose = 5
ECORR, t1, t2 = ccsolver.ccsd()
ECCSD = mf.hf_energy + ECORR
print "ECCSD for alpha ", alpha, " =", ECCSD
if (False):
mp2solver = mp.MP2(mf)
ECORR, t_mp2 = mp2solver.kernel()
EMP2 = mf.hf_energy + ECORR
print "EMP2 for alpha ", alpha, " =", EMP2
myInts = localintegrals.localintegrals(mf, range(mol.nao_nr()),
'meta_lowdin')
myInts.molden('polyyne-loc.molden')
return l1, l2
def _cp(a):
return numpy.array(a, copy=False, order='C')
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf.cc import ccsd
from pyscf import ao2mo
mol = gto.Mole()
mol.verbose = 0
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = 'cc-pvdz'
mol.build()
rhf = scf.RHF(mol)
rhf.conv_tol = 1e-16
rhf.scf()
mcc = ccsd.CCSD(rhf)
mcc.conv_tol = 1e-12
ecc, t1, t2 = mcc.kernel()
conv, l1, l2 = kernel(mcc, eris, t1, t2, tol=1e-8)
print(numpy.linalg.norm(l1) - 0.0132626841292)
print(numpy.linalg.norm(l2) - 0.212575609057)
from pyscf import gto
from pyscf import cc
from pyscf.cc import ccsd
from pyscf.cc import addons
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.verbose = 5
mol.output = '/dev/null'
mol.basis = '631g'
mol.spin = 0
mol.build()
mf1 = scf.RHF(mol).run(conv_tol=1e-12)
gmf = scf.addons.convert_to_ghf(mf1)
myrcc = ccsd.CCSD(mf1).run()
def tearDownModule():
global mol, mf1, gmf, myrcc
mol.stdout.close()
del mol, mf1, gmf, myrcc
class KnownValues(unittest.TestCase):
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)
def CCSD(mf, frozen=[], mo_energy=None, mo_coeff=None, mo_occ=None):
return ccsd.CCSD(mf, frozen, mo_energy, mo_coeff, mo_occ)
def CCSD(mf, frozen=[]):
return ccsd.CCSD(mf, frozen)
return dm2
def _rdm2_mo2ao(dm2, mo):
mo_C = mo.conj()
return lib.einsum('ijkl,pi,qj,rk,sl->pqrs', dm2, mo, mo_C, mo, mo_C)
if __name__ == '__main__':
from functools import reduce
from pyscf import gto
from pyscf import scf
mol = gto.M()
mf = scf.RHF(mol)
mcc = ccsd.CCSD(mf)
numpy.random.seed(2)
nocc = 5
nmo = 12
nvir = nmo - nocc
eri0 = numpy.random.random((nmo,nmo,nmo,nmo))
eri0 = ao2mo.restore(1, ao2mo.restore(8, eri0, nmo), nmo)
fock0 = numpy.random.random((nmo,nmo))
fock0 = fock0 + fock0.T + numpy.diag(range(nmo))*2
t1 = numpy.random.random((nocc,nvir))
t2 = numpy.random.random((nocc,nocc,nvir,nvir))
t2 = t2 + t2.transpose(1,0,3,2)
l1 = numpy.random.random((nocc,nvir))
l2 = numpy.random.random((nocc,nocc,nvir,nvir))
l2 = l2 + l2.transpose(1,0,3,2)
def test_rdm_vs_rccsd(self):
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.verbose = 5
mol.output = '/dev/null'
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run()
myrcc = ccsd.CCSD(mf).set(diis_start_cycle=1).run()
rdm1 = myrcc.make_rdm1()
rdm2 = myrcc.make_rdm2()
mf = scf.addons.convert_to_ghf(mf)
mygcc = gccsd.GCCSD(mf).set(diis_start_cycle=1).run()
dm1 = mygcc.make_rdm1()
dm2 = mygcc.make_rdm2()
nao = mol.nao_nr()
mo_a = mf.mo_coeff[:nao]
mo_b = mf.mo_coeff[nao:]
nmo = mo_a.shape[1]
eri = ao2mo.kernel(mf._eri, mo_a + mo_b,
compact=False).reshape([nmo] * 4)
orbspin = mf.mo_coeff.orbspin
sym_forbid = (orbspin[:, None] != orbspin)
eri[sym_forbid, :, :] = 0
eri[:, :, sym_forbid] = 0
hcore = scf.RHF(mol).get_hcore()
h1 = reduce(numpy.dot, (mo_a.T.conj(), hcore, mo_a))
h1 += reduce(numpy.dot, (mo_b.T.conj(), hcore, mo_b))
e1 = numpy.einsum('ij,ji', h1, dm1)
e1 += numpy.einsum('ijkl,ijkl', eri, dm2) * .5
e1 += mol.energy_nuc()
self.assertAlmostEqual(e1, mygcc.e_tot, 7)
idxa = numpy.where(orbspin == 0)[0]
idxb = numpy.where(orbspin == 1)[0]
trdm1 = dm1[idxa[:, None], idxa]
trdm1 += dm1[idxb[:, None], idxb]
trdm2 = dm2[idxa[:, None, None, None], idxa[:, None, None],
idxa[:, None], idxa]
trdm2 += dm2[idxb[:, None, None, None], idxb[:, None, None],
idxb[:, None], idxb]
dm2ab = dm2[idxa[:, None, None, None], idxa[:, None, None],
idxb[:, None], idxb]
trdm2 += dm2ab
trdm2 += dm2ab.transpose(2, 3, 0, 1)
self.assertAlmostEqual(abs(trdm1 - rdm1).max(), 0, 6)
self.assertAlmostEqual(abs(trdm2 - rdm2).max(), 0, 6)
rt1 = myrcc.t1 + numpy.cos(myrcc.t1) * .2j
rl1 = myrcc.l1 + numpy.cos(myrcc.l1) * .2j
rt2 = myrcc.t2 + numpy.sin(myrcc.t2) * .8j
rl2 = myrcc.l2 + numpy.sin(myrcc.l2) * .8j
rdm1 = myrcc.make_rdm1(rt1, rt2, rl1, rl2)
rdm2 = myrcc.make_rdm2(rt1, rt2, rl1, rl2)
gt1 = mygcc.spatial2spin(rt1)
gt2 = mygcc.spatial2spin(rt2)
gl1 = mygcc.spatial2spin(rl1)
gl2 = mygcc.spatial2spin(rl2)
gdm1 = mygcc.make_rdm1(gt1, gt2, gl1, gl2)
gdm2 = mygcc.make_rdm2(gt1, gt2, gl1, gl2)
trdm1 = gdm1[idxa[:, None], idxa]
trdm1 += gdm1[idxb[:, None], idxb]
trdm2 = gdm2[idxa[:, None, None, None], idxa[:, None, None],
idxa[:, None], idxa]
trdm2 += gdm2[idxb[:, None, None, None], idxb[:, None, None],
idxb[:, None], idxb]
dm2ab = gdm2[idxa[:, None, None, None], idxa[:, None, None],
idxb[:, None], idxb]
trdm2 += dm2ab
trdm2 += dm2ab.transpose(2, 3, 0, 1)
self.assertAlmostEqual(abs(trdm1 - rdm1).max(), 0, 9)
self.assertAlmostEqual(abs(trdm2 - rdm2).max(), 0, 9)
def test(tf, nobs, U):
nao = 2
U = U
htb = -1 * tools.tb(nao)
htb[0, 0] = 0.01 # make it non-symmetric
eri = np.zeros([nao, nao, nao, nao])
eri[0, 0, 0, 0] = U
mol = gto.M()
mol.build()
mol.nelectron = nao #nao
mf = scf.RHF(mol)
mf.verbose = 0
mf.max_memory = 1000
mf.get_hcore = lambda *args: htb
mf.get_ovlp = lambda *args: np.eye(nao)
mf._eri = pyscf.ao2mo.restore(8, eri, nao)
mf.init_guess = '1e'
mf.scf()
print 'MF energy = %20.12f' % (mf.e_tot)
print 'MO energies :'
print mf.mo_energy
print '----\n'
# 2*pi*max energy << tf-ti
ti = 0
tf = tf
nobs = nobs
times = np.linspace(ti, tf, nobs)
deltat = float(tf - ti) / nobs
# =================
# single particle GF
# ==================
nocc = mol.nelectron / 2
gip0 = single_particle.get_gip(mf.mo_energy, nocc, times)
gea0 = single_particle.get_gea(mf.mo_energy, nocc, times)
# =================
# CC GF
# ==================
cc = ccsd.CCSD(mf)
ecc = cc.ccsd()[0]
print "CCSD corr = %20.12f" % (ecc)
start = time.time()
print "Solving lambda equations..."
cc.solve_lambda()
stop = time.time()
print "Elapsed time for CC", stop - start
# This tolerance controls the accuracy of the
# RK45 integrator used in the green's function algorithm
# Each element will be computed to an accuracy of tol
tol = 1.e-5
start = time.time()
gip = get_ip_ao(cc, 1, times, mf.mo_coeff, tol)
gea = get_ea_ao(cc, 1, times, mf.mo_coeff, tol)
stop = time.time()
print "Elasped time for TD-propagation", stop - start
# This is the difference between the exact MF and CC
# Green's functions. If you dial tol up, this will go to 0
print "IP difference", np.linalg.norm(gip - gip0)
print "EA difference", np.linalg.norm(gea - gea0)
# predict out to long times
# note ntotal must be 2**n+1 since
# we use romberg integration to do fourier transform integral
tmax0 = 10000
ntotal0 = tmax0 / deltat
nbase2 = np.int(np.log(ntotal0) / np.log(2))
ntotal = 2**nbase2 + 1
# 2*pi/tmax gives a minimum oscillation frequency, so
# graph will wiggle at least on this scale
print "Total propagation time: ", ntotal * deltat
print "Predict ip0 ============"
predicted_gf_ip0 = tools.predict_gf(gip0, ntotal)
predicted_gf_ea0 = tools.predict_gf(gea0, ntotal)
print "Predict ip ============"
start = time.time()
predicted_gf_ip = tools.predict_gf(gip, ntotal)
predicted_gf_ea = tools.predict_gf(gea, ntotal)
stop = time.time()
print "Elasped time for prediction", stop - start
print "Norm difference", np.linalg.norm(gip - gip0)
#ddd
# transform time-domain to frequency domain
gret0 = -1j * (predicted_gf_ip0 + predicted_gf_ea0)
gret_ao0 = np.einsum("pi,ijt,jq->pqt", mf.mo_coeff, gret0, mf.mo_coeff.T)
# old stuff
# gret = -1j * (predicted_gf_ip + predicted_gf_ea)
# gret_ao = np.einsum("pi,ijt,jq->pqt", mf.mo_coeff, gret,
# mf.mo_coeff.T)
gret_ao = -1j * (predicted_gf_ip + predicted_gf_ea)
extrapolated_times = np.array([deltat * i for i in range(ntotal)])
tmax = extrapolated_times[-1]
# for i in range(gret_ao.shape[2]):
# print i, extrapolated_times[i], gret_ao0[0,0,i], gret_ao[0,0,i]
print np.linalg.norm(gret_ao0 - gret_ao)
# compute freq. dependent GF
freqs = np.linspace(-10, +10, 400)
delta = 1.e-1 # this should be on the scale of pi/tmax
# tdgf_w0 = tools.get_gfw(gret_ao0, extrapolated_times,
# freqs, delta)
start = time.time()
tdgf_w = tools.get_gfw(gret_ao, extrapolated_times, freqs, delta)
stop = time.time()
print "Elapsed time: FT", stop - start
start = time.time()
# w_gf_w = cc_gf(freqs, delta, cc, mf.mo_coeff)
# "1" is the number of impurities
w_gf_w = cc_gf_ao(1, freqs, delta, cc, mf.mo_coeff)
stop = time.time()
print "Elapsed time: frequency CC", stop - start
# when you see the peak, in addition to the broadening
# there is also a small real shift (on the size of the broadening);
# I don't fully get why it's there (maybe it's the use of the Gaussian
# form of broadening?)
#plt.plot(freqs, -1./np.pi*tdgf_w0[0,0].imag, "rx-")
plt.plot(freqs, -1. / np.pi * tdgf_w[0, 0].imag, "b+-")
plt.plot(freqs, -1. / np.pi * w_gf_w[0, 0].imag, "g*-")
plt.savefig("AO_" + str(U) + "_" + str(tf) + "_" + str(nobs) + ".pdf")
plt.close()
def _cp(a):
return numpy.array(a, copy=False, order='C')
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf.cc import ccsd
from pyscf import ao2mo
mol = gto.M()
mf = scf.RHF(mol)
mcc = ccsd.CCSD(mf)
numpy.random.seed(12)
nocc = 5
nmo = 12
nvir = nmo - nocc
eri0 = numpy.random.random((nmo, nmo, nmo, nmo))
eri0 = ao2mo.restore(1, ao2mo.restore(8, eri0, nmo), nmo)
fock0 = numpy.random.random((nmo, nmo))
fock0 = fock0 + fock0.T + numpy.diag(range(nmo)) * 2
t1 = numpy.random.random((nocc, nvir))
t2 = numpy.random.random((nocc, nocc, nvir, nvir))
t2 = t2 + t2.transpose(1, 0, 3, 2)
l1 = numpy.random.random((nocc, nvir))
l2 = numpy.random.random((nocc, nocc, nvir, nvir))
l2 = l2 + l2.transpose(1, 0, 3, 2)
from pyscf.cc import ccsd_t_lambda_slow as ccsd_t_lambda
from pyscf import ao2mo
mol = gto.Mole()
#mol.verbose = 5
#mol.output = 'out_h2o'
mol.atom = [[8, (0., 0., 0.)], [1, (0., -.957, .587)],
[1, (0.2, .757, .487)]]
#mol.basis = 'ccpvdz'
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol)
mf.conv_tol = 1e-14
mf.scf()
mcc = ccsd.CCSD(mf)
mcc.conv_tol = 1e-14
ecc, t1, t2 = mcc.kernel()
eris = mcc.ao2mo()
e3ref = ccsd_t.kernel(mcc, eris, t1, t2)
l1, l2 = ccsd_t_lambda.kernel(mcc, eris, t1, t2)[1:]
print(ecc, e3ref)
eri_mo = ao2mo.kernel(mf._eri, mf.mo_coeff, compact=False)
nmo = mf.mo_coeff.shape[1]
eri_mo = eri_mo.reshape(nmo, nmo, nmo, nmo)
dm1 = make_rdm1(mcc, t1, t2, l1, l2, eris=eris)
dm2 = make_rdm2(mcc, t1, t2, l1, l2, eris=eris)
h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff))
e3 = (numpy.einsum('ij,ij->', h1, dm1) +
numpy.einsum('ijkl,ijkl->', eri_mo, dm2) * .5 + mf.mol.energy_nuc())
def test_td():
nao = 2
U = 0.
htb = -1 * _tb(nao)
htb[0, 0] = 0.0
eri = np.zeros([nao, nao, nao, nao])
for k in range(nao):
eri[k, k, k, k] = U
delta = 0.01
mol = gto.M()
mol.build()
mol.nelectron = 2 #nao
mf = scf.RHF(mol)
mf.verbose = 0
mf.max_memory = 1000
mf.get_hcore = lambda *args: htb
mf.get_ovlp = lambda *args: np.eye(nao)
mf._eri = ao2mo.restore(8, eri, nao)
mf.init_guess = '1e'
mf.scf()
print 'MF energy = %20.12f' % (mf.e_tot)
print 'MO energies :'
print mf.mo_energy
print '----\n'
cc = ccsd.CCSD(mf)
ecc = cc.ccsd()[0]
print "CCSD corr = %20.12f" % (ecc)
print "Solving lambda equations..."
cc.solve_lambda()
ti = 0
tf = 400
nquad = 12
times = np.linspace(ti, tf, 2**nquad + 1)
gf_ret = cc_td_gf(ti, tf, times, cc, mf.mo_coeff)
freqs_ = _get_linear_freqs(-6, 6, 512)[0]
gf_ret_w = np.zeros([gf_ret.shape[0], gf_ret.shape[1],
len(freqs_)],
dtype=np.complex128)
halftime = (2**(nquad - 1) + 1)
inttimes = times[:halftime]
delta = 0.1
for iw, w in enumerate(freqs_):
ftwts = 1. / (tf - ti) * np.array([
np.exp(1j * (w * t)) * np.exp(-delta**2 * t)
for t in times[:halftime]
],
dtype=np.complex128)
for p in range(gf_ret.shape[0]):
for q in range(gf_ret.shape[1]):
gfft = gf_ret[p, q, :halftime] * ftwts
gf_ret_w[p, q, iw] = scipy.integrate.romb(gfft)
print gf_ret_w
dos = np.zeros([freqs_.shape[0]])
for k in range(nao):
dos[:] += 1. / np.pi * np.imag(gf_ret_w[k, k, :])
plt.plot(freqs_, dos)
plt.show()
