def _make_eris_outcore(mycc, mo_coeff=None):
cput0 = (logger.process_clock(), logger.perf_counter())
log = logger.Logger(mycc.stdout, mycc.verbose)
eris = _ChemistsERIs()
eris._common_init_(mycc, mo_coeff)
mol = mycc.mol
mo_coeff = eris.mo_coeff
nocc = eris.nocc
nao, nmo = mo_coeff.shape
nvir = nmo - nocc
eris.feri1 = lib.H5TmpFile()
eris.oooo = eris.feri1.create_dataset('oooo', (nocc, nocc, nocc, nocc),
'f8')
eris.ovoo = eris.feri1.create_dataset('ovoo', (nocc, nvir, nocc, nocc),
'f8',
chunks=(nocc, 1, nocc, nocc))
eris.ovov = eris.feri1.create_dataset('ovov', (nocc, nvir, nocc, nvir),
'f8',
chunks=(nocc, 1, nocc, nvir))
eris.ovvo = eris.feri1.create_dataset('ovvo', (nocc, nvir, nvir, nocc),
'f8',
chunks=(nocc, 1, nvir, nocc))
eris.ovvv = eris.feri1.create_dataset('ovvv', (nocc, nvir, nvir, nvir),
'f8')
eris.oovv = eris.feri1.create_dataset('oovv', (nocc, nocc, nvir, nvir),
'f8',
chunks=(nocc, nocc, 1, nvir))
max_memory = max(MEMORYMIN, mycc.max_memory - lib.current_memory()[0])
ftmp = lib.H5TmpFile()
ao2mo.full(mol, mo_coeff, ftmp, max_memory=max_memory, verbose=log)
eri = ftmp['eri_mo']
nocc_pair = nocc * (nocc + 1) // 2
tril2sq = lib.square_mat_in_trilu_indices(nmo)
oo = eri[:nocc_pair]
eris.oooo[:] = ao2mo.restore(1, oo[:, :nocc_pair], nocc)
oovv = lib.take_2d(oo, tril2sq[:nocc, :nocc].ravel(),
tril2sq[nocc:, nocc:].ravel())
eris.oovv[:] = oovv.reshape(nocc, nocc, nvir, nvir)
oo = oovv = None
tril2sq = lib.square_mat_in_trilu_indices(nmo)
blksize = min(nvir, max(BLKMIN, int(max_memory * 1e6 / 8 / nmo**3 / 2)))
for p0, p1 in lib.prange(0, nvir, blksize):
q0, q1 = p0 + nocc, p1 + nocc
off0 = q0 * (q0 + 1) // 2
off1 = q1 * (q1 + 1) // 2
buf = lib.unpack_tril(eri[off0:off1])
tmp = buf[tril2sq[q0:q1, :nocc] - off0]
eris.ovoo[:, p0:p1] = tmp[:, :, :nocc, :nocc].transpose(1, 0, 2, 3)
eris.ovvo[:, p0:p1] = tmp[:, :, nocc:, :nocc].transpose(1, 0, 2, 3)
eris.ovov[:, p0:p1] = tmp[:, :, :nocc, nocc:].transpose(1, 0, 2, 3)
eris.ovvv[:, p0:p1] = tmp[:, :, nocc:, nocc:].transpose(1, 0, 2, 3)
buf = tmp = None
log.timer('GW integral transformation', *cput0)
return eris
def from_scf(mf,
filename,
tol=TOL,
float_format=DEFAULT_FLOAT_FORMAT,
molpro_orbsym=MOLPRO_ORBSYM):
'''Use the given SCF object to transfrom the 1-electron and 2-electron
integrals then dump them to FCIDUMP.
Kwargs:
molpro_orbsym (bool): Whether to dump the orbsym in Molpro orbsym
convention as documented in
https://www.molpro.net/info/current/doc/manual/node36.html
'''
mol = mf.mol
mo_coeff = mf.mo_coeff
assert mo_coeff.dtype == numpy.double
h1e = reduce(numpy.dot, (mo_coeff.T, mf.get_hcore(), mo_coeff))
if mf._eri is None:
if getattr(mf, 'exxdiv', None): # PBC system
eri = mf.with_df.ao2mo(mo_coeff)
else:
eri = ao2mo.full(mf.mol, mo_coeff)
else: # Handle cached integrals or customized systems
eri = ao2mo.full(mf._eri, mo_coeff)
orbsym = getattr(mo_coeff, 'orbsym', None)
if molpro_orbsym and orbsym is not None:
orbsym = [ORBSYM_MAP[mol.groupname][i] for i in orbsym]
nuc = mf.energy_nuc()
from_integrals(filename, h1e, eri, h1e.shape[0], mf.mol.nelec, nuc, 0,
orbsym, tol, float_format)
def update_l1l2(mf, t1, t2, l1, l2, orbspin):
mol = mf.mol
nao, nmo = mf.mo_coeff[0].shape
nelec = mol.nelectron
nso = nmo * 2
hcore = mf.get_hcore()
h1e = np.zeros((nso, nso))
idxa = orbspin == 0
idxb = orbspin == 1
idxaa = idxa[:, None] & idxa
idxbb = idxb[:, None] & idxb
h1e[idxaa] = reduce(np.dot,
(mf.mo_coeff[0].T, hcore, mf.mo_coeff[0])).ravel()
h1e[idxbb] = reduce(np.dot,
(mf.mo_coeff[1].T, hcore, mf.mo_coeff[1])).ravel()
int2e = np.zeros((nso, nso, nso, nso))
int2e[idxaa[:, :, None, None] & idxaa] = ao2mo.full(mol,
mf.mo_coeff[0],
aosym='s1').ravel()
int2e[idxbb[:, :, None, None] & idxbb] = ao2mo.full(mol,
mf.mo_coeff[1],
aosym='s1').ravel()
eri_aabb = ao2mo.general(
mol, [mf.mo_coeff[0], mf.mo_coeff[0], mf.mo_coeff[1], mf.mo_coeff[1]],
aosym='s1').reshape([nmo] * 4)
int2e[idxaa[:, :, None, None] & idxbb] = eri_aabb.ravel()
int2e[idxbb[:, :, None, None] & idxaa] = eri_aabb.transpose(2, 3, 0,
1).ravel()
int2e = int2e.transpose(0, 2, 1, 3)
int2e = int2e - int2e.transpose(0, 1, 3, 2)
mycc = ccsd(nso, nelec, h1e, int2e, h1e_is_fock=False)
l1, l2 = update_l1l2_sub(mycc, t1, t2, l1, l2)
return l1, l2
def make_fcidump(self, filename):
mo_coeff = self.mf.mo_coeff
h1 = reduce(numpy.dot, (mo_coeff.T, self.mf.get_hcore(), mo_coeff))
if self.mf._eri is None:
eri = ao2mo.full(self.mol, mo_coeff)
else:
eri = ao2mo.full(self.mf._eri, mo_coeff)
nuc = self.mf.energy_nuc()
orbsym = getattr(mo_coeff, 'orbsym', None)
if self.symmetry in ('DOOH', 'COOV'):
self.writeComplexOrbIntegrals(h1, eri, h1.shape[0],
self.n_up + self.n_down, nuc, orbsym,
self.partner_orbs)
fcidump.from_integrals("FCIDUMP_real_orbs", h1, eri, h1.shape[0],
self.mol.nelec, nuc, 0, orbsym)
else:
orbsym = [sym + 1 for sym in orbsym]
fcidump.from_integrals(filename,
h1,
eri,
h1.shape[0],
self.mol.nelec,
nuc,
0,
orbsym,
tol=1e-15,
float_format=' %.16g')
def set_frozdm (self, frozdm1=None, frozdm2=None, eri_fo=None):
self.frozdm1 = frozdm1
self.frozdm2 = frozdm2
ncore = self.ncore
nfroz = self.nfroz
nocc = ncore + self.nfroz
fo_coeff = self.get_fo_coeff ()
if frozdm1 is not None:
fo_occ, u_no = sp.linalg.eigh (frozdm1)
idx = np.argsort (-fo_occ)
fo_occ = fo_occ[idx]
u_no = u_no[:,idx]
frozdm1, frozdm2 = update_rdm12 (u_no, frozdm1, frozdm2)
assert (np.allclose (fo_occ, np.diag (frozdm1))), "fo_occ = {0}\nfrozdm1 =\n{1}".format (fo_occ, frozdm1)
self.wo_coeff[:,ncore:nocc] = np.dot (self.wo_coeff[:,ncore:nocc], u_no)
self._fo_occ = fo_occ
dm1 = reduce (np.dot, [fo_coeff, frozdm1, fo_coeff.conjugate ().T])
self._e1_froz = energy_elec (self, dm1)[1]
if frozdm2 is not None:
if eri_fo is None and getattr (self, '_eri', None) is not None:
eri_fo = ao2mo.full(self._eri, fo_coeff, compact=False).reshape (nfroz, nfroz, nfroz, nfroz)
elif eri_fo is None:
eri_fo = ao2mo.full(self.mol, fo_coeff, compact=False).reshape (nfroz, nfroz, nfroz, nfroz)
else:
eri_fo = update_2body (u_no, ao2mo.restore (1, eri_fo, nfroz))
self._e2_froz = 0.5 * np.tensordot (eri_fo, frozdm2, axes=4)
def kernel(self,
h1e=None,
eri=None,
norb=None,
nelec=None,
ci0=None,
ecore=None,
**kwargs):
if h1e is None or eri is None:
if mf is None:
if h1e is None:
h1e = reduce(numpy.dot,
(mo.T, scf.hf.get_hcore(mol), mo))
if eri is None:
eri = ao2mo.full(mol, mo)
if ecore is None:
ecore = mol.energy_nuc()
else:
if h1e is None:
h1e = reduce(numpy.dot, (mo.T, mf.get_hcore(mol), mo))
if eri is None:
if mf._eri is None:
eri = ao2mo.full(mol, mo)
else:
eri = ao2mo.full(mf._eri, mo)
if ecore is None:
ecore = mf.energy_nuc()
if norb is None: norb = mo.shape[1]
if nelec is None: nelec = mol.nelec
self.eci, self.ci = \
cis.__class__.kernel(self, h1e, eri, norb, nelec, ci0,
ecore=ecore, **kwargs)
return self.eci, self.ci
def ref_energy(mf):
moa, mob = mf.mo_coeff
nmoa, nmob = moa.shape[1], mob.shape[1]
nea, neb = mf.mol.nelec
hcore = mf.get_hcore()
ha = np.linalg.multi_dot([moa.T,hcore,moa])
hb = np.linalg.multi_dot([mob.T,hcore,mob])
E0 = sum(ha.diagonal()[:nea]) + sum(hb.diagonal()[:neb])
eriao = mf._eri
eri_aa = ao2mo.restore(1, ao2mo.full(eriao, moa), nmoa)
eri_bb = ao2mo.restore(1, ao2mo.full(eriao, mob), nmob)
eri_ab = ao2mo.general(eriao, (moa,moa,mob,mob), compact=False)
eri_aa = eri_aa.reshape(nmoa,nmoa,nmoa,nmoa)
eri_bb = eri_bb.reshape(nmob,nmob,nmob,nmob)
eri_ab = eri_ab.reshape(nmoa,nmoa,nmob,nmob)
oooo = eri_aa[:nea,:nea,:nea,:nea].copy()
OOOO = eri_bb[:neb,:neb,:neb,:neb].copy()
ooOO = eri_ab[:nea,:nea,:neb,:neb].copy()
temp = einsum('iijj',OOOO)-einsum('ijji',OOOO)
temp += einsum('iijj',oooo)-einsum('ijji',oooo)
temp += 2*einsum('iijj',ooOO)
E0 += 0.5*temp
return E0
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 _make_eris_outcore(mycc, mo_coeff=None):
cput0 = (time.clock(), time.time())
log = logger.Logger(mycc.stdout, mycc.verbose)
eris = _ChemistsERIs()
eris._common_init_(mycc, mo_coeff)
mol = mycc.mol
mo_coeff = eris.mo_coeff
nocc = eris.nocc
nao, nmo = mo_coeff.shape
nvir = nmo - nocc
orbo = mo_coeff[:,:nocc]
orbv = mo_coeff[:,nocc:]
nvpair = nvir * (nvir+1) // 2
eris.feri1 = lib.H5TmpFile()
eris.oooo = eris.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), 'f8')
eris.ovoo = eris.feri1.create_dataset('ovoo', (nocc,nvir,nocc,nocc), 'f8', chunks=(nocc,1,nocc,nocc))
eris.ovov = eris.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), 'f8', chunks=(nocc,1,nocc,nvir))
eris.ovvo = eris.feri1.create_dataset('ovvo', (nocc,nvir,nvir,nocc), 'f8', chunks=(nocc,1,nvir,nocc))
eris.ovvv = eris.feri1.create_dataset('ovvv', (nocc,nvir,nvir,nvir), 'f8')
eris.oovv = eris.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), 'f8', chunks=(nocc,nocc,1,nvir))
eris.vvvv = eris.feri1.create_dataset('vvvv', (nvir,nvir,nvir,nvir), 'f8')
max_memory = max(MEMORYMIN, mycc.max_memory-lib.current_memory()[0])
ftmp = lib.H5TmpFile()
ao2mo.full(mol, mo_coeff, ftmp, max_memory=max_memory, verbose=log)
eri = ftmp['eri_mo']
nocc_pair = nocc*(nocc+1)//2
tril2sq = lib.square_mat_in_trilu_indices(nmo)
oo = eri[:nocc_pair]
eris.oooo[:] = ao2mo.restore(1, oo[:,:nocc_pair], nocc)
oovv = lib.take_2d(oo, tril2sq[:nocc,:nocc].ravel(), tril2sq[nocc:,nocc:].ravel())
eris.oovv[:] = oovv.reshape(nocc,nocc,nvir,nvir)
oo = oovv = None
tril2sq = lib.square_mat_in_trilu_indices(nmo)
blksize = min(nvir, max(BLKMIN, int(max_memory*1e6/8/nmo**3/2)))
for p0, p1 in lib.prange(0, nvir, blksize):
q0, q1 = p0+nocc, p1+nocc
off0 = q0*(q0+1)//2
off1 = q1*(q1+1)//2
buf = lib.unpack_tril(eri[off0:off1])
tmp = buf[ tril2sq[q0:q1,:nocc] - off0 ]
eris.ovoo[:,p0:p1] = tmp[:,:,:nocc,:nocc].transpose(1,0,2,3)
eris.ovvo[:,p0:p1] = tmp[:,:,nocc:,:nocc].transpose(1,0,2,3)
eris.ovov[:,p0:p1] = tmp[:,:,:nocc,nocc:].transpose(1,0,2,3)
eris.ovvv[:,p0:p1] = tmp[:,:,nocc:,nocc:].transpose(1,0,2,3)
tmp = buf[ tril2sq[q0:q1,nocc:q1] - off0 ]
eris.vvvv[p0:p1,:p1] = tmp[:,:,nocc:,nocc:]
if p0 > 0:
eris.vvvv[:p0,p0:p1] = tmp[:,:p0,nocc:,nocc:].transpose(1,0,2,3)
buf = tmp = None
log.timer('CCSD integral transformation', *cput0)
return eris
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 make_real2complex_coeffs(self):
mo_coeff = self.mf.mo_coeff
h1 = reduce(numpy.dot, (mo_coeff.T, self.mf.get_hcore(), mo_coeff))
if self.mf._eri is None:
eri = ao2mo.full(self.mol, mo_coeff)
else:
eri = ao2mo.full(self.mf._eri, mo_coeff)
nuc = self.mf.energy_nuc()
orbsym = getattr(mo_coeff, 'orbsym', None)
self.get_real2complex_coeffs(h1, eri, h1.shape[0],
self.n_up + self.n_down, nuc, orbsym,
self.partner_orbs)
def ao2mo(self, mo_coeff=None):
if mo_coeff is None:
mo_coeff = self.mo_coeff[:,self.ncore:self.ncore+self.ncas]
elif mo_coeff.shape[1] != self.ncas:
mo_coeff = mo_coeff[:,self.ncore:self.ncore+self.ncas]
if self._scf._eri is not None:
eri = ao2mo.full(self._scf._eri, mo_coeff,
max_memory=self.max_memory)
else:
eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose,
max_memory=self.max_memory)
return eri
def ao2mo(self, mo_coeff=None):
if mo_coeff is None:
mo_coeff = self.mo_coeff[:,self.ncore:self.ncore+self.ncas]
elif mo_coeff.shape[1] != self.ncas:
mo_coeff = mo_coeff[:,self.ncore:self.ncore+self.ncas]
if self._scf._eri is not None:
eri = ao2mo.full(self._scf._eri, mo_coeff,
max_memory=self.max_memory)
else:
eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose,
max_memory=self.max_memory)
return eri
def from_scf(mf, filename, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT):
'''Use the given SCF object to transfrom the 1-electron and 2-electron
integrals then dump them to FCIDUMP.
'''
mo_coeff = mf.mo_coeff
h1e = reduce(numpy.dot, (mo_coeff.T, mf.get_hcore(), mo_coeff))
if mf._eri is None:
eri = ao2mo.full(mol, mo_coeff)
else:
eri = ao2mo.full(mf._eri, mo_coeff)
orbsym = getattr(mo_coeff, 'orbsym', None)
nuc = mf.energy_nuc()
from_integrals(filename, h1e, eri, h1e.shape[0], mf.mol.nelec, nuc, 0, orbsym,
tol, float_format)
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 from_scf(mf, filename, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT):
'''Use the given SCF object to transfrom the 1-electron and 2-electron
integrals then dump them to FCIDUMP.
'''
mo_coeff = mf.mo_coeff
h1e = reduce(numpy.dot, (mo_coeff.T, mf.get_hcore(), mo_coeff))
if mf._eri is None:
eri = ao2mo.full(mol, mo_coeff)
else:
eri = ao2mo.full(mf._eri, mo_coeff)
orbsym = getattr(mo_coeff, 'orbsym', None)
nuc = mf.energy_nuc()
from_integrals(filename, h1e, eri, h1e.shape[0], mf.mol.nelec, nuc, 0,
orbsym, tol, float_format)
def from_chkfile(filename, chkfile, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT):
'''Read SCF results from PySCF chkfile and transform 1-electron,
2-electron integrals using the SCF orbitals. The transformed integrals is
written to FCIDUMP'''
from pyscf import scf, symm
with open(filename, 'w') as fout:
mol, scf_rec = scf.chkfile.load_scf(chkfile)
mo_coeff = numpy.array(scf_rec['mo_coeff'])
nmo = mo_coeff.shape[1]
if mol.symmetry:
orbsym = symm.label_orb_symm(mol, mol.irrep_id,
mol.symm_orb, mo_coeff, check=False)
write_head(fout, nmo, mol.nelectron, mol.spin, orbsym)
else:
write_head(fout, nmo, mol.nelectron, mol.spin)
eri = ao2mo.full(mol, mo_coeff, verbose=0)
write_eri(fout, ao2mo.restore(8, eri, nmo), nmo, tol, float_format)
t = mol.intor_symmetric('int1e_kin')
v = mol.intor_symmetric('int1e_nuc')
h = reduce(numpy.dot, (mo_coeff.T, t+v, mo_coeff))
write_hcore(fout, h, nmo, tol, float_format)
output_format = ' ' + float_format + ' 0 0 0 0\n'
fout.write(output_format % mol.energy_nuc())
def gen_hop_rhf_external(mf):
mol = mf.mol
mo_coeff = mf.mo_coeff
mo_energy = mf.mo_energy
mo_occ = mf.mo_occ
nmo = mo_coeff.shape[1]
nocc = numpy.count_nonzero(mo_occ)
nvir = nmo - nocc
nov = nocc * nvir
eri_mo = ao2mo.full(mol, mo_coeff)
eri_mo = ao2mo.restore(1, eri_mo, nmo)
eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc])
# A
h = numpy.einsum('ckld->kcld', eri_mo[nocc:,:nocc,:nocc,nocc:]) * 2
h-= numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc])
for a in range(nvir):
for i in range(nocc):
h[i,a,i,a] += eai[a,i]
# B
h-= numpy.einsum('ckdl->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) * 2
h+= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc])
h1 = h.transpose(1,0,3,2).reshape(nov,nov)
def hop1(x):
return h1.dot(x)
h =-numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc])
for a in range(nvir):
for i in range(nocc):
h[i,a,i,a] += eai[a,i]
h-= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc])
h2 = h.transpose(1,0,3,2).reshape(nov,nov)
def hop2(x):
return h2.dot(x)
return hop1, hop2
def get_eris_in_basis(basis, orbs):
""" Get electron repulsion integrals transformed in (in form eri[i,j,k,l] = (ij|kl))
"""
pmol = mol_to_pyscf(basis.wfn.molecule, basis=basis.basisname)
eri = ao2mo.full(pmol, orbs.T, compact=True) * u.hartree
eri.defunits_inplace()
return orbitals.ERI4FoldTensor(eri, orbs)
def from_mo(mol,
filename,
mo_coeff,
orbsym=None,
tol=TOL,
float_format=DEFAULT_FLOAT_FORMAT,
molpro_orbsym=MOLPRO_ORBSYM):
'''Use the given MOs to transfrom the 1-electron and 2-electron integrals
then dump them to FCIDUMP.
Kwargs:
molpro_orbsym (bool): Whether to dump the orbsym in Molpro orbsym
convention as documented in
https://www.molpro.net/info/current/doc/manual/node36.html
'''
if getattr(mol, '_mesh', None):
raise NotImplementedError('PBC system')
if orbsym is None:
orbsym = getattr(mo_coeff, 'orbsym', None)
if molpro_orbsym:
orbsym = [ORBSYM_MAP[mol.groupname][i] for i in orbsym]
t = mol.intor_symmetric('int1e_kin')
v = mol.intor_symmetric('int1e_nuc')
h1e = reduce(numpy.dot, (mo_coeff.T, t + v, mo_coeff))
eri = ao2mo.full(mol, mo_coeff, verbose=0)
nuc = mol.energy_nuc()
from_integrals(filename, h1e, eri, h1e.shape[0], mol.nelec, nuc, 0, orbsym,
tol, float_format)
def rhf_internal(mf, verbose=None):
log = logger.new_logger(mf, verbose)
mol = mf.mol
mo_coeff = mf.mo_coeff
mo_energy = mf.mo_energy
mo_occ = mf.mo_occ
nmo = mo_coeff.shape[1]
nocc = numpy.count_nonzero(mo_occ)
nvir = nmo - nocc
eri_mo = ao2mo.full(mol, mo_coeff)
eri_mo = ao2mo.restore(1, eri_mo, nmo)
eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc])
# A
h = numpy.einsum('ckld->kcld', eri_mo[nocc:,:nocc,:nocc,nocc:]) * 2
h-= numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc])
for a in range(nvir):
for i in range(nocc):
h[i,a,i,a] += eai[a,i]
# B
h+= numpy.einsum('ckdl->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) * 2
h-= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc])
nov = nocc * nvir
e = scipy.linalg.eigh(h.reshape(nov,nov))[0]
log.debug('rhf_internal: lowest eigs = %s', e[e<=max(e[0],1e-5)])
if e[0] < -1e-5:
log.log('RHF wavefunction has an internal instablity')
else:
log.log('RHF wavefunction is stable in the intenral stablity analysis')
def from_chkfile(output, chkfile, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT):
'''Read SCF results from PySCF chkfile and transform 1-electron,
2-electron integrals using the SCF orbitals. The transformed integrals is
written to FCIDUMP'''
from pyscf import scf, ao2mo, symm
with open(output, 'w') as fout:
mol, scf_rec = scf.chkfile.load_scf(chkfile)
mo_coeff = numpy.array(scf_rec['mo_coeff'])
nmo = mo_coeff.shape[1]
if mol.symmetry:
orbsym = symm.label_orb_symm(mol,
mol.irrep_id,
mol.symm_orb,
mo_coeff,
check=False)
write_head(fout, nmo, mol.nelectron, mol.spin, orbsym)
else:
write_head(fout, nmo, mol.nelectron, mol.spin)
eri = ao2mo.full(mol, mo_coeff, verbose=0)
write_eri(fout, ao2mo.restore(8, eri, nmo), nmo, tol, float_format)
t = mol.intor_symmetric('int1e_kin')
v = mol.intor_symmetric('int1e_nuc')
h = reduce(numpy.dot, (mo_coeff.T, t + v, mo_coeff))
write_hcore(fout, h, nmo, tol, float_format)
output_format = ' ' + float_format + ' 0 0 0 0\n'
fout.write(output_format % mol.energy_nuc())
def from_chkfile(filename, chkfile, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT):
'''Read SCF results from PySCF chkfile and transform 1-electron,
2-electron integrals using the SCF orbitals. The transformed integrals is
written to FCIDUMP'''
from pyscf import scf, symm
mol, scf_rec = scf.chkfile.load_scf(chkfile)
mo_coeff = numpy.array(scf_rec['mo_coeff'])
nmo = mo_coeff.shape[1]
s = reduce(numpy.dot, (mo_coeff.conj().T, mol.intor_symmetric('int1e_ovlp'), mo_coeff))
if abs(s - numpy.eye(nmo)).max() > 1e-6:
# Not support the chkfile from pbc calculation
raise RuntimeError('Non-orthogonal orbitals found in chkfile')
with open(filename, 'w') as fout:
if mol.symmetry:
orbsym = symm.label_orb_symm(mol, mol.irrep_id,
mol.symm_orb, mo_coeff, check=False)
write_head(fout, nmo, mol.nelectron, mol.spin, orbsym)
else:
write_head(fout, nmo, mol.nelectron, mol.spin)
eri = ao2mo.full(mol, mo_coeff, verbose=0)
write_eri(fout, ao2mo.restore(8, eri, nmo), nmo, tol, float_format)
t = mol.intor_symmetric('int1e_kin')
v = mol.intor_symmetric('int1e_nuc')
h = reduce(numpy.dot, (mo_coeff.T, t+v, mo_coeff))
write_hcore(fout, h, nmo, tol, float_format)
output_format = ' ' + float_format + ' 0 0 0 0\n'
fout.write(output_format % mol.energy_nuc())
def rhf_internal(mf, verbose=None):
log = logger.new_logger(mf, verbose)
mol = mf.mol
mo_coeff = mf.mo_coeff
mo_energy = mf.mo_energy
mo_occ = mf.mo_occ
nmo = mo_coeff.shape[1]
nocc = numpy.count_nonzero(mo_occ)
nvir = nmo - nocc
eri_mo = ao2mo.full(mol, mo_coeff)
eri_mo = ao2mo.restore(1, eri_mo, nmo)
eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc])
# A
h = numpy.einsum('ckld->kcld', eri_mo[nocc:,:nocc,:nocc,nocc:]) * 2
h-= numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc])
for a in range(nvir):
for i in range(nocc):
h[i,a,i,a] += eai[a,i]
# B
h+= numpy.einsum('ckdl->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) * 2
h-= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc])
nov = nocc * nvir
e = scipy.linalg.eigh(h.reshape(nov,nov))[0]
log.debug('rhf_internal: lowest eigs = %s', e[e<=max(e[0],1e-5)])
if e[0] < -1e-5:
log.log('RHF wavefunction has an internal instablity')
else:
log.log('RHF wavefunction is stable in the internal stablity analysis')
def kernel(self):
if (self.norb > 64):
raise RuntimeError('''Only support up to 64 orbitals''')
self.ncore = self.mol.nelectron - self.nelec[0] - self.nelec[1]
self.ncore = self.ncore // 2
e_core = self.mol.energy_nuc()
ci_idx = self.ncore + numpy.arange(self.norb)
coeff = self.mf.mo_coeff
hcore = self.mf.get_hcore()
corevhf = 0.0
if (self.ncore != 0):
core_idx = numpy.arange(self.ncore)
core_dm = numpy.dot(coeff[:, core_idx], coeff[:, core_idx].T) * 2.0
e_core += numpy.einsum('ij,ji', core_dm, hcore)
corevhf = self.mf.get_veff(mol, core_dm)
e_core += numpy.einsum('ij,ji', core_dm, corevhf) * 0.5
self.e_core = e_core
self.dump_flags()
self.h1e = reduce(
numpy.dot, (coeff[:, ci_idx].T, hcore + corevhf, coeff[:, ci_idx]))
self.h2e = ao2mo.full(self.mf._eri, coeff[:, ci_idx])
self.h2e = ao2mo.restore(1, self.h2e, self.norb)
self.gen_strs()
self.build_h()
return self
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 ao2mo(self, mo_coeff=None):
ncore = self.ncore
ncas = self.ncas
nocc = ncore + ncas
if mo_coeff is None:
ncore = self.ncore
mo_coeff = self.mo_coeff[:,ncore:nocc]
elif mo_coeff.shape[1] != ncas:
mo_coeff = mo_coeff[:,ncore:nocc]
if self._scf._eri is not None:
eri = ao2mo.full(self._scf._eri, mo_coeff,
max_memory=self.max_memory)
else:
eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose,
max_memory=self.max_memory)
return eri
def write_integrals(xci, orb):
mol = xci.mol
orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, orb)
h1e = reduce(numpy.dot, (orb.T, xci.get_hcore(), orb))
norb = orb.shape[1]
if xci._eri is not None:
h2e = ao2mo.restore(1, ao2mo.full(xci._eri, orb), norb)
else:
h2e = ao2mo.restore(1, ao2mo.full(mol, orb), norb)
with h5py.File(xci.integralfile, 'w') as f:
f['h1e'] = h1e
f['h2e'] = h2e
f['norb' ] = numpy.array(norb, dtype=numpy.int32)
f['group' ] = mol.groupname
f['orbsym'] = numpy.asarray(orbsym, dtype=numpy.int32)
f['ecore' ] = mol.energy_nuc()
def write_integrals(xci, orb):
mol = xci.mol
orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, orb)
h1e = reduce(numpy.dot, (orb.T, xci.get_hcore(), orb))
norb = orb.shape[1]
if xci._eri is not None:
h2e = ao2mo.restore(1, ao2mo.full(xci._eri, orb), norb)
else:
h2e = ao2mo.restore(1, ao2mo.full(mol, orb), norb)
with h5py.File(xci.integralfile, 'w') as f:
f['h1e'] = h1e
f['h2e'] = h2e
f['norb'] = numpy.array(norb, dtype=numpy.int32)
f['group'] = mol.groupname
f['orbsym'] = numpy.asarray(orbsym, dtype=numpy.int32)
f['ecore'] = mol.energy_nuc()
def ao2mo(self, mo_coeff=None):
ncore = self.ncore
ncas = self.ncas
nocc = ncore + ncas
if mo_coeff is None:
ncore = self.ncore
mo_coeff = self.mo_coeff[:,ncore:nocc]
elif mo_coeff.shape[1] != ncas:
mo_coeff = mo_coeff[:,ncore:nocc]
if self._scf._eri is not None:
eri = ao2mo.full(self._scf._eri, mo_coeff,
max_memory=self.max_memory)
else:
eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose,
max_memory=self.max_memory)
return eri
def perform_rhf_full(self) -> None:
norb = self.C.shape[-1]
tei_mo = full(self.pyscfmol,
self.C[0],
aosym="s4",
compact=False,
verbose=self.verbose).reshape(norb, norb, norb, norb)
self.tei_mo = (tei_mo, )
def perform_rhf_full(self):
assert self.pyscfmol is not None
norb = self.C.shape[-1]
from pyscf.ao2mo import full
tei_mo = full(
self.pyscfmol, self.C[0], aosym="s4", compact=False, verbose=self.verbose
).reshape(norb, norb, norb, norb)
self.tei_mo = (tei_mo,)
def get_eris_in_basis(basis, orbs):
""" Get electron repulsion integrals transformed into this basis (in form eri[i,j,k,l] = (ij|kl))
"""
from pyscf import ao2mo
pmol = mol_to_pyscf(basis.wfn.mol, basis=basis.basisname)
eri = ao2mo.full(pmol, orbs.T, compact=True) * u.hartree
eri.defunits_inplace()
return orbitals.ERI4FoldTensor(eri, orbs)
def test_from_integral(self):
tmpfcidump = tempfile.NamedTemporaryFile()
h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff))
h2 = ao2mo.full(mf._eri, mf.mo_coeff)
fcidump.from_integrals(tmpfcidump.name,
h1,
h2,
h1.shape[0],
mol.nelectron,
tol=1e-15)
def __init__(self):
self.__dict__.update(cis.__dict__)
self.h1e = reduce(numpy.dot, (mo.T, scf.hf.get_hcore(mol), mo))
self.eri = ao2mo.full(mol, mo)
self.eci = None
self.ci = None
if mol.symmetry:
self.orbsym = symm.label_orb_symm(mol, mol.irrep_id,
mol.symm_orb, mo)
self._keys = set(self.__dict__.keys())
def ao2mo(self, mo_coeff=None):
'''Compute the active space two-particle Hamiltonian.
'''
ncore = self.ncore
ncas = self.ncas
nocc = ncore + ncas
if mo_coeff is None:
ncore = self.ncore
mo_coeff = self.mo_coeff[:,ncore:nocc]
elif mo_coeff.shape[1] != ncas:
mo_coeff = mo_coeff[:,ncore:nocc]
if self._scf._eri is not None:
eri = ao2mo.full(self._scf._eri, mo_coeff,
max_memory=self.max_memory)
else:
eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose,
max_memory=self.max_memory)
return eri
def __init__(self):
self.__dict__.update(cis.__dict__)
self.h1e = reduce(numpy.dot, (mo.T, scf.hf.get_hcore(mol), mo))
self.eri = ao2mo.full(mol, mo)
self.eci = None
self.ci = None
if mol.symmetry:
self.orbsym = symm.label_orb_symm(mol, mol.irrep_id,
mol.symm_orb, mo)
self._keys = set(self.__dict__.keys())
def from_scf(mf, filename, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT):
'''Use the given SCF object to transfrom the 1-electron and 2-electron
integrals then dump them to FCIDUMP.
'''
mo_coeff = mf.mo_coeff
assert mo_coeff.dtype == numpy.double
h1e = reduce(numpy.dot, (mo_coeff.T, mf.get_hcore(), mo_coeff))
if mf._eri is None:
if getattr(mf, 'exxdiv'): # PBC system
eri = mf.with_df.ao2mo(mo_coeff)
else:
eri = ao2mo.full(mf.mol, mo_coeff)
else: # Handle cached integrals or customized systems
eri = ao2mo.full(mf._eri, mo_coeff)
orbsym = getattr(mo_coeff, 'orbsym', None)
nuc = mf.energy_nuc()
from_integrals(filename, h1e, eri, h1e.shape[0], mf.mol.nelec, nuc, 0,
orbsym, tol, float_format)
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 get_ham (self, mo_coeff=None):
if mo_coeff is None: mo_coeff = self.mo_coeff
h0 = self.mol.energy_nuc ()
h1 = self.mol.intor_symmetric ('int1e_kin')
h1 += self.mol.intor_symmetric ('int1e_nuc')
# Gotta at least make an orthonormal basis
if mo_coeff is None:
s0 = self.mol.intor_symmetric ('int1e_ovlp')
e1, mo_coeff = linalg.eigh (h1, b=s0)
h1 = mo_coeff.T @ h1 @ mo_coeff
h1 = h1[np.tril_indices (self.norb)]
h2 = ao2mo.restore (4, ao2mo.full (self.mol, mo_coeff), self.norb)
return mo_coeff, h0, h1, h2
def from_mo(mol, filename, mo_coeff, orbsym=None,
tol=TOL, float_format=DEFAULT_FLOAT_FORMAT):
'''Use the given MOs to transfrom the 1-electron and 2-electron integrals
then dump them to FCIDUMP.
'''
if orbsym is None:
orbsym = getattr(mo_coeff, 'orbsym', None)
t = mol.intor_symmetric('int1e_kin')
v = mol.intor_symmetric('int1e_nuc')
h1e = reduce(numpy.dot, (mo_coeff.T, t+v, mo_coeff))
eri = ao2mo.full(mol, mo_coeff, verbose=0)
nuc = mol.energy_nuc()
from_integrals(filename, h1e, eri, h1e.shape[0], mol.nelec, nuc, 0, orbsym,
tol, float_format)
def test_mp2_dm(self):
nocc = mol.nelectron // 2
nmo = mf.mo_energy.size
nvir = nmo - nocc
co = mf.mo_coeff[:, :nocc]
cv = mf.mo_coeff[:, nocc:]
g = ao2mo.incore.general(mf._eri, (co, cv, co, cv)).ravel()
eia = mf.mo_energy[:nocc, None] - mf.mo_energy[nocc:]
t2ref0 = g / (eia.reshape(-1, 1) + eia.reshape(-1)).ravel()
t2ref0 = t2ref0.reshape(nocc, nvir, nocc, nvir).transpose(0, 2, 3, 1)
pt = mp.mp2.MP2(mf)
emp2, t2 = pt.kernel()
t2s = numpy.zeros((nocc * 2, nocc * 2, nvir * 2, nvir * 2))
t2s[::2, ::2, ::2, ::2] = t2ref0 - t2ref0.transpose(0, 1, 3, 2)
t2s[1::2, 1::2, 1::2, 1::2] = t2ref0 - t2ref0.transpose(0, 1, 3, 2)
t2s[::2, 1::2, 1::2, ::2] = t2ref0
t2s[1::2, ::2, ::2, 1::2] = t2ref0
t2s[::2, 1::2, ::2, 1::2] = -t2ref0.transpose(0, 1, 3, 2)
t2s[1::2, ::2, 1::2, ::2] = -t2ref0.transpose(0, 1, 3, 2)
dm1occ = -.5 * numpy.einsum('ikab,jkab->ij', t2s, t2s)
dm1vir = .5 * numpy.einsum('ijac,ijbc->ab', t2s, t2s)
dm1ref = numpy.zeros((nmo, nmo))
dm1ref[:nocc, :nocc] = dm1occ[::2, ::2] + dm1occ[1::2, 1::2]
dm1ref[nocc:, nocc:] = dm1vir[::2, ::2] + dm1vir[1::2, 1::2]
for i in range(nocc):
dm1ref[i, i] += 2
dm1refao = reduce(numpy.dot, (mf.mo_coeff, dm1ref, mf.mo_coeff.T))
rdm1 = mp.mp2.make_rdm1_ao(pt, mf.mo_energy, mf.mo_coeff)
self.assertTrue(numpy.allclose(rdm1, dm1refao))
self.assertTrue(numpy.allclose(pt.make_rdm1(), dm1ref))
dm2ref = numpy.zeros((nmo * 2, ) * 4)
dm2ref[:nocc * 2, nocc * 2:, :nocc * 2,
nocc * 2:] = t2s.transpose(0, 3, 1, 2) * .5
dm2ref[nocc * 2:, :nocc * 2,
nocc * 2:, :nocc * 2] = t2s.transpose(3, 0, 2, 1) * .5
dm2ref = dm2ref[ ::2, ::2, ::2, ::2] + dm2ref[1::2,1::2,1::2,1::2] \
+ dm2ref[ ::2, ::2,1::2,1::2] + dm2ref[1::2,1::2, ::2, ::2]
eris = ao2mo.restore(1, ao2mo.full(mf._eri, mf.mo_coeff),
mf.mo_coeff.shape[1])
self.assertAlmostEqual(
numpy.einsum('iajb,iajb', eris, dm2ref) * .5, emp2, 9)
for i in range(nocc):
for j in range(nocc):
dm2ref[i, i, j, j] += 4
dm2ref[i, j, j, i] -= 2
self.assertTrue(numpy.allclose(pt.make_rdm2(), dm2ref))
def kernel(self, h1e=None, eri=None, norb=None, nelec=None, ci0=None,
ecore=None, **kwargs):
if h1e is None or eri is None:
if mf is None:
if h1e is None:
h1e = reduce(numpy.dot, (mo.T, scf.hf.get_hcore(mol), mo))
if eri is None:
eri = ao2mo.full(mol, mo)
if ecore is None:
ecore = mol.energy_nuc()
else:
if h1e is None:
h1e = reduce(numpy.dot, (mo.T, mf.get_hcore(mol), mo))
if eri is None:
if mf._eri is None:
eri = ao2mo.full(mol, mo)
else:
eri = ao2mo.full(mf._eri, mo)
if ecore is None:
ecore = mf.energy_nuc()
if norb is None: norb = mo.shape[1]
if nelec is None: nelec = mol.nelec
return cis.__class__.kernel(self, h1e, eri, norb, nelec, ci0,
ecore=ecore, **kwargs)
def test_mp2_dm(self):
nocc = mol.nelectron//2
nmo = mf.mo_energy.size
nvir = nmo - nocc
co = mf.mo_coeff[:,:nocc]
cv = mf.mo_coeff[:,nocc:]
g = ao2mo.incore.general(mf._eri, (co,cv,co,cv)).ravel()
eia = mf.mo_energy[:nocc,None] - mf.mo_energy[nocc:]
t2ref0 = g/(eia.reshape(-1,1)+eia.reshape(-1)).ravel()
t2ref0 = t2ref0.reshape(nocc,nvir,nocc,nvir).transpose(0,2,3,1)
pt = mp.mp2.MP2(mf)
emp2, t2 = pt.kernel()
t2s = numpy.zeros((nocc*2,nocc*2,nvir*2,nvir*2))
t2s[ ::2, ::2, ::2, ::2] = t2ref0 - t2ref0.transpose(0,1,3,2)
t2s[1::2,1::2,1::2,1::2] = t2ref0 - t2ref0.transpose(0,1,3,2)
t2s[ ::2,1::2,1::2, ::2] = t2ref0
t2s[1::2, ::2, ::2,1::2] = t2ref0
t2s[ ::2,1::2, ::2,1::2] = -t2ref0.transpose(0,1,3,2)
t2s[1::2, ::2,1::2, ::2] = -t2ref0.transpose(0,1,3,2)
dm1occ =-.5 * numpy.einsum('ikab,jkab->ij', t2s, t2s)
dm1vir = .5 * numpy.einsum('ijac,ijbc->ab', t2s, t2s)
dm1ref = numpy.zeros((nmo,nmo))
dm1ref[:nocc,:nocc] = dm1occ[ ::2, ::2]+dm1occ[1::2,1::2]
dm1ref[nocc:,nocc:] = dm1vir[ ::2, ::2]+dm1vir[1::2,1::2]
for i in range(nocc):
dm1ref[i,i] += 2
dm1refao = reduce(numpy.dot, (mf.mo_coeff, dm1ref, mf.mo_coeff.T))
rdm1 = mp.mp2.make_rdm1_ao(pt, mf.mo_energy, mf.mo_coeff)
self.assertTrue(numpy.allclose(rdm1, dm1refao))
self.assertTrue(numpy.allclose(pt.make_rdm1(), dm1ref))
dm2ref = numpy.zeros((nmo*2,)*4)
dm2ref[:nocc*2,nocc*2:,:nocc*2,nocc*2:] = t2s.transpose(0,3,1,2) * .5
dm2ref[nocc*2:,:nocc*2,nocc*2:,:nocc*2] = t2s.transpose(3,0,2,1) * .5
dm2ref = dm2ref[ ::2, ::2, ::2, ::2] + dm2ref[1::2,1::2,1::2,1::2] \
+ dm2ref[ ::2, ::2,1::2,1::2] + dm2ref[1::2,1::2, ::2, ::2]
eris = ao2mo.restore(1, ao2mo.full(mf._eri, mf.mo_coeff), mf.mo_coeff.shape[1])
self.assertAlmostEqual(numpy.einsum('iajb,iajb', eris, dm2ref)*.5, emp2, 9)
for i in range(nocc):
for j in range(nocc):
dm2ref[i,i,j,j] += 4
dm2ref[i,j,j,i] -= 2
self.assertTrue(numpy.allclose(pt.make_rdm2(), dm2ref))
def __init__(self, cc, mo_coeff):
nocc = numpy.count_nonzero(cc.mo_occ > 0)
eri0 = ao2mo.full(cc._scf._eri, mo_coeff)
eri0 = ao2mo.restore(1, eri0, mo_coeff.shape[1])
eri0 = eri0.reshape((mo_coeff.shape[1],)*4)
self.oooo = eri0[:nocc,:nocc,:nocc,:nocc].copy()
self.ooov = eri0[:nocc,:nocc,:nocc,nocc:].copy()
self.ovoo = eri0[:nocc,nocc:,:nocc,:nocc].copy()
self.oovo = eri0[:nocc,:nocc,nocc:,:nocc].copy()
self.oovv = eri0[:nocc,:nocc,nocc:,nocc:].copy()
self.ovov = eri0[:nocc,nocc:,:nocc,nocc:].copy()
self.ovvo = eri0[:nocc,nocc:,nocc:,:nocc].copy()
self.ovvv = eri0[:nocc,nocc:,nocc:,nocc:].copy()
self.vvvv = eri0[nocc:,nocc:,nocc:,nocc:].copy()
self.vvvo = eri0[nocc:,nocc:,nocc:,:nocc].copy()
self.vovv = eri0[nocc:,:nocc,nocc:,nocc:].copy()
self.vvov = eri0[nocc:,nocc:,:nocc,nocc:].copy()
self.vvoo = eri0[nocc:,nocc:,:nocc,:nocc].copy()
self.voov = eri0[nocc:,:nocc,:nocc,nocc:].copy()
self.vooo = eri0[nocc:,:nocc,:nocc,:nocc].copy()
self.mo_coeff = mo_coeff
self.fock = numpy.diag(cc._scf.mo_energy)
def update_l1l2(mf, t1, t2, l1, l2, orbspin):
mol = mf.mol
nao,nmo = mf.mo_coeff[0].shape
nelec = mol.nelectron
nso = nmo * 2
hcore = mf.get_hcore()
mo = np.zeros((nao,nso))
mo[:,orbspin==0] = mf.mo_coeff[0]
mo[:,orbspin==1] = mf.mo_coeff[1]
h1e = reduce(np.dot, (mo.T, hcore, mo))
h1e[orbspin[:,None]!=orbspin] = 0
int2e = ao2mo.full(mf._eri, mo)
sym_forbid = (orbspin[:,None] != orbspin)[np.tril_indices(nso)]
int2e[sym_forbid] = 0
int2e[:,sym_forbid] = 0
int2e = ao2mo.restore(1, int2e, nso)
int2e = int2e.transpose(0,2,1,3)
int2e = int2e - int2e.transpose(0,1,3,2)
mycc = ccsd(nso,nelec,h1e,int2e,h1e_is_fock=False)
l1, l2 = update_l1l2_sub(mycc, t1, t2, l1, l2)
return l1, l2
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 writeNumpyforMRLCC(mc, E1, E2, frozen) :
ncore = mc.ncore
nact = mc.ncas
norbs = mc.mo_coeff.shape[1]
nelec = mc.nelecas[0]+mc.nelecas[1]
nvirt = norbs - ncore-nact
nc = ncore+nact
nactElec = nelec - 2*ncore
#this is chemistry notation
int2popo = ao2mo.outcore.general_iofree(mc.mol, (mc.mo_coeff, mc.mo_coeff[:,:nc], mc.mo_coeff, mc.mo_coeff[:,:nc]), compact=False)
int2ppoo = ao2mo.outcore.general_iofree(mc.mol, (mc.mo_coeff, mc.mo_coeff, mc.mo_coeff[:,:nc], mc.mo_coeff[:,:nc]), compact=False)
int2popo.shape=(norbs, nc, norbs, nc)
int2ppoo.shape=(norbs, norbs, nc, nc)
mo = mc.mo_coeff
dmcore = numpy.dot(mo[:,:frozen], mo[:,:frozen].T)*2
vj, vk = mc._scf.get_jk(mc.mol, dmcore)
vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo))
int1 = reduce(numpy.dot, (mc.mo_coeff.T, mc.get_hcore(), mc.mo_coeff)) +vhfcore
dmcore = numpy.dot(mo[:,:ncore], mo[:,:ncore].T)*2
vj, vk = mc._scf.get_jk(mc.mol, dmcore)
vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo))
int1_eff = reduce(numpy.dot, (mc.mo_coeff.T, mc.get_hcore(), mc.mo_coeff)) +vhfcore
#int1_eff = makeheff(int1, int2popo, int2ppoo, E1, ncore, nvirt, frozen)
energy_frozen_core = numpy.einsum('ij,ji', dmcore, mc.get_hcore()) \
+ numpy.einsum('ij,ji', dmcore, vj-0.5*vk) * .5
#numpy.save("int/E3",E3)
#numpy.save("int/E3B.npy", E3.transpose(0,3,1,4,2,5))
#numpy.save("int/E3C.npy", E3.transpose(5,0,2,4,1,3))
numpy.save("int/E2",numpy.asfortranarray(E2))
numpy.save("int/E1",numpy.asfortranarray(E1))
#numpy.save("int/int2",int2)
numpy.save("int/int1",numpy.asfortranarray(int1[frozen:,frozen:]))
numpy.save("int/int1eff",numpy.asfortranarray(int1_eff[frozen:, frozen:]))
numpy.save("int/W:caca", numpy.asfortranarray(int2ppoo[frozen:ncore, frozen:ncore, ncore:nc, ncore:nc].transpose(0,2,1,3)))
numpy.save("int/W:caac", numpy.asfortranarray(int2popo[frozen:ncore,ncore:nc, ncore:nc, frozen:ncore].transpose(0,2,1,3)))
numpy.save("int/W:cece", numpy.asfortranarray(int2ppoo[nc:, nc:, frozen:ncore, frozen:ncore].transpose(2,0,3,1)))
numpy.save("int/W:ceec", numpy.asfortranarray(int2popo[nc:, frozen:ncore, nc:, frozen:ncore].transpose(1,2,0,3)))
numpy.save("int/W:aeae", numpy.asfortranarray(int2ppoo[nc:, nc:, ncore:nc,ncore:nc].transpose(2,0,3,1)))
numpy.save("int/W:aeea", numpy.asfortranarray(int2popo[nc:, ncore:nc,nc:, ncore:nc].transpose(1,2,0,3)))
numpy.save("int/W:cccc", numpy.asfortranarray(int2ppoo[frozen:ncore,frozen:ncore, frozen:ncore, frozen:ncore].transpose(0,2,1,3)))
numpy.save("int/W:aaaa", numpy.asfortranarray(int2ppoo[ncore:nc,ncore:nc, ncore:nc, ncore:nc].transpose(0,2,1,3)))
feri = h5py.File("int/int2eeee.hdf5", 'w')
ao2mo.full(mc.mol, mc.mo_coeff[:,nc:], feri, compact=False)
for o in range(nvirt):
int2eee = feri['eri_mo'][o*(norbs-nc):(o+1)*(norbs-nc),:]
numpy.asfortranarray(int2eee).tofile("int/W:eeee%04d"%(o))
#store perturbers
numpy.save("int/W:eecc", numpy.asfortranarray(int2popo[nc:,frozen:ncore,nc:,frozen:ncore].transpose(0,2,1,3)))
numpy.save("int/W:eeca", numpy.asfortranarray(int2popo[nc:,frozen:ncore, nc:, ncore:nc].transpose(0,2,1,3)))
numpy.save("int/W:ccaa", numpy.asfortranarray(int2popo[frozen:ncore,ncore:nc, frozen:ncore, ncore:nc].transpose(0,2,1,3)))
numpy.save("int/W:eeaa", numpy.asfortranarray(int2popo[nc:,ncore:nc, nc:, ncore:nc].transpose(0,2,1,3)))
numpy.save("int/W:eaca", numpy.asfortranarray(int2popo[nc:,frozen:ncore, ncore:nc, ncore:nc].transpose(0,2,1,3)))
numpy.save("int/W:aeca", numpy.asfortranarray(int2popo[ncore:nc,frozen:ncore, nc:,ncore:nc].transpose(0,2,1,3)))
numpy.save("int/W:ccae", numpy.asfortranarray(int2popo[frozen:ncore,ncore:nc, nc:, frozen:ncore].transpose(0,3,1,2)))
#write FCIDUMP_AAAV and FCIDUMP_AAAC
from pyscf import symm
mol = mc.mol
orbsymout=[]
orbsym = []
if (mol.symmetry):
orbsym = symm.label_orb_symm(mc.mol, mc.mol.irrep_id,
mc.mol.symm_orb, mc.mo_coeff, s=mc._scf.get_ovlp())
if mol.symmetry and orbsym:
if mol.groupname.lower() == 'dooh':
orbsymout = [dmrg_sym.IRREP_MAP['D2h'][i % 10] for i in orbsym]
elif mol.groupname.lower() == 'coov':
orbsymout = [dmrg_sym.IRREP_MAP['C2v'][i % 10] for i in orbsym]
else:
orbsymout = [dmrg_sym.IRREP_MAP[mol.groupname][i] for i in orbsym]
else:
orbsymout = []
'''
dmcore = numpy.dot(mo[:,frozen:ncore], mo[:,frozen:ncore].T)*2
vj, vk = mc._scf.get_jk(mc.mol, dmcore)
vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo))
h1eff = int1+vhfcore
energy_core = numpy.einsum('ij,ji', dmcore, mc.get_hcore()) \
+ numpy.einsum('ij,ji', dmcore, vj-0.5*vk) * .5\
+energy_frozen_core
'''
dmcore = numpy.dot(mo[:,:ncore], mo[:,:ncore].T)*2
vj, vk = mc._scf.get_jk(mc.mol, dmcore)
vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo))
h1eff = int1_eff
energy_core = numpy.einsum('ij,ji', dmcore, mc.get_hcore()) \
+ numpy.einsum('ij,ji', dmcore, vj-0.5*vk) * .5
#print energy_core2+mc.mol.energy_nuc(), energy_core+mc.mol.energy_nuc(), energy_frozen_core+mc.mol.energy_nuc()
nc = mc.ncore+mc.ncas
energyE0 = 1.0*numpy.einsum('ij,ij', h1eff[ncore:nc, ncore:nc], E1)
#+ 0.5*numpy.einsum('ikjl,ijkl', E2, int2ppoo[ncore:,ncore:,ncore:,ncore:])
for i in range(mc.ncas):
for j in range(mc.ncas):
for k in range(mc.ncas):
for l in range(mc.ncas):
I,J = max(i,j)+ncore, min(i,j)+ncore
K,L = max(k,l)+ncore, min(k,l)+ncore
energyE0 += 0.5*E2[i,k,j,l] * int2ppoo[i+ncore, j+ncore, k+ncore, l+ncore]
energyE0 += energy_core
energyE0 += mc.mol.energy_nuc()
print "Energy = ", energyE0
fout = open('FCIDUMP_aaav0','w')
tools.fcidump.write_head(fout, int1.shape[0]-ncore, mc.mol.nelectron-2*ncore, orbsym= orbsymout[ncore:])
for i in range(ncore,int1.shape[0]):
for j in range(ncore, i+1):
for k in range(mc.ncas):
for l in range(k+1):
if abs(int2ppoo[i,j, k+ncore,l+ncore]) > 1.e-8 :
fout.write(' %17.9e %4d %4d %4d %4d\n' \
% (int2ppoo[i,j, k+ncore,l+ncore], i+1-ncore, j+1-ncore, k+1, l+1))
if (j >= nc and abs(int2popo[i, k+ncore, j, l+ncore]) > 1.e-8):
fout.write(' %17.9e %4d %4d %4d %4d\n' \
% (int2popo[i,k+ncore,j, l+ncore], i+1-ncore, k+1, l+1, j+1-ncore))
if (j >= nc and abs(int2popo[i, l+ncore, j, k+ncore]) > 1.e-8):
fout.write(' %17.9e %4d %4d %4d %4d\n' \
% (int2popo[i,l+ncore, j, k+ncore], i+1-ncore, l+1, k+1, j+1-ncore))
tools.fcidump.write_hcore(fout, h1eff[ncore:,ncore:], int1.shape[0]-ncore, tol=1e-8)
fout.write(' %17.9e 0 0 0 0\n' %( mc.mol.energy_nuc()+energy_core-energyE0))
fout.close()
nc = ncore+mc.ncas
eri1cas = ao2mo.outcore.general_iofree(mc.mol, (mc.mo_coeff[:,frozen:nc], mc.mo_coeff[:,frozen:nc], mc.mo_coeff[:,frozen:nc], mc.mo_coeff[:,frozen:nc]), compact=True)
tools.fcidump.from_integrals("FCIDUMP_aaac", int1[frozen:nc,frozen:nc], eri1cas, nc-frozen, mc.mol.nelectron-2*frozen, nuc=mc.mol.energy_nuc()-energyE0, orbsym = orbsymout[frozen:nc], tol=1e-8)
return energyE0, norbs
def kernel(mc, mo_coeff=None, ci=None, atmlst=None, mf_grad=None,
verbose=None):
if mo_coeff is None: mo_coeff = mc._scf.mo_coeff
if ci is None: ci = mc.ci
if mf_grad is None: mf_grad = mc._scf.nuc_grad_method()
mol = mc.mol
ncore = mc.ncore
ncas = mc.ncas
nocc = ncore + ncas
nelecas = mc.nelecas
nao, nmo = mo_coeff.shape
nao_pair = nao * (nao+1) // 2
mo_energy = mc._scf.mo_energy
hcore_deriv = mf_grad.hcore_generator(mol)
s1 = mf_grad.get_ovlp(mol)
mo_occ = mo_coeff[:,:nocc]
mo_core = mo_coeff[:,:ncore]
mo_cas = mo_coeff[:,ncore:nocc]
casdm1, casdm2 = mc.fcisolver.make_rdm12(mc.ci, ncas, nelecas)
# gfock = Generalized Fock, Adv. Chem. Phys., 69, 63
dm_core = numpy.dot(mo_core, mo_core.T) * 2
dm_cas = reduce(numpy.dot, (mo_cas, casdm1, mo_cas.T))
aapa = ao2mo.kernel(mol, (mo_cas, mo_cas, mo_occ, mo_cas), compact=False)
aapa = aapa.reshape(ncas,ncas,nocc,ncas)
vj, vk = mc._scf.get_jk(mol, (dm_core, dm_cas))
h1 = mc.get_hcore()
vhf_c = vj[0] - vk[0] * .5
vhf_a = vj[1] - vk[1] * .5
gfock = reduce(numpy.dot, (mo_occ.T, h1 + vhf_c + vhf_a, mo_occ)) * 2
gfock[:,ncore:nocc] = reduce(numpy.dot, (mo_occ.T, h1 + vhf_c, mo_cas, casdm1))
gfock[:,ncore:nocc] += numpy.einsum('uviw,vuwt->it', aapa, casdm2)
dme0 = reduce(numpy.dot, (mo_occ, (gfock+gfock.T)*.5, mo_occ.T))
aapa = vj = vk = vhf_c = vhf_a = h1 = gfock = None
dm1 = dm_core + dm_cas
vhf1c, vhf1a = mf_grad.get_veff(mol, (dm_core, dm_cas))
diag_idx = numpy.arange(nao)
diag_idx = diag_idx * (diag_idx+1) // 2 + diag_idx
casdm2_cc = casdm2 + casdm2.transpose(0,1,3,2)
dm2buf = ao2mo._ao2mo.nr_e2(casdm2_cc.reshape(ncas**2,ncas**2), mo_cas.T,
(0, nao, 0, nao)).reshape(ncas**2,nao,nao)
dm2buf = lib.pack_tril(dm2buf)
dm2buf[:,diag_idx] *= .5
dm2buf = dm2buf.reshape(ncas,ncas,nao_pair)
#casdm2 = casdm2_cc = None
atmlst = range(mol.natm)
aoslices = mol.aoslice_by_atom()
de = numpy.zeros((len(atmlst),3))
max_memory = mc.max_memory - lib.current_memory()[0]
blksize = int(max_memory*.9e6/8 / ((aoslices[:,3]-aoslices[:,2]).max()*nao_pair))
blksize = min(nao, max(2, blksize))
for k, ia in enumerate(atmlst):
shl0, shl1, p0, p1 = aoslices[ia]
h1ao = hcore_deriv(ia)
de[k] += numpy.einsum('xij,ij->x', h1ao, dm1)
#de[k] -= numpy.einsum('xij,ij->x', s1[:,p0:p1], dme0[p0:p1]) * 2
q1 = 0
for b0, b1, nf in _shell_prange(mol, 0, mol.nbas, blksize):
q0, q1 = q1, q1 + nf
dm2_ao = lib.einsum('ijw,pi,qj->pqw', dm2buf, mo_cas[p0:p1], mo_cas[q0:q1])
shls_slice = (shl0,shl1,b0,b1,0,mol.nbas,0,mol.nbas)
eri1 = mol.intor('int2e_ip1', comp=3, aosym='s2kl',
shls_slice=shls_slice).reshape(3,p1-p0,nf,nao_pair)
de[k] -= numpy.einsum('xijw,ijw->x', eri1, dm2_ao) * 2
eri1 = None
de[k] += numpy.einsum('xij,ij->x', vhf1c[:,p0:p1], dm1[p0:p1]) * 2
de[k] += numpy.einsum('xij,ij->x', vhf1a[:,p0:p1], dm_core[p0:p1]) * 2
dm2 = numpy.zeros((nmo,nmo,nmo,nmo))
for i in range(ncore):
for j in range(ncore):
dm2[i,i,j,j] += 4
dm2[i,j,j,i] -= 2
dm2[i,i,ncore:nocc,ncore:nocc] = casdm1 * 2
dm2[ncore:nocc,ncore:nocc,i,i] = casdm1 * 2
dm2[i,ncore:nocc,ncore:nocc,i] =-casdm1
dm2[ncore:nocc,i,i,ncore:nocc] =-casdm1
dm2[ncore:nocc,ncore:nocc,ncore:nocc,ncore:nocc] = casdm2
eri0 = ao2mo.restore(1, ao2mo.full(mc._scf._eri, mo_coeff), nmo)
Imat = numpy.einsum('pjkl,qjkl->pq', eri0, dm2)
dm1 = numpy.zeros((nmo,nmo))
for i in range(ncore):
dm1[i,i] = 2
dm1[ncore:nocc,ncore:nocc] = casdm1
neleca, nelecb = mol.nelec
h1 =-(mol.intor('int1e_ipkin', comp=3)
+mol.intor('int1e_ipnuc', comp=3))
s1 =-mol.intor('int1e_ipovlp', comp=3)
eri1 = mol.intor('int2e_ip1', comp=3).reshape(3,nao,nao,nao,nao)
eri1 = numpy.einsum('xipkl,pj->xijkl', eri1, mo_coeff)
eri1 = numpy.einsum('xijpl,pk->xijkl', eri1, mo_coeff)
eri1 = numpy.einsum('xijkp,pl->xijkl', eri1, mo_coeff)
h0 = reduce(numpy.dot, (mo_coeff.T, mc._scf.get_hcore(), mo_coeff))
g0 = ao2mo.restore(1, ao2mo.full(mol, mo_coeff), nmo)
def hess():
nocc = mol.nelectron//2
nvir = nmo - nocc
eri_mo = g0
eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc])
h = eri_mo[nocc:,:nocc,nocc:,:nocc] * 4
h-= numpy.einsum('cdlk->ckdl', eri_mo[nocc:,nocc:,:nocc,:nocc])
h-= numpy.einsum('cldk->ckdl', eri_mo[nocc:,:nocc,nocc:,:nocc])
for a in range(nvir):
for i in range(nocc):
h[a,i,a,i] += eai[a,i]
return -h.reshape(nocc*nvir,-1)
hh = hess()
ee = mo_energy[:,None] - mo_energy
for k,(sh0, sh1, p0, p1) in enumerate(mol.offset_nr_by_atom()):
mol.set_rinv_origin(mol.atom_coord(k))
vrinv = -mol.atom_charge(k) * mol.intor('int1e_iprinv', comp=3)
# 2e AO integrals dot 2pdm
for i in range(3):
g1 = numpy.einsum('pjkl,pi->ijkl', eri1[i,p0:p1], mo_coeff[p0:p1])
g1 = g1 + g1.transpose(1,0,2,3)
g1 = g1 + g1.transpose(2,3,0,1)
g1 *= -1
hx =(numpy.einsum('pq,pi,qj->ij', h1[i,p0:p1], mo_coeff[p0:p1], mo_coeff)
+ reduce(numpy.dot, (mo_coeff.T, vrinv[i], mo_coeff)))
hx = hx + hx.T
sx = numpy.einsum('pq,pi,qj->ij', s1[i,p0:p1], mo_coeff[p0:p1], mo_coeff)
sx = sx + sx.T
fij =(hx[:neleca,:neleca]
- numpy.einsum('ij,j->ij', sx[:neleca,:neleca], mo_energy[:neleca])
- numpy.einsum('kl,ijlk->ij', sx[:neleca,:neleca],
g0[:neleca,:neleca,:neleca,:neleca]) * 2
+ numpy.einsum('kl,iklj->ij', sx[:neleca,:neleca],
g0[:neleca,:neleca,:neleca,:neleca])
+ numpy.einsum('ijkk->ij', g1[:neleca,:neleca,:neleca,:neleca]) * 2
- numpy.einsum('ikkj->ij', g1[:neleca,:neleca,:neleca,:neleca]))
fab =(hx[neleca:,neleca:]
- numpy.einsum('ij,j->ij', sx[neleca:,neleca:], mo_energy[neleca:])
- numpy.einsum('kl,ijlk->ij', sx[:neleca,:neleca],
g0[neleca:,neleca:,:neleca,:neleca]) * 2
+ numpy.einsum('kl,iklj->ij', sx[:neleca,:neleca],
g0[neleca:,:neleca,:neleca,neleca:])
+ numpy.einsum('ijkk->ij', g1[neleca:,neleca:,:neleca,:neleca]) * 2
- numpy.einsum('ikkj->ij', g1[neleca:,:neleca,:neleca,neleca:]))
fai =(hx[neleca:,:neleca]
- numpy.einsum('ai,i->ai', sx[neleca:,:neleca], mo_energy[:neleca])
- numpy.einsum('kl,ijlk->ij', sx[:neleca,:neleca],
g0[neleca:,:neleca,:neleca,:neleca]) * 2
+ numpy.einsum('kl,iklj->ij', sx[:neleca,:neleca],
g0[neleca:,:neleca,:neleca,:neleca])
+ numpy.einsum('ijkk->ij', g1[neleca:,:neleca,:neleca,:neleca]) * 2
- numpy.einsum('ikkj->ij', g1[neleca:,:neleca,:neleca,:neleca]))
c1 = numpy.zeros((nmo,nmo))
c1[:neleca,:neleca] = -.5 * sx[:neleca,:neleca]
c1[neleca:,neleca:] = -.5 * sx[neleca:,neleca:]
cvo1 = numpy.linalg.solve(hh, fai.ravel()).reshape(-1,neleca)
cov1 = -(sx[neleca:,:neleca] + cvo1).T
c1[neleca:,:neleca] = cvo1
c1[:neleca,neleca:] = cov1
v1 = numpy.einsum('pqai,ai->pq', g0[:,:,neleca:,:neleca], cvo1) * 4
v1-= numpy.einsum('paiq,ai->pq', g0[:,neleca:,:neleca,:], cvo1)
v1-= numpy.einsum('piaq,ai->pq', g0[:,:neleca,neleca:,:], cvo1)
fij += v1[:neleca,:neleca]
fab += v1[neleca:,neleca:]
c1[:ncore,ncore:neleca] = -fij[:ncore,ncore:] / ee[:ncore,ncore:neleca]
c1[ncore:neleca,:ncore] = -fij[ncore:,:ncore] / ee[ncore:neleca,:ncore]
m = nocc - neleca
c1[nocc:,neleca:nocc] = -fab[m:,:m] / ee[nocc:,neleca:nocc]
c1[neleca:nocc,nocc:] = -fab[:m,m:] / ee[neleca:nocc,nocc:]
h0c1 = h0.dot(c1)
h0c1 = h0c1 + h0c1.T
g0c1 = numpy.einsum('pjkl,pi->ijkl', g0, c1)
g0c1 = g0c1 + g0c1.transpose(1,0,2,3)
g0c1 = g0c1 + g0c1.transpose(2,3,0,1)
de[k,i] += numpy.einsum('ij,ji', h0c1, dm1)
de[k,i] += numpy.einsum('ijkl,jilk', g0c1, dm2)*.5
de += rhf_grad.grad_nuc(mol)
return de
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 __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 test_from_integral(self):
tmpfcidump = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff))
h2 = ao2mo.full(mf._eri, mf.mo_coeff)
fcidump.from_integrals(tmpfcidump.name, h1, h2, h1.shape[0],
mol.nelectron, tol=1e-15)
def kernel(cc, t1, t2, l1, l2, eris=None):
if eris is None:
eris = _ERIS(cc, cc.mo_coeff)
mol = cc.mol
mo_coeff = cc.mo_coeff
mo_energy = cc._scf.mo_energy
nao, nmo = mo_coeff.shape
nocc = numpy.count_nonzero(cc.mo_occ > 0)
nvir = nmo - nocc
mo_e_o = mo_energy[:nocc]
mo_e_v = mo_energy[nocc:]
with_frozen = not (cc.frozen is None or cc.frozen is 0)
d1 = _gamma1_intermediates(cc, t1, t2, l1, l2)
d2 = _gamma2_intermediates(cc, t1, t2, l1, l2)
dm2 = ccsd_rdm._make_rdm2(cc, d1, d2, with_dm1=False, with_frozen=False)
eri = ao2mo.restore(1, ao2mo.full(cc.mol, mo_coeff), nmo)
Imat = numpy.einsum('jqrs,iqrs->ij', dm2, eri) * -1
Ioo = Imat[:nocc,:nocc]
Ivv = Imat[nocc:,nocc:]
doo, dov, dvo, dvv = d1
if with_frozen:
OA, VA, OF, VF = index_frozen_active(cc)
doo[OF[:,None],OA] = Ioo[OF[:,None],OA] / lib.direct_sum('i-j->ij', mo_e_o[OF], mo_e_o[OA])
doo[OA[:,None],OF] = Ioo[OA[:,None],OF] / lib.direct_sum('i-j->ij', mo_e_o[OA], mo_e_o[OF])
dvv[VF[:,None],VA] = Ivv[VF[:,None],VA] / lib.direct_sum('a-b->ab', mo_e_v[VF], mo_e_v[VA])
dvv[VA[:,None],VF] = Ivv[VA[:,None],VF] / lib.direct_sum('a-b->ab', mo_e_v[VA], mo_e_v[VF])
dm1 = scipy.linalg.block_diag(doo+doo.T, dvv+dvv.T)
dm1ao = reduce(numpy.dot, (mo_coeff, dm1, mo_coeff.T))
vj, vk = cc._scf.get_jk(cc.mol, dm1ao)
Xvo = reduce(numpy.dot, (mo_coeff[:,nocc:].T, vj*2-vk, mo_coeff[:,:nocc]))
Xvo += Imat[:nocc,nocc:].T - Imat[nocc:,:nocc]
dm1 += ccsd_grad._response_dm1(cc, Xvo, eris)
Imat[nocc:,:nocc] = Imat[:nocc,nocc:].T
h1 =-(mol.intor('int1e_ipkin', comp=3)
+mol.intor('int1e_ipnuc', comp=3))
s1 =-mol.intor('int1e_ipovlp', comp=3)
zeta = lib.direct_sum('i-j->ij', mo_energy, mo_energy)
eri1 = mol.intor('int2e_ip1', comp=3).reshape(3,nao,nao,nao,nao)
eri1 = numpy.einsum('xipkl,pj->xijkl', eri1, mo_coeff)
eri1 = numpy.einsum('xijpl,pk->xijkl', eri1, mo_coeff)
eri1 = numpy.einsum('xijkp,pl->xijkl', eri1, mo_coeff)
g0 = ao2mo.restore(1, ao2mo.full(mol, mo_coeff), nmo)
de = numpy.empty((mol.natm,3))
for k,(sh0, sh1, p0, p1) in enumerate(mol.offset_nr_by_atom()):
mol.set_rinv_origin(mol.atom_coord(k))
vrinv = -mol.atom_charge(k) * mol.intor('int1e_iprinv', comp=3)
# 2e AO integrals dot 2pdm
de2 = numpy.zeros(3)
for i in range(3):
g1 = numpy.einsum('pjkl,pi->ijkl', eri1[i,p0:p1], mo_coeff[p0:p1])
g1 = g1 + g1.transpose(1,0,2,3)
g1 = g1 + g1.transpose(2,3,0,1)
g1 *= -1
hx =(numpy.einsum('pq,pi,qj->ij', h1[i,p0:p1], mo_coeff[p0:p1], mo_coeff)
+ reduce(numpy.dot, (mo_coeff.T, vrinv[i], mo_coeff)))
hx = hx + hx.T
sx = numpy.einsum('pq,pi,qj->ij', s1[i,p0:p1], mo_coeff[p0:p1], mo_coeff)
sx = sx + sx.T
fij =(hx[:nocc,:nocc]
- numpy.einsum('ij,j->ij', sx[:nocc,:nocc], mo_e_o) * .5
- numpy.einsum('ij,i->ij', sx[:nocc,:nocc], mo_e_o) * .5
- numpy.einsum('kl,ijlk->ij', sx[:nocc,:nocc],
g0[:nocc,:nocc,:nocc,:nocc]) * 2
+ numpy.einsum('kl,iklj->ij', sx[:nocc,:nocc],
g0[:nocc,:nocc,:nocc,:nocc])
+ numpy.einsum('ijkk->ij', g1[:nocc,:nocc,:nocc,:nocc]) * 2
- numpy.einsum('ikkj->ij', g1[:nocc,:nocc,:nocc,:nocc]))
fab =(hx[nocc:,nocc:]
- numpy.einsum('ij,j->ij', sx[nocc:,nocc:], mo_e_v) * .5
- numpy.einsum('ij,i->ij', sx[nocc:,nocc:], mo_e_v) * .5
- numpy.einsum('kl,ijlk->ij', sx[:nocc,:nocc],
g0[nocc:,nocc:,:nocc,:nocc]) * 2
+ numpy.einsum('kl,iklj->ij', sx[:nocc,:nocc],
g0[nocc:,:nocc,:nocc,nocc:])
+ numpy.einsum('ijkk->ij', g1[nocc:,nocc:,:nocc,:nocc]) * 2
- numpy.einsum('ikkj->ij', g1[nocc:,:nocc,:nocc,nocc:]))
if with_frozen:
fij[OA[:,None],OF] -= numpy.einsum('ij,j->ij', sx[OA[:,None],OF], mo_e_o[OF]) * .5
fij[OA[:,None],OF] += numpy.einsum('ij,i->ij', sx[OA[:,None],OF], mo_e_o[OA]) * .5
fij[OF[:,None],OA] -= numpy.einsum('ij,j->ij', sx[OF[:,None],OA], mo_e_o[OA]) * .5
fij[OF[:,None],OA] += numpy.einsum('ij,i->ij', sx[OF[:,None],OA], mo_e_o[OF]) * .5
fab[VA[:,None],VF] -= numpy.einsum('ij,j->ij', sx[VA[:,None],VF], mo_e_v[VF]) * .5
fab[VA[:,None],VF] += numpy.einsum('ij,i->ij', sx[VA[:,None],VF], mo_e_v[VA]) * .5
fab[VF[:,None],VA] -= numpy.einsum('ij,j->ij', sx[VF[:,None],VA], mo_e_v[VA]) * .5
fab[VF[:,None],VA] += numpy.einsum('ij,i->ij', sx[VF[:,None],VA], mo_e_v[VF]) * .5
fai =(hx[nocc:,:nocc]
- numpy.einsum('ai,i->ai', sx[nocc:,:nocc], mo_e_o)
- numpy.einsum('kl,ijlk->ij', sx[:nocc,:nocc],
g0[nocc:,:nocc,:nocc,:nocc]) * 2
+ numpy.einsum('kl,iklj->ij', sx[:nocc,:nocc],
g0[nocc:,:nocc,:nocc,:nocc])
+ numpy.einsum('ijkk->ij', g1[nocc:,:nocc,:nocc,:nocc]) * 2
- numpy.einsum('ikkj->ij', g1[nocc:,:nocc,:nocc,:nocc]))
f1 = numpy.zeros((nmo,nmo))
f1[:nocc,:nocc] = fij
f1[nocc:,nocc:] = fab
f1[nocc:,:nocc] = fai
f1[:nocc,nocc:] = fai.T
de2[i] += numpy.einsum('ij,ji', f1, dm1)
de2[i] += numpy.einsum('ij,ji', sx, Imat)
de2[i] += numpy.einsum('iajb,iajb', dm2, g1) * .5
de[k] = de2
return de
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
mol.basis = "cc-pvdz"
mol.build()
rhf = scf.RHF(mol)
rhf.conv_tol = 1e-16
rhf.scf()
mcc = ccsd.CCSD(rhf)
mcc.conv_tol = 1e-12
ecc, t1, t2 = mcc.kernel()
nmo = rhf.mo_energy.size
fock0 = numpy.diag(rhf.mo_energy)
nocc = mol.nelectron // 2
nvir = nmo - nocc
eris = mcc.ao2mo()
conv, l1, l2 = kernel(mcc, eris, t1, t2, tol=1e-8)
print(numpy.linalg.norm(l1) - 0.0132626841292)
print(numpy.linalg.norm(l2) - 0.212575609057)
from pyscf.cc import ccsd_rdm
dm1 = ccsd_rdm.make_rdm1(mcc, t1, t2, l1, l2)
dm2 = ccsd_rdm.make_rdm2(mcc, t1, t2, l1, l2)
h1 = reduce(numpy.dot, (rhf.mo_coeff.T, rhf.get_hcore(), rhf.mo_coeff))
eri = ao2mo.full(rhf._eri, rhf.mo_coeff)
eri = ao2mo.restore(1, eri, nmo).reshape((nmo,) * 4)
e1 = numpy.einsum("pq,pq", h1, dm1)
e2 = numpy.einsum("pqrs,pqrs", eri, dm2) * 0.5
print(e1 + e2 + mol.energy_nuc() - rhf.e_tot - ecc)
# Author: Qiming Sun <*****@*****.**>
#
'''
Assign spin state for HCI wavefunction.
If spin-contamination is observed for HCI wavefunction, :func:`hci.fix_spin`
function can be used to level shift the states of wrong spin. This is often
helpful to reduce the spin-contamination.
'''
from pyscf import gto, scf, ao2mo
from pyscf.hci import hci
mol = gto.M(atom='O 0 0 0', basis='631g', spin=0)
myhf = scf.RHF(mol).run()
cisolver = hci.SCI(mol)
nmo = myhf.mo_coeff.shape[1]
nelec = mol.nelec
h1 = myhf.mo_coeff.T.dot(myhf.get_hcore()).dot(myhf.mo_coeff)
h2 = ao2mo.full(mol, myhf.mo_coeff)
e, civec = cisolver.kernel(h1, h2, nmo, nelec, verbose=4)
print('E = %.12f 2S+1 = %.7f' %
(e, cisolver.spin_square(civec[0], nmo, nelec)[1]))
cisolver = hci.fix_spin(cisolver, ss=0) # ss = S^2
e, civec = cisolver.kernel(h1, h2, nmo, nelec, verbose=4)
print('E = %.12f 2S+1 = %.7f' %
(e, cisolver.spin_square(civec[0], nmo, nelec)[1]))
def __init__(self, cc, mo_coeff=None, method='incore',
ao2mofn=ao2mo.outcore.general_iofree):
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: # 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):
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)
# <ij|kl> = (ik|jl)
eri = eri.transpose(0,2,1,3)
self.dtype = eri.dtype
self.oooo = eri[:nocc,:nocc,:nocc,:nocc].copy()
self.ooov = eri[:nocc,:nocc,:nocc,nocc:].copy()
self.oovv = eri[:nocc,:nocc,nocc:,nocc:].copy()
self.ovov = eri[:nocc,nocc:,:nocc,nocc:].copy()
self.voov = eri[nocc:,:nocc,:nocc,nocc:].copy()
self.vovv = eri[nocc:,:nocc,nocc:,nocc:].copy()
self.vvvv = eri[nocc:,nocc:,nocc:,nocc:].copy()
else:
_tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
self.feri1 = h5py.File(_tmpfile1.name)
orbo = mo_coeff[:,:nocc]
orbv = mo_coeff[:,nocc:]
if mo_coeff.dtype == np.complex: ds_type = 'c16'
else: ds_type = 'f8'
self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), ds_type)
self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), ds_type)
self.oovv = self.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), ds_type)
self.ovov = self.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), ds_type)
self.voov = self.feri1.create_dataset('voov', (nvir,nocc,nocc,nvir), ds_type)
self.vovv = self.feri1.create_dataset('vovv', (nvir,nocc,nvir,nvir), ds_type)
self.vvvv = self.feri1.create_dataset('vvvv', (nvir,nvir,nvir,nvir), ds_type)
cput1 = time.clock(), time.time()
# <ij|pq> = (ip|jq)
buf = ao2mofn(cc._scf.mol, (orbo,mo_coeff,orbo,mo_coeff), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc,nmo,nocc,nmo)).transpose(0,2,1,3)
cput1 = log.timer_debug1('transforming oopq', *cput1)
self.dtype = buf.dtype
self.oooo[:,:,:,:] = buf[:,:,:nocc,:nocc]
self.ooov[:,:,:,:] = buf[:,:,:nocc,nocc:]
self.oovv[:,:,:,:] = buf[:,:,nocc:,nocc:]
cput1 = time.clock(), time.time()
# <ia|pq> = (ip|aq)
buf = ao2mofn(cc._scf.mol, (orbo,mo_coeff,orbv,mo_coeff), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc,nmo,nvir,nmo)).transpose(0,2,1,3)
cput1 = log.timer_debug1('transforming ovpq', *cput1)
self.ovov[:,:,:,:] = buf[:,:,:nocc,nocc:]
self.vovv[:,:,:,:] = buf[:,:,nocc:,nocc:].transpose(1,0,3,2)
self.voov[:,:,:,:] = buf[:,:,nocc:,:nocc].transpose(1,0,3,2)
_tmpfile2 = tempfile.NamedTemporaryFile()
self.feri2 = h5py.File(_tmpfile2.name, 'w')
ao2mo.full(cc.mol, orbv, self.feri2, max_memory=cc.max_memory,
verbose=log, compact=False)
vvvv_buf = self.feri2['eri_mo']
for a in range(nvir):
abrange = a*nvir + np.arange(nvir)
self.vvvv[a,:,:,:] = np.array(vvvv_buf[abrange,:]).reshape((nvir,nvir,nvir)).transpose(1,0,2)
cput1 = log.timer_debug1('transforming vvvv', *cput1)
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
