def test_sort_left_right_eigensystem(self):
myeom = eom_rccsd.EOMIP(mycc)
right_evecs = [numpy.ones(10)] * 4
left_evecs = [numpy.ones(10)] * 5
right_evecs = [x * i for i, x in enumerate(right_evecs)]
left_evecs = [x * i for i, x in enumerate(left_evecs)]
revals, revecs, levecs = eom_rccsd._sort_left_right_eigensystem(
myeom, [True, False, True, True], [-1.1, 0, 1.1, 2.2], right_evecs,
[True, True, True, False, True], [-2.2, -1.1, 0, 1.1, 2.2],
left_evecs)
self.assertEqual(revals[0], -1.1)
self.assertEqual(revals[1], 2.2)
self.assertEqual(revecs[0][0], 0)
self.assertEqual(revecs[1][0], 3)
self.assertEqual(levecs[0][0], 1)
self.assertEqual(levecs[1][0], 4)
revals, revecs, levecs = eom_rccsd._sort_left_right_eigensystem(
myeom, [True, False, True, True], [-1.1, 0, 1.1, 2.2], right_evecs,
[True, True, False, True, True], [-2.2, -1.1, 0, 1.1, 2.2],
left_evecs)
self.assertEqual(revals[0], -1.1)
self.assertEqual(revals[1], 1.1)
self.assertEqual(revals[2], 2.2)
self.assertEqual(revecs[0][0], 0)
self.assertEqual(revecs[1][0], 2)
self.assertEqual(revecs[2][0], 3)
self.assertEqual(levecs[0][0], 1)
self.assertEqual(levecs[1][0], 3)
self.assertEqual(levecs[2][0], 4)
def test_ipccsd3(self):
e, v = mycc3.ipccsd(nroots=1)
self.assertAlmostEqual(e, 0.4335604332073799, 6)
e, v = mycc3.ipccsd(nroots=3)
self.assertAlmostEqual(e[0], 0.4335604332073799, 6)
self.assertAlmostEqual(e[1], 0.5187659896045407, 6)
self.assertAlmostEqual(e[2], 0.6782876002229172, 6)
myeom = eom_rccsd.EOMIP(mycc3)
lv = myeom.ipccsd(nroots=3, left=True)[1]
e = myeom.ipccsd_star(e, v, lv)
self.assertAlmostEqual(e[0], 0.43793202122290747, 6)
self.assertAlmostEqual(e[1], 0.52287073076243218, 6)
self.assertAlmostEqual(e[2], 0.67994597799835099, 6)
def test_ip_matvec1(self):
numpy.random.seed(12)
r1 = numpy.random.random((no)) - .9 + numpy.random.random((no)) * .2j
r2 = (numpy.random.random((no, no, nv)) - .9 + numpy.random.random(
(no, no, nv)) * .2j)
myeom = eom_rccsd.EOMIP(mycci)
vec = myeom.amplitudes_to_vector(r1, r2)
r1, r2 = myeom.vector_to_amplitudes(vec)
eris1
imds = myeom.make_imds(erisi)
vec1 = myeom.matvec(vec, imds)
self.assertAlmostEqual(lib.finger(vec1),
25176.428829164193 - 4955.5351324520125j, 9)
self.assertAlmostEqual(lib.finger(myeom.get_diag()),
1106.2601542024306, 9)
def test_df_ipccsd(self):
e, v = mycc.ipccsd(nroots=1)
self.assertAlmostEqual(e, 0.42788191082629801, 6)
e, v = mycc.ipccsd(nroots=3)
self.assertAlmostEqual(e[0], 0.42788191082629801, 6)
self.assertAlmostEqual(e[1], 0.50229582430658171, 6)
self.assertAlmostEqual(e[2], 0.68557652412060088, 6)
myeom = eom_rccsd.EOMIP(mycc)
lv = myeom.ipccsd(nroots=3, left=True)[1]
e = myeom.ipccsd_star_contract(e, v, lv)
self.assertAlmostEqual(e[0], 0.43584093045349137, 6)
self.assertAlmostEqual(e[1], 0.50959675100507518, 6)
self.assertAlmostEqual(e[2], 0.69021193094404043, 6)
def test_ipccsd(self):
eom = mycc.eomip_method()
e, v = eom.kernel(nroots=1, left=False, koopmans=False)
e = eom.eip
self.assertAlmostEqual(e, 0.4335604332073799, 6)
e, v = mycc.ipccsd(nroots=3)
self.assertAlmostEqual(e[0], 0.4335604332073799, 6)
self.assertAlmostEqual(e[1], 0.5187659896045407, 6)
self.assertAlmostEqual(e[2], 0.6782876002229172, 6)
myeom = eom_rccsd.EOMIP(mycc)
lv = myeom.ipccsd(nroots=3, left=True)[1]
e = myeom.ipccsd_star(e, v, lv)
self.assertAlmostEqual(e[0], 0.43793202122290747, 6)
self.assertAlmostEqual(e[1], 0.52287073076243218, 6)
self.assertAlmostEqual(e[2], 0.67994597799835099, 6)
def test_h2o_star(self):
mol_h2o = gto.Mole()
mol_h2o.atom = [
[8, [0.000000000000000, -0.000000000000000, -0.124143731294022]],
[1, [0.000000000000000, -1.430522735894536, 0.985125550040314]],
[1, [0.000000000000000, 1.430522735894536, 0.985125550040314]]
]
mol_h2o.unit = 'B'
mol_h2o.basis = {
'H': [[0, [5.4471780, 0.156285], [0.8245472, 0.904691]],
[0, [0.1831916, 1.0]]],
'O':
'3-21G'
}
mol_h2o.verbose = 7
mol_h2o.output = '/dev/null'
mol_h2o.build()
mol.conv_tol = 1e-12
mf_h2o = scf.RHF(mol_h2o)
mf_h2o.conv_tol_grad = 1e-12
mf_h2o.kernel()
mycc_h2o = cc.RCCSD(mf_h2o).run()
mycc_h2o.conv_tol_normt = 1e-12
mycc_h2o.conv_tol = 1e-12
mycc_h2o.kernel()
myeom = eom_rccsd.EOMIP(mycc_h2o)
e = myeom.ipccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.410661965883, 6)
myeom = eom_rccsd.EOMIP_Ta(mycc_h2o)
e = myeom.ipccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.411695647736, 6)
myeom = eom_rccsd.EOMEA(mycc_h2o)
e = myeom.eaccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.250589854185, 6)
myeom = eom_rccsd.EOMEA_Ta(mycc_h2o)
e = myeom.eaccsd_star(nroots=3)
self.assertAlmostEqual(e[0], 0.250720295150, 6)
def test_ip_matvec3(self):
numpy.random.seed(12)
r1 = numpy.random.random((no)) - .9
r2 = numpy.random.random((no, no, nv)) - .9
myeom = eom_rccsd.EOMIP(mycc31)
vec = myeom.amplitudes_to_vector(r1, r2)
r1, r2 = myeom.vector_to_amplitudes(vec)
myeom.partition = 'mp'
self.assertAlmostEqual(lib.finger(r1), 0.37404344676857076, 12)
self.assertAlmostEqual(lib.finger(r2), -1.1568913404570922, 12)
imds = myeom.make_imds(eris31)
vec1 = myeom.matvec(vec, imds)
self.assertAlmostEqual(lib.finger(vec1), -14894.669606811192, 9)
self.assertAlmostEqual(lib.finger(myeom.get_diag()),
1182.3095479451745, 9)
myeom.partition = 'full'
imds = myeom.make_imds(eris31)
diag = myeom.get_diag(imds)
vec1 = myeom.matvec(vec, imds, diag=diag)
self.assertAlmostEqual(lib.finger(vec1), -3795.9122245246967, 9)
self.assertAlmostEqual(lib.finger(diag), 1106.260154202434, 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'