def greens_e_vector_ea_rhf(cc, p):
nocc, nvir = cc.t1.shape
ds_type = cc.t1.dtype
vector1 = np.zeros((nvir), dtype=ds_type)
vector2 = np.zeros((nocc, nvir, nvir), dtype=ds_type)
if hasattr(cc, 'l1') and cc.l1 is not None:
l1 = cc.l1
l2 = cc.l2
else:
l1 = cc.t1
l2 = cc.t2
if p < nocc:
# Changed both to plus
vector1 += l1[p, :]
vector2 += (2 * l2[p, :, :, :] - l2[:, p, :, :])
pass
else:
vector1[p - nocc] = -1.0
vector1 += np.einsum('ia,i->a', l1, cc.t1[:, p - nocc])
#vector1 += 2*np.einsum('klca,klc->a', l2, cc.t2[:,:,:,p-nocc])
#vector1 -= np.einsum('klca,lkc->a', l2, cc.t2[:,:,:,p-nocc])
vector2[:, p - nocc, :] += -2. * l1
vector2[:, :, p - nocc] += l1
#vector2 += 2*np.einsum('k,jkba->jab', cc.t1[:,p-nocc], l2)
#vector2 -= np.einsum('k,jkab->jab', cc.t1[:,p-nocc], l2)
return eom_rccsd.amplitudes_to_vector_ea(vector1, vector2)
def greens_b_vector_ea_rhf(cc, p):
nocc, nvir = cc.t1.shape
ds_type = cc.t1.dtype
vector1 = np.zeros((nvir), dtype=ds_type)
vector2 = np.zeros((nocc, nvir, nvir), dtype=ds_type)
if p < nocc:
# Changed both to minus
vector1 += -cc.t1[p, :]
vector2 += -cc.t2[p, :, :, :]
else:
vector1[p - nocc] = 1.0
return eom_rccsd.amplitudes_to_vector_ea(vector1, vector2)
def greens_e_vector_ea_rhf(cc, p, kp=None):
nkpts, nocc, nvir = cc.t1.shape
ds_type = cc.t1.dtype
vector1 = np.zeros((nvir), dtype=ds_type)
vector2 = np.zeros((nkpts, nkpts, nocc, nvir, nvir), dtype=ds_type)
if hasattr(cc, 'l1') and cc.l1 is not None:
l1 = cc.l1
l2 = cc.l2
else:
l1 = np.conj(cc.t1)
l2 = np.conj(cc.t2)
if p < nocc:
# Changed both to plus
vector1 += l1[kp, p, :]
for ki in range(nkpts):
for kj in range(nkpts):
vector2[ki, kj] += 2*l2[ki,kj,kp,p,:,:,:] - \
l2[kj,ki,kp,:,p,:,:]
else:
vector1[p - nocc] = -1.0
vector1 += np.einsum('ia,i->a', l1[kp], cc.t1[kp, :, p - nocc])
for kk in range(nkpts):
for kl in range(nkpts):
kconserv = kpts_helper.get_kconserv(cc._scf.cell, cc.kpts)
ka = kconserv[kl, kp, kk]
vector1 += 2 * np.einsum('klca,klc->a', l2[ka,kk,kl], \
cc.t2[ka,kk,kl,:,:,:,p-nocc])
vector1 -= np.einsum('klca,lkc->a', l2[ka,kk,kl], \
cc.t2[kk,ka,kl,:,:,:,p-nocc])
for kb in range(nkpts):
vector2[kb, kp, :, p - nocc, :] += -2. * l1[kb]
for ka in range(nkpts):
# kj == ka
# kb == kc == kp
vector2[ka, ka, :, :, p - nocc] += l1[ka]
for kj in range(nkpts):
for kb in range(nkpts):
kconserv = kpts_helper.get_kconserv(cc._scf.cell, cc.kpts)
ka = kconserv[kp, kj, kb]
vector2[kj,ka] += 2*np.einsum('k,jkba->jab', \
cc.t1[kp,:,p-nocc], l2[kj,kp,kb,:,:,:,:])
vector2[kj,ka] -= np.einsum('k,jkab->jab', \
cc.t1[kp,:,p-nocc], l2[kj,kp,ka,:,:,:,:])
return eom_rccsd.amplitudes_to_vector_ea(vector1, vector2)
def greens_b_vector_ea_rhf(cc, p, kp=None):
nkpts, nocc, nvir = cc.t1.shape
ds_type = cc.t1.dtype
vector1 = np.zeros((nvir), dtype=ds_type)
vector2 = np.zeros((nkpts, nkpts, nocc, nvir, nvir), dtype=ds_type)
if p < nocc:
# Changed both to minus
vector1 += -cc.t1[kp, p, :]
for ki in range(nkpts):
for kj in range(nkpts):
vector2[ki, kj] += -cc.t2[ki, kj, kp, p, :, :, :]
else:
vector1[p - nocc] = 1.0
return eom_rccsd.amplitudes_to_vector_ea(vector1, vector2)
def greens_e_vector_ea_rhf(cc, p, kp=None):
nkpts, nocc, nvir = cc.t1.shape
ds_type = cc.t1.dtype
vector1 = np.zeros((nvir), dtype=ds_type)
vector2 = np.zeros((nkpts, nkpts, nocc, nvir, nvir), dtype=ds_type)
if hasattr(cc, 'l1') and cc.l1 is not None:
l1 = cc.l1
l2 = cc.l2
else:
l1 = cc.t1
l2 = cc.t2
if p < nocc:
# Changed both to plus
vector1 += l1[kp, p, :]
for ki in range(nkpts):
for kj in range(nkpts):
vector2[ki, kj] += 2*l2[ki,kj,kp,p,:,:,:] - \
l2[kj,ki,kp,:,p,:,:]
pass
else:
vector1[p - nocc] = -1.0
vector1 += np.einsum('ia,i->a', l1[kp], cc.t1[kp, :, p - nocc])
for kl in range(nkpts):
for kc in range(nkpts):
vector1 += 2 * np.einsum('klca,klc->a', l2[kp,kl,kc], \
cc.t2[kp,kl,kc,:,:,:,p-nocc])
vector1 -= np.einsum('klca,lkc->a', l2[kp,kl,kc], \
cc.t2[kp,kl,kc,:,:,:,p-nocc])
for kj in range(nkpts):
vector2[kp, kj, :, p - nocc, :] += -2. * l1[kj]
for ki in range(nkpts):
vector2[ki, kp, :, :, p - nocc] += l1[ki]
for kj in range(nkpts):
vector2[ki,kj] += 2*np.einsum('k,jkba->jab', \
cc.t1[kp,:,p-nocc], l2[ki,kj,kp,:,:,:,:])
vector2[ki,kj] -= np.einsum('k,jkab->jab', \
cc.t1[kp,:,p-nocc], l2[ki,kj,kp,:,:,:,:])
return eom_rccsd.amplitudes_to_vector_ea(vector1, vector2)
def eaccsd_diag(eom, imds=None):
if imds is None: imds = eom.make_imds()
t1, t2 = imds.t1, imds.t2
dtype = np.result_type(t1, t2)
nocc, nvir = t1.shape
fock = imds.eris.fock
foo = fock[:nocc, :nocc]
fvv = fock[nocc:, nocc:]
Hr1 = np.diag(imds.Lvv)
Hr2 = np.zeros((nocc, nvir, nvir), dtype)
for a in range(nvir):
if eom.partition != 'mp':
_Wvvvva = np.array(imds.Wvvvv[a])
for b in range(nvir):
for j in range(nocc):
if eom.partition == 'mp':
Hr2[j, a, b] += fvv[a, a]
Hr2[j, a, b] += fvv[b, b]
Hr2[j, a, b] += -foo[j, j]
else:
Hr2[j, a, b] += imds.Lvv[a, a]
Hr2[j, a, b] += imds.Lvv[b, b]
Hr2[j, a, b] += -imds.Loo[j, j]
Hr2[j, a, b] += 2 * imds.Wovvo[j, b, b, j]
Hr2[j, a, b] += -imds.Wovov[j, b, j, b]
Hr2[j, a, b] += -imds.Wovov[j, a, j, a]
Hr2[j, a, b] += -imds.Wovvo[j, b, b, j] * (a == b)
Hr2[j, a, b] += _Wvvvva[b, a, b]
Hr2[j, a, b] += -2 * np.dot(imds.Woovv[:, j, a, b],
t2[:, j, a, b])
Hr2[j, a, b] += np.dot(imds.Woovv[:, j, b, a], t2[:, j, a,
b])
vector = amplitudes_to_vector_ea(Hr1, Hr2)
return vector
def initial_ea_guess(cc):
nocc, nvir = cc.t1.shape
vector1 = np.zeros((nvir), dtype=complex)
vector2 = np.zeros((nocc, nvir, nvir), dtype=complex)
return eom_rccsd.amplitudes_to_vector_ea(vector1, vector2)
def greens_e_vector_ea_rhf(cc, p):
return amplitudes_to_vector_ea(
greens_e_singles_ea_rhf(cc.t1, cc.t2, cc.l1, cc.l2, p),
greens_e_doubles_ea_rhf(cc.t1, cc.l1, cc.l2, p),
)
def initial_ea_guess(cc):
nocc, nvir = cc.t1.shape
vector1 = np.zeros((nvir,), dtype=complex)
vector2 = np.zeros((nocc, nvir, nvir), dtype=complex)
return amplitudes_to_vector_ea(vector1, vector2)
def eaccsd_matvec(eom, vector, imds=None, diag=None):
# Ref: Nooijen and Bartlett, J. Chem. Phys. 102, 3629 (1995) Eqs.(30)-(31)
if imds is None: imds = eom.make_imds()
nocc = eom.nocc
nmo = eom.nmo
r1, r2 = vector_to_amplitudes_ea(vector, nmo, nocc)
occ_act = np.arange(nocc)
vir_act = np.arange(eom.nvir_act)
iab_act = np.ix_(occ_act, vir_act, vir_act)
ib_act = np.ix_(occ_act, vir_act)
# Eq. (37)
# 1p-1p block
Hr1 = np.einsum('ac,c->a', imds.Lvv, r1)
# 1p-2p1h block
Hr1 += np.einsum('ld,lad->a', 2. * imds.Fov, r2)
Hr1 += np.einsum('ld,lda->a', -imds.Fov, r2)
Hr1 += np.einsum('alcd,lcd->a',
2. * imds.Wvovv - imds.Wvovv.transpose(0, 1, 3, 2), r2)
# 2p1h-2p1h block
# first, do a diagonal (MP) update
fock = imds.eris.fock
foo = fock[:nocc, :nocc]
fvv = fock[nocc:, nocc:]
FVV_DIAG = False
if FVV_DIAG:
Hr2 = lib.einsum('aa,jab->jab', fvv, r2)
Hr2 += lib.einsum('bb,jab->jab', fvv, r2)
else:
Hr2 = lib.einsum('ac,jcb->jab', fvv, r2)
Hr2 += lib.einsum('bd,jad->jab', fvv, r2)
Hr2 += -lib.einsum('lj,lab->jab', foo, r2)
# then zero out the internal amplitudes, to start over
Hr2[iab_act] = 0.
# now do a full update of internal amplitudes
SYM = True
if SYM:
r2_in = np.zeros_like(r2)
r2_in[iab_act] = np.copy(r2)[iab_act]
else:
r2_in = np.copy(r2)
Hr2[iab_act] += lib.einsum('ac,jcb->jab', imds.Lvv, r2_in)[iab_act]
Hr2[iab_act] += lib.einsum('bd,jad->jab', imds.Lvv, r2_in)[iab_act]
Hr2[iab_act] += -lib.einsum('lj,lab->jab', imds.Loo, r2_in)[iab_act]
Hr2[iab_act] += lib.einsum(
'lbdj,lad->jab', 2. * imds.Wovvo - imds.Wovov.transpose(0, 1, 3, 2),
r2_in)[iab_act]
Hr2[iab_act] += -lib.einsum('lajc,lcb->jab', imds.Wovov, r2_in)[iab_act]
Hr2[iab_act] += -lib.einsum('lbcj,lca->jab', imds.Wovvo, r2_in)[iab_act]
for a in range(eom.nvir_act):
Hr2[:, a, :][ib_act] += lib.einsum('bcd,jcd->jb', imds.Wvvvv[a],
r2_in)[ib_act]
tmp = np.einsum('klcd,lcd->k',
2. * imds.Woovv - imds.Woovv.transpose(0, 1, 3, 2), r2_in)
Hr2[iab_act] += -np.einsum('k,kjab->jab', tmp, imds.t2)[iab_act]
# Eq. (38)
# 2p1h-1p block
Hr2 += np.einsum('abcj,c->jab', imds.Wvvvo, r1)
vector = amplitudes_to_vector_ea(Hr1, Hr2)
return vector
def greens_e_vector_ea_rhf(cc, p, kp=None):
nkpts, nocc, nvir = cc.t1.shape
ds_type = cc.t1.dtype
vector1 = np.zeros((nvir),dtype=ds_type)
vector2 = np.zeros((nkpts,nkpts,nocc,nvir,nvir),dtype=ds_type)
if hasattr(cc, 'l1') and cc.l1 is not None:
l1 = cc.l1
l2 = cc.l2
else:
l1 = np.conj(cc.t1)
l2 = np.conj(cc.t2)
if p < nocc:
# Changed both to plus
vector1 += l1[kp,p,:]
for ki in range(nkpts):
for kj in range(nkpts):
vector2[ki, kj] += 2*l2[ki,kj,kp,p,:,:,:] - \
l2[kj,ki,kp,:,p,:,:]
else:
vector1[ p-nocc ] = -1.0
vector1 += np.einsum('ia,i->a', l1[kp], cc.t1[kp,:,p-nocc])
#for kl in range(nkpts):
# for kc in range(nkpts):
# vector1 += 2 * np.einsum('klca,klc->a', l2[kp,kl,kc], \
# cc.t2[kp,kl,kc,:,:,:,p-nocc])
# vector1 -= np.einsum('klca,lkc->a', l2[kp,kl,kc], \
# cc.t2[kl,kp,kc,:,:,:,p-nocc])
#for kd in range(nkpts):
# for ki in range(nkpts):
# kconserv = kpts_helper.get_kconserv(cc._scf.cell, cc.kpts)
# kj = kconserv[kp,ki,kd]
# vector1 += 2 * np.einsum('cdij,dij->c', l2[kp,kd,ki], \
# cc.t2[kp,kd,ki,:,:,:,p-nocc])
# vector1 -= np.einsum('cdij,dji->c', l2[kp,kd,ki], \
# cc.t2[kp,kd,kj,:,:,:,p-nocc])
for kb in range(nkpts):
vector2[kb,kp,:,p-nocc,:] += -2.*l1[kb]
#print '###############vector2[kb,kp,:,p-nocc,:]+=-2.*l1[kb]###################'
#print vector2
for ka in range(nkpts):
# delta_bc z_j^a -> { j}^{ab}
# kj == ka
# kb == kc == kp
vector2[ka,ka,:,:,p-nocc] += l1[ka]
#print '###############vector2[kp,ka,:,:,p-nocc]+=l1[ka]###################'
#print vector2
tempvec2=np.zeros((nkpts,nkpts,nocc,nvir,nvir),dtype=ds_type)
for ki in range(nkpts):
for kj in range(nkpts):
vector2[ki,kj] += 2*np.einsum('k,jkba->jab', \
cc.t1[kp,:,p-nocc], l2[ki,kj,kp,:,:,:,:])
tempvec2[ki,kj] += 2*np.einsum('k,jkba->jab', \
cc.t1[kp,:,p-nocc], l2[ki,kj,kp,:,:,:,:])
print '#######vector2[ki,kj] += 2*np.einsum(k,jkba->jab, cc.t1[kp,:,p-nocc], l2[ki,kj,kp,:,:,:,:])######'
print tempvec2
# vector2[ki,kj] -= np.einsum('k,jkab->jab', \
# cc.t1[kp,:,p-nocc], l2[kj,ki,kp,:,:,:,:])
# vector2[ki,kj] += 2*np.einsum('k,jkba->jab', \
# cc.t1[kp,:,p-nocc], l2[ki,kj,kp,:,:,:,:])
# vector2[kj,ki] -= np.einsum('k,jkab->jab', \
# cc.t1[kp,:,p-nocc], l2[ki,kp,kj,:,:,:,:])
return eom_rccsd.amplitudes_to_vector_ea(vector1,vector2)
