def __init__(self, method, mp_results, omega=0.0):
self.omega = omega
super().__init__(method, mp_results)
diagonal = AmplitudeVector(*tuple(
self.diagonal(block) for block in self.blocks
))
self.omegamat = adcc.ones_like(diagonal) * omega
def diagonal_pphh_pphh_0(hf):
# Note: adcman similarly does not symmetrise the occupied indices
# (for both CVS and general ADC)
fCC = hf.fcc if hf.has_core_occupied_space else hf.foo
res = direct_sum("-i-J+a+b->iJab", hf.foo.diagonal(), fCC.diagonal(),
hf.fvv.diagonal(), hf.fvv.diagonal())
return AmplitudeVector(pphh=res.symmetrise(2, 3))
def apply(ampl):
return AmplitudeVector(ph=(
+ einsum("jkib,jkab->ia", pia_ooov, ampl.pphh)
+ einsum("ijbc,jabc->ia", ampl.pphh, pib_ovvv)
+ einsum("icab,jkcd,jkbd->ia", hf.ovvv, ampl.pphh, mp.t2oo) # 2nd
+ einsum("ijka,jlbc,klbc->ia", hf.ooov, mp.t2oo, ampl.pphh) # 2nd
))
def apply(ampl):
return AmplitudeVector(phhh=(
+ einsum("il,jkla->ijka", ampl.hh, hf.ooov).antisymmetrise(0, 1)
- einsum("kila,lj->ijka", hf.ooov, ampl.hh).antisymmetrise(0, 1)
+ einsum("ijla,kl->ijka", hf.ooov, ampl.hh) # Possible symmetrisation?
- einsum("ijla,lk->ijka", hf.ooov, ampl.hh)
))
def apply(ampl):
return AmplitudeVector(
pphh=(1 / sqrt(2)) *
(-2.0 *
einsum("jIKa,Kb->jIab", pia_occv, ampl.ph).antisymmetrise(2, 3) -
einsum("Ic,jcab->jIab", ampl.ph, pib_ovvv) -
einsum("lKIc,Kc,jlab->jIab", hf.occv, ampl.ph, mp.t2oo)))
def apply(ampl):
return AmplitudeVector(ph=(
+ einsum("ib,ab->ia", ampl.ph, i1)
- einsum("ij,ja->ia", i2, ampl.ph)
- einsum("jaib,jb->ia", hf.ovov, ampl.ph) # 1
- 0.5 * einsum("ikac,kc->ia", term_t2_eri, ampl.ph) # 2
))
def __init__(self, adcmatrix, shifts=0.0):
if not isinstance(adcmatrix, AdcMatrix):
raise TypeError("Only an AdcMatrix may be used with this "
"preconditioner for now.")
self.diagonal = AmplitudeVector(*tuple(
adcmatrix.diagonal(block) for block in adcmatrix.blocks))
self.shifts = shifts
def apply(ampl):
return AmplitudeVector(pphh=((
+einsum("ic,jcab->ijab", ampl.ph, pib_ovvv) +
einsum("lkic,kc,jlab->ijab", hf.ooov, ampl.ph, mp.t2oo) # 2st
).antisymmetrise(0, 1) + (
-einsum("ijka,kb->ijab", pia_ooov, ampl.ph) -
einsum("ijac,kbcd,kd->ijab", mp.t2oo, hf.ovvv, ampl.ph) # 2st
).antisymmetrise(2, 3)))
def block_ph_ph_3(hf, mp, intermediates):
if hf.has_core_occupied_space:
m11 = intermediates.cvs_adc3_m11
else:
m11 = intermediates.adc3_m11
diagonal = AmplitudeVector(ph=einsum("iaia->ia", m11))
def apply(ampl):
return AmplitudeVector(ph=einsum("iajb,jb->ia", m11, ampl.ph))
return AdcBlock(apply, diagonal)
def block_ph_ph_0(hf, mp, intermediates):
fCC = hf.fcc if hf.has_core_occupied_space else hf.foo
diagonal = AmplitudeVector(
ph=direct_sum("a-i->ia", hf.fvv.diagonal(), fCC.diagonal()))
def apply(ampl):
return AmplitudeVector(ph=(+einsum("ib,ab->ia", ampl.ph, hf.fvv) -
einsum("IJ,Ja->Ia", fCC, ampl.ph)))
return AdcBlock(apply, diagonal)
def apply(ampl):
return AmplitudeVector(pphh=( # 0th order
+ 2 * einsum("ijac,bc->ijab", ampl.pphh, hf.fvv).antisymmetrise(2, 3)
- 2 * einsum("ik,kjab->ijab", hf.foo, ampl.pphh).antisymmetrise(0, 1)
# 1st order
+ (
-4 * einsum("ikac,kbjc->ijab", ampl.pphh, hf.ovov)
).antisymmetrise(0, 1).antisymmetrise(2, 3)
+ 0.5 * einsum("ijkl,klab->ijab", hf.oooo, ampl.pphh)
+ 0.5 * einsum("ijcd,abcd->ijab", ampl.pphh, hf.vvvv)
))
def block_cvs_ph_ph_2(hf, mp, intermediates):
i1 = intermediates.adc2_i1
diagonal = AmplitudeVector(
ph=(+direct_sum("a-i->ia", i1.diagonal(), hf.fcc.diagonal()) -
einsum("IaIa->Ia", hf.cvcv)))
def apply(ampl):
return AmplitudeVector(ph=(+einsum("ib,ab->ia", ampl.ph, i1) -
einsum("ij,ja->ia", hf.fcc, ampl.ph) -
einsum("JaIb,Jb->Ia", hf.cvcv, ampl.ph)))
return AdcBlock(apply, diagonal)
def block_phhh_phhh_0(hf, mp, intermediates):
df = direct_sum("a-i->ia",
hf.fvv.diagonal(),
hf.foo.diagonal())
# Possible speed up trough symmetrisation possible, but not pursued
# at the present moment.
diagonal = AmplitudeVector(phhh=direct_sum("ij+ma->maij",
direct_sum("-k-l->lk", hf.foo.diagonal(), hf.foo.diagonal()),
df))
return AdcBlock(lambda ampl: 0, diagonal)
def apply(ampl):
return AmplitudeVector(pphh=(
# 0th order
+2.0 *
einsum("iJac,bc->iJab", ampl.pphh, hf.fvv).antisymmetrise(2, 3) -
1.0 * einsum("ik,kJab->iJab", hf.foo, ampl.pphh) -
1.0 * einsum("JK,iKab->iJab", hf.fcc, ampl.pphh)
# 1st order
+ (-2.0 * einsum("iKac,KbJc->iJab", ampl.pphh, hf.cvcv) +
2.0 * einsum("icka,kJbc->iJab", hf.ovov, ampl.pphh)
).antisymmetrise(2, 3) +
1.0 * einsum("iJlK,lKab->iJab", hf.ococ, ampl.pphh) +
0.5 * einsum("iJcd,abcd->iJab", ampl.pphh, hf.vvvv)))
def block_hh_hh_1(hf, mp, intermediates):
diagonal = AmplitudeVector(hh=(
direct_sum("-i-k>ki",
hf.foo.diagonalize(), hf.foo.diagonalize()).symmetrise ()
+ 0.5 * hf.oooo.diagonalize()
))
def apply(ampl):
return AmplitudeVector(hh=(
- einsum("ik,kj->ij", hf.foo, ampl.hh)
- einsum("jk,ik->ij", hf.foo, ampl.hh)
+ 0.25 * einsum("ijkl,kl->ij", hf.oooo, ampl.hh)
))
return AdcBlock(apply, diagonal)
def block_ph_ph_1(hf, mp, intermediates):
fCC = hf.fcc if hf.has_core_occupied_space else hf.foo
CvCv = hf.cvcv if hf.has_core_occupied_space else hf.ovov
diagonal = AmplitudeVector(ph=(
+ direct_sum("a-i->ia", hf.fvv.diagonal(), fCC.diagonal()) # order 0
- einsum("IaIa->Ia", CvCv) # order 1
))
def apply(ampl):
return AmplitudeVector(ph=( # PT order
+ einsum("ib,ab->ia", ampl.ph, hf.fvv) # 0
- einsum("IJ,Ja->Ia", fCC, ampl.ph) # 0
- einsum("JaIb,Jb->Ia", CvCv, ampl.ph) # 1
))
return AdcBlock(apply, diagonal)
def mtm_adc2(mp, dipop, intermediates):
t2 = mp.t2(b.oovv)
p0 = mp.mp2_diffdm
f1 = (+dipop.ov -
einsum("ijab,jb->ia", t2,
+dipop.ov - 0.5 * einsum("jkbc,kc->jb", t2, dipop.ov)) +
0.5 * einsum("ij,ja->ia", p0.oo, dipop.ov) -
0.5 * einsum("ib,ab->ia", dipop.ov, p0.vv) +
einsum("ib,ab->ia", p0.ov, dipop.vv) -
einsum("ij,ja->ia", dipop.oo, p0.ov) -
einsum("ijab,jb->ia", mp.td2(b.oovv), dipop.ov))
f2 = (+einsum("ijac,bc->ijab", t2, dipop.vv).antisymmetrise(2, 3) -
einsum("ik,kjab->ijab", dipop.oo, t2).antisymmetrise(0, 1))
return AmplitudeVector(ph=f1, pphh=f2)
def diagonal_pphh_pphh_1(hf):
# Fock matrix and ovov diagonal term (sometimes called "intermediate diagonal")
dinterm_ov = (direct_sum("a-i->ia", hf.fvv.diagonal(), hf.foo.diagonal())
- 2.0 * einsum("iaia->ia", hf.ovov)).evaluate()
if hf.has_core_occupied_space:
dinterm_Cv = (direct_sum("a-I->Ia", hf.fvv.diagonal(), hf.fcc.diagonal())
- 2.0 * einsum("IaIa->Ia", hf.cvcv)).evaluate()
diag_oC = einsum("iJiJ->iJ", hf.ococ)
else:
dinterm_Cv = dinterm_ov
diag_oC = einsum("ijij->ij", hf.oooo).symmetrise()
diag_vv = einsum("abab->ab", hf.vvvv).symmetrise()
return AmplitudeVector(pphh=(
+ direct_sum("ia+Jb->iJab", dinterm_ov, dinterm_Cv).symmetrise(2, 3)
+ direct_sum("iJ+ab->iJab", diag_oC, diag_vv)
))
def block_ph_ph_2(hf, mp, intermediates):
i1 = intermediates.adc2_i1
i2 = intermediates.adc2_i2
diagonal = AmplitudeVector(
ph=(+direct_sum("a-i->ia", i1.diagonal(), i2.diagonal()) -
einsum("IaIa->Ia", hf.ovov) -
einsum("ikac,ikac->ia", mp.t2oo, hf.oovv)))
# Not used anywhere else, so kept as an anonymous intermediate
term_t2_eri = (+einsum("ijab,jkbc->ikac", mp.t2oo, hf.oovv) +
einsum("ijab,jkbc->ikac", hf.oovv, mp.t2oo)).evaluate()
def apply(ampl):
return AmplitudeVector(ph=(
+einsum("ib,ab->ia", ampl.ph, i1) -
einsum("ij,ja->ia", i2, ampl.ph) -
einsum("jaib,jb->ia", hf.ovov, ampl.ph) # 1
- 0.5 * einsum("ikac,kc->ia", term_t2_eri, ampl.ph) # 2
))
return AdcBlock(apply, diagonal)
def apply(ampl):
return AmplitudeVector(ph=(
+ einsum("ib,ab->ia", ampl.ph, hf.fvv)
- einsum("IJ,Ja->Ia", fCC, ampl.ph)
))
def apply(ampl):
return AmplitudeVector(ph=( # PT order
+ einsum("ib,ab->ia", ampl.ph, hf.fvv) # 0
- einsum("IJ,Ja->Ia", fCC, ampl.ph) # 0
- einsum("JaIb,Jb->Ia", CvCv, ampl.ph) # 1
))
def apply(ampl):
return AmplitudeVector(pphh=(
+ 2 * einsum("ijac,bc->ijab", ampl.pphh, hf.fvv).antisymmetrise(2, 3)
- 2 * einsum("ik,kjab->ijab", hf.foo, ampl.pphh).antisymmetrise(0, 1)
))
def apply(ampl):
return AmplitudeVector(ph=einsum("iajb,jb->ia", m11, ampl.ph))
def apply(ampl):
return AmplitudeVector(pphh=(
+ 2 * einsum("iJac,bc->iJab", ampl.pphh, hf.fvv).antisymmetrise(2, 3)
- einsum("ik,kJab->iJab", hf.foo, ampl.pphh)
- einsum("JK,iKab->iJab", hf.fcc, ampl.pphh)
))
def apply(ampl):
return AmplitudeVector(ph=(1 / sqrt(2)) * (
+ 2.0 * einsum("lKIc,lKac->Ia", pia_occv, ampl.pphh)
- einsum("lIcd,lacd->Ia", ampl.pphh, pib_ovvv)
- einsum("jIKa,ljcd,lKcd->Ia", hf.occv, mp.t2oo, ampl.pphh)
))
def apply(ampl):
return AmplitudeVector(ph=(
+ einsum("ib,ab->ia", ampl.ph, i1)
- einsum("ij,ja->ia", hf.fcc, ampl.ph)
- einsum("JaIb,Jb->Ia", hf.cvcv, ampl.ph)
))
def apply(ampl):
return AmplitudeVector(ph=(
+ einsum("jkib,jkab->ia", hf.ooov, ampl.pphh)
+ einsum("ijbc,jabc->ia", ampl.pphh, hf.ovvv)
))
def apply(ampl):
return AmplitudeVector(pphh=(
+ sqrt(2) * einsum("jIKb,Ka->jIab",
hf.occv, ampl.ph).antisymmetrise(2, 3)
- 1 / sqrt(2) * einsum("Ic,jcab->jIab", ampl.ph, hf.ovvv)
))
def apply(ampl):
return AmplitudeVector(pphh=(
+ einsum("ic,jcab->ijab", ampl.ph, hf.ovvv).antisymmetrise(0, 1)
- einsum("ijka,kb->ijab", hf.ooov, ampl.ph).antisymmetrise(2, 3)
))
def apply(ampl):
return AmplitudeVector(ph=(
+ sqrt(2) * einsum("jKIb,jKab->Ia", hf.occv, ampl.pphh)
- 1 / sqrt(2) * einsum("jIbc,jabc->Ia", ampl.pphh, hf.ovvv)
))