def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None):
log = logger.new_logger(mp, verbose)
time0 = (time.clock(), time.time())
eris = _ChemistsERIs(mp, mo_coeff)
nocca, noccb = mp.get_nocc()
nmoa, nmob = mp.get_nmo()
nvira, nvirb = nmoa-nocca, nmob-noccb
nao = eris.mo_coeff[0].shape[0]
nmo_pair = nmoa * (nmoa+1) // 2
nao_pair = nao * (nao+1) // 2
mem_incore = (nao_pair**2 + nmo_pair**2) * 8/1e6
mem_now = lib.current_memory()[0]
max_memory = max(0, mp.max_memory-mem_now)
moa = eris.mo_coeff[0]
mob = eris.mo_coeff[1]
orboa = moa[:,:nocca]
orbob = mob[:,:noccb]
orbva = moa[:,nocca:]
orbvb = mob[:,noccb:]
if (mp.mol.incore_anyway or
(mp._scf._eri is not None and mem_incore+mem_now < mp.max_memory)):
log.debug('transform (ia|jb) incore')
if callable(ao2mofn):
eris.ovov = ao2mofn((orboa,orbva,orboa,orbva)).reshape(nocca*nvira,nocca*nvira)
eris.ovOV = ao2mofn((orboa,orbva,orbob,orbvb)).reshape(nocca*nvira,noccb*nvirb)
eris.OVOV = ao2mofn((orbob,orbvb,orbob,orbvb)).reshape(noccb*nvirb,noccb*nvirb)
else:
eris.ovov = ao2mo.general(mp._scf._eri, (orboa,orbva,orboa,orbva))
eris.ovOV = ao2mo.general(mp._scf._eri, (orboa,orbva,orbob,orbvb))
eris.OVOV = ao2mo.general(mp._scf._eri, (orbob,orbvb,orbob,orbvb))
elif getattr(mp._scf, 'with_df', None):
logger.warn(mp, 'UMP2 detected DF being used in the HF object. '
'MO integrals are computed based on the DF 3-index tensors.\n'
'It\'s recommended to use DF-UMP2 module.')
log.debug('transform (ia|jb) with_df')
eris.ovov = mp._scf.with_df.ao2mo((orboa,orbva,orboa,orbva))
eris.ovOV = mp._scf.with_df.ao2mo((orboa,orbva,orbob,orbvb))
eris.OVOV = mp._scf.with_df.ao2mo((orbob,orbvb,orbob,orbvb))
else:
log.debug('transform (ia|jb) outcore')
eris.feri = lib.H5TmpFile()
_ao2mo_ovov(mp, (orboa,orbva,orbob,orbvb), eris.feri,
max(2000, max_memory), log)
eris.ovov = eris.feri['ovov']
eris.ovOV = eris.feri['ovOV']
eris.OVOV = eris.feri['OVOV']
time1 = log.timer('Integral transformation', *time0)
return eris
def general(mydf, mo_coeffs, kpts=None, compact=True):
if isinstance(mo_coeffs, numpy.ndarray) and mo_coeffs.ndim == 2:
mo_coeffs = (mo_coeffs,) * 4
eri = mydf.get_eri(kpts)
####################
# gamma point, the integral is real and with s4 symmetry
if eri.dtype == numpy.float64:
return ao2mo.general(eri, mo_coeffs, compact=compact)
else:
mokl, klslice = ao2mo.incore._conc_mos(mo_coeffs[2], mo_coeffs[3],
False)[2:]
if mokl.dtype == numpy.float64:
mokl = mokl + 0j
nao = mo_coeffs[0].shape[0]
nmoi = mo_coeffs[0].shape[1]
nmoj = mo_coeffs[1].shape[1]
nmok = mo_coeffs[2].shape[1]
nmol = mo_coeffs[3].shape[1]
moi = numpy.asarray(mo_coeffs[0], order='F')
moj = numpy.asarray(mo_coeffs[1], order='F')
tao = [0]
ao_loc = None
pqkl = _ao2mo.r_e2(eri.reshape(-1,nao**2), mokl, klslice, tao, ao_loc, aosym='s1')
pqkl = pqkl.reshape(nao,nao,nmok*nmol)
pjkl = numpy.empty((nao,nmoj,nmok*nmol), dtype=numpy.complex128)
for i in range(nao):
lib.dot(moj.T, pqkl[i], 1, pjkl[i], 0)
pqkl = None
eri_mo = lib.dot(moi.T.conj(), pjkl.reshape(nao,-1))
return eri_mo.reshape(nmoi*nmoj,-1)
def add_hf_(a, b, hyb=1):
eri_mo = ao2mo.general(mol, [orbo,mo,mo,mo], compact=False)
eri_mo = eri_mo.reshape(nocc,nmo,nmo,nmo)
a += numpy.einsum('iabj->iajb', eri_mo[:nocc,nocc:,nocc:,:nocc]) * 2
a -= numpy.einsum('ijba->iajb', eri_mo[:nocc,:nocc,nocc:,nocc:]) * hyb
b += numpy.einsum('iajb->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:]) * 2
b -= numpy.einsum('jaib->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:]) * hyb
def test_mp2_ao2mo_ovov(self):
pt = mp.mp2.MP2(mf)
orbo = mf.mo_coeff[:,:8]
orbv = mf.mo_coeff[:,8:]
ftmp = lib.H5TmpFile()
h5dat = mp.mp2._ao2mo_ovov(pt, orbo, orbv, ftmp, 1)
ovov = numpy.asarray(h5dat)
ovov_ref = ao2mo.general(mf._eri, (orbo,orbv,orbo,orbv))
self.assertAlmostEqual(numpy.linalg.norm(ovov_ref-ovov), 0, 9)
def _exact_paaa(self, mo, u, out=None):
nmo = mo.shape[1]
ncore = self.ncore
ncas = self.ncas
nocc = ncore + ncas
mo1 = numpy.dot(mo, u)
mo1_cas = mo1[:,ncore:nocc]
mos = (mo1_cas, mo1_cas, mo1, mo1_cas)
if self._scf._eri is None:
aapa = ao2mo.general(self.mol, mos)
else:
aapa = ao2mo.general(self._scf._eri, mos)
paaa = numpy.empty((nmo*ncas,ncas*ncas))
buf = numpy.empty((ncas,ncas,nmo*ncas))
for ij, (i, j) in enumerate(zip(*numpy.tril_indices(ncas))):
buf[i,j] = buf[j,i] = aapa[ij]
paaa = lib.transpose(buf.reshape(ncas*ncas,-1), out=out)
return paaa.reshape(nmo,ncas,ncas,ncas)
def gen_hop_uhf_external(mf):
mol = mf.mol
mo_a, mo_b = mf.mo_coeff
mo_ea, mo_eb = mf.mo_energy
mo_occa, mo_occb = mf.mo_occ
nmo = mo_a.shape[1]
nocca = numpy.count_nonzero(mo_occa)
noccb = numpy.count_nonzero(mo_occb)
nvira = nmo - nocca
nvirb = nmo - noccb
eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo)
eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo)
eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo)
# alpha -> alpha
haa =-numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca])
haa+= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca])
for a in range(nvira):
for i in range(nocca):
haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i]
# beta -> beta
hbb =-numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb])
hbb+= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb])
for a in range(nvirb):
for i in range(noccb):
hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i]
nova = nocca * nvira
novb = noccb * nvirb
h1 = numpy.zeros((nova+novb,nova+novb))
h1[:nova,:nova] = haa.transpose(1,0,3,2).reshape(nova,nova)
h1[nova:,nova:] = hbb.transpose(1,0,3,2).reshape(novb,novb)
def hop1(x):
return h1.dot(x)
h11 =-numpy.einsum('abji->iajb', eri_ab[nocca:,nocca:,:noccb,:noccb])
for a in range(nvira):
for i in range(noccb):
h11[i,a,i,a] += mo_ea[nocca+a] - mo_eb[i]
h22 =-numpy.einsum('jiab->iajb', eri_ab[:nocca,:nocca,noccb:,noccb:])
for a in range(nvirb):
for i in range(nocca):
h22[i,a,i,a] += mo_eb[noccb+a] - mo_ea[i]
h12 =-numpy.einsum('ajbi->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb])
h21 =-numpy.einsum('biaj->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb])
n1 = noccb * nvira
n2 = nocca * nvirb
h2 = numpy.empty((n1+n2,n1+n2))
h2[:n1,:n1] = h11.transpose(1,0,3,2).reshape(n1,n1)
h2[n1:,n1:] = h22.transpose(1,0,3,2).reshape(n2,n2)
h2[:n1,n1:] = h12.transpose(1,0,3,2).reshape(n1,n2)
h2[n1:,:n1] = h21.transpose(1,0,3,2).reshape(n2,n1)
def hop2(x):
return h2.dot(x)
return hop1, hop2
def test_ump2_ao2mo_ovov(self):
pt = mp.UMP2(mf)
nocca, noccb = mol.nelec
orboa = mf.mo_coeff[0][:,:nocca]
orbva = mf.mo_coeff[0][:,nocca:]
orbob = mf.mo_coeff[1][:,:noccb]
orbvb = mf.mo_coeff[1][:,noccb:]
orbs = (orboa, orbva, orbob, orbvb)
ftmp = lib.H5TmpFile()
mp.ump2._ao2mo_ovov(pt, orbs, ftmp, 1)
ovov = numpy.asarray(ftmp['ovov'])
ovOV = numpy.asarray(ftmp['ovOV'])
OVOV = numpy.asarray(ftmp['OVOV'])
ovov_ref = ao2mo.general(mf._eri, (orboa,orbva,orboa,orbva))
ovOV_ref = ao2mo.general(mf._eri, (orboa,orbva,orbob,orbvb))
OVOV_ref = ao2mo.general(mf._eri, (orbob,orbvb,orbob,orbvb))
self.assertAlmostEqual(numpy.linalg.norm(ovov_ref-ovov), 0, 9)
self.assertAlmostEqual(numpy.linalg.norm(ovOV_ref-ovOV), 0, 9)
self.assertAlmostEqual(numpy.linalg.norm(OVOV_ref-OVOV), 0, 9)
def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None):
log = logger.new_logger(mp, verbose)
time0 = (time.clock(), time.time())
eris = _ChemistsERIs(mp, mo_coeff)
mo_coeff = eris.mo_coeff
nocc = mp.nocc
nmo = mp.nmo
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
max_memory = max(0, mp.max_memory - mem_now)
if max_memory < mem_basic:
log.warn(
'Not enough memory for integral transformation. '
'Available mem %s MB, required mem %s MB', max_memory, mem_basic)
co = numpy.asarray(mo_coeff[:, :nocc], order='F')
cv = numpy.asarray(mo_coeff[:, nocc:], order='F')
if (mp.mol.incore_anyway
or (mp._scf._eri is not None and mem_incore < max_memory)):
log.debug('transform (ia|jb) incore')
if callable(ao2mofn):
eris.ovov = ao2mofn(
(co, cv, co, cv)).reshape(nocc * nvir, nocc * nvir)
else:
eris.ovov = ao2mo.general(mp._scf._eri, (co, cv, co, cv))
elif getattr(mp._scf, 'with_df', None):
# To handle the PBC or custom 2-electron with 3-index tensor.
# Call dfmp2.MP2 for efficient DF-MP2 implementation.
log.warn('DF-HF is found. (ia|jb) is computed based on the DF '
'3-tensor integrals.\n'
'You can switch to dfmp2.MP2 for better performance')
log.debug('transform (ia|jb) with_df')
eris.ovov = mp._scf.with_df.ao2mo((co, cv, co, cv))
else:
log.debug('transform (ia|jb) outcore')
eris.feri = lib.H5TmpFile()
#ao2mo.outcore.general(mp.mol, (co,cv,co,cv), eris.feri,
# max_memory=max_memory, verbose=log)
#eris.ovov = eris.feri['eri_mo']
eris.ovov = _ao2mo_ovov(mp, co, cv, eris.feri, max(2000, max_memory),
log)
time1 = log.timer('Integral transformation', *time0)
return eris
def myump2(mol, mo_energy, mo_coeff, mo_occ):
o = numpy.hstack((mo_coeff[0][:,mo_occ[0]>0] ,mo_coeff[1][:,mo_occ[1]>0]))
v = numpy.hstack((mo_coeff[0][:,mo_occ[0]==0],mo_coeff[1][:,mo_occ[1]==0]))
eo = numpy.hstack((mo_energy[0][mo_occ[0]>0] ,mo_energy[1][mo_occ[1]>0]))
ev = numpy.hstack((mo_energy[0][mo_occ[0]==0],mo_energy[1][mo_occ[1]==0]))
no = o.shape[1]
nv = v.shape[1]
noa = sum(mo_occ[0]>0)
nva = sum(mo_occ[0]==0)
eri = ao2mo.general(mol, (o,v,o,v)).reshape(no,nv,no,nv)
eri[:noa,nva:] = eri[noa:,:nva] = eri[:,:,:noa,nva:] = eri[:,:,noa:,:nva] = 0
g = eri - eri.transpose(0,3,2,1)
eov = eo.reshape(-1,1) - ev.reshape(-1)
de = 1/(eov.reshape(-1,1) + eov.reshape(-1)).reshape(g.shape)
emp2 = .25 * numpy.einsum('iajb,iajb,iajb->', g, g, de)
return emp2
def test_incore_eri_s4(self):
numpy.random.seed(1)
norb = 4
# A 4-index eri with 4-fold symmetry
h2_s1 = numpy.random.random((norb, norb, norb, norb))
h2_s1 = h2_s1 + h2_s1.transpose(1, 0, 2, 3)
h2_s1 = h2_s1 + h2_s1.transpose(0, 1, 3, 2)
# pack the eri to 2-index
h2_s4 = ao2mo.restore(4, h2_s1, norb)
mos = numpy.random.random((4, norb, norb - 1))
eri_mo_from_s4 = ao2mo.general(h2_s4, mos)
eri_ref = trans(h2_s4, mos).reshape(eri_mo_from_s4.shape)
self.assertAlmostEqual(abs(eri_mo_from_s4 - eri_ref).max(), 0, 12)
def uhf_internal(mf, verbose=None):
log = logger.new_logger(mf, verbose)
mol = mf.mol
mo_a, mo_b = mf.mo_coeff
mo_ea, mo_eb = mf.mo_energy
mo_occa, mo_occb = mf.mo_occ
nmo = mo_a.shape[1]
nocca = numpy.count_nonzero(mo_occa)
noccb = numpy.count_nonzero(mo_occb)
nvira = nmo - nocca
nvirb = nmo - noccb
eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo)
eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo)
eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo)
# alpha -> alpha
haa = numpy.einsum('aijb->iajb', eri_aa[nocca:,:nocca,:nocca,nocca:]) * 2
haa-= numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca])
haa-= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca])
for a in range(nvira):
for i in range(nocca):
haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i]
# beta -> beta
hbb = numpy.einsum('aijb->iajb', eri_bb[noccb:,:noccb,:noccb,noccb:]) * 2
hbb-= numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb])
hbb-= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb])
for a in range(nvirb):
for i in range(noccb):
hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i]
# (alpha -> alpha, beta -> beta)
hab = numpy.einsum('aijb->iajb', eri_ab[nocca:,:nocca,:noccb,noccb:]) * 2
nova = nocca * nvira
novb = noccb * nvirb
hall = numpy.empty((nova+novb,nova+novb))
hall[:nova,:nova] = haa.reshape(nova,nova)
hall[nova:,nova:] = hbb.reshape(novb,novb)
hall[:nova,nova:] = hab.reshape(nova,novb)
hall[nova:,:nova] = hab.reshape(nova,novb).T
e = scipy.linalg.eigh(hall)[0]
log.debug('uhf_internal: lowest eigs of H = %s', e[e<=max(e[0],1e-5)])
if e[0] < -1e-5:
log.log('UHF wavefunction has an internal instablity. '
'It maybe corresponds to (spatial) symmetry broken wfn.')
else:
log.log('UHF wavefunction is stable in the intenral stablity analysis')
def uhf_internal(mf, verbose=None):
log = logger.new_logger(mf, verbose)
mol = mf.mol
mo_a, mo_b = mf.mo_coeff
mo_ea, mo_eb = mf.mo_energy
mo_occa, mo_occb = mf.mo_occ
nmo = mo_a.shape[1]
nocca = numpy.count_nonzero(mo_occa)
noccb = numpy.count_nonzero(mo_occb)
nvira = nmo - nocca
nvirb = nmo - noccb
eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo)
eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo)
eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo)
# alpha -> alpha
haa = numpy.einsum('aijb->iajb', eri_aa[nocca:,:nocca,:nocca,nocca:]) * 2
haa-= numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca])
haa-= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca])
for a in range(nvira):
for i in range(nocca):
haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i]
# beta -> beta
hbb = numpy.einsum('aijb->iajb', eri_bb[noccb:,:noccb,:noccb,noccb:]) * 2
hbb-= numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb])
hbb-= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb])
for a in range(nvirb):
for i in range(noccb):
hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i]
# (alpha -> alpha, beta -> beta)
hab = numpy.einsum('aijb->iajb', eri_ab[nocca:,:nocca,:noccb,noccb:]) * 2
nova = nocca * nvira
novb = noccb * nvirb
hall = numpy.empty((nova+novb,nova+novb))
hall[:nova,:nova] = haa.reshape(nova,nova)
hall[nova:,nova:] = hbb.reshape(novb,novb)
hall[:nova,nova:] = hab.reshape(nova,novb)
hall[nova:,:nova] = hab.reshape(nova,novb).T
e = scipy.linalg.eigh(hall)[0]
log.debug('uhf_internal: lowest eigs of H = %s', e[e<=max(e[0],1e-5)])
if e[0] < -1e-5:
log.log('UHF wavefunction has an internal instablity. '
'It maybe corresponds to (spatial) symmetry broken wfn.')
else:
log.log('UHF wavefunction is stable in the internal stablity analysis')
def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None):
log = logger.new_logger(mp, verbose)
time0 = (time.clock(), time.time())
eris = _ChemistsERIs(mp, mo_coeff)
mo_coeff = eris.mo_coeff
nocc = mp.nocc
nmo = mp.nmo
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
max_memory = max(0, mp.max_memory - mem_now)
if max_memory < mem_basic:
log.warn('Not enough memory for integral transformation. '
'Available mem %s MB, required mem %s MB',
max_memory, mem_basic)
co = numpy.asarray(mo_coeff[:,:nocc], order='F')
cv = numpy.asarray(mo_coeff[:,nocc:], order='F')
if (mp.mol.incore_anyway or
(mp._scf._eri is not None and mem_incore < max_memory)):
log.debug('transform (ia|jb) incore')
if callable(ao2mofn):
eris.ovov = ao2mofn((co,cv,co,cv)).reshape(nocc*nvir,nocc*nvir)
else:
eris.ovov = ao2mo.general(mp._scf._eri, (co,cv,co,cv))
elif getattr(mp._scf, 'with_df', None):
# To handle the PBC or custom 2-electron with 3-index tensor.
# Call dfmp2.MP2 for efficient DF-MP2 implementation.
log.warn('DF-HF is found. (ia|jb) is computed based on the DF '
'3-tensor integrals.\n'
'You can switch to dfmp2.MP2 for better performance')
log.debug('transform (ia|jb) with_df')
eris.ovov = mp._scf.with_df.ao2mo((co,cv,co,cv))
else:
log.debug('transform (ia|jb) outcore')
eris.feri = lib.H5TmpFile()
#ao2mo.outcore.general(mp.mol, (co,cv,co,cv), eris.feri,
# max_memory=max_memory, verbose=log)
#eris.ovov = eris.feri['eri_mo']
eris.ovov = _ao2mo_ovov(mp, co, cv, eris.feri, max(2000, max_memory), log)
time1 = log.timer('Integral transformation', *time0)
return eris
def __init__(self, mycc, mo_coeff=None):
moidx = uccsd.get_umoidx(mycc)
if mo_coeff is None:
mo_coeff = (mycc.mo_coeff[0][:,moidx[0]], mycc.mo_coeff[1][:,moidx[1]])
else:
mo_coeff = (mo_coeff[0][:,moidx[0]], mo_coeff[1][:,moidx[1]])
# Note: Always recompute the fock matrix in UCISD because the mf object may be
# converted from ROHF object in which orbital energies are eigenvalues of
# Roothaan Fock rather than the true alpha, beta orbital energies.
dm = mycc._scf.make_rdm1(mycc.mo_coeff, mycc.mo_occ)
fockao = mycc._scf.get_hcore() + mycc._scf.get_veff(mycc.mol, dm)
self.focka = reduce(numpy.dot, (mo_coeff[0].T, fockao[0], mo_coeff[0]))
self.fockb = reduce(numpy.dot, (mo_coeff[1].T, fockao[1], mo_coeff[1]))
self.mo_coeff = mo_coeff
self.nocca, self.noccb = mycc.get_nocc()
nocca = self.nocca
noccb = self.noccb
nmoa = self.focka.shape[0]
nmob = self.fockb.shape[0]
nvira = nmoa - nocca
nvirb = nmob - noccb
moa, mob = self.mo_coeff
eri_aa = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, moa), nmoa)
self.vovp = eri_aa[nocca:,:nocca,nocca:].copy()
self.vooo = eri_aa[nocca:,:nocca,:nocca,:nocca].copy()
eri_bb = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, mob), nmob)
self.VOVP = eri_bb[noccb:,:noccb,noccb:].copy()
self.VOOO = eri_bb[noccb:,:noccb,:noccb,:noccb].copy()
eri_ab = ao2mo.general(mycc._scf._eri, (moa,moa,mob,mob), compact=False)
eri_ab = eri_ab.reshape(nmoa,nmoa,nmob,nmob)
self.voVP = eri_ab[nocca:,:nocca,noccb:].copy()
self.voOO = eri_ab[nocca:,:nocca,:noccb,:noccb].copy()
eri_ba = lib.transpose(eri_ab.reshape(nmoa**2,nmob**2))
eri_ba = eri_ba.reshape(nmob,nmob,nmoa,nmoa)
self.VOvp = eri_ba[noccb:,:noccb,nocca:].copy()
self.VOoo = eri_ba[noccb:,:noccb,:nocca,:nocca].copy()
def myump2(mol, mo_energy, mo_coeff, mo_occ):
o = numpy.hstack(
(mo_coeff[0][:, mo_occ[0] > 0], mo_coeff[1][:, mo_occ[1] > 0]))
v = numpy.hstack(
(mo_coeff[0][:, mo_occ[0] == 0], mo_coeff[1][:, mo_occ[1] == 0]))
eo = numpy.hstack(
(mo_energy[0][mo_occ[0] > 0], mo_energy[1][mo_occ[1] > 0]))
ev = numpy.hstack(
(mo_energy[0][mo_occ[0] == 0], mo_energy[1][mo_occ[1] == 0]))
no = o.shape[1]
nv = v.shape[1]
noa = sum(mo_occ[0] > 0)
nva = sum(mo_occ[0] == 0)
eri = ao2mo.general(mol, (o, v, o, v)).reshape(no, nv, no, nv)
eri[:noa, nva:] = eri[noa:, :nva] = eri[:, :, :noa,
nva:] = eri[:, :, noa:, :nva] = 0
g = eri - eri.transpose(0, 3, 2, 1)
eov = eo.reshape(-1, 1) - ev.reshape(-1)
de = 1 / (eov.reshape(-1, 1) + eov.reshape(-1)).reshape(g.shape)
emp2 = .25 * numpy.einsum('iajb,iajb,iajb->', g, g, de)
return emp2
def myump2(mf):
# As UHF objects, mo_energy, mo_occ, mo_coeff are two-item lists
# (the first item for alpha spin, the second for beta spin).
mo_energy = mf.mo_energy
mo_occ = mf.mo_occ
mo_coeff = mf.mo_coeff
o = np.hstack((mo_coeff[0][:,mo_occ[0]>0] ,mo_coeff[1][:,mo_occ[1]>0]))
v = np.hstack((mo_coeff[0][:,mo_occ[0]==0],mo_coeff[1][:,mo_occ[1]==0]))
eo = np.hstack((mo_energy[0][mo_occ[0]>0] ,mo_energy[1][mo_occ[1]>0]))
ev = np.hstack((mo_energy[0][mo_occ[0]==0],mo_energy[1][mo_occ[1]==0]))
no = o.shape[1]
nv = v.shape[1]
noa = sum(mo_occ[0]>0)
nva = sum(mo_occ[0]==0)
eri = ao2mo.general(mf.mol, (o,v,o,v)).reshape(no,nv,no,nv)
eri[:noa,nva:] = eri[noa:,:nva] = eri[:,:,:noa,nva:] = eri[:,:,noa:,:nva] = 0
g = eri - eri.transpose(0,3,2,1)
eov = eo.reshape(-1,1) - ev.reshape(-1)
de = 1/(eov.reshape(-1,1) + eov.reshape(-1)).reshape(g.shape)
emp2 = .25 * np.einsum('iajb,iajb,iajb->', g, g, de)
return emp2
def kernel(self):
no = self.mol.nelectron // 2
nv = len(self.mf.mo_energy) - no
#cprint(no)
#cprint(nv)
co = self.mf.mo_coeff[:, :no]
cv = self.mf.mo_coeff[:, no:]
'''
g = core4hf_(self.mf, 0, (-1,-1))
g = ao2mo_4(g, cv, co, cv, co) # abij
'''
#from pyscf import ao2mo
g = ao2mo.general(self.mol, (cv, co, cv, co)).reshape(nv, no, nv, no).transpose(0,2,1,3)
e = self.mf.mo_energy
ie = np.empty((nv, nv, no, no))
for a in xrange(nv):
for b in xrange(nv):
for i in xrange(no):
for j in xrange(no):
ie[a, b, i, j] = 1.0 / (e[i] + e[j] - e[a + no] - e[b + no])
#ie = ie.reshape(nv * nv, -1) # abij
return np.dot((g.conj() * ie).reshape(-1), (2 * g - g.transpose(0,1,3,2)).reshape(-1))
def ao2mo(self, coeff):
"""
Phys ERI in MO basis.
Args:
coeff (Iterable): MO orbitals;
Returns:
ERI in MO basis.
"""
coeff = (coeff[0], coeff[2], coeff[1], coeff[3])
if "with_df" in dir(self.model):
if "kpt" in dir(self.model):
result = self.model.with_df.ao2mo(coeff,
(self.model.kpt, ) * 4,
compact=False)
else:
result = self.model.with_df.ao2mo(coeff, compact=False)
else:
result = ao2mo.general(self.model.mol, coeff, compact=False)
return result.reshape(tuple(i.shape[1] for i in coeff)).swapaxes(1, 2)
def general(mydf, mo_coeffs, kpts=None, compact=True):
if isinstance(mo_coeffs, numpy.ndarray) and mo_coeffs.ndim == 2:
mo_coeffs = (mo_coeffs, ) * 4
eri = mydf.get_eri(kpts)
####################
# gamma point, the integral is real and with s4 symmetry
if eri.dtype == numpy.float64:
return ao2mo.general(eri, mo_coeffs, compact=compact)
else:
mokl, klslice = ao2mo.incore._conc_mos(mo_coeffs[2], mo_coeffs[3],
False)[2:]
if mokl.dtype == numpy.float64:
mokl = mokl + 0j
nao = mo_coeffs[0].shape[0]
nmoi = mo_coeffs[0].shape[1]
nmoj = mo_coeffs[1].shape[1]
nmok = mo_coeffs[2].shape[1]
nmol = mo_coeffs[3].shape[1]
moi = numpy.asarray(mo_coeffs[0], order='F')
moj = numpy.asarray(mo_coeffs[1], order='F')
tao = [0]
ao_loc = None
pqkl = _ao2mo.r_e2(eri.reshape(-1, nao**2),
mokl,
klslice,
tao,
ao_loc,
aosym='s1')
pqkl = pqkl.reshape(nao, nao, nmok * nmol)
pjkl = numpy.empty((nao, nmoj, nmok * nmol), dtype=numpy.complex128)
for i in range(nao):
lib.dot(moj.T, pqkl[i], 1, pjkl[i], 0)
pqkl = None
eri_mo = lib.dot(moi.T.conj(), pjkl.reshape(nao, -1))
return eri_mo.reshape(nmoi * nmoj, -1)
def transform_integrals_incore(myadc):
occ = myadc.mo_coeff[:, :myadc._nocc]
vir = myadc.mo_coeff[:, myadc._nocc:]
nocc = occ.shape[1]
nvir = vir.shape[1]
eris = lambda: None
# TODO: check if myadc._scf._eri is not None
eris.oooo = ao2mo.general(myadc._scf._eri, (occ, occ, occ, occ),
compact=False).reshape(nocc, nocc, nocc,
nocc).copy()
eris.ovoo = ao2mo.general(myadc._scf._eri, (occ, vir, occ, occ),
compact=False).reshape(nocc, nvir, nocc,
nocc).copy()
eris.ovov = ao2mo.general(myadc._scf._eri, (occ, vir, occ, vir),
compact=False).reshape(nocc, nvir, nocc,
nvir).copy()
eris.oovv = ao2mo.general(myadc._scf._eri, (occ, occ, vir, vir),
compact=False).reshape(nocc, nocc, nvir,
nvir).copy()
eris.ovvo = ao2mo.general(myadc._scf._eri, (occ, vir, vir, occ),
compact=False).reshape(nocc, nvir, nvir,
nocc).copy()
eris.ovvv = ao2mo.general(myadc._scf._eri, (occ, vir, vir, vir),
compact=True).reshape(nocc, nvir, -1).copy()
if (myadc.method == "adc(2)-x" or myadc.method == "adc(3)"):
eris.vvvv = ao2mo.general(myadc._scf._eri, (vir, vir, vir, vir),
compact=False).reshape(
nvir, nvir, nvir, nvir)
eris.vvvv = np.ascontiguousarray(eris.vvvv.transpose(0, 2, 1, 3))
eris.vvvv = eris.vvvv.reshape(nvir * nvir, nvir * nvir)
return eris
def perform_uhf_partial(self):
assert self.pyscfmol is not None
nocc_a, nvirt_a, nocc_b, nvirt_b = self.occupations
C_occ_alph = self.C[0, :, :nocc_a]
C_virt_alph = self.C[0, :, nocc_a:]
C_occ_beta = self.C[1, :, :nocc_b]
C_virt_beta = self.C[1, :, nocc_b:]
C_ovov_aaaa = (C_occ_alph, C_virt_alph, C_occ_alph, C_virt_alph)
C_ovov_aabb = (C_occ_alph, C_virt_alph, C_occ_beta, C_virt_beta)
C_ovov_bbaa = (C_occ_beta, C_virt_beta, C_occ_alph, C_virt_alph)
C_ovov_bbbb = (C_occ_beta, C_virt_beta, C_occ_beta, C_virt_beta)
C_oovv_aaaa = (C_occ_alph, C_occ_alph, C_virt_alph, C_virt_alph)
C_oovv_bbbb = (C_occ_beta, C_occ_beta, C_virt_beta, C_virt_beta)
from pyscf.ao2mo import general
tei_mo_ovov_aaaa = general(
self.pyscfmol, C_ovov_aaaa, aosym="s4", compact=False, verbose=self.verbose
).reshape(nocc_a, nvirt_a, nocc_a, nvirt_a)
tei_mo_ovov_aabb = general(
self.pyscfmol, C_ovov_aabb, aosym="s4", compact=False, verbose=self.verbose
).reshape(nocc_a, nvirt_a, nocc_b, nvirt_b)
tei_mo_ovov_bbaa = general(
self.pyscfmol, C_ovov_bbaa, aosym="s4", compact=False, verbose=self.verbose
).reshape(nocc_b, nvirt_b, nocc_a, nvirt_a)
tei_mo_ovov_bbbb = general(
self.pyscfmol, C_ovov_bbbb, aosym="s4", compact=False, verbose=self.verbose
).reshape(nocc_b, nvirt_b, nocc_b, nvirt_b)
tei_mo_oovv_aaaa = general(
self.pyscfmol, C_oovv_aaaa, aosym="s4", compact=False, verbose=self.verbose
).reshape(nocc_a, nocc_a, nvirt_a, nvirt_a)
tei_mo_oovv_bbbb = general(
self.pyscfmol, C_oovv_bbbb, aosym="s4", compact=False, verbose=self.verbose
).reshape(nocc_b, nocc_b, nvirt_b, nvirt_b)
self.tei_mo = (
tei_mo_ovov_aaaa,
tei_mo_ovov_aabb,
tei_mo_ovov_bbaa,
tei_mo_ovov_bbbb,
tei_mo_oovv_aaaa,
tei_mo_oovv_bbbb,
)
def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None):
log = logger.new_logger(mp, verbose)
time0 = (time.clock(), time.time())
eris = _ChemistsERIs(mp, mo_coeff)
nocca, noccb = mp.get_nocc()
nmoa, nmob = mp.get_nmo()
nvira, nvirb = nmoa - nocca, nmob - noccb
nao = eris.mo_coeff[0].shape[0]
nmo_pair = nmoa * (nmoa + 1) // 2
nao_pair = nao * (nao + 1) // 2
mem_incore = (nao_pair**2 + nmo_pair**2) * 8 / 1e6
mem_now = lib.current_memory()[0]
max_memory = max(0, mp.max_memory - mem_now)
moa = eris.mo_coeff[0]
mob = eris.mo_coeff[1]
orboa = moa[:, :nocca]
orbob = mob[:, :noccb]
orbva = moa[:, nocca:]
orbvb = mob[:, noccb:]
if (mp.mol.incore_anyway or
(mp._scf._eri is not None and mem_incore + mem_now < mp.max_memory)):
log.debug('transform (ia|jb) incore')
if callable(ao2mofn):
eris.ovov = ao2mofn(
(orboa, orbva, orboa, orbva)).reshape(nocca * nvira,
nocca * nvira)
eris.ovOV = ao2mofn(
(orboa, orbva, orbob, orbvb)).reshape(nocca * nvira,
noccb * nvirb)
eris.OVOV = ao2mofn(
(orbob, orbvb, orbob, orbvb)).reshape(noccb * nvirb,
noccb * nvirb)
else:
eris.ovov = ao2mo.general(mp._scf._eri,
(orboa, orbva, orboa, orbva))
eris.ovOV = ao2mo.general(mp._scf._eri,
(orboa, orbva, orbob, orbvb))
eris.OVOV = ao2mo.general(mp._scf._eri,
(orbob, orbvb, orbob, orbvb))
elif getattr(mp._scf, 'with_df', None):
logger.warn(
mp, 'UMP2 detected DF being used in the HF object. '
'MO integrals are computed based on the DF 3-index tensors.\n'
'It\'s recommended to use DF-UMP2 module.')
log.debug('transform (ia|jb) with_df')
eris.ovov = mp._scf.with_df.ao2mo((orboa, orbva, orboa, orbva))
eris.ovOV = mp._scf.with_df.ao2mo((orboa, orbva, orbob, orbvb))
eris.OVOV = mp._scf.with_df.ao2mo((orbob, orbvb, orbob, orbvb))
else:
log.debug('transform (ia|jb) outcore')
eris.feri = lib.H5TmpFile()
_ao2mo_ovov(mp, (orboa, orbva, orbob, orbvb), eris.feri,
max(2000, max_memory), log)
eris.ovov = eris.feri['ovov']
eris.ovOV = eris.feri['ovOV']
eris.OVOV = eris.feri['OVOV']
time1 = log.timer('Integral transformation', *time0)
return eris
def write_chk(mc,root,chkfile):
t0 = (time.clock(), time.time())
fh5 = h5py.File(chkfile,'w')
if mc.fcisolver.nroots > 1:
mc.mo_coeff,_, mc.mo_energy = mc.canonicalize(mc.mo_coeff,ci=root)
fh5['mol'] = mc.mol.dumps()
fh5['mc/mo'] = mc.mo_coeff
fh5['mc/ncore'] = mc.ncore
fh5['mc/ncas'] = mc.ncas
nvirt = mc.mo_coeff.shape[1] - mc.ncas-mc.ncore
fh5['mc/nvirt'] = nvirt
fh5['mc/nelecas'] = mc.nelecas
fh5['mc/root'] = root
fh5['mc/orbe'] = mc.mo_energy
fh5['mc/nroots'] = mc.fcisolver.nroots
fh5['mc/wfnsym'] = mc.fcisolver.wfnsym
if getattr(mc.mo_coeff, 'orbsym', None) is not None:
fh5.create_dataset('mc/orbsym',data=mc.mo_coeff.orbsym)
if getattr(mc.mo_coeff, 'orbsym', None) is not None and mc.mol.symmetry:
orbsym = numpy.asarray(mc.mo_coeff.orbsym)
pair_irrep = orbsym.reshape(-1,1) ^ orbsym
else:
pair_irrep = None
ncore = mc.ncore
nocc = mc.ncore + mc.ncas
mo_core = mc.mo_coeff[:,:mc.ncore]
mo_cas = mc.mo_coeff[:,mc.ncore:mc.ncore+mc.ncas]
mo_virt = mc.mo_coeff[:,mc.ncore+mc.ncas:]
core_dm = numpy.dot(mo_core,mo_core.T) *2
core_vhf = mc.get_veff(mc.mol,core_dm)
h1e_Sr = reduce(numpy.dot, (mo_virt.T,mc.get_hcore()+core_vhf , mo_cas))
h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore()+core_vhf , mo_core))
h1e, e_core = mc.h1e_for_cas()
if pair_irrep is not None:
h1e_Sr[pair_irrep[nocc:,ncore:nocc] != 0] = 0
h1e_Si[pair_irrep[ncore:nocc,:ncore] != 0] = 0
h1e[pair_irrep[ncore:nocc,ncore:nocc] != 0] = 0
fh5['h1e_Si'] = h1e_Si
fh5['h1e_Sr'] = h1e_Sr
fh5['h1e'] = h1e
fh5['e_core'] = e_core
if mc._scf._eri is None:
h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff,mo_cas,mo_cas,mo_cas), compact=False)
h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas)
if pair_irrep is not None:
sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) !=
pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape)
h2e_t[sym_forbid] = 0
h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:]
fh5['h2e'] = h2e
h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3))
fh5['h2e_Si'] = h2e_Si
else:
eri = mc._scf._eri
h2e_t = ao2mo.general(eri, [mc.mo_coeff,mo_cas,mo_cas,mo_cas], compact=False)
h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas)
if pair_irrep is not None:
sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) !=
pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape)
h2e_t[sym_forbid] = 0
h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:]
fh5['h2e'] = h2e
h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3))
fh5['h2e_Si'] = h2e_Si
fh5.close()
logger.timer(mc,'Write MPS NEVPT integral', *t0)
grad = numpy.array(feri['eri_mo']).reshape(-1,nocc,nvir,nocc,nvir)
print('shape of gradient integrals %s' % str(grad.shape))
import tempfile
import numpy
import h5py
from pyscf import ao2mo
nocc = mol.nelectron // 2
nvir = len(mf.mo_energy) - nocc
co = mf.mo_coeff[:,:nocc]
cv = mf.mo_coeff[:,nocc:]
hess1tmp = tempfile.NamedTemporaryFile()
ao2mo.kernel(mol, (co,cv,co,cv), hess1tmp.name, intor='cint2e_ipvip1_sph',
dataname='hessints1', aosym='s4', comp=9, verbose=0)
with ao2mo.load(hess1tmp, 'hessints1') as eri:
hess1 = numpy.array(eri).reshape(-1,nocc,nvir,nocc,nvir)
hess2tmp = tempfile.NamedTemporaryFile()
ao2mo.general(mol, (co,cv,co,cv), hess2tmp.name, intor='cint2e_ipip1_sph',
dataname='hessints2', aosym='s2kl', comp=9, verbose=0)
feri = h5py.File(hess2tmp.name, 'r')
hess2 = numpy.array(feri['hessints2']).reshape(-1,nocc,nvir,nocc,nvir)
hess3tmp = tempfile.NamedTemporaryFile()
with ao2mo.load(ao2mo.general(mol, (co,cv,co,cv), hess3tmp.name, intor='cint2e_ip1ip2_sph',
aosym='s1', comp=9, verbose=0)) as eri:
hess3 = numpy.array(eri).reshape(-1,nocc,nvir,nocc,nvir)
print('shape of hessian integrals: hess1 %s, hess2 %s, hess3 %s' %
(str(hess1.shape), str(hess2.shape), str(hess3.shape)))
def __init__(self, myci, mo_coeff=None, method='incore'):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(myci.mo_occ.size, dtype=numpy.bool)
if isinstance(myci.frozen, (int, numpy.integer)):
moidx[:myci.frozen] = False
elif len(myci.frozen) > 0:
moidx[numpy.asarray(myci.frozen)] = False
if mo_coeff is None:
self.mo_coeff = mo_coeff = myci.mo_coeff[:,moidx]
else:
self.mo_coeff = mo_coeff = mo_coeff[:,moidx]
dm = myci._scf.make_rdm1(myci.mo_coeff, myci.mo_occ)
fockao = myci._scf.get_hcore() + myci._scf.get_veff(myci.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = myci.nocc
nmo = myci.nmo
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = ccsd._mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
log = logger.Logger(myci.stdout, myci.verbose)
if (method == 'incore' and myci._scf._eri is not None and
(mem_incore+mem_now < myci.max_memory) or myci.mol.incore_anyway):
eri1 = ao2mo.incore.full(myci._scf._eri, mo_coeff)
#:eri1 = ao2mo.restore(1, eri1, nmo)
#:self.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy()
#:self.ooov = eri1[:nocc,:nocc,:nocc,nocc:].copy()
#:self.vooo = eri1[nocc:,:nocc,:nocc,:nocc].copy()
#:self.voov = eri1[nocc:,:nocc,:nocc,nocc:].copy()
#:self.vvoo = eri1[nocc:,nocc:,:nocc,:nocc].copy()
#:vovv = eri1[nocc:,:nocc,nocc:,nocc:].copy()
#:self.vovv = lib.pack_tril(vovv.reshape(-1,nvir,nvir))
#:self.vvvv = ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
nvir_pair = nvir * (nvir+1) // 2
self.oooo = numpy.empty((nocc,nocc,nocc,nocc))
self.ooov = numpy.empty((nocc,nocc,nocc,nvir))
self.vooo = numpy.empty((nvir,nocc,nocc,nocc))
self.voov = numpy.empty((nvir,nocc,nocc,nvir))
self.vovv = numpy.empty((nvir,nocc,nvir_pair))
self.vvvv = numpy.empty((nvir_pair,nvir_pair))
ij = 0
outbuf = numpy.empty((nmo,nmo,nmo))
oovv = numpy.empty((nocc,nocc,nvir,nvir))
for i in range(nocc):
buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1])
for j in range(i+1):
self.oooo[i,j] = self.oooo[j,i] = buf[j,:nocc,:nocc]
self.ooov[i,j] = self.ooov[j,i] = buf[j,:nocc,nocc:]
oovv[i,j] = oovv[j,i] = buf[j,nocc:,nocc:]
ij += i + 1
self.vvoo = lib.transpose(oovv.reshape(nocc**2,-1)).reshape(nvir,nvir,nocc,nocc)
oovv = None
ij1 = 0
for i in range(nocc,nmo):
buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1])
self.vooo[i-nocc] = buf[:nocc,:nocc,:nocc]
self.voov[i-nocc] = buf[:nocc,:nocc,nocc:]
lib.pack_tril(_cp(buf[:nocc,nocc:,nocc:]), out=self.vovv[i-nocc])
dij = i - nocc + 1
lib.pack_tril(_cp(buf[nocc:i+1,nocc:,nocc:]),
out=self.vvvv[ij1:ij1+dij])
ij += i + 1
ij1 += dij
else:
cput1 = time.clock(), time.time()
_tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
_tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
self.feri1 = feri1 = h5py.File(_tmpfile1.name)
def __del__feri1(self):
feri1.close()
self.feri1.__del__ = __del__feri1
orbo = mo_coeff[:,:nocc]
orbv = mo_coeff[:,nocc:]
nvpair = nvir * (nvir+1) // 2
self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), 'f8')
self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), 'f8')
self.vvoo = self.feri1.create_dataset('vvoo', (nvir,nvir,nocc,nocc), 'f8')
self.vooo = self.feri1.create_dataset('vooo', (nvir,nocc,nocc,nocc), 'f8')
self.voov = self.feri1.create_dataset('voov', (nvir,nocc,nocc,nvir), 'f8')
self.vovv = self.feri1.create_dataset('vovv', (nvir,nocc,nvpair), 'f8')
fsort = _ccsd.libcc.CCsd_sort_inplace
nocc_pair = nocc*(nocc+1)//2
nvir_pair = nvir*(nvir+1)//2
def sort_inplace(p0, p1, eri):
fsort(eri.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nocc), ctypes.c_int(nvir),
ctypes.c_int((p1-p0)*nocc))
vv = eri[:,:nvir_pair]
oo = eri[:,nvir_pair:nvir_pair+nocc_pair]
ov = eri[:,nvir_pair+nocc_pair:].reshape(-1,nocc,nvir)
return oo, ov, vv
buf = numpy.empty((nmo,nmo,nmo))
oovv = numpy.empty((nocc,nocc,nvir,nvir))
def save_occ_frac(p0, p1, eri):
oo, ov, vv = sort_inplace(p0, p1, eri)
self.oooo[p0:p1] = lib.unpack_tril(oo, out=buf).reshape(p1-p0,nocc,nocc,nocc)
self.ooov[p0:p1] = ov.reshape(p1-p0,nocc,nocc,nvir)
oovv[p0:p1] = lib.unpack_tril(vv, out=buf).reshape(p1-p0,nocc,nvir,nvir)
def save_vir_frac(p0, p1, eri):
oo, ov, vv = sort_inplace(p0, p1, eri)
self.vooo[p0:p1] = lib.unpack_tril(oo, out=buf).reshape(p1-p0,nocc,nocc,nocc)
self.voov[p0:p1] = ov.reshape(p1-p0,nocc,nocc,nvir)
self.vovv[p0:p1] = vv.reshape(p1-p0,nocc,-1)
if not myci.direct:
max_memory = max(2000,myci.max_memory-lib.current_memory()[0])
self.feri2 = feri2 = h5py.File(_tmpfile2.name)
def __del__feri2(self):
feri2.close()
self.feri2.__del__ = __del__feri2
ao2mo.full(myci.mol, orbv, self.feri2, max_memory=max_memory, verbose=log)
self.vvvv = self.feri2['eri_mo']
cput1 = log.timer_debug1('transforming vvvv', *cput1)
tmpfile3 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
with h5py.File(tmpfile3.name, 'w') as feri:
max_memory = max(2000, myci.max_memory-lib.current_memory()[0])
mo = numpy.hstack((orbv, orbo))
ao2mo.general(myci.mol, (mo,orbo,mo,mo),
feri, max_memory=max_memory, verbose=log)
cput1 = log.timer_debug1('transforming oppp', *cput1)
blksize = max(1, int(min(8e9,max_memory*.5e6)/8/nmo**2/nocc))
handler = None
for p0, p1 in lib.prange(0, nvir, blksize):
eri = _cp(feri['eri_mo'][p0*nocc:p1*nocc])
handler = async_do(handler, save_vir_frac, p0, p1, eri)
for p0, p1 in lib.prange(0, nocc, blksize):
eri = _cp(feri['eri_mo'][(p0+nvir)*nocc:(p1+nvir)*nocc])
handler = async_do(handler, save_occ_frac, p0, p1, eri)
if handler is not None:
handler.join()
self.vvoo[:] = lib.transpose(oovv.reshape(nocc**2,-1)).reshape(nvir,nvir,nocc,nocc)
log.timer('CISD integral transformation', *cput0)
def _make_eris_outcore(myci, mo_coeff=None):
cput0 = (time.clock(), time.time())
log = logger.Logger(myci.stdout, myci.verbose)
eris = _UCISD_ERIs(myci, mo_coeff)
nocca = eris.nocca
noccb = eris.noccb
nmoa = eris.focka.shape[0]
nmob = eris.fockb.shape[0]
nvira = nmoa - nocca
nvirb = nmob - noccb
moa, mob = eris.mo_coeff
mol = myci.mol
eris.feri = lib.H5TmpFile()
dtype = 'f8'
eris.oooo = eris.feri.create_dataset('oooo', (nocca, nocca, nocca, nocca),
dtype)
eris.vooo = eris.feri.create_dataset('vooo', (nvira, nocca, nocca, nocca),
dtype)
eris.voov = eris.feri.create_dataset('voov', (nvira, nocca, nocca, nvira),
dtype)
eris.vvoo = eris.feri.create_dataset('vvoo', (nvira, nvira, nocca, nocca),
dtype)
eris.vovv = eris.feri.create_dataset('vovv', (nvira, nocca, nvira *
(nvira + 1) // 2), dtype)
#eris.vvvv = eris.feri.create_dataset('vvvv', (nvira,nvira,nvira,nvira), dtype)
eris.OOOO = eris.feri.create_dataset('OOOO', (noccb, noccb, noccb, noccb),
dtype)
eris.VOOO = eris.feri.create_dataset('VOOO', (nvirb, noccb, noccb, noccb),
dtype)
eris.VOOV = eris.feri.create_dataset('VOOV', (nvirb, noccb, noccb, nvirb),
dtype)
eris.VVOO = eris.feri.create_dataset('VVOO', (nvirb, nvirb, noccb, noccb),
dtype)
eris.VOVV = eris.feri.create_dataset('VOVV', (nvirb, noccb, nvirb *
(nvirb + 1) // 2), dtype)
#eris.VVVV = eris.feri.create_dataset('VVVV', (nvirb,nvirb,nvirb,nvirb), dtype)
eris.ooOO = eris.feri.create_dataset('ooOO', (nocca, nocca, noccb, noccb),
dtype)
eris.voOO = eris.feri.create_dataset('voOO', (nvira, nocca, noccb, noccb),
dtype)
eris.voOV = eris.feri.create_dataset('voOV', (nvira, nocca, noccb, nvirb),
dtype)
eris.vvOO = eris.feri.create_dataset('vvOO', (nvira, nvira, noccb, noccb),
dtype)
eris.voVV = eris.feri.create_dataset('voVV', (nvira, nocca, nvirb *
(nvirb + 1) // 2), dtype)
#eris.vvVV = eris.feri.create_dataset('vvVV', (nvira,nvira,nvirb,nvirb), dtype)
eris.VOoo = eris.feri.create_dataset('VOoo', (nvirb, noccb, nocca, nocca),
dtype)
eris.VVoo = eris.feri.create_dataset('VVoo', (nvirb, nvirb, nocca, nocca),
dtype)
eris.VOvv = eris.feri.create_dataset('VOvv', (nvirb, noccb, nvira *
(nvira + 1) // 2), dtype)
cput1 = time.clock(), time.time()
# <ij||pq> = <ij|pq> - <ij|qp> = (ip|jq) - (iq|jp)
tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
ao2mo.general(mol, (moa, moa[:, :nocca], moa, moa), tmpfile2.name, 'aa')
with h5py.File(tmpfile2.name) as f:
buf = lib.unpack_tril(f['aa'][:nocca * nocca])
buf = buf.reshape(nocca, nocca, nmoa, nmoa)
eris.oooo[:] = buf[:, :, :nocca, :nocca]
oovv = buf[:, :, nocca:, nocca:].reshape(nocca**2, nvira**2)
eris.vvoo[:] = lib.transpose(oovv).reshape(nvira, nvira, nocca, nocca)
buf = oovv = None
for i0, i1 in lib.prange(0, nvira, nocca):
buf = lib.unpack_tril(f['aa'][(nocca + i0) * nocca:(nocca + i1) *
nocca])
eris.vovv[i0:i1] = lib.pack_tril(buf[:, nocca:, nocca:]).reshape(
i1 - i0, nocca, -1)
buf = buf.reshape(i1 - i0, nocca, nmoa, nmoa)
eris.vooo[i0:i1] = buf[:, :nocca, :nocca, :nocca]
eris.voov[i0:i1] = buf[:, :nocca, :nocca, nocca:]
buf = None
del (f['aa'])
if noccb > 0:
ao2mo.general(mol, (mob, mob[:, :noccb], mob, mob), tmpfile2.name,
'bb')
with h5py.File(tmpfile2.name) as f:
buf = lib.unpack_tril(f['bb'][:noccb * noccb])
buf = buf.reshape(noccb, noccb, nmob, nmob)
eris.OOOO[:] = buf[:, :, :noccb, :noccb]
oovv = buf[:, :, noccb:, noccb:].reshape(noccb**2, nvirb**2)
eris.VVOO[:] = lib.transpose(oovv).reshape(nvirb, nvirb, noccb,
noccb)
buf = oovv = None
for i0, i1 in lib.prange(0, nvirb, noccb):
buf = lib.unpack_tril(f['bb'][(noccb + i0) *
noccb:(noccb + i1) * noccb])
eris.VOVV[i0:i1] = lib.pack_tril(buf[:, noccb:,
noccb:]).reshape(
i1 - i0, noccb, -1)
buf = buf.reshape(i1 - i0, noccb, nmob, nmob)
eris.VOOO[i0:i1] = buf[:, :noccb, :noccb, :noccb]
eris.VOOV[i0:i1] = buf[:, :noccb, :noccb, noccb:]
buf = None
del (f['bb'])
ao2mo.general(mol, (moa, moa[:, :nocca], mob, mob), tmpfile2.name, 'ab')
with h5py.File(tmpfile2.name) as f:
buf = lib.unpack_tril(f['ab'][:nocca * nocca])
buf = buf.reshape(nocca, nocca, nmob, nmob)
eris.ooOO[:] = buf[:, :, :noccb, :noccb]
oovv = buf[:, :, noccb:, noccb:].reshape(nocca**2, nvirb**2)
eris.VVoo[:] = lib.transpose(oovv).reshape(nvirb, nvirb, nocca, nocca)
buf = oovv = None
for i0, i1 in lib.prange(0, nvira, nocca):
buf = lib.unpack_tril(f['ab'][(nocca + i0) * nocca:(nocca + i1) *
nocca])
eris.voVV[i0:i1] = lib.pack_tril(buf[:, noccb:, noccb:]).reshape(
i1 - i0, nocca, -1)
buf = buf.reshape(i1 - i0, nocca, nmob, nmob)
eris.voOO[i0:i1] = buf[:, :nocca, :noccb, :noccb]
eris.voOV[i0:i1] = buf[:, :nocca, :noccb, noccb:]
buf = None
del (f['ab'])
if noccb > 0:
ao2mo.general(mol, (mob, mob[:, :noccb], moa, moa), tmpfile2.name,
'ba')
with h5py.File(tmpfile2.name) as f:
buf = lib.unpack_tril(f['ba'][:noccb * noccb])
buf = buf.reshape(noccb, noccb, nmoa, nmoa)
oovv = buf[:, :, nocca:, nocca:].reshape(noccb**2, nvira**2)
eris.vvOO[:] = lib.transpose(oovv).reshape(nvira, nvira, noccb,
noccb)
buf = oovv = None
for i0, i1 in lib.prange(0, nvirb, noccb):
buf = lib.unpack_tril(f['ba'][(noccb + i0) *
noccb:(noccb + i1) * noccb])
eris.VOvv[i0:i1] = lib.pack_tril(buf[:, nocca:,
nocca:]).reshape(
i1 - i0, noccb, -1)
buf = buf.reshape(i1 - i0, noccb, nmoa, nmoa)
eris.VOoo[i0:i1] = buf[:, :noccb, :nocca, :nocca]
buf = None
del (f['ba'])
cput1 = log.timer_debug1('transforming vopq', *cput1)
orbva = moa[:, nocca:]
orbvb = mob[:, noccb:]
ao2mo.full(mol, orbva, eris.feri, dataname='vvvv')
ao2mo.full(mol, orbvb, eris.feri, dataname='VVVV')
ao2mo.general(mol, (orbva, orbva, orbvb, orbvb),
eris.feri,
dataname='vvVV')
eris.vvvv = eris.feri['vvvv']
eris.VVVV = eris.feri['VVVV']
eris.vvVV = eris.feri['vvVV']
cput1 = log.timer_debug1('transforming vvvv', *cput1)
log.timer('CISD integral transformation', *cput0)
return eris
def fn(x, mo0, mo1, mo2, mo3):
return ao2mo.general(x, (mo0, mo1, mo2, mo3),
compact=False).reshape(mo0.shape[-1], mo1.shape[-1],
mo2.shape[-1], mo3.shape[-1])
def uhf_external(mf, verbose=None):
log = logger.new_logger(mf, verbose)
mol = mf.mol
mo_a, mo_b = mf.mo_coeff
mo_ea, mo_eb = mf.mo_energy
mo_occa, mo_occb = mf.mo_occ
nmo = mo_a.shape[1]
nocca = numpy.count_nonzero(mo_occa)
noccb = numpy.count_nonzero(mo_occb)
nvira = nmo - nocca
nvirb = nmo - noccb
eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo)
eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo)
eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo)
# alpha -> alpha
haa =-numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca])
haa+= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca])
for a in range(nvira):
for i in range(nocca):
haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i]
# beta -> beta
hbb =-numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb])
hbb+= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb])
for a in range(nvirb):
for i in range(noccb):
hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i]
nova = nocca * nvira
novb = noccb * nvirb
hall = numpy.zeros((nova+novb,nova+novb))
hall[:nova,:nova] = haa.reshape(nova,nova)
hall[nova:,nova:] = hbb.reshape(novb,novb)
e1 = scipy.linalg.eigh(hall)[0]
log.debug('uhf_external: lowest eigs of H = %s', e1[e1<=max(e1[0],1e-5)])
if e1[0] < -1e-5:
log.log('UHF wavefunction has an UHF real -> complex instablity')
else:
log.log('UHF wavefunction is stable in the UHF real -> complex stablity analysis')
h11 =-numpy.einsum('abji->iajb', eri_ab[nocca:,nocca:,:noccb,:noccb])
for a in range(nvira):
for i in range(noccb):
h11[i,a,i,a] += mo_ea[nocca+a] - mo_eb[i]
h22 =-numpy.einsum('jiab->iajb', eri_ab[:nocca,:nocca,noccb:,noccb:])
for a in range(nvirb):
for i in range(nocca):
h22[i,a,i,a] += mo_eb[noccb+a] - mo_ea[i]
h12 =-numpy.einsum('ajbi->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb])
h21 =-numpy.einsum('biaj->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb])
n1 = noccb * nvira
n2 = nocca * nvirb
hall = numpy.empty((n1+n2,n1+n2))
hall[:n1,:n1] = h11.reshape(n1,n1)
hall[n1:,n1:] = h22.reshape(n2,n2)
hall[:n1,n1:] = h12.reshape(n1,n2)
hall[n1:,:n1] = h21.reshape(n2,n1)
e3 = scipy.linalg.eigh(hall)[0]
log.debug('uhf_external: lowest eigs of H = %s', e3[e3<=max(e3[0],1e-5)])
if e3[0] < -1e-5:
log.log('UHF wavefunction has an UHF -> GHF instablity.')
else:
log.log('UHF wavefunction is stable in the UHF -> GHF stablity analysis')
ehf = mf.kernel()
ncore = 0
nao, nmo = mf.mo_coeff.shape
nocc = mol.nelectron // 2 - ncore
nvir = nmo - nocc - ncore
nov = nocc * nvir
mo_core = mf.mo_coeff[:, :ncore]
mo_occ = mf.mo_coeff[:, ncore:ncore + nocc]
mo_vir = mf.mo_coeff[:, ncore + nocc:]
co = mo_occ
cv = mo_vir
eo = mf.mo_energy[ncore:ncore + nocc]
ev = mf.mo_energy[ncore + nocc:]
v_ijab = ao2mo.general(mf._eri, (co, co, cv, cv), compact=False)
v_ijab = v_ijab.reshape(nocc, nocc, nvir, nvir)
v_iajb = ao2mo.general(mf._eri, (co, cv, co, cv), compact=False)
v_iajb = v_iajb.reshape(nocc, nvir, nocc, nvir)
def diagonalize(a, b, nroots=3):
e, c = numpy.linalg.eig(\
numpy.bmat([[ a, b],
[-b,-a]]))
c = numpy.array(c)
idx = numpy.where(e > 0)
idx = numpy.asarray(idx[0])
e = e[idx]
c = c[:, idx]
idx = numpy.argsort(e)
def __init__(self, cc, mo_coeff=None, method='incore'):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(cc.mo_occ.size, dtype=numpy.bool)
if isinstance(cc.frozen, (int, numpy.integer)):
moidx[:cc.frozen] = False
elif len(cc.frozen) > 0:
moidx[numpy.asarray(cc.frozen)] = False
if mo_coeff is None:
self.mo_coeff = mo_coeff = cc.mo_coeff[:,moidx]
else:
self.mo_coeff = mo_coeff = mo_coeff[:,moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = cc.nocc
nmo = cc.nmo
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
log = logger.Logger(cc.stdout, cc.verbose)
if hasattr(cc._scf, 'with_df') and cc._scf.with_df:
#log.warn('CCSD detected DF being bound to the HF object. '
# 'MO integrals are computed based on the DF 3-tensor integrals.\n'
# 'You can switch to dfccsd.CCSD for the DF-CCSD implementation')
nvir_pair = nvir * (nvir+1) // 2
oooo = numpy.zeros((nocc*nocc,nocc*nocc))
ooov = numpy.zeros((nocc*nocc,nocc*nvir))
ovoo = numpy.zeros((nocc*nvir,nocc*nocc))
oovv = numpy.zeros((nocc*nocc,nvir*nvir))
ovov = numpy.zeros((nocc*nvir,nocc*nvir))
ovvv = numpy.zeros((nocc*nvir,nvir_pair))
vvvv = numpy.zeros((nvir_pair,nvir_pair))
mo = numpy.asarray(mo_coeff, order='F')
nmo = mo.shape[1]
ijslice = (0, nmo, 0, nmo)
Lpq = None
for eri1 in cc._scf.with_df.loop():
Lpq = _ao2mo.nr_e2(eri1, mo, ijslice, aosym='s2', out=Lpq).reshape(-1,nmo,nmo)
Loo = Lpq[:,:nocc,:nocc].reshape(-1,nocc**2)
Lov = Lpq[:,:nocc,nocc:].reshape(-1,nocc*nvir)
Lvv = Lpq[:,nocc:,nocc:].reshape(-1,nvir**2)
lib.ddot(Loo.T, Loo, 1, oooo, 1)
lib.ddot(Loo.T, Lov, 1, ooov, 1)
lib.ddot(Lov.T, Loo, 1, ovoo, 1)
lib.ddot(Loo.T, Lvv, 1, oovv, 1)
lib.ddot(Lov.T, Lov, 1, ovov, 1)
Lvv = lib.pack_tril(Lvv.reshape(-1,nvir,nvir))
lib.ddot(Lov.T, Lvv, 1, ovvv, 1)
lib.ddot(Lvv.T, Lvv, 1, vvvv, 1)
_tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
self.feri1 = feri1 = h5py.File(_tmpfile1.name)
def __del__feri1(self):
feri1.close()
self.feri1.__del__ = __del__feri1
self.feri1['oooo'] = oooo.reshape(nocc,nocc,nocc,nocc)
self.feri1['ooov'] = ooov.reshape(nocc,nocc,nocc,nvir)
self.feri1['ovoo'] = ovoo.reshape(nocc,nvir,nocc,nocc)
self.feri1['oovv'] = oovv.reshape(nocc,nocc,nvir,nvir)
self.feri1['ovov'] = ovov.reshape(nocc,nvir,nocc,nvir)
self.feri1['ovvv'] = ovvv.reshape(nocc,nvir,nvir_pair)
self.feri1['vvvv'] = vvvv.reshape(nvir_pair,nvir_pair)
self.oooo = self.feri1['oooo']
self.ooov = self.feri1['ooov']
self.ovoo = self.feri1['ovoo']
self.oovv = self.feri1['oovv']
self.ovov = self.feri1['ovov']
self.ovvv = self.feri1['ovvv']
self.vvvv = self.feri1['vvvv']
elif (method == 'incore' and cc._scf._eri is not None and
(mem_incore+mem_now < cc.max_memory) or cc.mol.incore_anyway):
eri1 = ao2mo.incore.full(cc._scf._eri, mo_coeff)
#:eri1 = ao2mo.restore(1, eri1, nmo)
#:self.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy()
#:self.ooov = eri1[:nocc,:nocc,:nocc,nocc:].copy()
#:self.ovoo = eri1[:nocc,nocc:,:nocc,:nocc].copy()
#:self.oovv = eri1[:nocc,:nocc,nocc:,nocc:].copy()
#:self.ovov = eri1[:nocc,nocc:,:nocc,nocc:].copy()
#:ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy()
#:self.ovvv = numpy.empty((nocc,nvir,nvir*(nvir+1)//2))
#:for i in range(nocc):
#: for j in range(nvir):
#: self.ovvv[i,j] = lib.pack_tril(ovvv[i,j])
#:self.vvvv = ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
nvir_pair = nvir * (nvir+1) // 2
self.oooo = numpy.empty((nocc,nocc,nocc,nocc))
self.ooov = numpy.empty((nocc,nocc,nocc,nvir))
self.ovoo = numpy.empty((nocc,nvir,nocc,nocc))
self.oovv = numpy.empty((nocc,nocc,nvir,nvir))
self.ovov = numpy.empty((nocc,nvir,nocc,nvir))
self.ovvv = numpy.empty((nocc,nvir,nvir_pair))
self.vvvv = numpy.empty((nvir_pair,nvir_pair))
ij = 0
outbuf = numpy.empty((nmo,nmo,nmo))
for i in range(nocc):
buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1])
for j in range(i+1):
self.oooo[i,j] = self.oooo[j,i] = buf[j,:nocc,:nocc]
self.ooov[i,j] = self.ooov[j,i] = buf[j,:nocc,nocc:]
self.oovv[i,j] = self.oovv[j,i] = buf[j,nocc:,nocc:]
ij += i + 1
ij1 = 0
for i in range(nocc,nmo):
buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1])
self.ovoo[:,i-nocc] = buf[:nocc,:nocc,:nocc]
self.ovov[:,i-nocc] = buf[:nocc,:nocc,nocc:]
for j in range(nocc):
self.ovvv[j,i-nocc] = lib.pack_tril(_cp(buf[j,nocc:,nocc:]))
for j in range(nocc, i+1):
self.vvvv[ij1] = lib.pack_tril(_cp(buf[j,nocc:,nocc:]))
ij1 += 1
ij += i + 1
else:
cput1 = time.clock(), time.time()
_tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
_tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
self.feri1 = feri1 = h5py.File(_tmpfile1.name)
def __del__feri1(self):
feri1.close()
self.feri1.__del__ = __del__feri1
orbo = mo_coeff[:,:nocc]
orbv = mo_coeff[:,nocc:]
nvpair = nvir * (nvir+1) // 2
self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), 'f8')
self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), 'f8')
self.ovoo = self.feri1.create_dataset('ovoo', (nocc,nvir,nocc,nocc), 'f8')
self.oovv = self.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), 'f8')
self.ovov = self.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), 'f8')
self.ovvv = self.feri1.create_dataset('ovvv', (nocc,nvir,nvpair), 'f8')
fsort = _ccsd.libcc.CCsd_sort_inplace
nocc_pair = nocc*(nocc+1)//2
nvir_pair = nvir*(nvir+1)//2
def sort_inplace(eri):
fsort(eri.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nocc), ctypes.c_int(nvir),
ctypes.c_int(eri.shape[0]))
vv = eri[:,:nvir_pair]
oo = eri[:,nvir_pair:nvir_pair+nocc_pair]
ov = eri[:,nvir_pair+nocc_pair:].reshape(-1,nocc,nvir)
return oo, ov, vv
buf = numpy.empty((nmo,nmo,nmo))
def save_occ_frac(i, p0, p1, eri):
oo, ov, vv = sort_inplace(eri)
self.oooo[i,p0:p1] = lib.unpack_tril(oo, out=buf)
self.ooov[i,p0:p1] = ov
self.oovv[i,p0:p1] = lib.unpack_tril(vv, out=buf)
def save_vir_frac(i, p0, p1, eri):
oo, ov, vv = sort_inplace(eri)
self.ovoo[i,p0:p1] = lib.unpack_tril(oo, out=buf)
self.ovov[i,p0:p1] = ov
self.ovvv[i,p0:p1] = vv
if not cc.direct:
max_memory = max(2000,cc.max_memory-lib.current_memory()[0])
self.feri2 = feri2 = h5py.File(_tmpfile2.name)
def __del__feri2(self):
feri2.close()
self.feri2.__del__ = __del__feri2
ao2mo.full(cc.mol, orbv, self.feri2, max_memory=max_memory, verbose=log)
self.vvvv = self.feri2['eri_mo']
cput1 = log.timer_debug1('transforming vvvv', *cput1)
tmpfile3 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
with h5py.File(tmpfile3.name, 'w') as feri:
max_memory = max(2000, cc.max_memory-lib.current_memory()[0])
mo = numpy.hstack((orbv, orbo))
ao2mo.general(cc.mol, (orbo,mo,mo,mo),
feri, max_memory=max_memory, verbose=log)
cput1 = log.timer_debug1('transforming oppp', *cput1)
blksize = max(1, int(min(8e9,max_memory*.5e6)/8/nmo**2))
handler = None
for i in range(nocc):
for p0, p1 in lib.prange(0, nvir, blksize):
eri = _cp(feri['eri_mo'][i*nmo+p0:i*nmo+p1])
handler = async_do(handler, save_vir_frac, i, p0, p1, eri)
for p0, p1 in lib.prange(0, nocc, blksize):
eri = _cp(feri['eri_mo'][i*nmo+nvir+p0:i*nmo+nvir+p1])
handler = async_do(handler, save_occ_frac, i, p0, p1, eri)
cput1 = log.timer_debug1('sorting %d'%i, *cput1)
if handler is not None:
handler.join()
for key in feri.keys():
del(feri[key])
log.timer('CCSD integral transformation', *cput0)
def _make_eris_outcore(mycc, mo_coeff=None):
cput0 = (time.clock(), time.time())
eris = _ChemistsERIs()
eris._common_init_(mycc, mo_coeff)
nocca, noccb = mycc.nocc
nmoa, nmob = mycc.nmo
nvira, nvirb = nmoa-nocca, nmob-noccb
moa = eris.mo_coeff[0]
mob = eris.mo_coeff[1]
nmoa = moa.shape[1]
nmob = mob.shape[1]
orboa = moa[:,:nocca]
orbob = mob[:,:noccb]
orbva = moa[:,nocca:]
orbvb = mob[:,noccb:]
eris.feri = lib.H5TmpFile()
eris.oooo = eris.feri.create_dataset('oooo', (nocca,nocca,nocca,nocca), 'f8')
eris.ovoo = eris.feri.create_dataset('ovoo', (nocca,nvira,nocca,nocca), 'f8')
eris.ovov = eris.feri.create_dataset('ovov', (nocca,nvira,nocca,nvira), 'f8')
eris.oovv = eris.feri.create_dataset('oovv', (nocca,nocca,nvira,nvira), 'f8')
eris.ovvo = eris.feri.create_dataset('ovvo', (nocca,nvira,nvira,nocca), 'f8')
eris.ovvv = eris.feri.create_dataset('ovvv', (nocca,nvira,nvira*(nvira+1)//2), 'f8')
#eris.vvvv = eris.feri.create_dataset('vvvv', (nvira,nvira,nvira,nvira), 'f8')
eris.OOOO = eris.feri.create_dataset('OOOO', (noccb,noccb,noccb,noccb), 'f8')
eris.OVOO = eris.feri.create_dataset('OVOO', (noccb,nvirb,noccb,noccb), 'f8')
eris.OVOV = eris.feri.create_dataset('OVOV', (noccb,nvirb,noccb,nvirb), 'f8')
eris.OOVV = eris.feri.create_dataset('OOVV', (noccb,noccb,nvirb,nvirb), 'f8')
eris.OVVO = eris.feri.create_dataset('OVVO', (noccb,nvirb,nvirb,noccb), 'f8')
eris.OVVV = eris.feri.create_dataset('OVVV', (noccb,nvirb,nvirb*(nvirb+1)//2), 'f8')
#eris.VVVV = eris.feri.create_dataset('VVVV', (nvirb,nvirb,nvirb,nvirb), 'f8')
eris.ooOO = eris.feri.create_dataset('ooOO', (nocca,nocca,noccb,noccb), 'f8')
eris.ovOO = eris.feri.create_dataset('ovOO', (nocca,nvira,noccb,noccb), 'f8')
eris.ovOV = eris.feri.create_dataset('ovOV', (nocca,nvira,noccb,nvirb), 'f8')
eris.ooVV = eris.feri.create_dataset('ooVV', (nocca,nocca,nvirb,nvirb), 'f8')
eris.ovVO = eris.feri.create_dataset('ovVO', (nocca,nvira,nvirb,noccb), 'f8')
eris.ovVV = eris.feri.create_dataset('ovVV', (nocca,nvira,nvirb*(nvirb+1)//2), 'f8')
#eris.vvVV = eris.feri.create_dataset('vvVV', (nvira,nvira,nvirb,nvirb), 'f8')
eris.OVoo = eris.feri.create_dataset('OVoo', (noccb,nvirb,nocca,nocca), 'f8')
eris.OOvv = eris.feri.create_dataset('OOvv', (noccb,noccb,nvira,nvira), 'f8')
eris.OVvo = eris.feri.create_dataset('OVvo', (noccb,nvirb,nvira,nocca), 'f8')
eris.OVvv = eris.feri.create_dataset('OVvv', (noccb,nvirb,nvira*(nvira+1)//2), 'f8')
cput1 = time.clock(), time.time()
mol = mycc.mol
# <ij||pq> = <ij|pq> - <ij|qp> = (ip|jq) - (iq|jp)
tmpf = lib.H5TmpFile()
if nocca > 0:
ao2mo.general(mol, (orboa,moa,moa,moa), tmpf, 'aa')
buf = np.empty((nmoa,nmoa,nmoa))
for i in range(nocca):
lib.unpack_tril(tmpf['aa'][i*nmoa:(i+1)*nmoa], out=buf)
eris.oooo[i] = buf[:nocca,:nocca,:nocca]
eris.ovoo[i] = buf[nocca:,:nocca,:nocca]
eris.ovov[i] = buf[nocca:,:nocca,nocca:]
eris.oovv[i] = buf[:nocca,nocca:,nocca:]
eris.ovvo[i] = buf[nocca:,nocca:,:nocca]
eris.ovvv[i] = lib.pack_tril(buf[nocca:,nocca:,nocca:])
del(tmpf['aa'])
if noccb > 0:
buf = np.empty((nmob,nmob,nmob))
ao2mo.general(mol, (orbob,mob,mob,mob), tmpf, 'bb')
for i in range(noccb):
lib.unpack_tril(tmpf['bb'][i*nmob:(i+1)*nmob], out=buf)
eris.OOOO[i] = buf[:noccb,:noccb,:noccb]
eris.OVOO[i] = buf[noccb:,:noccb,:noccb]
eris.OVOV[i] = buf[noccb:,:noccb,noccb:]
eris.OOVV[i] = buf[:noccb,noccb:,noccb:]
eris.OVVO[i] = buf[noccb:,noccb:,:noccb]
eris.OVVV[i] = lib.pack_tril(buf[noccb:,noccb:,noccb:])
del(tmpf['bb'])
if nocca > 0:
buf = np.empty((nmoa,nmob,nmob))
ao2mo.general(mol, (orboa,moa,mob,mob), tmpf, 'ab')
for i in range(nocca):
lib.unpack_tril(tmpf['ab'][i*nmoa:(i+1)*nmoa], out=buf)
eris.ooOO[i] = buf[:nocca,:noccb,:noccb]
eris.ovOO[i] = buf[nocca:,:noccb,:noccb]
eris.ovOV[i] = buf[nocca:,:noccb,noccb:]
eris.ooVV[i] = buf[:nocca,noccb:,noccb:]
eris.ovVO[i] = buf[nocca:,noccb:,:noccb]
eris.ovVV[i] = lib.pack_tril(buf[nocca:,noccb:,noccb:])
del(tmpf['ab'])
if noccb > 0:
buf = np.empty((nmob,nmoa,nmoa))
ao2mo.general(mol, (orbob,mob,moa,moa), tmpf, 'ba')
for i in range(noccb):
lib.unpack_tril(tmpf['ba'][i*nmob:(i+1)*nmob], out=buf)
eris.OVoo[i] = buf[noccb:,:nocca,:nocca]
eris.OOvv[i] = buf[:noccb,nocca:,nocca:]
eris.OVvo[i] = buf[noccb:,nocca:,:nocca]
eris.OVvv[i] = lib.pack_tril(buf[noccb:,nocca:,nocca:])
del(tmpf['ba'])
buf = None
cput1 = logger.timer_debug1(mycc, 'transforming oopq, ovpq', *cput1)
if not mycc.direct:
ao2mo.full(mol, orbva, eris.feri, dataname='vvvv')
ao2mo.full(mol, orbvb, eris.feri, dataname='VVVV')
ao2mo.general(mol, (orbva,orbva,orbvb,orbvb), eris.feri, dataname='vvVV')
eris.vvvv = eris.feri['vvvv']
eris.VVVV = eris.feri['VVVV']
eris.vvVV = eris.feri['vvVV']
cput1 = logger.timer_debug1(mycc, 'transforming vvvv', *cput1)
return eris
mf.conv_tol = 1e-8
e = mf.kernel()
print('E = %.15g, ref -230.776765415' % e)
#
# Given four MOs, compute the MO-integrals and saved in dataset "mp2_bz"
#
eritmp = tempfile.NamedTemporaryFile()
nocc = mol.nelectron // 2
nvir = len(mf.mo_energy) - nocc
co = mf.mo_coeff[:,:nocc]
cv = mf.mo_coeff[:,nocc:]
orbs = (co, cv, co, cv)
# Depending on your hardware and BLAS library, it needs about 1 min on I5 3GHz
# CPU with MKL library to transform the integrals
ao2mo.general(mol, orbs, eritmp.name, dataname='mp2_bz')#, verbose=5)
eia = mf.mo_energy[:nocc,None] - mf.mo_energy[None,nocc:]
f = h5py.File(eritmp.name, 'r')
eri = f['mp2_bz']
print('Note the shape of the transformed integrals (ij|kl) is %s.' % str(eri.shape))
print("It's a 2D array: the first index for compressed ij, the second index for compressed kl")
emp2 = 0
for i in range(nocc):
dajb = eia[i].reshape(-1,1) + eia.reshape(1,-1)
gi = numpy.array(eri[i*nvir:(i+1)*nvir])
t2 = gi.flatten() / dajb.flatten()
gi = gi.reshape(nvir,nocc,nvir)
theta = gi*2 - gi.transpose(2,1,0)
emp2 += numpy.dot(t2, theta.flatten())
def dump(self, fname='mole.h5'):
# Effective
nbas = self.nbas - self.nfrozen
sbas = nbas * 2
print '\n[iface.dump] (self.nbas,nbas)=', (self.nbas, nbas)
#
# Basic information
#
f = h5py.File(fname, "w")
cal = f.create_dataset("cal", (1, ), dtype='i')
enuc = self.mol.energy_nuc()
nelec = self.nelec - self.nfrozen * 2
cal.attrs["nelec"] = nelec
cal.attrs["sbas"] = sbas
cal.attrs["enuc"] = enuc
cal.attrs[
"escf"] = 0. # Not useful at all: self.mf.energy_elec(self.mf.make_rdm1())[0]
#
# Intergrals
#
flter = 'lzf'
# Local or CMO
if self.iflocal:
self.local()
mo_coeff = self.lmo_coeff.copy()
else:
print 'canonical or user defined mo'
mo_coeff = self.mo_coeff[:, self.nfrozen:].copy()
# Reorder
if self.ifreorder:
order = list(self.reorder(mo_coeff))
else:
order = range(mo_coeff.shape[1])
mo_coeff = mo_coeff[:, numpy.array(order)].copy()
self.molden(mo_coeff, fname='mocoeff')
# Dump MO coefficients
f.create_dataset("mo_coeff_spatial", data=mo_coeff)
# Occupation
occun = numpy.zeros(sbas)
for i in range(self.nalpha - self.nfrozen):
occun[2 * i] = 1.0
for i in range(self.nbeta - self.nfrozen):
occun[2 * i + 1] = 1.0
print
print 'initial occun for', len(occun), ' spin orbitals:\n', occun
sorder = numpy.array([[2 * i, 2 * i + 1] for i in order]).flatten()
occun = occun[sorder].copy()
assert abs(numpy.sum(occun) - nelec) < 1.e-10
print "sorder:", sorder
print "occun :", occun
# Symmetry
if self.mol.symmetry and not self.iflocal:
import pyscf.symm
irrep_name = self.mol.irrep_id
orbsym0 = pyscf.symm.label_orb_symm(self.mol, irrep_name,
self.mol.symm_orb, mo_coeff)
print '\nSpatial orbsym:\n', orbsym0
orbsym = numpy.array([[i, i] for i in orbsym0]).flatten()
else:
orbsym = numpy.array([0] * sbas)
spinsym = numpy.array([[0, 1] for i in range(nbas)]).flatten()
print "orbsym :", orbsym
print "spinsym:", spinsym
f.create_dataset("occun", data=occun)
f.create_dataset("orbsym", data=orbsym)
f.create_dataset("spinsym", data=spinsym)
#====================================================================
# Spin orbital integrals
#====================================================================
# Integral transformation
# SPECIAL FORM of MO for TRANS
gmo_coeff = numpy.hstack((self.mo_coeff[:, :self.nfrozen], mo_coeff))
print 'gmo_coeff.shape=', gmo_coeff.shape
f.create_dataset("mo_coeff_spatialAll", data=gmo_coeff)
kbas = gmo_coeff.shape[0]
abas = gmo_coeff.shape[1] * 2
b = numpy.zeros((kbas, abas))
b[:, ::2] = gmo_coeff.copy()
b[:, 1::2] = gmo_coeff.copy()
# INT1e:
h = self.mf.get_hcore()
hmo = reduce(numpy.dot, (b.T, h, b))
hmo[::2, 1::2] = hmo[1::2, ::2] = 0.
# INT2e:
from pyscf import ao2mo
nb = abas
eri = ao2mo.general(self.mol, (b, b, b, b),
compact=0).reshape(nb, nb, nb, nb)
#eri = ao2mo.incore.general(self.mf._eri,(b,b,b,b),compact=0).reshape(nb,nb,nb,nb)
eri[::2, 1::2] = eri[1::2, ::2] = eri[:, :, ::2,
1::2] = eri[:, :, 1::2, ::2] = 0.
# <ij|kl>=[ik|jl]
eri = eri.transpose(0, 2, 1, 3)
# Antisymmetrize V[pqrs]=-1/2*<pq||rs> - In MPO construnction, only r<s part is used.
eri = -0.5 * (eri - eri.transpose(0, 1, 3, 2))
#------------------ Frozen Core ------------------
# fpq = hpq + <pr||qr>nr
sfrozen = 2 * self.nfrozen
nr = numpy.zeros(abas)
nr[:sfrozen] = 1.0
# Ecore = hcc + 1/2*<pq||pq>npnq
ecore = numpy.einsum('pp,p',hmo,nr)\
- numpy.einsum('pqpq,p,q',eri,nr,nr)
print 'E[core]=', ecore
cal.attrs["ecor"] = ecore
fpq = hmo - 2.0 * numpy.einsum('prqr,r->pq', eri, nr)
orbrg = range(sfrozen, abas)
hmo = fpq[numpy.ix_(orbrg, orbrg)].copy()
eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy()
#------------------ Frozen Core ------------------
# DUMP modified Integrals
e1 = cal.attrs["escf"]
ioccun = map(lambda x: x[0], numpy.argwhere(occun > 1.e-4))
#print 'ioccun=',ioccun
e2 = numpy.einsum('ii',hmo[numpy.ix_(ioccun,ioccun)])\
- numpy.einsum('ijij',eri[numpy.ix_(ioccun,ioccun,ioccun,ioccun)])
ediff = abs(e1 - e2 - ecore)
print 'E[pyscf]=', e1
print 'E[elec] =', e2, ' E[elec]+E[core]=', e2 + ecore
print 'E[diff] =', ediff
#=====================================
# Complex case with SOC [ZL@20161014]
#=====================================
# Construct hSO
hSO = numpy.zeros((sbas, sbas),
dtype=numpy.complex_) # alpha,beta-ordering
for iatom in range(self.mol.natm):
zA = self.mol.atom_charge(iatom)
xyz = self.mol.atom_coord(iatom)
self.mol.set_rinv_orig(xyz)
soxyz = zA * self.mol.intor('cint1e_prinvxp_sph', 3)
# transform to MO
for ic in range(3):
soxyz[ic] = reduce(numpy.dot,
(gmo_coeff.T.conj(), soxyz[ic], gmo_coeff))
# [ hZ hX-i*hY ]
# i*sigma*lA/r3 = i*[ ]
# [ hX+i*hY -hZ]
hSO[0::2, 0::2] += soxyz[2]
hSO[1::2, 1::2] += -soxyz[2]
hSO[0::2, 1::2] += soxyz[0] - 1.j * soxyz[1]
hSO[1::2, 0::2] += soxyz[0] + 1.j * soxyz[1]
if iatom == 0: print '\nCheck antisymmetricity:'
print 'iatom=',iatom,\
numpy.linalg.norm(soxyz[0]+soxyz[0].T),\
numpy.linalg.norm(soxyz[1]+soxyz[1].T),\
numpy.linalg.norm(soxyz[2]+soxyz[2].T)
# Check Hermiticity
hSO = 1.j * hSO
diff = numpy.linalg.norm(hSO - hSO.T.conj())
print 'Hermicity of Hso=', diff
assert diff < 1.e-10
fsc = 0.25 * (1.0 / self.mol.light_speed)**2
h1e = numpy.zeros(hmo.shape, dtype=numpy.complex_)
h1e = hmo + fsc * hSO
h2e = numpy.zeros(eri.shape, dtype=numpy.complex_)
h2e = eri + 0.j
int1e = f.create_dataset("int1e", data=h1e, compression=flter)
int2e = f.create_dataset("int2e", data=h2e, compression=flter)
#=====================================
#====================================================================
# Spatial integrals
#====================================================================
b = gmo_coeff
# INT1e:
h = self.mf.get_hcore()
hmo = reduce(numpy.dot, (b.T, h, b))
# INT2e:
from pyscf import ao2mo
nb = abas / 2
eri = ao2mo.general(self.mol, (b, b, b, b),
compact=0).reshape(nb, nb, nb, nb)
# Frozen core case:
# fpq = hpq + [pq|rr]*nr - 0.5*[pr|rq]*nr
nr = numpy.zeros(nb)
nr[:self.nfrozen] = 2.0
Fpq = hmo + numpy.einsum('pqrr,r->pq',eri,nr)\
- 0.5*numpy.einsum('prrq,r->pq',eri,nr)
#print numpy.linalg.norm(fpq[::2,::2] - Fpq)
#print numpy.linalg.norm(fpq[1::2,1::2] - Fpq)
#print numpy.linalg.norm(fpq[::2,1::2])
#print numpy.linalg.norm(fpq[1::2,::2])
orbrg = range(self.nfrozen, self.nbas)
hmo = Fpq[numpy.ix_(orbrg, orbrg)].copy()
eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy()
f.create_dataset("int1e_spatial", data=hmo, compression=flter)
f.create_dataset("int2e_spatial", data=eri, compression=flter)
#====================================================================
f.close()
print 'Successfully dump information for HS-DMRG calculations! fname=', fname
self.check(fname)
return 0
def _make_eris_incore(myci, mo_coeff=None):
cput0 = (time.clock(), time.time())
eris = _UCISD_ERIs(myci, mo_coeff)
nocca = eris.nocca
noccb = eris.noccb
nmoa = eris.focka.shape[0]
nmob = eris.fockb.shape[0]
nvira = nmoa - nocca
nvirb = nmob - noccb
moa, mob = eris.mo_coeff
eri_aa = ao2mo.restore(1, ao2mo.full(myci._scf._eri, moa), nmoa)
eris.oooo = eri_aa[:nocca, :nocca, :nocca, :nocca].copy()
eris.ooov = eri_aa[:nocca, :nocca, :nocca, nocca:].copy()
eris.vooo = eri_aa[nocca:, :nocca, :nocca, :nocca].copy()
eris.oovo = eri_aa[:nocca, :nocca, nocca:, :nocca].copy()
eris.voov = eri_aa[nocca:, :nocca, :nocca, nocca:].copy()
eris.vvoo = eri_aa[nocca:, nocca:, :nocca, :nocca].copy()
eris.oovv = eri_aa[:nocca, :nocca, nocca:, nocca:].copy()
eris.vovo = eri_aa[nocca:, :nocca, nocca:, :nocca].copy()
eris.vovv = eri_aa[nocca:, :nocca, nocca:, nocca:].copy()
#vovv = eri_aa[nocca:,:nocca,nocca:,nocca:].reshape(-1,nvira,nvira)
#eris.vovv = lib.pack_tril(vovv).reshape(nvira,nocca,nvira*(nvira+1)//2)
eris.vvvv = ao2mo.restore(4, eri_aa[nocca:, nocca:, nocca:, nocca:].copy(),
nvira)
vovv = eri_aa = None
eri_bb = ao2mo.restore(1, ao2mo.full(myci._scf._eri, mob), nmob)
eris.OOOO = eri_bb[:noccb, :noccb, :noccb, :noccb].copy()
eris.OOOV = eri_bb[:noccb, :noccb, :noccb, noccb:].copy()
eris.VOOO = eri_bb[noccb:, :noccb, :noccb, :noccb].copy()
eris.OOVO = eri_bb[:noccb, :noccb, noccb:, :noccb].copy()
eris.VOOV = eri_bb[noccb:, :noccb, :noccb, noccb:].copy()
eris.VVOO = eri_bb[noccb:, noccb:, :noccb, :noccb].copy()
eris.OOVV = eri_bb[:noccb, :noccb, noccb:, noccb:].copy()
eris.VOVO = eri_bb[noccb:, :noccb, noccb:, :noccb].copy()
eris.VOVV = eri_bb[noccb:, :noccb, noccb:, noccb:].copy()
#VOVV = eri_bb[noccb:,:noccb,noccb:,noccb:].reshape(-1,nvirb,nvirb)
#eris.VOVV = lib.pack_tril(VOVV).reshape(nvirb,noccb,nvirb*(nvirb+1)//2)
eris.VVVV = ao2mo.restore(4, eri_bb[noccb:, noccb:, noccb:, noccb:].copy(),
nvirb)
VOVV = eri_bb = None
eri_ab = ao2mo.general(myci._scf._eri, (moa, moa, mob, mob), compact=False)
eri_ab = eri_ab.reshape(nmoa, nmoa, nmob, nmob)
eris.ooOO = eri_ab[:nocca, :nocca, :noccb, :noccb].copy()
eris.ooOV = eri_ab[:nocca, :nocca, :noccb, noccb:].copy()
eris.voOO = eri_ab[nocca:, :nocca, :noccb, :noccb].copy()
eris.ooVO = eri_ab[:nocca, :nocca, noccb:, :noccb].copy()
eris.voOV = eri_ab[nocca:, :nocca, :noccb, noccb:].copy()
eris.ooVV = eri_ab[:nocca, :nocca, noccb:, noccb:].copy()
eris.vvOO = eri_ab[nocca:, nocca:, :noccb, :noccb].copy()
eris.voVO = eri_ab[nocca:, :nocca, noccb:, :noccb].copy()
eris.voVV = eri_ab[nocca:, :nocca, noccb:, noccb:].copy()
#voVV = eri_ab[nocca:,:nocca,noccb:,noccb:].reshape(nocca*nvira,nvirb,nvirb)
#eris.voVV = lib.pack_tril(voVV).reshape(nvira,nocca,nvirb*(nvirb+1)//2)
voVV = None
vvVV = eri_ab[nocca:, nocca:, noccb:, noccb:].reshape(nvira**2, nvirb**2)
idxa = numpy.tril_indices(nvira)
idxb = numpy.tril_indices(nvirb)
eris.vvVV = lib.take_2d(vvVV, idxa[0] * nvira + idxa[1],
idxb[0] * nvirb + idxb[1])
eri_ba = lib.transpose(eri_ab.reshape(nmoa**2, nmob**2))
eri_ba = eri_ba.reshape(nmob, nmob, nmoa, nmoa)
eris.OOoo = eri_ba[:noccb, :noccb, :nocca, :nocca].copy()
eris.OOov = eri_ba[:noccb, :noccb, :nocca, nocca:].copy()
eris.VOoo = eri_ba[noccb:, :noccb, :nocca, :nocca].copy()
eris.OOvo = eri_ba[:noccb, :noccb, nocca:, :nocca].copy()
eris.VOov = eri_ba[noccb:, :noccb, :nocca, nocca:].copy()
eris.VVoo = eri_ba[noccb:, noccb:, :nocca, :nocca].copy()
eris.VOvo = eri_ba[noccb:, :noccb, nocca:, :nocca].copy()
eris.VOvv = eri_ba[noccb:, :noccb, nocca:, nocca:].copy()
#VOvv = eri_ba[noccb:,:noccb,nocca:,nocca:].reshape(noccb*nvirb,nvira,nvira)
#eris.VOvv = lib.pack_tril(VOvv).reshape(nvirb,noccb,nvira*(nvira+1)//2)
VOvv = None
eris.VVvv = eri_ba[noccb:, noccb:, nocca:, nocca:].copy()
return eris
def _make_eris_incore(mycc, mo_coeff=None, ao2mofn=None):
cput0 = (time.clock(), time.time())
eris = _ChemistsERIs()
eris._common_init_(mycc, mo_coeff)
nocca, noccb = mycc.nocc
nmoa, nmob = mycc.nmo
nvira, nvirb = nmoa-nocca, nmob-noccb
moa = eris.mo_coeff[0]
mob = eris.mo_coeff[1]
nmoa = moa.shape[1]
nmob = mob.shape[1]
if callable(ao2mofn):
eri_aa = ao2mofn(moa).reshape([nmoa]*4)
eri_bb = ao2mofn(mob).reshape([nmob]*4)
eri_ab = ao2mofn((moa,moa,mob,mob))
else:
eri_aa = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, moa), nmoa)
eri_bb = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, mob), nmob)
eri_ab = ao2mo.general(mycc._scf._eri, (moa,moa,mob,mob), compact=False)
eri_ba = eri_ab.reshape(nmoa,nmoa,nmob,nmob).transpose(2,3,0,1)
eri_aa = eri_aa.reshape(nmoa,nmoa,nmoa,nmoa)
eri_ab = eri_ab.reshape(nmoa,nmoa,nmob,nmob)
eri_ba = eri_ba.reshape(nmob,nmob,nmoa,nmoa)
eri_bb = eri_bb.reshape(nmob,nmob,nmob,nmob)
eris.oooo = eri_aa[:nocca,:nocca,:nocca,:nocca].copy()
eris.ovoo = eri_aa[:nocca,nocca:,:nocca,:nocca].copy()
eris.ovov = eri_aa[:nocca,nocca:,:nocca,nocca:].copy()
eris.oovv = eri_aa[:nocca,:nocca,nocca:,nocca:].copy()
eris.ovvo = eri_aa[:nocca,nocca:,nocca:,:nocca].copy()
eris.ovvv = eri_aa[:nocca,nocca:,nocca:,nocca:].copy()
eris.vvvv = eri_aa[nocca:,nocca:,nocca:,nocca:].copy()
eris.OOOO = eri_bb[:noccb,:noccb,:noccb,:noccb].copy()
eris.OVOO = eri_bb[:noccb,noccb:,:noccb,:noccb].copy()
eris.OVOV = eri_bb[:noccb,noccb:,:noccb,noccb:].copy()
eris.OOVV = eri_bb[:noccb,:noccb,noccb:,noccb:].copy()
eris.OVVO = eri_bb[:noccb,noccb:,noccb:,:noccb].copy()
eris.OVVV = eri_bb[:noccb,noccb:,noccb:,noccb:].copy()
eris.VVVV = eri_bb[noccb:,noccb:,noccb:,noccb:].copy()
eris.ooOO = eri_ab[:nocca,:nocca,:noccb,:noccb].copy()
eris.ovOO = eri_ab[:nocca,nocca:,:noccb,:noccb].copy()
eris.ovOV = eri_ab[:nocca,nocca:,:noccb,noccb:].copy()
eris.ooVV = eri_ab[:nocca,:nocca,noccb:,noccb:].copy()
eris.ovVO = eri_ab[:nocca,nocca:,noccb:,:noccb].copy()
eris.ovVV = eri_ab[:nocca,nocca:,noccb:,noccb:].copy()
eris.vvVV = eri_ab[nocca:,nocca:,noccb:,noccb:].copy()
#eris.OOoo = eri_ba[:noccb,:noccb,:nocca,:nocca].copy()
eris.OVoo = eri_ba[:noccb,noccb:,:nocca,:nocca].copy()
#eris.OVov = eri_ba[:noccb,noccb:,:nocca,nocca:].copy()
eris.OOvv = eri_ba[:noccb,:noccb,nocca:,nocca:].copy()
eris.OVvo = eri_ba[:noccb,noccb:,nocca:,:nocca].copy()
eris.OVvv = eri_ba[:noccb,noccb:,nocca:,nocca:].copy()
#eris.VVvv = eri_ba[noccb:,noccb:,nocca:,nocca:].copy()
if not callable(ao2mofn):
ovvv = eris.ovvv.reshape(nocca*nvira,nvira,nvira)
eris.ovvv = lib.pack_tril(ovvv).reshape(nocca,nvira,nvira*(nvira+1)//2)
eris.vvvv = ao2mo.restore(4, eris.vvvv, nvira)
OVVV = eris.OVVV.reshape(noccb*nvirb,nvirb,nvirb)
eris.OVVV = lib.pack_tril(OVVV).reshape(noccb,nvirb,nvirb*(nvirb+1)//2)
eris.VVVV = ao2mo.restore(4, eris.VVVV, nvirb)
ovVV = eris.ovVV.reshape(nocca*nvira,nvirb,nvirb)
eris.ovVV = lib.pack_tril(ovVV).reshape(nocca,nvira,nvirb*(nvirb+1)//2)
vvVV = eris.vvVV.reshape(nvira**2,nvirb**2)
idxa = np.tril_indices(nvira)
idxb = np.tril_indices(nvirb)
eris.vvVV = lib.take_2d(vvVV, idxa[0]*nvira+idxa[1], idxb[0]*nvirb+idxb[1])
OVvv = eris.OVvv.reshape(noccb*nvirb,nvira,nvira)
eris.OVvv = lib.pack_tril(OVvv).reshape(noccb,nvirb,nvira*(nvira+1)//2)
return eris
def write_chk(mc, root, chkfile):
t0 = (time.clock(), time.time())
fh5 = h5py.File(chkfile, 'w')
if mc.fcisolver.nroots > 1:
mc.mo_coeff, _, mc.mo_energy = mc.canonicalize(mc.mo_coeff, ci=root)
fh5['mol'] = mc.mol.dumps()
fh5['mc/mo'] = mc.mo_coeff
fh5['mc/ncore'] = mc.ncore
fh5['mc/ncas'] = mc.ncas
nvirt = mc.mo_coeff.shape[1] - mc.ncas - mc.ncore
fh5['mc/nvirt'] = nvirt
fh5['mc/nelecas'] = mc.nelecas
fh5['mc/root'] = root
fh5['mc/orbe'] = mc.mo_energy
fh5['mc/nroots'] = mc.fcisolver.nroots
fh5['mc/wfnsym'] = mc.fcisolver.wfnsym
if hasattr(mc, 'orbsym'):
fh5.create_dataset('mc/orbsym', data=mc.orbsym)
else:
fh5.create_dataset('mc/orbsym', data=[])
mo_core = mc.mo_coeff[:, :mc.ncore]
mo_cas = mc.mo_coeff[:, mc.ncore:mc.ncore + mc.ncas]
mo_virt = mc.mo_coeff[:, mc.ncore + mc.ncas:]
core_dm = numpy.dot(mo_core, mo_core.T) * 2
core_vhf = mc.get_veff(mc.mol, core_dm)
h1e_Sr = reduce(numpy.dot, (mo_virt.T, mc.get_hcore() + core_vhf, mo_cas))
h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore() + core_vhf, mo_core))
fh5['h1e_Si'] = h1e_Si
fh5['h1e_Sr'] = h1e_Sr
h1e, e_core = mc.h1e_for_cas()
fh5['h1e'] = h1e
fh5['e_core'] = e_core
if mc._scf._eri is None:
h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff, mo_cas, mo_cas, mo_cas),
compact=False)
h2e_t = h2e_t.reshape(-1, mc.ncas, mc.ncas, mc.ncas)
h2e = h2e_t[mc.ncore:mc.ncore + mc.ncas, :, :, :]
fh5['h2e'] = h2e
h2e_Sr = h2e_t[mc.ncore + mc.ncas:, :, :, :]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si = numpy.transpose(h2e_t[:mc.ncore, :, :, :], (1, 0, 2, 3))
fh5['h2e_Si'] = h2e_Si
else:
eri = mc._scf._eri
h2e_t = ao2mo.general(eri, [mc.mo_coeff, mo_cas, mo_cas, mo_cas],
compact=False)
h2e_t = h2e_t.reshape(-1, mc.ncas, mc.ncas, mc.ncas)
h2e = h2e_t[mc.ncore:mc.ncore + mc.ncas, :, :, :]
fh5['h2e'] = h2e
h2e_Sr = h2e_t[mc.ncore + mc.ncas:, :, :, :]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si = numpy.transpose(h2e_t[:mc.ncore, :, :, :], (1, 0, 2, 3))
fh5['h2e_Si'] = h2e_Si
fh5.close()
logger.timer(mc, 'Write MPS NEVPT integral', *t0)
ev = energy[ncore + nocc:]
e_denom = 1.0 / (eo.reshape(-1, 1, 1, 1) - ev.reshape(-1, 1, 1) +
eo.reshape(-1, 1) - ev)
eri_ao = ao2mo.restore(1, mf._eri, nao0)
eri_ao = eri_ao.reshape((nao0, nao0, nao0, nao0))
def spin_block(eri):
identity = numpy.eye(2)
eri = numpy.kron(identity, eri)
return numpy.kron(identity, eri.T)
eri_ao = spin_block(eri_ao)
eri_mo = ao2mo.general(eri_ao, (co, cv, co, cv), compact=False)
eri_mo = eri_mo.reshape(nocc, nvir, nocc, nvir)
# Antisymmetrize:
# <pr||qs> = <pr|qs> - <ps|qr>
#eri_mo = eri_mo - eri_mo.transpose(0,3,2,1)
#t2 = numpy.zeros((nocc,nvir,nocc,nvir))
#t2 = einsum('iajb,iajb->iajb', eri_mo, e_denom)
#e_mp2 = 0.25*numpy.einsum('iajb,iajb->', eri_mo, t2, optimize=True)
#lib.logger.info(mf,"!*** E(MP2): %12.8f" % e_mp2)
#lib.logger.info(mf,"!**** E(HF+MP2): %12.8f" % (e_mp2+ehf))
t2 = numpy.zeros((nocc, nvir, nocc, nvir))
t2 = numpy.einsum('iajb,iajb->iajb', \
eri_mo - eri_mo.transpose(0,3,2,1), e_denom, optimize=True)
e_mp2 = 0.5 * numpy.einsum('iajb,iajb->', eri_mo, t2, optimize=True)
mf = x2c.RHF(mol)
dm = mf.get_init_guess() + 0.1j
mf.kernel(dm)
ncore = 2
eri_ao = mol.intor('int2e_spinor')
pt = MP2(mf)
pt.frozen = ncore
pt.kernel()
rdm1 = pt.make_rdm1()
rdm2 = pt.make_rdm2()
c = mf.mo_coeff
nmo = mf.mo_coeff.shape[1]
eri_mo = ao2mo.general(eri_ao, (c, c, c, c)).reshape(nmo, nmo, nmo, nmo)
hcore = mf.get_hcore()
h1 = reduce(numpy.dot, (mf.mo_coeff.T.conj(), hcore, mf.mo_coeff))
e = numpy.einsum('ij,ji', h1, rdm1)
e += numpy.einsum('ijkl,ijkl', eri_mo, rdm2) * 0.5
e += mol.energy_nuc()
print("!*** E(X2CMP2) with RDM: %s" % e)
mo_coeff, mo_energy, mo_occ = pt.fno()
pt = MP2(mf, mo_coeff=mo_coeff, mo_occ=mo_occ)
pt.frozen = ncore
pt.kernel(mo_energy=mo_energy)
rdm1 = pt.make_rdm1()
rdm2 = pt.make_rdm2()
c = mo_coeff
mf = scf.RHF(mol)
mf.conv_tol = 1e-8
e = mf.scf()
print('E = %.15g, ref -230.776765415' % e)
# Given four MOs, compute the MO-integrals
import tempfile
import numpy
import h5py
from pyscf import ao2mo
eritmp = tempfile.NamedTemporaryFile()
nocc = mol.nelectron // 2
nvir = len(mf.mo_energy) - nocc
co = mf.mo_coeff[:,:nocc]
cv = mf.mo_coeff[:,nocc:]
ao2mo.general(mol, (co,cv,co,cv), eritmp.name, max_memory=500,
dataname='mp2_bz', verbose=5)
eia = mf.mo_energy[:nocc,None] - mf.mo_energy[None,nocc:]
f = h5py.File(eritmp.name, 'r')
eri = f['mp2_bz']
emp2 = 0
for i in range(nocc):
dajb = (eia[i].reshape(-1,1) + eia.reshape(1,-1)).ravel()
gi = numpy.array(eri[i*nvir:(i+1)*nvir]).reshape(nvir,nocc,nvir)
t2 = (gi.ravel()/dajb).reshape(nvir,nocc,nvir)
theta = gi.ravel()*2 - gi.transpose(2,1,0).ravel()
emp2 += numpy.dot(t2.ravel(), theta)
print('E_MP2 = %.15g, ref = -1.0435476768' % emp2)
f.close()
ehf = mf.kernel(dm)
ncore = 1
nao, nmo = mf.mo_coeff.shape
nocc = mol.nelectron // 2 - ncore
nvir = nmo - nocc - ncore
mo_core = mf.mo_coeff[:, :ncore]
mo_occ = mf.mo_coeff[:, ncore:ncore + nocc]
mo_vir = mf.mo_coeff[:, ncore + nocc:]
co = mo_occ
cv = mo_vir
eo = mf.mo_energy[ncore:ncore + nocc]
ev = mf.mo_energy[ncore + nocc:]
lib.logger.info(mf, "* Core orbitals: %d" % ncore)
lib.logger.info(mf, "* Virtual orbitals: %d" % (len(ev)))
eri_mo = ao2mo.general(mf._eri, (co, cv, co, cv), compact=False)
eri_mo = eri_mo.reshape(nocc, nvir, nocc, nvir)
e_denom = 1.0 / (eo.reshape(-1, 1, 1, 1) - ev.reshape(-1, 1, 1) +
eo.reshape(-1, 1) - ev)
t2 = numpy.zeros((nocc, nvir, nocc, nvir))
# erf(omega * r12) / r12
omega = 0.5
mol.set_range_coulomb(omega)
erf_r12 = mol.intor('cint2e_sph')
erf_r12 = ao2mo.restore(8, erf_r12, nao)
eri_mo_erfr12 = ao2mo.general(erf_r12, (co, cv, co, cv), compact=False)
eri_mo_erfr12 = eri_mo_erfr12.reshape(nocc, nvir, nocc, nvir)
erfc_r12 = eri_mo - eri_mo_erfr12
#erfc_r12 = 1.0 - eri_mo_erfr12
def transform_integrals_outcore(myadc):
cput0 = (logger.process_clock(), logger.perf_counter())
log = logger.Logger(myadc.stdout, myadc.verbose)
mo_a = myadc.mo_coeff[0]
mo_b = myadc.mo_coeff[1]
nmo_a = mo_a.shape[1]
nmo_b = mo_b.shape[1]
occ_a = myadc.mo_coeff[0][:, :myadc._nocc[0]]
occ_b = myadc.mo_coeff[1][:, :myadc._nocc[1]]
vir_a = myadc.mo_coeff[0][:, myadc._nocc[0]:]
vir_b = myadc.mo_coeff[1][:, myadc._nocc[1]:]
nocc_a = occ_a.shape[1]
nocc_b = occ_b.shape[1]
nvir_a = vir_a.shape[1]
nvir_b = vir_b.shape[1]
nvpair_a = nvir_a * (nvir_a + 1) // 2
nvpair_b = nvir_b * (nvir_b + 1) // 2
eris = lambda: None
eris.feri1 = lib.H5TmpFile()
eris.oooo = eris.feri1.create_dataset('oooo',
(nocc_a, nocc_a, nocc_a, nocc_a),
'f8')
eris.oovv = eris.feri1.create_dataset('oovv',
(nocc_a, nocc_a, nvir_a, nvir_a),
'f8',
chunks=(nocc_a, nocc_a, 1, nvir_a))
eris.ovoo = eris.feri1.create_dataset('ovoo',
(nocc_a, nvir_a, nocc_a, nocc_a),
'f8',
chunks=(nocc_a, 1, nocc_a, nocc_a))
eris.ovvo = eris.feri1.create_dataset('ovvo',
(nocc_a, nvir_a, nvir_a, nocc_a),
'f8',
chunks=(nocc_a, 1, nvir_a, nocc_a))
eris.ovvv = eris.feri1.create_dataset('ovvv', (nocc_a, nvir_a, nvpair_a),
'f8')
eris.OOOO = eris.feri1.create_dataset('OOOO',
(nocc_b, nocc_b, nocc_b, nocc_b),
'f8')
eris.OOVV = eris.feri1.create_dataset('OOVV',
(nocc_b, nocc_b, nvir_b, nvir_b),
'f8',
chunks=(nocc_b, nocc_b, 1, nvir_b))
eris.OVOO = eris.feri1.create_dataset('OVOO',
(nocc_b, nvir_b, nocc_b, nocc_b),
'f8',
chunks=(nocc_b, 1, nocc_b, nocc_b))
eris.OVVO = eris.feri1.create_dataset('OVVO',
(nocc_b, nvir_b, nvir_b, nocc_b),
'f8',
chunks=(nocc_b, 1, nvir_b, nocc_b))
eris.OVVV = eris.feri1.create_dataset('OVVV', (nocc_b, nvir_b, nvpair_b),
'f8')
eris.ooOO = eris.feri1.create_dataset('ooOO',
(nocc_a, nocc_a, nocc_b, nocc_b),
'f8')
eris.ooVV = eris.feri1.create_dataset('ooVV',
(nocc_a, nocc_a, nvir_b, nvir_b),
'f8',
chunks=(nocc_a, nocc_a, 1, nvir_b))
eris.ovOO = eris.feri1.create_dataset('ovOO',
(nocc_a, nvir_a, nocc_b, nocc_b),
'f8',
chunks=(nocc_a, 1, nocc_b, nocc_b))
eris.ovVO = eris.feri1.create_dataset('ovVO',
(nocc_a, nvir_a, nvir_b, nocc_b),
'f8',
chunks=(nocc_a, 1, nvir_b, nocc_b))
eris.ovVV = eris.feri1.create_dataset('ovVV', (nocc_a, nvir_a, nvpair_b),
'f8')
eris.OOvv = eris.feri1.create_dataset('OOvv',
(nocc_b, nocc_b, nvir_a, nvir_a),
'f8',
chunks=(nocc_b, nocc_b, 1, nvir_a))
eris.OVoo = eris.feri1.create_dataset('OVoo',
(nocc_b, nvir_b, nocc_a, nocc_a),
'f8',
chunks=(nocc_b, 1, nocc_a, nocc_a))
eris.OVvo = eris.feri1.create_dataset('OVvo',
(nocc_b, nvir_b, nvir_a, nocc_a),
'f8',
chunks=(nocc_b, 1, nvir_a, nocc_a))
eris.OVvv = eris.feri1.create_dataset('OVvv', (nocc_b, nvir_b, nvpair_a),
'f8')
cput1 = logger.process_clock(), logger.perf_counter()
mol = myadc.mol
tmpf = lib.H5TmpFile()
if nocc_a > 0:
ao2mo.general(mol, (occ_a, mo_a, mo_a, mo_a), tmpf, 'aa')
buf = np.empty((nmo_a, nmo_a, nmo_a))
for i in range(nocc_a):
lib.unpack_tril(tmpf['aa'][i * nmo_a:(i + 1) * nmo_a], out=buf)
eris.oooo[i] = buf[:nocc_a, :nocc_a, :nocc_a]
eris.ovoo[i] = buf[nocc_a:, :nocc_a, :nocc_a]
eris.oovv[i] = buf[:nocc_a, nocc_a:, nocc_a:]
eris.ovvo[i] = buf[nocc_a:, nocc_a:, :nocc_a]
eris.ovvv[i] = lib.pack_tril(buf[nocc_a:, nocc_a:, nocc_a:])
del (tmpf['aa'])
if nocc_b > 0:
buf = np.empty((nmo_b, nmo_b, nmo_b))
ao2mo.general(mol, (occ_b, mo_b, mo_b, mo_b), tmpf, 'bb')
for i in range(nocc_b):
lib.unpack_tril(tmpf['bb'][i * nmo_b:(i + 1) * nmo_b], out=buf)
eris.OOOO[i] = buf[:nocc_b, :nocc_b, :nocc_b]
eris.OVOO[i] = buf[nocc_b:, :nocc_b, :nocc_b]
eris.OOVV[i] = buf[:nocc_b, nocc_b:, nocc_b:]
eris.OVVO[i] = buf[nocc_b:, nocc_b:, :nocc_b]
eris.OVVV[i] = lib.pack_tril(buf[nocc_b:, nocc_b:, nocc_b:])
del (tmpf['bb'])
if nocc_a > 0:
buf = np.empty((nmo_a, nmo_b, nmo_b))
ao2mo.general(mol, (occ_a, mo_a, mo_b, mo_b), tmpf, 'ab')
for i in range(nocc_a):
lib.unpack_tril(tmpf['ab'][i * nmo_a:(i + 1) * nmo_a], out=buf)
eris.ooOO[i] = buf[:nocc_a, :nocc_b, :nocc_b]
eris.ovOO[i] = buf[nocc_a:, :nocc_b, :nocc_b]
eris.ooVV[i] = buf[:nocc_a, nocc_b:, nocc_b:]
eris.ovVO[i] = buf[nocc_a:, nocc_b:, :nocc_b]
eris.ovVV[i] = lib.pack_tril(buf[nocc_a:, nocc_b:, nocc_b:])
del (tmpf['ab'])
if nocc_b > 0:
buf = np.empty((nmo_b, nmo_a, nmo_a))
ao2mo.general(mol, (occ_b, mo_b, mo_a, mo_a), tmpf, 'ba')
for i in range(nocc_b):
lib.unpack_tril(tmpf['ba'][i * nmo_b:(i + 1) * nmo_b], out=buf)
eris.OVoo[i] = buf[nocc_b:, :nocc_a, :nocc_a]
eris.OOvv[i] = buf[:nocc_b, nocc_a:, nocc_a:]
eris.OVvo[i] = buf[nocc_b:, nocc_a:, :nocc_a]
eris.OVvv[i] = lib.pack_tril(buf[nocc_b:, nocc_a:, nocc_a:])
del (tmpf['ba'])
buf = None
cput1 = logger.timer_debug1(myadc, 'transforming oopq, ovpq', *cput1)
############### forming eris_vvvv ########################################
if (myadc.method == "adc(2)-x" or myadc.method == "adc(3)"):
cput2 = logger.process_clock(), logger.perf_counter()
ind_vv_g = np.tril_indices(nvir_a, k=-1)
ind_VV_g = np.tril_indices(nvir_b, k=-1)
eris.vvvv_p = []
eris.VVVV_p = []
eris.vVvV_p = []
eris.VvVv_p = []
avail_mem = (myadc.max_memory - lib.current_memory()[0]) * 0.25
vvv_mem = (nvir_a**3) * 8 / 1e6
chnk_size = int(avail_mem / vvv_mem)
if chnk_size <= 0:
chnk_size = 1
for p in range(0, vir_a.shape[1], chnk_size):
if chnk_size < vir_a.shape[1]:
orb_slice = vir_a[:, p:p + chnk_size]
else:
orb_slice = vir_a[:, p:]
_, tmp = tempfile.mkstemp()
ao2mo.outcore.general(mol, (orb_slice, vir_a, vir_a, vir_a),
tmp,
max_memory=avail_mem,
ioblk_size=100,
compact=False)
vvvv = radc_ao2mo.read_dataset(tmp, 'eri_mo')
del (tmp)
vvvv = vvvv.reshape(orb_slice.shape[1], vir_a.shape[1],
vir_a.shape[1], vir_a.shape[1])
vvvv = np.ascontiguousarray(vvvv.transpose(0, 2, 1, 3))
vvvv -= np.ascontiguousarray(vvvv.transpose(0, 1, 3, 2))
vvvv = vvvv[:, :, ind_vv_g[0], ind_vv_g[1]]
vvvv_p = radc_ao2mo.write_dataset(vvvv)
del vvvv
eris.vvvv_p.append(vvvv_p)
for p in range(0, vir_b.shape[1], chnk_size):
if chnk_size < vir_b.shape[1]:
orb_slice = vir_b[:, p:p + chnk_size]
else:
orb_slice = vir_b[:, p:]
_, tmp = tempfile.mkstemp()
ao2mo.outcore.general(mol, (orb_slice, vir_b, vir_b, vir_b),
tmp,
max_memory=avail_mem,
ioblk_size=100,
compact=False)
VVVV = radc_ao2mo.read_dataset(tmp, 'eri_mo')
del (tmp)
VVVV = VVVV.reshape(orb_slice.shape[1], vir_b.shape[1],
vir_b.shape[1], vir_b.shape[1])
VVVV = np.ascontiguousarray(VVVV.transpose(0, 2, 1, 3))
VVVV -= np.ascontiguousarray(VVVV.transpose(0, 1, 3, 2))
VVVV = VVVV[:, :, ind_VV_g[0], ind_VV_g[1]]
VVVV_p = radc_ao2mo.write_dataset(VVVV)
del VVVV
eris.VVVV_p.append(VVVV_p)
for p in range(0, vir_a.shape[1], chnk_size):
if chnk_size < vir_a.shape[1]:
orb_slice = vir_a[:, p:p + chnk_size]
else:
orb_slice = vir_a[:, p:]
_, tmp = tempfile.mkstemp()
ao2mo.outcore.general(mol, (orb_slice, vir_a, vir_b, vir_b),
tmp,
max_memory=avail_mem,
ioblk_size=100,
compact=False)
vVvV = radc_ao2mo.read_dataset(tmp, 'eri_mo')
del (tmp)
vVvV = vVvV.reshape(orb_slice.shape[1], vir_a.shape[1],
vir_b.shape[1], vir_b.shape[1])
vVvV = np.ascontiguousarray(vVvV.transpose(0, 2, 1, 3))
vVvV = vVvV.reshape(-1, vir_b.shape[1],
vir_a.shape[1] * vir_b.shape[1])
vVvV_p = radc_ao2mo.write_dataset(vVvV)
del vVvV
eris.vVvV_p.append(vVvV_p)
for p in range(0, vir_b.shape[1], chnk_size):
if chnk_size < vir_b.shape[1]:
orb_slice = vir_b[:, p:p + chnk_size]
else:
orb_slice = vir_b[:, p:]
_, tmp = tempfile.mkstemp()
ao2mo.outcore.general(mol, (orb_slice, vir_b, vir_a, vir_a),
tmp,
max_memory=avail_mem,
ioblk_size=100,
compact=False)
VvVv = radc_ao2mo.read_dataset(tmp, 'eri_mo')
del tmp
VvVv = VvVv.reshape(orb_slice.shape[1], vir_b.shape[1],
vir_a.shape[1], vir_a.shape[1])
VvVv = np.ascontiguousarray(VvVv.transpose(0, 2, 1, 3))
VvVv = VvVv.reshape(-1, vir_a.shape[1],
vir_b.shape[1] * vir_a.shape[1])
VvVv_p = radc_ao2mo.write_dataset(VvVv)
del VvVv
eris.VvVv_p.append(VvVv_p)
cput2 = logger.timer_debug1(myadc, 'transforming vvvv', *cput2)
log.timer('ADC outcore integral transformation', *cput0)
return eris
def dump(self, fname='mole.h5'):
# Effective
nbas = self.nbas - self.nfrozen
sbas = nbas * 2
print('\n[iface.dump] (self.nbas,nbas)=', (self.nbas, nbas))
#
# Basic information
#
f = h5py.File(fname, "w")
cal = f.create_dataset("cal", (1, ), dtype='i')
enuc = self.mol.energy_nuc()
nelec = self.nelec - self.nfrozen * 2
cal.attrs["nelec"] = nelec
cal.attrs["sbas"] = sbas
cal.attrs["enuc"] = enuc
cal.attrs[
"escf"] = 0. # Not useful at all: self.mf.energy_elec(self.mf.make_rdm1())[0]
#
# Intergrals
#
flter = 'lzf'
# Local or CMO
if self.iflocal:
self.local()
mo_coeff = self.lmo_coeff.copy()
else:
print('canonical or user defined mo')
mo_coeff = self.mo_coeff[:, self.nfrozen:].copy()
# Reorder
if self.ifreorder:
order = list(self.reorder(mo_coeff))
else:
order = list(range(mo_coeff.shape[1]))
mo_coeff = mo_coeff[:, numpy.array(order)].copy()
self.molden(mo_coeff, fname='mocoeff')
# Dump MO coefficients
f.create_dataset("mo_coeff_spatial", data=mo_coeff)
# Occupation
occun = numpy.zeros(sbas)
for i in range(self.nalpha - self.nfrozen):
occun[2 * i] = 1.0
for i in range(self.nbeta - self.nfrozen):
occun[2 * i + 1] = 1.0
print()
print('initial occun for', len(occun), ' spin orbitals:\n', occun)
sorder = numpy.array([[2 * i, 2 * i + 1] for i in order]).flatten()
occun = occun[sorder].copy()
assert abs(numpy.sum(occun) - nelec) < 1.e-10
print("sorder:", sorder)
print("occun :", occun)
# Symmetry
if self.mol.symmetry and not self.iflocal:
import pyscf.symm
irrep_name = self.mol.irrep_id
orbsym0 = pyscf.symm.label_orb_symm(self.mol, irrep_name,
self.mol.symm_orb, mo_coeff)
print('\nSpatial orbsym:\n', orbsym0)
orbsym = numpy.array([[i, i] for i in orbsym0]).flatten()
else:
orbsym = numpy.array([0] * sbas)
spinsym = numpy.array([[0, 1] for i in range(nbas)]).flatten()
print("orbsym :", orbsym)
print("spinsym:", spinsym)
f.create_dataset("occun", data=occun)
f.create_dataset("orbsym", data=orbsym)
f.create_dataset("spinsym", data=spinsym)
#====================================================================
# Spin orbital integrals
#====================================================================
# Integral transformation
# SPECIAL FORM of MO for TRANS
gmo_coeff = numpy.hstack((self.mo_coeff[:, :self.nfrozen], mo_coeff))
print('gmo_coeff.shape=', gmo_coeff.shape)
f.create_dataset("mo_coeff_spatialAll", data=gmo_coeff)
kbas = gmo_coeff.shape[0]
abas = gmo_coeff.shape[1] * 2
b = numpy.zeros((kbas, abas))
b[:, ::2] = gmo_coeff.copy()
b[:, 1::2] = gmo_coeff.copy()
# INT1e:
h = self.mf.get_hcore()
hmo = reduce(numpy.dot, (b.T, h, b))
hmo[::2, 1::2] = hmo[1::2, ::2] = 0.
# INT2e:
from pyscf import ao2mo
nb = abas
eri = ao2mo.general(self.mol, (b, b, b, b),
compact=0).reshape(nb, nb, nb, nb)
#eri = ao2mo.incore.general(self.mf._eri,(b,b,b,b),compact=0).reshape(nb,nb,nb,nb)
eri[::2, 1::2] = eri[1::2, ::2] = eri[:, :, ::2,
1::2] = eri[:, :, 1::2, ::2] = 0.
# <ij|kl>=[ik|jl]
eri = eri.transpose(0, 2, 1, 3)
# Antisymmetrize V[pqrs]=-1/2*<pq||rs> - In MPO construnction, only r<s part is used.
eri = -0.5 * (eri - eri.transpose(0, 1, 3, 2))
#------------------ Frozen Core ------------------
# fpq = hpq + <pr||qr>nr
sfrozen = 2 * self.nfrozen
nr = numpy.zeros(abas)
nr[:sfrozen] = 1.0
# Ecore = hcc + 1/2*<pq||pq>npnq
ecore = numpy.einsum('pp,p',hmo,nr)\
- numpy.einsum('pqpq,p,q',eri,nr,nr)
print('E[core]=', ecore)
cal.attrs["ecor"] = ecore
fpq = hmo - 2.0 * numpy.einsum('prqr,r->pq', eri, nr)
orbrg = list(range(sfrozen, abas))
hmo = fpq[numpy.ix_(orbrg, orbrg)].copy()
eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy()
#------------------ Frozen Core ------------------
# DUMP modified Integrals
e1 = cal.attrs["escf"]
ioccun = [x[0] for x in numpy.argwhere(occun > 1.e-4)]
#print 'ioccun=',ioccun
e2 = numpy.einsum('ii',hmo[numpy.ix_(ioccun,ioccun)])\
- numpy.einsum('ijij',eri[numpy.ix_(ioccun,ioccun,ioccun,ioccun)])
ediff = abs(e1 - e2 - ecore)
print('E[pyscf]=', e1)
print('E[elec] =', e2, ' E[elec]+E[core]=', e2 + ecore)
print('E[diff] =', ediff)
#assert ediff<1.e-10 # can be different for casscf case
int1e = f.create_dataset("int1e", data=hmo, compression=flter)
int2e = f.create_dataset("int2e", data=eri, compression=flter)
#====================================================================
# Spatial integrals
#====================================================================
b = gmo_coeff
# INT1e:
h = self.mf.get_hcore()
hmo = reduce(numpy.dot, (b.T, h, b))
# INT2e:
from pyscf import ao2mo
nb = abas // 2
eri = ao2mo.general(self.mol, (b, b, b, b),
compact=0).reshape(nb, nb, nb, nb)
# Frozen core case:
# fpq = hpq + [pq|rr]*nr - 0.5*[pr|rq]*nr
nr = numpy.zeros(nb)
nr[:self.nfrozen] = 2.0
Fpq = hmo + numpy.einsum('pqrr,r->pq',eri,nr)\
- 0.5*numpy.einsum('prrq,r->pq',eri,nr)
#print numpy.linalg.norm(fpq[::2,::2] - Fpq)
#print numpy.linalg.norm(fpq[1::2,1::2] - Fpq)
#print numpy.linalg.norm(fpq[::2,1::2])
#print numpy.linalg.norm(fpq[1::2,::2])
orbrg = list(range(self.nfrozen, self.nbas))
hmo = Fpq[numpy.ix_(orbrg, orbrg)].copy()
eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy()
f.create_dataset("int1e_spatial", data=hmo, compression=flter)
f.create_dataset("int2e_spatial", data=eri, compression=flter)
#====================================================================
f.close()
print('Successfully dump information for HS-DMRG calculations! fname=',
fname)
self.check(fname)
return 0
def transform_integrals_incore(myadc):
cput0 = (logger.process_clock(), logger.perf_counter())
log = logger.Logger(myadc.stdout, myadc.verbose)
occ_a = myadc.mo_coeff[0][:, :myadc._nocc[0]]
occ_b = myadc.mo_coeff[1][:, :myadc._nocc[1]]
vir_a = myadc.mo_coeff[0][:, myadc._nocc[0]:]
vir_b = myadc.mo_coeff[1][:, myadc._nocc[1]:]
nocc_a = occ_a.shape[1]
nocc_b = occ_b.shape[1]
nvir_a = vir_a.shape[1]
nvir_b = vir_b.shape[1]
ind_vv_g = np.tril_indices(nvir_a, k=-1)
ind_VV_g = np.tril_indices(nvir_b, k=-1)
eris = lambda: None
# TODO: check if myadc._scf._eri is not None
eris.oooo = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, occ_a, occ_a),
compact=False).reshape(
nocc_a, nocc_a, nocc_a,
nocc_a).copy() # noqa: E501
eris.ovoo = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, occ_a, occ_a),
compact=False).reshape(
nocc_a, nvir_a, nocc_a,
nocc_a).copy() # noqa: E501
eris.ovvo = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_a, occ_a),
compact=False).reshape(
nocc_a, nvir_a, nvir_a,
nocc_a).copy() # noqa: E501
eris.oovv = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, vir_a, vir_a),
compact=False).reshape(
nocc_a, nocc_a, nvir_a,
nvir_a).copy() # noqa: E501
eris.ovvv = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_a, vir_a),
compact=True).reshape(nocc_a, nvir_a,
-1).copy() # noqa: E501
eris.OOOO = ao2mo.general(myadc._scf._eri, (occ_b, occ_b, occ_b, occ_b),
compact=False).reshape(
nocc_b, nocc_b, nocc_b,
nocc_b).copy() # noqa: E501
eris.OVOO = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, occ_b, occ_b),
compact=False).reshape(
nocc_b, nvir_b, nocc_b,
nocc_b).copy() # noqa: E501
eris.OOVV = ao2mo.general(myadc._scf._eri, (occ_b, occ_b, vir_b, vir_b),
compact=False).reshape(
nocc_b, nocc_b, nvir_b,
nvir_b).copy() # noqa: E501
eris.OVVO = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_b, occ_b),
compact=False).reshape(
nocc_b, nvir_b, nvir_b,
nocc_b).copy() # noqa: E501
eris.OVVV = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_b, vir_b),
compact=True).reshape(nocc_b, nvir_b,
-1).copy() # noqa: E501
eris.ooOO = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, occ_b, occ_b),
compact=False).reshape(
nocc_a, nocc_a, nocc_b,
nocc_b).copy() # noqa: E501
eris.ovOO = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, occ_b, occ_b),
compact=False).reshape(
nocc_a, nvir_a, nocc_b,
nocc_b).copy() # noqa: E501
eris.ooVV = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, vir_b, vir_b),
compact=False).reshape(
nocc_a, nocc_a, nvir_b,
nvir_b).copy() # noqa: E501
eris.ovVO = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_b, occ_b),
compact=False).reshape(
nocc_a, nvir_a, nvir_b,
nocc_b).copy() # noqa: E501
eris.ovVV = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_b, vir_b),
compact=True).reshape(nocc_a, nvir_a,
-1).copy() # noqa: E501
eris.OVoo = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, occ_a, occ_a),
compact=False).reshape(
nocc_b, nvir_b, nocc_a,
nocc_a).copy() # noqa: E501
eris.OOvv = ao2mo.general(myadc._scf._eri, (occ_b, occ_b, vir_a, vir_a),
compact=False).reshape(
nocc_b, nocc_b, nvir_a,
nvir_a).copy() # noqa: E501
eris.OVvo = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_a, occ_a),
compact=False).reshape(
nocc_b, nvir_b, nvir_a,
nocc_a).copy() # noqa: E501
eris.OVvv = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_a, vir_a),
compact=True).reshape(nocc_b, nvir_b,
-1).copy() # noqa: E501
if (myadc.method == "adc(2)-x" or myadc.method == "adc(3)"):
eris.vvvv_p = ao2mo.general(myadc._scf._eri,
(vir_a, vir_a, vir_a, vir_a),
compact=False).reshape(
nvir_a, nvir_a, nvir_a, nvir_a)
eris.vvvv_p = eris.vvvv_p.transpose(0, 2, 1, 3)
eris.vvvv_p -= eris.vvvv_p.transpose(0, 1, 3, 2)
eris.vvvv_p = eris.vvvv_p[:, :, ind_vv_g[0], ind_vv_g[1]]
eris.vvvv_p = eris.vvvv_p[ind_vv_g[0], ind_vv_g[1]].copy()
eris.VVVV_p = ao2mo.general(myadc._scf._eri,
(vir_b, vir_b, vir_b, vir_b),
compact=False).reshape(
nvir_b, nvir_b, nvir_b, nvir_b)
eris.VVVV_p = eris.VVVV_p.transpose(0, 2, 1, 3)
eris.VVVV_p -= eris.VVVV_p.transpose(0, 1, 3, 2)
eris.VVVV_p = eris.VVVV_p[:, :, ind_VV_g[0], ind_VV_g[1]]
eris.VVVV_p = eris.VVVV_p[ind_VV_g[0], ind_VV_g[1]].copy()
eris.vVvV_p = ao2mo.general(myadc._scf._eri,
(vir_a, vir_a, vir_b, vir_b),
compact=False).reshape(
nvir_a, nvir_a, nvir_b, nvir_b)
eris.vVvV_p = np.ascontiguousarray(eris.vVvV_p.transpose(0, 2, 1, 3))
eris.vVvV_p = eris.vVvV_p.reshape(nvir_a * nvir_b, nvir_a * nvir_b)
log.timer('ADC incore integral transformation', *cput0)
return eris
t = time.time()
lib.logger.debug(mf, 'Start building spin AO eri')
eri_ao = spin_block(eri_ao)
eri_ao = eri_ao - eri_ao.transpose(0, 3, 2, 1)
hao = numpy.kron(numpy.eye(2), mf.get_hcore())
lib.logger.debug(mf, '.. finished in %.3f seconds.' % (time.time() - t))
o = slice(0, nocc)
v = slice(nocc, None)
x = numpy.newaxis
c = coeff[:, ncore:]
n = c.shape[1]
t = time.time()
lib.logger.debug(mf, 'Start transform AO to MO basis')
eri_mo = ao2mo.general(eri_ao, (c, c, c, c), compact=False)
lib.logger.debug(mf, '.. finished in %.3f seconds.' % (time.time() - t))
eri_mo = eri_mo.reshape(n, n, n, n)
def ao_to_mo(hao, c):
return c.T.dot(hao).dot(c)
hmo = ao_to_mo(hao, c)
# Intialize amplitudes and RDMs
t2 = numpy.zeros((nvir, nocc, nvir, nocc))
opdm_corr = numpy.zeros((nso, nso))
opdm_ref = numpy.zeros((nso, nso))
opdm_ref[o, o] = numpy.identity(nocc)
mol.basis = 'aug-cc-pvdz'
mol.verbose = 4
mol.build()
mf = scf.RHF(mol)
ehf = mf.kernel()
nao, nmo = mf.mo_coeff.shape
ncore = 0
nocc = mol.nelectron / 2 - ncore
nvir = nmo - nocc - ncore
c = mf.mo_coeff[:, ncore:ncore + nocc + nvir]
eo = mf.mo_energy[ncore:ncore + nocc]
ev = mf.mo_energy[ncore + nocc:]
eri_mo = ao2mo.general(mf._eri, (c, c, c, c), compact=False)
eri_mo = eri_mo.reshape(nocc + nvir, nocc + nvir, nocc + nvir, nocc + nvir)
epsilon = 1 / (eo.reshape(-1, 1, 1, 1) + eo.reshape(-1, 1, 1) -
ev.reshape(-1, 1) - ev)
o = slice(0, nocc)
v = slice(nocc, None)
eri_mo = eri_mo.swapaxes(1, 2)
t2 = numpy.zeros((nocc, nvir, nocc, nvir))
t2 = 2.0 * numpy.einsum('rsab,abrs->abrs', eri_mo[v, v, o, o], epsilon)
t2 -= numpy.einsum('rsba,abrs->abrs', eri_mo[v, v, o, o], epsilon)
t2 = t2.swapaxes(1, 2)
e_mp2 = numpy.einsum('iajb,iajb->', eri_mo[o, o, v, v].swapaxes(1, 2), t2)
lib.logger.info(mf, "!*** E(MP2): %12.8f" % e_mp2)
lib.logger.info(mf, "!**** E(HF+MP2): %12.8f" % (e_mp2 + ehf))
def update_casdm(self, mo, u, fcivec, e_ci, eris):
nmo = mo.shape[1]
rmat = u - numpy.eye(nmo)
#g = hessian_co(self, mo, rmat, fcivec, e_ci, eris)
### hessian_co part start ###
ncas = self.ncas
nelecas = self.nelecas
ncore = self.ncore
nocc = ncore + ncas
uc = u[:,:ncore]
ua = u[:,ncore:nocc].copy()
ra = rmat[:,ncore:nocc].copy()
rc = rmat[:,:ncore]
h1e_mo = reduce(numpy.dot, (mo.T, self.get_hcore(), mo))
ddm = numpy.dot(uc, uc.T) * 2 # ~ dm(1) + dm(2)
ddm[numpy.diag_indices(ncore)] -= 2
if self.ci_update_dep == 4 or self.grad_update_dep == 4:
from pyscf import ao2mo
mo1 = numpy.dot(mo, u)
dm_core0 = numpy.dot(mo[:,:ncore], mo[:,:ncore].T) * 2
dm_core = numpy.dot(mo1[:,:ncore], mo1[:,:ncore].T) * 2
vj, vk = self._scf.get_jk(self.mol, dm_core-dm_core0)
vhf_c =(reduce(numpy.dot, (mo1.T, vj-vk*.5, mo1[:,:nocc]))
+ reduce(numpy.dot, (u.T, eris.vhf_c, u[:,:nocc])))
h1 =(reduce(numpy.dot, (ua.T, h1e_mo, ua)) + vhf_c[ncore:nocc,ncore:nocc])
mo1_cas = mo1[:,ncore:nocc]
if self._scf._eri is None:
paaa = ao2mo.general(self.mol, (mo1,)+(mo1_cas,)*3, compact=False)
eris._paaa = paaa.reshape(nmo,ncas,ncas,ncas)
else:
paaa = ao2mo.general(self._scf._eri, (mo1,)+(mo1_cas,)*3, compact=False)
eris._paaa = paaa.reshape(nmo,ncas,ncas,ncas)
h2 = eris._paaa[ncore:nocc]
vj = vk = paaa = None
elif self.ci_update_dep == 2: # (0) + (1) + part-of-(2)
## missing terms:
#jk =(numpy.dot(numpy.einsum('upqv,qv->up', eris.appc, rc*2), rc)
# - numpy.dot(numpy.einsum('upqv,pv->uq', eris.appc, rc), rc)*.5
# - numpy.dot(numpy.einsum('uvpq,pv->uq', eris.acpp, rc), rc)*.5)
#jk = jk + jk.T
p1aa = numpy.empty((nmo,ncas,ncas**2))
paa1 = numpy.empty((nmo,ncas**2,ncas))
jk = reduce(numpy.dot, (ua.T, eris.vhf_c, ua))
for i in range(nmo):
jbuf = eris.ppaa[i]
kbuf = eris.papa[i]
jk +=(numpy.einsum('quv,q->uv', jbuf, ddm[i])
- numpy.einsum('uqv,q->uv', kbuf, ddm[i]) * .5)
p1aa[i] = pyscf.lib.dot(ua.T, jbuf.reshape(nmo,-1))
paa1[i] = pyscf.lib.dot(kbuf.transpose(0,2,1).reshape(-1,nmo), ra)
h1 = reduce(numpy.dot, (ua.T, h1e_mo, ua)) + jk
aa11 = pyscf.lib.dot(ua.T, p1aa.reshape(nmo,-1)).reshape((ncas,)*4)
aaaa = eris.ppaa[ncore:nocc,ncore:nocc,:,:]
aa11 = aa11 + aa11.transpose(2,3,0,1) - aaaa
a11a = numpy.dot(ra.T, paa1.reshape(nmo,-1)).reshape((ncas,)*4)
a11a = a11a + a11a.transpose(1,0,2,3)
a11a = a11a + a11a.transpose(0,1,3,2)
h2 = aa11 + a11a
jbuf = kbuf = p1aa = paa1 = aaaa = aa11 = a11a = None
else: # jk(0) + jk(1)
ddm[:] = 0
ddm[:,:ncore] = rc * 2
ddm[:ncore] += rc.T * 2
jk = numpy.dot(ra.T, eris.vhf_c[:,ncore:nocc])
jk = jk + jk.T + eris.vhf_c[ncore:nocc,ncore:nocc]
for i in range(nmo):
jk +=(numpy.einsum('quv,q->uv', eris.ppaa[i], ddm[i])
- numpy.einsum('uqv,q->uv', eris.papa[i], ddm[i]) * .5)
h1 = numpy.dot(ra.T, h1e_mo[:,ncore:nocc])
h1 = h1 + h1.T + h1e_mo[ncore:nocc,ncore:nocc] + jk
a1aa = numpy.empty((ncas,ncas,ncas**2))
for i in range(ncas):
jbuf = eris.ppaa[ncore+i]
a1aa[i] = pyscf.lib.dot(ra.T, jbuf.reshape(nmo,-1))
aaaa = eris.ppaa[ncore:nocc,ncore:nocc,:,:]
a1aa = a1aa.reshape((ncas,)*4)
a1aa = a1aa + a1aa.transpose(1,0,2,3)
a1aa = a1aa + a1aa.transpose(2,3,0,1)
h2 = aaaa + a1aa
jbuf = aaaa = a1aa = None
# pure core response
# response of (1/2 dm * vhf * dm) ~ ddm*vhf
# Should I consider core response as a part of CI gradients?
ecore =(numpy.einsum('pq,pq->', h1e_mo, ddm)
+ numpy.einsum('pq,pq->', eris.vhf_c, ddm))
### hessian_co part end ###
ci1, g = self.solve_approx_ci(h1, h2, fcivec, ecore, e_ci)
casdm1, casdm2 = self.fcisolver.make_rdm12(ci1, ncas, nelecas)
return casdm1, casdm2, g, ci1
nocc = nocca + noccb
nvir = nvira + nvirb
lib.logger.info(mf, "* Core orbitals: %d %d" % ncore)
lib.logger.info(mf, "* Virtual orbitals: %d %d" % (nvira, nvirb))
coa = mf.mo_coeff[0][:, ncorea:ncorea + nocca]
cob = mf.mo_coeff[1][:, ncoreb:ncoreb + noccb]
cva = mf.mo_coeff[0][:, ncorea + nocca:]
cvb = mf.mo_coeff[1][:, ncoreb + noccb:]
eoa = mf.mo_energy[0][ncorea:ncorea + nocca]
eob = mf.mo_energy[1][ncoreb:ncoreb + noccb]
eva = mf.mo_energy[0][ncorea + nocca:]
evb = mf.mo_energy[1][ncoreb + noccb:]
# Transform the alpha part
eri = ao2mo.general(mol, (coa, cva, coa, cva))
eri = eri.reshape(nocca, nvira, nocca, nvira)
e_denom = 1.0/(eoa.reshape(-1, 1, 1, 1) - eva.reshape(-1, 1, 1) + \
eoa.reshape(-1, 1) - eva)
rdm2_ss_aa = numpy.zeros((nocca, nvira, nocca, nvira))
rdm2_ss_aa = numpy.einsum('iajb,iajb->iajb', eri, e_denom)
rdm2_ss_aa -= numpy.einsum('ibja,iajb->iajb', eri, e_denom)
echeck_aa = numpy.einsum('iajb,iajb->', eri, rdm2_ss_aa) * 0.5
print('E(MP2 SS AA) is %12.8f' % echeck_aa)
# Transform the beta part
eri = ao2mo.general(mol, (cob, cvb, cob, cvb))
eri = eri.reshape(noccb, nvirb, noccb, nvirb)
e_denom = 1.0/(eob.reshape(-1, 1, 1, 1) - evb.reshape(-1, 1, 1) + \
eob.reshape(-1, 1) - evb)
rdm2_ss_bb = numpy.zeros((noccb, nvirb, noccb, nvirb))
def __init__(self, myci, mo_coeff=None, method='incore'):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(myci.mo_occ.size, dtype=numpy.bool)
if isinstance(myci.frozen, (int, numpy.integer)):
moidx[:myci.frozen] = False
elif len(myci.frozen) > 0:
moidx[numpy.asarray(myci.frozen)] = False
if mo_coeff is None:
self.mo_coeff = mo_coeff = myci.mo_coeff[:, moidx]
else:
self.mo_coeff = mo_coeff = mo_coeff[:, moidx]
dm = myci._scf.make_rdm1(myci.mo_coeff, myci.mo_occ)
fockao = myci._scf.get_hcore() + myci._scf.get_veff(myci.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = myci.nocc
nmo = myci.nmo
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = ccsd._mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
log = logger.Logger(myci.stdout, myci.verbose)
if (method == 'incore' and myci._scf._eri is not None and
(mem_incore + mem_now < myci.max_memory)
or myci.mol.incore_anyway):
eri1 = ao2mo.incore.full(myci._scf._eri, mo_coeff)
#:eri1 = ao2mo.restore(1, eri1, nmo)
#:self.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy()
#:self.ooov = eri1[:nocc,:nocc,:nocc,nocc:].copy()
#:self.vooo = eri1[nocc:,:nocc,:nocc,:nocc].copy()
#:self.voov = eri1[nocc:,:nocc,:nocc,nocc:].copy()
#:self.vvoo = eri1[nocc:,nocc:,:nocc,:nocc].copy()
#:vovv = eri1[nocc:,:nocc,nocc:,nocc:].copy()
#:self.vovv = lib.pack_tril(vovv.reshape(-1,nvir,nvir))
#:self.vvvv = ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
nvir_pair = nvir * (nvir + 1) // 2
self.oooo = numpy.empty((nocc, nocc, nocc, nocc))
self.ooov = numpy.empty((nocc, nocc, nocc, nvir))
self.vooo = numpy.empty((nvir, nocc, nocc, nocc))
self.voov = numpy.empty((nvir, nocc, nocc, nvir))
self.vovv = numpy.empty((nvir, nocc, nvir_pair))
self.vvvv = numpy.empty((nvir_pair, nvir_pair))
ij = 0
outbuf = numpy.empty((nmo, nmo, nmo))
oovv = numpy.empty((nocc, nocc, nvir, nvir))
for i in range(nocc):
buf = lib.unpack_tril(eri1[ij:ij + i + 1], out=outbuf[:i + 1])
for j in range(i + 1):
self.oooo[i, j] = self.oooo[j, i] = buf[j, :nocc, :nocc]
self.ooov[i, j] = self.ooov[j, i] = buf[j, :nocc, nocc:]
oovv[i, j] = oovv[j, i] = buf[j, nocc:, nocc:]
ij += i + 1
self.vvoo = lib.transpose(oovv.reshape(nocc**2, -1)).reshape(
nvir, nvir, nocc, nocc)
oovv = None
ij1 = 0
for i in range(nocc, nmo):
buf = lib.unpack_tril(eri1[ij:ij + i + 1], out=outbuf[:i + 1])
self.vooo[i - nocc] = buf[:nocc, :nocc, :nocc]
self.voov[i - nocc] = buf[:nocc, :nocc, nocc:]
lib.pack_tril(_cp(buf[:nocc, nocc:, nocc:]),
out=self.vovv[i - nocc])
dij = i - nocc + 1
lib.pack_tril(_cp(buf[nocc:i + 1, nocc:, nocc:]),
out=self.vvvv[ij1:ij1 + dij])
ij += i + 1
ij1 += dij
else:
cput1 = time.clock(), time.time()
self.feri1 = lib.H5TmpFile()
orbo = mo_coeff[:, :nocc]
orbv = mo_coeff[:, nocc:]
nvpair = nvir * (nvir + 1) // 2
self.oooo = self.feri1.create_dataset('oooo',
(nocc, nocc, nocc, nocc),
'f8')
self.ooov = self.feri1.create_dataset('ooov',
(nocc, nocc, nocc, nvir),
'f8')
self.vvoo = self.feri1.create_dataset('vvoo',
(nvir, nvir, nocc, nocc),
'f8')
self.vooo = self.feri1.create_dataset('vooo',
(nvir, nocc, nocc, nocc),
'f8')
self.voov = self.feri1.create_dataset('voov',
(nvir, nocc, nocc, nvir),
'f8')
self.vovv = self.feri1.create_dataset('vovv', (nvir, nocc, nvpair),
'f8')
fsort = _ccsd.libcc.CCsd_sort_inplace
nocc_pair = nocc * (nocc + 1) // 2
nvir_pair = nvir * (nvir + 1) // 2
def sort_inplace(p0, p1, eri):
fsort(eri.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(nocc),
ctypes.c_int(nvir), ctypes.c_int((p1 - p0) * nocc))
vv = eri[:, :nvir_pair]
oo = eri[:, nvir_pair:nvir_pair + nocc_pair]
ov = eri[:, nvir_pair + nocc_pair:].reshape(-1, nocc, nvir)
return oo, ov, vv
buf = numpy.empty((nmo, nmo, nmo))
oovv = numpy.empty((nocc, nocc, nvir, nvir))
def save_occ_frac(p0, p1, eri):
oo, ov, vv = sort_inplace(p0, p1, eri)
self.oooo[p0:p1] = lib.unpack_tril(oo, out=buf).reshape(
p1 - p0, nocc, nocc, nocc)
self.ooov[p0:p1] = ov.reshape(p1 - p0, nocc, nocc, nvir)
oovv[p0:p1] = lib.unpack_tril(vv, out=buf).reshape(
p1 - p0, nocc, nvir, nvir)
def save_vir_frac(p0, p1, eri):
oo, ov, vv = sort_inplace(p0, p1, eri)
self.vooo[p0:p1] = lib.unpack_tril(oo, out=buf).reshape(
p1 - p0, nocc, nocc, nocc)
self.voov[p0:p1] = ov.reshape(p1 - p0, nocc, nocc, nvir)
self.vovv[p0:p1] = vv.reshape(p1 - p0, nocc, -1)
if not myci.direct:
max_memory = max(2000,
myci.max_memory - lib.current_memory()[0])
self.feri2 = lib.H5TmpFile()
ao2mo.full(myci.mol,
orbv,
self.feri2,
max_memory=max_memory,
verbose=log)
self.vvvv = self.feri2['eri_mo']
cput1 = log.timer_debug1('transforming vvvv', *cput1)
tmpfile3 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
with h5py.File(tmpfile3.name, 'w') as feri:
max_memory = max(2000,
myci.max_memory - lib.current_memory()[0])
mo = numpy.hstack((orbv, orbo))
ao2mo.general(myci.mol, (mo, orbo, mo, mo),
feri,
max_memory=max_memory,
verbose=log)
cput1 = log.timer_debug1('transforming oppp', *cput1)
blksize = max(
1, int(min(8e9, max_memory * .5e6) / 8 / nmo**2 / nocc))
handler = None
for p0, p1 in lib.prange(0, nvir, blksize):
eri = _cp(feri['eri_mo'][p0 * nocc:p1 * nocc])
handler = async_do(handler, save_vir_frac, p0, p1, eri)
for p0, p1 in lib.prange(0, nocc, blksize):
eri = _cp(feri['eri_mo'][(p0 + nvir) * nocc:(p1 + nvir) *
nocc])
handler = async_do(handler, save_occ_frac, p0, p1, eri)
if handler is not None:
handler.join()
self.vvoo[:] = lib.transpose(oovv.reshape(nocc**2, -1)).reshape(
nvir, nvir, nocc, nocc)
log.timer('CISD integral transformation', *cput0)
def uhf_external(mf, verbose=None):
log = logger.new_logger(mf, verbose)
mol = mf.mol
mo_a, mo_b = mf.mo_coeff
mo_ea, mo_eb = mf.mo_energy
mo_occa, mo_occb = mf.mo_occ
nmo = mo_a.shape[1]
nocca = numpy.count_nonzero(mo_occa)
noccb = numpy.count_nonzero(mo_occb)
nvira = nmo - nocca
nvirb = nmo - noccb
eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo)
eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo)
eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo)
# alpha -> alpha
haa =-numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca])
haa+= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca])
for a in range(nvira):
for i in range(nocca):
haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i]
# beta -> beta
hbb =-numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb])
hbb+= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb])
for a in range(nvirb):
for i in range(noccb):
hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i]
nova = nocca * nvira
novb = noccb * nvirb
hall = numpy.zeros((nova+novb,nova+novb))
hall[:nova,:nova] = haa.reshape(nova,nova)
hall[nova:,nova:] = hbb.reshape(novb,novb)
e1 = scipy.linalg.eigh(hall)[0]
log.debug('uhf_external: lowest eigs of H = %s', e1[e1<=max(e1[0],1e-5)])
if e1[0] < -1e-5:
log.log('UHF wavefunction has an UHF real -> complex instablity')
else:
log.log('UHF wavefunction is stable in the UHF real -> complex stablity analysis')
h11 =-numpy.einsum('abji->iajb', eri_ab[nocca:,nocca:,:noccb,:noccb])
for a in range(nvira):
for i in range(noccb):
h11[i,a,i,a] += mo_ea[nocca+a] - mo_eb[i]
h22 =-numpy.einsum('jiab->iajb', eri_ab[:nocca,:nocca,noccb:,noccb:])
for a in range(nvirb):
for i in range(nocca):
h22[i,a,i,a] += mo_eb[noccb+a] - mo_ea[i]
h12 =-numpy.einsum('ajbi->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb])
h21 =-numpy.einsum('biaj->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb])
n1 = noccb * nvira
n2 = nocca * nvirb
hall = numpy.empty((n1+n2,n1+n2))
hall[:n1,:n1] = h11.reshape(n1,n1)
hall[n1:,n1:] = h22.reshape(n2,n2)
hall[:n1,n1:] = h12.reshape(n1,n2)
hall[n1:,:n1] = h21.reshape(n2,n1)
e3 = scipy.linalg.eigh(hall)[0]
log.debug('uhf_external: lowest eigs of H = %s', e3[e3<=max(e3[0],1e-5)])
if e3[0] < -1e-5:
log.log('UHF wavefunction has an UHF -> GHF instablity.')
else:
log.log('UHF wavefunction is stable in the UHF -> GHF stablity analysis')
def write_chk(mc,root,chkfile):
t0 = (time.clock(), time.time())
fh5 = h5py.File(chkfile,'w')
if mc.fcisolver.nroots > 1:
mc.mo_coeff,_, mc.mo_energy = mc.canonicalize(mc.mo_coeff,ci=root)
fh5['mol'] = mc.mol.dumps()
fh5['mc/mo'] = mc.mo_coeff
fh5['mc/ncore'] = mc.ncore
fh5['mc/ncas'] = mc.ncas
nvirt = mc.mo_coeff.shape[1] - mc.ncas-mc.ncore
fh5['mc/nvirt'] = nvirt
fh5['mc/nelecas'] = mc.nelecas
fh5['mc/root'] = root
fh5['mc/orbe'] = mc.mo_energy
fh5['mc/nroots'] = mc.fcisolver.nroots
fh5['mc/wfnsym'] = mc.fcisolver.wfnsym
if hasattr(mc.mo_coeff, 'orbsym'):
fh5.create_dataset('mc/orbsym',data=mc.mo_coeff.orbsym)
else :
fh5.create_dataset('mc/orbsym',data=[])
if hasattr(mc.mo_coeff, 'orbsym') and mc.mol.symmetry:
orbsym = numpy.asarray(mc.mo_coeff.orbsym)
pair_irrep = orbsym.reshape(-1,1) ^ orbsym
else:
pair_irrep = None
ncore = mc.ncore
nocc = mc.ncore + mc.ncas
mo_core = mc.mo_coeff[:,:mc.ncore]
mo_cas = mc.mo_coeff[:,mc.ncore:mc.ncore+mc.ncas]
mo_virt = mc.mo_coeff[:,mc.ncore+mc.ncas:]
core_dm = numpy.dot(mo_core,mo_core.T) *2
core_vhf = mc.get_veff(mc.mol,core_dm)
h1e_Sr = reduce(numpy.dot, (mo_virt.T,mc.get_hcore()+core_vhf , mo_cas))
h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore()+core_vhf , mo_core))
h1e, e_core = mc.h1e_for_cas()
if pair_irrep is not None:
h1e_Sr[pair_irrep[nocc:,ncore:nocc] != 0] = 0
h1e_Si[pair_irrep[ncore:nocc,:ncore] != 0] = 0
h1e[pair_irrep[ncore:nocc,ncore:nocc] != 0] = 0
fh5['h1e_Si'] = h1e_Si
fh5['h1e_Sr'] = h1e_Sr
fh5['h1e'] = h1e
fh5['e_core'] = e_core
if mc._scf._eri is None:
h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff,mo_cas,mo_cas,mo_cas), compact=False)
h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas)
if pair_irrep is not None:
sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) !=
pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape)
h2e_t[sym_forbid] = 0
h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:]
fh5['h2e'] = h2e
h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3))
fh5['h2e_Si'] = h2e_Si
else:
eri = mc._scf._eri
h2e_t = ao2mo.general(eri, [mc.mo_coeff,mo_cas,mo_cas,mo_cas], compact=False)
h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas)
if pair_irrep is not None:
sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) !=
pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape)
h2e_t[sym_forbid] = 0
h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:]
fh5['h2e'] = h2e
h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3))
fh5['h2e_Si'] = h2e_Si
fh5.close()
logger.timer(mc,'Write MPS NEVPT integral', *t0)
def write_chk(mc,root,chkfile):
t0 = (time.clock(), time.time())
fh5 = h5py.File(chkfile,'w')
if mc.fcisolver.nroots > 1:
mc.mo_coeff,_, mc.mo_energy = mc.canonicalize(mc.mo_coeff,ci=root)
fh5['mol'] = mc.mol.dumps()
fh5['mc/mo'] = mc.mo_coeff
fh5['mc/ncore'] = mc.ncore
fh5['mc/ncas'] = mc.ncas
nvirt = mc.mo_coeff.shape[1] - mc.ncas-mc.ncore
fh5['mc/nvirt'] = nvirt
fh5['mc/nelecas'] = mc.nelecas
fh5['mc/root'] = root
fh5['mc/orbe'] = mc.mo_energy
fh5['mc/nroots'] = mc.fcisolver.nroots
fh5['mc/wfnsym'] = mc.fcisolver.wfnsym
if hasattr(mc, 'orbsym'):
fh5.create_dataset('mc/orbsym',data=mc.orbsym)
else :
fh5.create_dataset('mc/orbsym',data=[])
mo_core = mc.mo_coeff[:,:mc.ncore]
mo_cas = mc.mo_coeff[:,mc.ncore:mc.ncore+mc.ncas]
mo_virt = mc.mo_coeff[:,mc.ncore+mc.ncas:]
core_dm = numpy.dot(mo_core,mo_core.T) *2
core_vhf = mc.get_veff(mc.mol,core_dm)
h1e_Sr = reduce(numpy.dot, (mo_virt.T,mc.get_hcore()+core_vhf , mo_cas))
h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore()+core_vhf , mo_core))
fh5['h1e_Si'] = h1e_Si
fh5['h1e_Sr'] = h1e_Sr
h1e, e_core = mc.h1e_for_cas()
fh5['h1e'] = h1e
fh5['e_core'] = e_core
if mc._scf._eri is None:
h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff,mo_cas,mo_cas,mo_cas), compact=False)
h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas)
h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:]
fh5['h2e'] = h2e
h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3))
fh5['h2e_Si'] = h2e_Si
else:
eri = mc._scf._eri
h2e_t = ao2mo.general(eri, [mc.mo_coeff,mo_cas,mo_cas,mo_cas], compact=False)
h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas)
h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:]
fh5['h2e'] = h2e
h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:]
fh5['h2e_Sr'] = h2e_Sr
h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3))
fh5['h2e_Si'] = h2e_Si
fh5.close()
logger.timer(mc,'Write MPS NEVPT integral', *t0)
ncore = 0
nao, nmo = mf.mo_coeff.shape
nocc = cell.nelectron // 2 - ncore
nvir = nmo - nocc - ncore
mo_core = mf.mo_coeff[:, :ncore]
mo_occ = mf.mo_coeff[:, ncore:ncore + nocc]
mo_vir = mf.mo_coeff[:, ncore + nocc:]
co = mo_occ
cv = mo_vir
eo = mf.mo_energy[ncore:ncore + nocc]
ev = mf.mo_energy[ncore + nocc:]
lib.logger.info(mf, "\n+++ GAMMA point MP2 ")
lib.logger.info(mf, "* Core orbitals: %d" % ncore)
lib.logger.info(mf, "* Virtual orbitals: %d" % (len(ev)))
eri_mo = ao2mo.general(mf._eri, (co, cv, co, cv), compact=False)
eri_mo = eri_mo.reshape(nocc, nvir, nocc, nvir)
e_denom = 1.0 / (eo.reshape(-1, 1, 1, 1) - ev.reshape(-1, 1, 1) +
eo.reshape(-1, 1) - ev)
t2 = numpy.zeros((nocc, nvir, nocc, nvir))
t2 = 2.0 * lib.einsum('iajb,iajb->iajb', eri_mo, e_denom)
t2 -= lib.einsum('ibja,iajb->iajb', eri_mo, e_denom)
e_mp2 = numpy.einsum('iajb,iajb->', eri_mo, t2, optimize=True)
lib.logger.info(mf, "!*** E(MP2): %12.8f" % e_mp2)
lib.logger.info(mf, "!**** E(HF+MP2): %12.8f" % (e_mp2 + ehf))
wfn_file = name + '.wfn'
ao_loc = cell.ao_loc_nr()
fspt = open(wfn_file, 'w')
wfn_format.write_mo(fspt,
cell,
def __init__(self, cc, mo_coeff=None, method='incore', ao2mofn=ao2mo.full):
cput0 = (time.clock(), time.time())
moidx = get_frozen_mask(cc)
if mo_coeff is None:
self.mo_coeff = mo_coeff = cc.mo_coeff[:, moidx]
else: # If mo_coeff is not canonical orbital
self.mo_coeff = mo_coeff = mo_coeff[:, moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = cc.nocc
nmo = cc.nmo
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
log = logger.Logger(cc.stdout, cc.verbose)
if (method == 'incore' and (mem_incore + mem_now < cc.max_memory)
or cc.mol.incore_anyway):
if ao2mofn == ao2mo.full:
if cc._scf._eri is not None:
eri = ao2mo.restore(1, ao2mofn(cc._scf._eri, mo_coeff),
nmo)
else:
eri = ao2mo.restore(
1, ao2mofn(cc._scf.mol, mo_coeff, compact=0), nmo)
else:
eri = ao2mofn(cc._scf.mol,
(mo_coeff, mo_coeff, mo_coeff, mo_coeff),
compact=0)
if mo_coeff.dtype == np.float: eri = eri.real
eri = eri.reshape((nmo, ) * 4)
self.dtype = eri.dtype
self.oooo = eri[:nocc, :nocc, :nocc, :nocc].copy()
self.ooov = eri[:nocc, :nocc, :nocc, nocc:].copy()
self.ovoo = eri[:nocc, nocc:, :nocc, :nocc].copy()
self.oovo = eri[:nocc, :nocc, nocc:, :nocc].copy()
self.ovov = eri[:nocc, nocc:, :nocc, nocc:].copy()
self.oovv = eri[:nocc, :nocc, nocc:, nocc:].copy()
self.ovvo = eri[:nocc, nocc:, nocc:, :nocc].copy()
self.ovvv = eri[:nocc, nocc:, nocc:, nocc:].copy()
elif hasattr(cc._scf, 'with_df') and cc._scf.with_df:
raise NotImplementedError
else:
orbo = mo_coeff[:, :nocc]
self.dtype = mo_coeff.dtype
ds_type = mo_coeff.dtype.char
self.feri = lib.H5TmpFile()
self.oooo = self.feri.create_dataset('oooo',
(nocc, nocc, nocc, nocc),
ds_type)
self.ooov = self.feri.create_dataset('ooov',
(nocc, nocc, nocc, nvir),
ds_type)
self.ovoo = self.feri.create_dataset('ovoo',
(nocc, nvir, nocc, nocc),
ds_type)
self.oovo = self.feri.create_dataset('oovo',
(nocc, nocc, nvir, nocc),
ds_type)
self.ovov = self.feri.create_dataset('ovov',
(nocc, nvir, nocc, nvir),
ds_type)
self.oovv = self.feri.create_dataset('oovv',
(nocc, nocc, nvir, nvir),
ds_type)
self.ovvo = self.feri.create_dataset('ovvo',
(nocc, nvir, nvir, nocc),
ds_type)
self.ovvv = self.feri.create_dataset('ovvv',
(nocc, nvir, nvir, nvir),
ds_type)
cput1 = time.clock(), time.time()
# <ij||pq> = <ij|pq> - <ij|qp> = (ip|jq) - (iq|jp)
tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
ao2mo.general(cc.mol, (orbo, mo_coeff, mo_coeff, mo_coeff),
tmpfile2.name, 'aa')
with h5py.File(tmpfile2.name) as f:
buf = numpy.empty((nmo, nmo, nmo))
for i in range(nocc):
lib.unpack_tril(f['aa'][i * nmo:(i + 1) * nmo], out=buf)
self.oooo[i] = buf[:nocc, :nocc, :nocc]
self.ooov[i] = buf[:nocc, :nocc, nocc:]
self.ovoo[i] = buf[nocc:, :nocc, :nocc]
self.ovov[i] = buf[nocc:, :nocc, nocc:]
self.oovo[i] = buf[:nocc, nocc:, :nocc]
self.oovv[i] = buf[:nocc, nocc:, nocc:]
self.ovvo[i] = buf[nocc:, nocc:, :nocc]
self.ovvv[i] = buf[nocc:, nocc:, nocc:]
del (f['aa'])
buf = None
cput1 = log.timer_debug1('transforming oopq, ovpq', *cput1)
log.timer('GW integral transformation', *cput0)
