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)