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 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 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_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 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_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 block_hh_hh_2(hf, mp, intermediates):
# Not sure if this will work directly...
itm = intermediates.adc2_itm
diagonal = Amplitude(hh=(
+ direct_sum("-i-k->ki", hf.foo.diagonal(), hf.foo.diagonal())
- hf.foooo.diagonal()
- itm.diagonal()
+ 0.5 * einsum("ikab,jlab->ik", mp.t2oo, hf.oovv)
))
def apply(ampl):
return NotImplemented
return AdcBlock(apply, diagonal)
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 block_hh_hh_0(hf, mp, intermediates):
diagonal = AmplitudeVector(hh=direct_sum("-a-i->ia", hf.foo.diagonal(),
hf.foo.diagonal()))
return AdcBlock(lambda ampl: 0, diagonal)
