def _sort_t2_vooo(mycc, orbsym, t1, t2, eris):
ovoo = numpy.asarray(eris.ovoo)
nocc, nvir = t1.shape
if mycc.mol.symmetry:
orbsym = numpy.asarray(orbsym, dtype=numpy.int32)
o_sorted = _irrep_argsort(orbsym[:nocc])
v_sorted = _irrep_argsort(orbsym[nocc:])
mo_energy = eris.fock.diagonal()
mo_energy = numpy.hstack((mo_energy[:nocc][o_sorted],
mo_energy[nocc:][v_sorted]))
t1T = numpy.asarray(t1.T[v_sorted][:,o_sorted], order='C')
t2T = lib.transpose(t2.reshape(nocc**2,-1))
_ccsd.libcc.CCsd_t_sort_t2(t2.ctypes.data_as(ctypes.c_void_p),
t2T.ctypes.data_as(ctypes.c_void_p),
orbsym.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nocc), ctypes.c_int(nvir))
t2T = t2.reshape(nvir,nvir,nocc,nocc)
vooo = numpy.empty((nvir,nocc,nocc,nocc))
_ccsd.libcc.CCsd_t_sort_vooo(vooo.ctypes.data_as(ctypes.c_void_p),
ovoo.ctypes.data_as(ctypes.c_void_p),
orbsym.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nocc), ctypes.c_int(nvir))
ovoo = None
else:
t1T = t1.T.copy()
t2T = lib.transpose(t2.reshape(nocc**2,-1))
t2T = lib.transpose(t2T.reshape(-1,nocc,nocc), axes=(0,2,1), out=t2)
t2T = t2T.reshape(nvir,nvir,nocc,nocc)
vooo = ovoo.transpose(1,0,2,3).copy()
mo_energy = numpy.asarray(eris.fock.diagonal(), order='C')
return mo_energy, t1T, t2T, vooo
def cholesky_eri(mol, auxbasis='weigend+etb', aosym='s1', verbose=0):
t0 = (time.clock(), time.time())
if isinstance(verbose, logger.Logger):
log = verbose
else:
log = logger.Logger(mol.stdout, verbose)
auxmol = incore.format_aux_basis(mol, auxbasis)
j2c = incore.fill_2c2e(mol, auxmol)
log.debug('size of aux basis %d', j2c.shape[0])
t1 = log.timer('2c2e', *t0)
low = scipy.linalg.cholesky(j2c, lower=True)
j2c = None
t1 = log.timer('Cholesky 2c2e', *t1)
j3c_ll = aux_e2(mol, auxmol, intor='cint3c2e_spinor', aosym=aosym)
j3c_ss = aux_e2(mol, auxmol, intor='cint3c2e_spsp1_spinor', aosym=aosym)
t1 = log.timer('3c2e', *t1)
cderi_ll = scipy.linalg.solve_triangular(low, j3c_ll.T, lower=True,
overwrite_b=True)
cderi_ss = scipy.linalg.solve_triangular(low, j3c_ss.T, lower=True,
overwrite_b=True)
# solve_triangular return cderi in Fortran order
cderi = (lib.transpose(cderi_ll.T), lib.transpose(cderi_ss.T))
log.timer('cholesky_eri', *t0)
return cderi
def eval_ao_kpts(cell, coords, kpts=None, deriv=0, relativity=0,
shl_slice=None, non0tab=None, out=None, verbose=None, **kwargs):
'''
Returns:
ao_kpts: (nkpts, ngs, nao) ndarray
AO values at each k-point
'''
if kpts is None:
if 'kpt' in kwargs:
sys.stderr.write('WARN: _KNumInt.eval_ao function finds keyword '
'argument "kpt" and converts it to "kpts"\n')
kpts = kpt
else:
kpts = numpy.zeros((1,3))
kpts = numpy.reshape(kpts, (-1,3))
nkpts = len(kpts)
ngrids = len(coords)
if non0tab is None:
non0tab = numpy.ones(((ngrids+BLKSIZE-1)//BLKSIZE, cell.nbas),
dtype=numpy.int8)
ao_loc = cell.ao_loc_nr()
nao = ao_loc[-1]
comp = (deriv+1)*(deriv+2)*(deriv+3)//6
ao_kpts = [numpy.zeros((ngrids,nao,comp), dtype=numpy.complex128, order='F')
for k in range(nkpts)]
out_ptrs = (ctypes.c_void_p*nkpts)(
*[x.ctypes.data_as(ctypes.c_void_p) for x in ao_kpts])
coords = numpy.asarray(coords, order='C')
Ls = cell.get_lattice_Ls()
expLk = numpy.exp(1j * numpy.asarray(numpy.dot(Ls, kpts.T), order='C'))
drv = getattr(libpbc, 'PBCval_sph_deriv%d' % deriv)
drv(ctypes.c_int(ngrids), ctypes.c_int(BLKSIZE),
Ls.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(len(Ls)),
expLk.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(nkpts),
(ctypes.c_int*2)(0, cell.nbas),
ao_loc.ctypes.data_as(ctypes.c_void_p),
out_ptrs, coords.ctypes.data_as(ctypes.c_void_p),
non0tab.ctypes.data_as(ctypes.c_void_p),
cell._atm.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(cell.natm),
cell._bas.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(cell.nbas),
cell._env.ctypes.data_as(ctypes.c_void_p))
for k, kpt in enumerate(kpts):
mat = ao_kpts[k].transpose(2,0,1)
if comp == 1:
aos = lib.transpose(mat[0].T)
else:
aos = numpy.empty((comp,ngrids,nao), dtype=numpy.complex128)
for i in range(comp):
lib.transpose(mat[i].T, out=aos[i])
if abs(kpt).sum() < 1e-9: # gamma point
aos = aos.real.copy()
ao_kpts[k] = aos
return ao_kpts
def test_transpose(self):
a = numpy.random.random((400,900))
self.assertAlmostEqual(abs(a.T - lib.transpose(a)).max(), 0, 12)
b = a[:400,:400]
c = numpy.copy(b)
self.assertAlmostEqual(abs(b.T - lib.transpose(c,inplace=True)).max(), 0, 12)
a = a.reshape(40,10,-1)
self.assertAlmostEqual(abs(a.transpose(0,2,1) - lib.transpose(a,(0,2,1))).max(), 0, 12)
def contract_2e(eri, civec_strs, norb, nelec, link_index=None):
ci_coeff, nelec, ci_strs = _unpack(civec_strs, nelec)
if link_index is None:
link_index = _all_linkstr_index(ci_strs, norb, nelec)
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = cd_indexa.shape[:2]
nb, nlinkb = cd_indexb.shape[:2]
eri = ao2mo.restore(1, eri, norb)
eri1 = eri.transpose(0, 2, 1, 3) - eri.transpose(0, 2, 3, 1)
idx, idy = numpy.tril_indices(norb, -1)
idx = idx * norb + idy
eri1 = lib.take_2d(eri1.reshape(norb**2, -1), idx, idx) * 2
fcivec = ci_coeff.reshape(na, nb)
# (bb|bb)
if nelec[1] > 1:
mb, mlinkb = dd_indexb.shape[:2]
fcivecT = lib.transpose(fcivec)
ci1T = numpy.zeros((nb, na))
libfci.SCIcontract_2e_aaaa(eri1.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
ci1T.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(nb),
ctypes.c_int(na), ctypes.c_int(mb),
ctypes.c_int(mlinkb),
dd_indexb.ctypes.data_as(ctypes.c_void_p))
ci1 = lib.transpose(ci1T, out=fcivecT)
else:
ci1 = numpy.zeros_like(fcivec)
# (aa|aa)
if nelec[0] > 1:
ma, mlinka = dd_indexa.shape[:2]
libfci.SCIcontract_2e_aaaa(eri1.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ci1.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(na),
ctypes.c_int(nb), ctypes.c_int(ma),
ctypes.c_int(mlinka),
dd_indexa.ctypes.data_as(ctypes.c_void_p))
h_ps = numpy.einsum('pqqs->ps', eri)
eri1 = eri * 2
for k in range(norb):
eri1[:, :, k, k] += h_ps / nelec[0]
eri1[k, k, :, :] += h_ps / nelec[1]
eri1 = ao2mo.restore(4, eri1, norb)
# (bb|aa)
libfci.SCIcontract_2e_bbaa(eri1.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ci1.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(na),
ctypes.c_int(nb), ctypes.c_int(nlinka),
ctypes.c_int(nlinkb),
cd_indexa.ctypes.data_as(ctypes.c_void_p),
cd_indexb.ctypes.data_as(ctypes.c_void_p))
return _as_SCIvector(ci1.reshape(ci_coeff.shape), ci_strs)
def contract_2e(eri, civec_strs, norb, nelec, link_index=None):
ci_coeff, nelec, ci_strs = _unpack(civec_strs, nelec)
if link_index is None:
link_index = _all_linkstr_index(ci_strs, norb, nelec)
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = cd_indexa.shape[:2]
nb, nlinkb = cd_indexb.shape[:2]
eri = ao2mo.restore(1, eri, norb)
eri1 = eri.transpose(0,2,1,3) - eri.transpose(0,2,3,1)
idx,idy = numpy.tril_indices(norb, -1)
idx = idx * norb + idy
eri1 = lib.take_2d(eri1.reshape(norb**2,-1), idx, idx) * 2
fcivec = ci_coeff.reshape(na,nb)
# (bb|bb)
if nelec[1] > 1:
mb, mlinkb = dd_indexb.shape[:2]
fcivecT = lib.transpose(fcivec)
ci1T = numpy.zeros((nb,na))
libfci.SCIcontract_2e_aaaa(eri1.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
ci1T.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(nb), ctypes.c_int(na),
ctypes.c_int(mb), ctypes.c_int(mlinkb),
dd_indexb.ctypes.data_as(ctypes.c_void_p))
ci1 = lib.transpose(ci1T, out=fcivecT)
else:
ci1 = numpy.zeros_like(fcivec)
# (aa|aa)
if nelec[0] > 1:
ma, mlinka = dd_indexa.shape[:2]
libfci.SCIcontract_2e_aaaa(eri1.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ci1.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(nb),
ctypes.c_int(ma), ctypes.c_int(mlinka),
dd_indexa.ctypes.data_as(ctypes.c_void_p))
h_ps = numpy.einsum('pqqs->ps', eri)
eri1 = eri * 2
for k in range(norb):
eri1[:,:,k,k] += h_ps/nelec[0]
eri1[k,k,:,:] += h_ps/nelec[1]
eri1 = ao2mo.restore(4, eri1, norb)
# (bb|aa)
libfci.SCIcontract_2e_bbaa(eri1.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ci1.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(nb),
ctypes.c_int(nlinka), ctypes.c_int(nlinkb),
cd_indexa.ctypes.data_as(ctypes.c_void_p),
cd_indexb.ctypes.data_as(ctypes.c_void_p))
return _as_SCIvector(ci1.reshape(ci_coeff.shape), ci_strs)
def make_kpt(kpt): # kpt = kptj - kpti
# search for all possible ki and kj that has ki-kj+kpt=0
kk_match = numpy.einsum('ijx->ij', abs(kk_table + kpt)) < 1e-9
kpti_idx, kptj_idx = numpy.where(kk_todo & kk_match)
nkptj = len(kptj_idx)
log.debug1('kpt = %s', kpt)
log.debug2('kpti_idx = %s', kpti_idx)
log.debug2('kptj_idx = %s', kptj_idx)
kk_todo[kpti_idx,kptj_idx] = False
if swap_2e and not is_zero(kpt):
kk_todo[kptj_idx,kpti_idx] = False
max_memory1 = max_memory * (nkptj+1)/(nkptj+5)
blksize = max(int(max_memory1*4e6/(nkptj+5)/16/nao**2), 16)
bufR = numpy.empty((blksize*nao**2))
bufI = numpy.empty((blksize*nao**2))
# Use DF object to mimic KRHF/KUHF object in function get_coulG
mydf.exxdiv = exxdiv
vkcoulG = mydf.weighted_coulG(kpt, True, mydf.gs)
kptjs = kpts[kptj_idx]
# <r|-G+k_rs|s> = conj(<s|G-k_rs|r>) = conj(<s|G+k_sr|r>)
for k, pqkR, pqkI, p0, p1 \
in mydf.ft_loop(mydf.gs, kpt, kptjs, max_memory=max_memory1):
ki = kpti_idx[k]
kj = kptj_idx[k]
coulG = numpy.sqrt(vkcoulG[p0:p1])
# case 1: k_pq = (pi|iq)
#:v4 = numpy.einsum('ijL,lkL->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,jk->il', v4, dm)
pqkR *= coulG
pqkI *= coulG
pLqR = lib.transpose(pqkR.reshape(nao,nao,-1), axes=(0,2,1), out=bufR)
pLqI = lib.transpose(pqkI.reshape(nao,nao,-1), axes=(0,2,1), out=bufI)
iLkR = numpy.empty((nao*(p1-p0),nao))
iLkI = numpy.empty((nao*(p1-p0),nao))
for i in range(nset):
iLkR, iLkI = zdotNN(pLqR.reshape(-1,nao), pLqI.reshape(-1,nao),
dmsR[i,kj], dmsI[i,kj], 1, iLkR, iLkI)
zdotNC(iLkR.reshape(nao,-1), iLkI.reshape(nao,-1),
pLqR.reshape(nao,-1).T, pLqI.reshape(nao,-1).T,
1, vkR[i,ki], vkI[i,ki], 1)
# case 2: k_pq = (iq|pi)
#:v4 = numpy.einsum('iLj,lLk->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,li->kj', v4, dm)
if swap_2e and not is_zero(kpt):
iLkR = iLkR.reshape(nao,-1)
iLkI = iLkI.reshape(nao,-1)
for i in range(nset):
iLkR, iLkI = zdotNN(dmsR[i,ki], dmsI[i,ki], pLqR.reshape(nao,-1),
pLqI.reshape(nao,-1), 1, iLkR, iLkI)
zdotCN(pLqR.reshape(-1,nao).T, pLqI.reshape(-1,nao).T,
iLkR.reshape(-1,nao), iLkI.reshape(-1,nao),
1, vkR[i,kj], vkI[i,kj], 1)
pqkR = pqkI = coulG = pLqR = pLqI = iLkR = iLkI = None
def make_kpt(kpt): # kpt = kptj - kpti
# search for all possible ki and kj that has ki-kj+kpt=0
kk_match = numpy.einsum('ijx->ij', abs(kk_table + kpt)) < 1e-9
kpti_idx, kptj_idx = numpy.where(kk_todo & kk_match)
nkptj = len(kptj_idx)
log.debug1('kpt = %s', kpt)
log.debug2('kpti_idx = %s', kpti_idx)
log.debug2('kptj_idx = %s', kptj_idx)
kk_todo[kpti_idx,kptj_idx] = False
if swap_2e and not is_zero(kpt):
kk_todo[kptj_idx,kpti_idx] = False
max_memory1 = max_memory * (nkptj+1)/(nkptj+5)
blksize = max(int(max_memory1*4e6/(nkptj+5)/16/nao**2), 16)
bufR = numpy.empty((blksize*nao**2))
bufI = numpy.empty((blksize*nao**2))
# Use DF object to mimic KRHF/KUHF object in function get_coulG
mydf.exxdiv = exxdiv
vkcoulG = mydf.weighted_coulG(kpt, True, mydf.gs)
kptjs = kpts[kptj_idx]
# <r|-G+k_rs|s> = conj(<s|G-k_rs|r>) = conj(<s|G+k_sr|r>)
for k, pqkR, pqkI, p0, p1 \
in mydf.ft_loop(mydf.gs, kpt, kptjs, max_memory=max_memory1):
ki = kpti_idx[k]
kj = kptj_idx[k]
coulG = numpy.sqrt(vkcoulG[p0:p1])
# case 1: k_pq = (pi|iq)
#:v4 = numpy.einsum('ijL,lkL->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,jk->il', v4, dm)
pqkR *= coulG
pqkI *= coulG
pLqR = lib.transpose(pqkR.reshape(nao,nao,-1), axes=(0,2,1), out=bufR)
pLqI = lib.transpose(pqkI.reshape(nao,nao,-1), axes=(0,2,1), out=bufI)
iLkR = numpy.empty((nao*(p1-p0),nao))
iLkI = numpy.empty((nao*(p1-p0),nao))
for i in range(nset):
iLkR, iLkI = zdotNN(pLqR.reshape(-1,nao), pLqI.reshape(-1,nao),
dmsR[i,kj], dmsI[i,kj], 1, iLkR, iLkI)
zdotNC(iLkR.reshape(nao,-1), iLkI.reshape(nao,-1),
pLqR.reshape(nao,-1).T, pLqI.reshape(nao,-1).T,
1, vkR[i,ki], vkI[i,ki], 1)
# case 2: k_pq = (iq|pi)
#:v4 = numpy.einsum('iLj,lLk->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,li->kj', v4, dm)
if swap_2e and not is_zero(kpt):
iLkR = iLkR.reshape(nao,-1)
iLkI = iLkI.reshape(nao,-1)
for i in range(nset):
iLkR, iLkI = zdotNN(dmsR[i,ki], dmsI[i,ki], pLqR.reshape(nao,-1),
pLqI.reshape(nao,-1), 1, iLkR, iLkI)
zdotCN(pLqR.reshape(-1,nao).T, pLqI.reshape(-1,nao).T,
iLkR.reshape(-1,nao), iLkI.reshape(-1,nao),
1, vkR[i,kj], vkI[i,kj], 1)
pqkR = pqkI = coulG = pLqR = pLqI = iLkR = iLkI = None
def test_transpose(self):
a = numpy.random.random((400, 900))
self.assertAlmostEqual(abs(a.T - lib.transpose(a)).max(), 0, 12)
b = a[:400, :400]
c = numpy.copy(b)
self.assertAlmostEqual(
abs(b.T - lib.transpose(c, inplace=True)).max(), 0, 12)
a = a.reshape(40, 10, -1)
self.assertAlmostEqual(
abs(a.transpose(0, 2, 1) - lib.transpose(a, (0, 2, 1))).max(), 0,
12)
def loop(self):
Lpq = None
coulG = self.weighted_coulG()
for pqkR, pqkI, p0, p1 in self.pw_loop(aosym='s2', blksize=self.blockdim):
vG = numpy.sqrt(coulG[p0:p1])
pqkR *= vG
pqkI *= vG
Lpq = lib.transpose(pqkR, out=Lpq)
yield Lpq
Lpq = lib.transpose(pqkI, out=Lpq)
yield Lpq
def loop(self):
Lpq = None
coulG = self.weighted_coulG()
for pqkR, pqkI, p0, p1 in self.pw_loop(aosym='s2', blksize=self.blockdim):
vG = numpy.sqrt(coulG[p0:p1])
pqkR *= vG
pqkI *= vG
Lpq = lib.transpose(pqkR, out=Lpq)
yield Lpq
Lpq = lib.transpose(pqkI, out=Lpq)
yield Lpq
def transform(b):
if b.ndim == 3 and b.flags.f_contiguous:
b = lib.transpose(b.T, axes=(0,2,1)).reshape(naoaux,-1)
else:
b = b.reshape((-1,naoaux)).T
if tag == 'cd':
if b.flags.c_contiguous:
b = lib.transpose(b).T
return scipy.linalg.solve_triangular(low, b, lower=True,
overwrite_b=True, check_finite=False)
else:
return lib.dot(low.T, b)
def _sort_t2_vooo_(mycc, orbsym, t1, t2, eris):
assert(t2.flags.c_contiguous)
vooo = numpy.asarray(eris.ovoo).transpose(1,0,3,2).conj().copy()
nocc, nvir = t1.shape
if mycc.mol.symmetry:
orbsym = numpy.asarray(orbsym, dtype=numpy.int32)
o_sorted = _irrep_argsort(orbsym[:nocc])
v_sorted = _irrep_argsort(orbsym[nocc:])
mo_energy = eris.mo_energy
mo_energy = numpy.hstack((mo_energy[:nocc][o_sorted],
mo_energy[nocc:][v_sorted]))
t1T = numpy.asarray(t1.T[v_sorted][:,o_sorted], order='C')
fvo = eris.fock[nocc:,:nocc]
fvo = numpy.asarray(fvo[v_sorted][:,o_sorted], order='C')
o_sym = orbsym[o_sorted]
oo_sym = (o_sym[:,None] ^ o_sym).ravel()
oo_sorted = _irrep_argsort(oo_sym)
#:vooo = eris.ovoo.transpose(1,0,2,3)
#:vooo = vooo[v_sorted][:,o_sorted][:,:,o_sorted][:,:,:,o_sorted]
#:vooo = vooo.reshape(nvir,-1,nocc)[:,oo_sorted]
oo_idx = numpy.arange(nocc**2).reshape(nocc,nocc)[o_sorted][:,o_sorted]
oo_idx = oo_idx.ravel()[oo_sorted]
oo_idx = (oo_idx[:,None]*nocc+o_sorted).ravel()
vooo = lib.take_2d(vooo.reshape(nvir,-1), v_sorted, oo_idx)
vooo = vooo.reshape(nvir,nocc,nocc,nocc)
#:t2T = t2.transpose(2,3,1,0)
#:t2T = ref_t2T[v_sorted][:,v_sorted][:,:,o_sorted][:,:,:,o_sorted]
#:t2T = ref_t2T.reshape(nvir,nvir,-1)[:,:,oo_sorted]
t2T = lib.transpose(t2.reshape(nocc**2,-1))
oo_idx = numpy.arange(nocc**2).reshape(nocc,nocc).T[o_sorted][:,o_sorted]
oo_idx = oo_idx.ravel()[oo_sorted]
vv_idx = (v_sorted[:,None]*nvir+v_sorted).ravel()
t2T = lib.take_2d(t2T.reshape(nvir**2,nocc**2), vv_idx, oo_idx, out=t2)
t2T = t2T.reshape(nvir,nvir,nocc,nocc)
def restore_t2_inplace(t2T):
tmp = numpy.zeros((nvir**2,nocc**2), dtype=t2T.dtype)
lib.takebak_2d(tmp, t2T.reshape(nvir**2,nocc**2), vv_idx, oo_idx)
t2 = lib.transpose(tmp.reshape(nvir**2,nocc**2), out=t2T)
return t2.reshape(nocc,nocc,nvir,nvir)
else:
fvo = eris.fock[nocc:,:nocc].copy()
t1T = t1.T.copy()
t2T = lib.transpose(t2.reshape(nocc**2,nvir**2))
t2T = lib.transpose(t2T.reshape(nvir**2,nocc,nocc), axes=(0,2,1), out=t2)
mo_energy = numpy.asarray(eris.mo_energy, order='C')
def restore_t2_inplace(t2T):
tmp = lib.transpose(t2T.reshape(nvir**2,nocc,nocc), axes=(0,2,1))
t2 = lib.transpose(tmp.reshape(nvir**2,nocc**2), out=t2T)
return t2.reshape(nocc,nocc,nvir,nvir)
t2T = t2T.reshape(nvir,nvir,nocc,nocc)
return mo_energy, t1T, t2T, vooo, fvo, restore_t2_inplace
def _sort_t2_vooo_(mycc, orbsym, t1, t2, eris):
assert(t2.flags.c_contiguous)
vooo = numpy.asarray(eris.ovoo).transpose(1,0,3,2).conj().copy()
nocc, nvir = t1.shape
if mycc.mol.symmetry:
orbsym = numpy.asarray(orbsym, dtype=numpy.int32)
o_sorted = _irrep_argsort(orbsym[:nocc])
v_sorted = _irrep_argsort(orbsym[nocc:])
mo_energy = eris.fock.diagonal().real
mo_energy = numpy.hstack((mo_energy[:nocc][o_sorted],
mo_energy[nocc:][v_sorted]))
t1T = numpy.asarray(t1.T[v_sorted][:,o_sorted], order='C')
fvo = eris.fock[nocc:,:nocc]
fvo = numpy.asarray(fvo[v_sorted][:,o_sorted], order='C')
o_sym = orbsym[o_sorted]
oo_sym = (o_sym[:,None] ^ o_sym).ravel()
oo_sorted = _irrep_argsort(oo_sym)
#:vooo = eris.ovoo.transpose(1,0,2,3)
#:vooo = vooo[v_sorted][:,o_sorted][:,:,o_sorted][:,:,:,o_sorted]
#:vooo = vooo.reshape(nvir,-1,nocc)[:,oo_sorted]
oo_idx = numpy.arange(nocc**2).reshape(nocc,nocc)[o_sorted][:,o_sorted]
oo_idx = oo_idx.ravel()[oo_sorted]
oo_idx = (oo_idx[:,None]*nocc+o_sorted).ravel()
vooo = lib.take_2d(vooo.reshape(nvir,-1), v_sorted, oo_idx)
vooo = vooo.reshape(nvir,nocc,nocc,nocc)
#:t2T = t2.transpose(2,3,1,0)
#:t2T = ref_t2T[v_sorted][:,v_sorted][:,:,o_sorted][:,:,:,o_sorted]
#:t2T = ref_t2T.reshape(nvir,nvir,-1)[:,:,oo_sorted]
t2T = lib.transpose(t2.reshape(nocc**2,-1))
oo_idx = numpy.arange(nocc**2).reshape(nocc,nocc).T[o_sorted][:,o_sorted]
oo_idx = oo_idx.ravel()[oo_sorted]
vv_idx = (v_sorted[:,None]*nvir+v_sorted).ravel()
t2T = lib.take_2d(t2T.reshape(nvir**2,nocc**2), vv_idx, oo_idx, out=t2)
t2T = t2T.reshape(nvir,nvir,nocc,nocc)
def restore_t2_inplace(t2T):
tmp = numpy.zeros((nvir**2,nocc**2), dtype=t2T.dtype)
lib.takebak_2d(tmp, t2T.reshape(nvir**2,nocc**2), vv_idx, oo_idx)
t2 = lib.transpose(tmp.reshape(nvir**2,nocc**2), out=t2T)
return t2.reshape(nocc,nocc,nvir,nvir)
else:
fvo = eris.fock[nocc:,:nocc].copy()
t1T = t1.T.copy()
t2T = lib.transpose(t2.reshape(nocc**2,nvir**2))
t2T = lib.transpose(t2T.reshape(nvir**2,nocc,nocc), axes=(0,2,1), out=t2)
mo_energy = numpy.asarray(eris.fock.diagonal().real, order='C')
def restore_t2_inplace(t2T):
tmp = lib.transpose(t2T.reshape(nvir**2,nocc,nocc), axes=(0,2,1))
t2 = lib.transpose(tmp.reshape(nvir**2,nocc**2), out=t2T)
return t2.reshape(nocc,nocc,nvir,nvir)
t2T = t2T.reshape(nvir,nvir,nocc,nocc)
return mo_energy, t1T, t2T, vooo, fvo, restore_t2_inplace
def get_Lpq(shls_slice, col0, col1, buf):
# Be cautious here, _ri.nr_auxe2 assumes buf in F-order
Lpq = _ri.nr_auxe2(intor, atm, bas, env, shls_slice, ao_loc,
's2ij', 1, cintopt, buf).T
if mydf.charge_constraint:
Lpq = numpy.ndarray(shape=(naux+1,col1-col0), buffer=buf)
Lpq[naux,:] = ovlp[col0:col1]
Lpq1 = solve(Lpq)
assert(Lpq1.flags.f_contiguous)
lib.transpose(Lpq1.T, out=Lpq)
return Lpq[:naux]
else:
return solve(Lpq)
def store(b, label):
if b.ndim == 3 and b.flags.f_contiguous:
b = lib.transpose(b.T, axes=(0,2,1)).reshape(naux,-1)
else:
b = b.reshape((-1,naux)).T
cderi = scipy.linalg.solve_triangular(low, b, lower=True, overwrite_b=True)
feri[label] = cderi
def gen_int3c(auxcell, job_id, ish0, ish1):
dataname = 'j3c-chunks/%d' % job_id
if dataname in feri:
del (feri[dataname])
i0 = ao_loc[ish0]
i1 = ao_loc[ish1]
dii = i1 * (i1 + 1) // 2 - i0 * (i0 + 1) // 2
dij = (i1 - i0) * nao
if j_only:
buflen = max(8, int(max_memory * 1e6 / 16 / (nkptij * dii + dii)))
else:
buflen = max(8, int(max_memory * 1e6 / 16 / (nkptij * dij + dij)))
auxranges = balance_segs(aux_loc[1:] - aux_loc[:-1], buflen)
buflen = max([x[2] for x in auxranges])
buf = numpy.empty(nkptij * dij * buflen, dtype=dtype)
buf1 = numpy.empty(dij * buflen, dtype=dtype)
naux = aux_loc[-1]
for kpt_id, kptij in enumerate(kptij_lst):
key = '%s/%d' % (dataname, kpt_id)
if aosym_s2[kpt_id]:
shape = (naux, dii)
else:
shape = (naux, dij)
if gamma_point(kptij):
feri.create_dataset(key, shape, 'f8')
else:
feri.create_dataset(key, shape, 'c16')
naux0 = 0
for istep, auxrange in enumerate(auxranges):
log.alldebug2("aux_e2 job_id %d step %d", job_id, istep)
sh0, sh1, nrow = auxrange
sub_slice = (ish0, ish1, 0, cell.nbas, sh0, sh1)
if j_only:
mat = numpy.ndarray((nkptij, dii, nrow),
dtype=dtype,
buffer=buf)
else:
mat = numpy.ndarray((nkptij, dij, nrow),
dtype=dtype,
buffer=buf)
mat = int3c(sub_slice, mat)
for k, kptij in enumerate(kptij_lst):
h5dat = feri['%s/%d' % (dataname, k)]
v = lib.transpose(mat[k], out=buf1)
if not j_only and aosym_s2[k]:
idy = idxb[i0 * (i0 + 1) // 2:i1 *
(i1 + 1) // 2] - i0 * nao
out = numpy.ndarray((nrow, dii),
dtype=v.dtype,
buffer=mat[k])
v = numpy.take(v, idy, axis=1, out=out)
if gamma_point(kptij):
h5dat[naux0:naux0 + nrow] = v.real
else:
h5dat[naux0:naux0 + nrow] = v
naux0 += nrow
def trans_e1_incore(eri_ao, mo, ncore, ncas):
nmo = mo.shape[1]
nocc = ncore + ncas
eri1 = ao2mo.incore.half_e1(eri_ao, (mo,mo[:,:nocc]), compact=False)
eri1 = eri1.reshape(nmo,nocc,-1)
klppshape = (0, nmo, 0, nmo)
klpashape = (0, nmo, ncore, nocc)
aapp = numpy.empty((ncas,ncas,nmo,nmo))
for i in range(ncas):
_ao2mo.nr_e2(eri1[ncore+i,ncore:nocc], mo, klppshape,
aosym='s4', mosym='s1', out=aapp[i])
ppaa = lib.transpose(aapp.reshape(ncas*ncas,-1)).reshape(nmo,nmo,ncas,ncas)
aapp = None
papa = numpy.empty((nmo,ncas,nmo,ncas))
for i in range(nmo):
_ao2mo.nr_e2(eri1[i,ncore:nocc], mo, klpashape,
aosym='s4', mosym='s1', out=papa[i])
pp = numpy.empty((nmo,nmo))
j_cp = numpy.zeros((ncore,nmo))
k_pc = numpy.zeros((nmo,ncore))
for i in range(ncore):
_ao2mo.nr_e2(eri1[i,i:i+1], mo, klppshape, aosym='s4', mosym='s1', out=pp)
j_cp[i] = pp.diagonal()
j_pc = j_cp.T.copy()
pp = numpy.empty((ncore,ncore))
for i in range(nmo):
klshape = (i, i+1, 0, ncore)
_ao2mo.nr_e2(eri1[i,:ncore], mo, klshape, aosym='s4', mosym='s1', out=pp)
k_pc[i] = pp.diagonal()
return j_pc, k_pc, ppaa, papa
def cholesky_eri(mol, auxbasis='weigend+etb', auxmol=None,
int3c='int3c2e_sph', aosym='s2ij', int2c='int2c2e_sph', comp=1,
verbose=0, fauxe2=aux_e2):
'''
Returns:
2D array of (naux,nao*(nao+1)/2) in C-contiguous
'''
assert(comp == 1)
t0 = (time.clock(), time.time())
log = logger.new_logger(mol, verbose)
if auxmol is None:
auxmol = addons.make_auxmol(mol, auxbasis)
j2c = auxmol.intor(int2c, hermi=1)
naux = j2c.shape[0]
log.debug('size of aux basis %d', naux)
t1 = log.timer('2c2e', *t0)
try:
low = scipy.linalg.cholesky(j2c, lower=True)
except scipy.linalg.LinAlgError:
j2c[numpy.diag_indices(j2c.shape[1])] += 1e-14
low = scipy.linalg.cholesky(j2c, lower=True)
j2c = None
t1 = log.timer('Cholesky 2c2e', *t1)
j3c = fauxe2(mol, auxmol, intor=int3c, aosym=aosym).reshape(-1,naux)
t1 = log.timer('3c2e', *t1)
cderi = scipy.linalg.solve_triangular(low, j3c.T, lower=True,
overwrite_b=True)
j3c = None
if cderi.flags.f_contiguous:
cderi = lib.transpose(cderi.T)
log.timer('cholesky_eri', *t0)
return cderi
def trans_e1_incore(eri_ao, mo, ncore, ncas):
nmo = mo.shape[1]
nocc = ncore + ncas
eri1 = ao2mo.incore.half_e1(eri_ao, (mo,mo[:,:nocc]), compact=False)
eri1 = eri1.reshape(nmo,nocc,-1)
klppshape = (0, nmo, 0, nmo)
klpashape = (0, nmo, ncore, nocc)
aapp = numpy.empty((ncas,ncas,nmo,nmo))
for i in range(ncas):
_ao2mo.nr_e2(eri1[ncore+i,ncore:nocc], mo, klppshape,
aosym='s4', mosym='s1', out=aapp[i])
ppaa = lib.transpose(aapp.reshape(ncas*ncas,-1)).reshape(nmo,nmo,ncas,ncas)
aapp = None
papa = numpy.empty((nmo,ncas,nmo,ncas))
for i in range(nmo):
_ao2mo.nr_e2(eri1[i,ncore:nocc], mo, klpashape,
aosym='s4', mosym='s1', out=papa[i])
pp = numpy.empty((nmo,nmo))
j_cp = numpy.zeros((ncore,nmo))
k_pc = numpy.zeros((nmo,ncore))
for i in range(ncore):
_ao2mo.nr_e2(eri1[i,i:i+1], mo, klppshape, aosym='s4', mosym='s1', out=pp)
j_cp[i] = pp.diagonal()
j_pc = j_cp.T.copy()
pp = numpy.empty((ncore,ncore))
for i in range(nmo):
klshape = (i, i+1, 0, ncore)
_ao2mo.nr_e2(eri1[i,:ncore], mo, klshape, aosym='s4', mosym='s1', out=pp)
k_pc[i] = pp.diagonal()
return j_pc, k_pc, ppaa, papa
def _dot_ao_mo(mol,
ao,
mo,
non0tab=None,
shls_slice=None,
ao_loc=None,
hermi=0):
if hermi:
#print ("_dot_ao_mo punting to numint._dot_ao_ao")
return numint._dot_ao_ao(mol,
ao,
mo,
non0tab=non0tab,
shls_slice=shls_slice,
ao_loc=ao_loc,
hermi=hermi)
ngrids, nao = ao.shape
nmo = mo.shape[-1]
if nao < SWITCH_SIZE:
#print ("_dot_ao_mo punting to lib.dot")
return lib.dot(ao.T.conj(), mo)
#print ("_dot_ao_mo doing my own thing")
if not ao.flags.f_contiguous:
ao = lib.transpose(ao)
if not mo.flags.f_contiguous:
mo = lib.transpose(mo)
if ao.dtype == mo.dtype == np.double:
fn = libpdft.VOTdot_ao_mo
else:
raise NotImplementedError("Complex-orbital PDFT")
if non0tab is None or shls_slice is None or ao_loc is None:
pnon0tab = pshls_slice = pao_loc = lib.c_null_ptr()
else:
pnon0tab = non0tab.ctypes.data_as(ctypes.c_void_p)
pshls_slice = (ctypes.c_int * 2)(*shls_slice)
pao_loc = ao_loc.ctypes.data_as(ctypes.c_void_p)
vv = np.empty((nao, nmo), dtype=ao.dtype)
fn(vv.ctypes.data_as(ctypes.c_void_p), ao.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nao), ctypes.c_int(nmo), ctypes.c_int(ngrids),
ctypes.c_int(mol.nbas), pnon0tab, pshls_slice, pao_loc)
return vv
def _sort_t2_vooo_(mycc, orbsym, t1, t2, eris):
ovoo = numpy.asarray(eris.ovoo)
nocc, nvir = t1.shape
if mycc.mol.symmetry:
orbsym = numpy.asarray(orbsym, dtype=numpy.int32)
o_sorted = _irrep_argsort(orbsym[:nocc])
v_sorted = _irrep_argsort(orbsym[nocc:])
mo_energy = eris.fock.diagonal()
mo_energy = numpy.hstack(
(mo_energy[:nocc][o_sorted], mo_energy[nocc:][v_sorted]))
t1T = numpy.asarray(t1.T[v_sorted][:, o_sorted], order='C')
o_sym = orbsym[o_sorted]
oo_sym = (o_sym[:, None] ^ o_sym).ravel()
oo_sorted = _irrep_argsort(oo_sym)
#:vooo = eris.ovoo.transpose(1,0,2,3)
#:vooo = vooo[v_sorted][:,o_sorted][:,:,o_sorted][:,:,:,o_sorted]
#:vooo = vooo.reshape(nvir,-1,nocc)[:,oo_sorted]
oo_idx = numpy.arange(nocc**2).reshape(nocc, nocc)[o_sorted][:,
o_sorted]
oo_idx = oo_idx.ravel()[oo_sorted]
oo_idx = (oo_idx[:, None] * nocc + o_sorted).ravel()
vooo = lib.take_2d(
ovoo.transpose(1, 0, 2, 3).reshape(nvir, -1), v_sorted, oo_idx)
#:t2T = t2.transpose(2,3,1,0)
#:t2T = ref_t2T[v_sorted][:,v_sorted][:,:,o_sorted][:,:,:,o_sorted]
#:t2T = ref_t2T.reshape(nvir,nvir,-1)[:,:,oo_sorted]
t2T = lib.transpose(t2.reshape(nocc**2, -1))
oo_idx = numpy.arange(nocc**2).reshape(nocc,
nocc).T[o_sorted][:, o_sorted]
oo_idx = oo_idx.ravel()[oo_sorted]
vv_idx = (v_sorted[:, None] * nvir + v_sorted).ravel()
t2T = lib.take_2d(t2T.reshape(nvir**2, -1), vv_idx, oo_idx, out=t2)
t2T = t2T.reshape(nvir, nvir, nocc, nocc)
else:
t1T = t1.T.copy()
t2T = lib.transpose(t2.reshape(nocc**2, -1))
t2T = lib.transpose(t2T.reshape(-1, nocc, nocc),
axes=(0, 2, 1),
out=t2)
vooo = ovoo.transpose(1, 0, 2, 3).copy()
mo_energy = numpy.asarray(eris.fock.diagonal(), order='C')
vooo = vooo.reshape(nvir, nocc, nocc, nocc)
t2T = t2T.reshape(nvir, nvir, nocc, nocc)
return mo_energy, t1T, t2T, vooo
def store(b, label):
cderi = scipy.linalg.solve_triangular(low,
b,
lower=True,
overwrite_b=True)
if cderi.flags.f_contiguous:
cderi = lib.transpose(cderi.T)
feri[label] = cderi
def __getitem__(self, s):
dat = self.dat
if isinstance(dat, h5py.Group):
v = numpy.hstack([dat[str(i)][s] for i in range(len(dat))])
else: # For mpi4pyscf, pyscf-1.5.1 or older
v = numpy.asarray(dat[s])
nao = int(numpy.sqrt(v.shape[-1]))
v1 = lib.transpose(v.reshape(-1, nao, nao), axes=(0, 2, 1)).conj()
return v1.reshape(v.shape)
def __getitem__(self, s):
dat = self.dat
if isinstance(dat, h5py.Group):
v = numpy.hstack([dat[str(i)][s] for i in range(len(dat))])
else: # For mpi4pyscf, pyscf-1.5.1 or older
v = numpy.asarray(dat[s])
nao = int(numpy.sqrt(v.shape[-1]))
v1 = lib.transpose(v.reshape(-1,nao,nao), axes=(0,2,1)).conj()
return v1.reshape(v.shape)
def store(b, label):
if b.ndim == 3 and b.flags.f_contiguous:
b = lib.transpose(b.T, axes=(0,2,1)).reshape(naux,-1)
else:
b = b.reshape((-1,naux)).T
if tag == 'cd':
cderi = scipy.linalg.solve_triangular(low, b, lower=True,
overwrite_b=True)
else:
cderi = lib.dot(low.T, b)
feri[label] = cderi
def loop(self, blksize=None):
cell = self.cell
if cell.dimension == 2 and cell.low_dim_ft_type != 'inf_vacuum':
raise RuntimeError('ERIs of PBC-2D systems are not positive '
'definite. Current API only supports postive '
'definite ERIs.')
if blksize is None:
blksize = self.blockdim
# coulG of 1D and 2D has negative elements.
coulG = self.weighted_coulG()
Lpq = None
for pqkR, pqkI, p0, p1 in self.pw_loop(aosym='s2', blksize=blksize):
vG = numpy.sqrt(coulG[p0:p1])
pqkR *= vG
pqkI *= vG
Lpq = lib.transpose(pqkR, out=Lpq)
yield Lpq
Lpq = lib.transpose(pqkI, out=Lpq)
yield Lpq
def loop(self, blksize=None):
cell = self.cell
if cell.dimension == 2 and cell.low_dim_ft_type != 'inf_vacuum':
raise RuntimeError('ERIs of PBC-2D systems are not positive '
'definite. Current API only supports postive '
'definite ERIs.')
if blksize is None:
blksize = self.blockdim
# coulG of 1D and 2D has negative elements.
coulG = self.weighted_coulG()
Lpq = None
for pqkR, pqkI, p0, p1 in self.pw_loop(aosym='s2', blksize=blksize):
vG = numpy.sqrt(coulG[p0:p1])
pqkR *= vG
pqkI *= vG
Lpq = lib.transpose(pqkR, out=Lpq)
yield Lpq
Lpq = lib.transpose(pqkI, out=Lpq)
yield Lpq
def _fftn_blas(f, mesh):
Gx = np.fft.fftfreq(mesh[0])
Gy = np.fft.fftfreq(mesh[1])
Gz = np.fft.fftfreq(mesh[2])
expRGx = np.exp(np.einsum('x,k->xk', -2j * np.pi * np.arange(mesh[0]), Gx))
expRGy = np.exp(np.einsum('x,k->xk', -2j * np.pi * np.arange(mesh[1]), Gy))
expRGz = np.exp(np.einsum('x,k->xk', -2j * np.pi * np.arange(mesh[2]), Gz))
g0 = g = lib.transpose(f.reshape(-1,
mesh[1] * mesh[2])).astype(np.complex128)
g1 = np.empty_like(g0)
g = lib.dot(g.reshape(-1, mesh[0]), expRGx, c=g1.reshape(-1, mesh[0]))
g = lib.dot(g.reshape(mesh[1], -1).T, expRGy, c=g0.reshape(-1, mesh[1]))
g = lib.dot(g.reshape(mesh[2], -1).T, expRGz, c=g1.reshape(-1, mesh[2]))
return g.reshape(-1, *mesh)
def gen_int3c(job_id, ish0, ish1):
dataname = 'j3c-chunks/%d' % job_id
i0 = ao_loc[ish0]
i1 = ao_loc[ish1]
dii = i1*(i1+1)//2 - i0*(i0+1)//2
dij = (i1 - i0) * nao
if j_only:
buflen = max(8, int(max_memory*1e6/16/(nkptij*dii+dii)))
else:
buflen = max(8, int(max_memory*1e6/16/(nkptij*dij+dij)))
auxranges = balance_segs(aux_loc[1:]-aux_loc[:-1], buflen)
buflen = max([x[2] for x in auxranges])
buf = numpy.empty(nkptij*dij*buflen, dtype=dtype)
buf1 = numpy.empty(dij*buflen, dtype=dtype)
naux = aux_loc[-1]
for kpt_id, kptij in enumerate(kptij_lst):
key = '%s/%d' % (dataname, kpt_id)
if aosym_s2[kpt_id]:
shape = (naux, dii)
else:
shape = (naux, dij)
if gamma_point(kptij):
fswap.create_dataset(key, shape, 'f8')
else:
fswap.create_dataset(key, shape, 'c16')
naux0 = 0
for istep, auxrange in enumerate(auxranges):
log.alldebug2("aux_e1 job_id %d step %d", job_id, istep)
sh0, sh1, nrow = auxrange
sub_slice = (ish0, ish1, 0, cell.nbas, sh0, sh1)
if j_only:
mat = numpy.ndarray((nkptij,dii,nrow), dtype=dtype, buffer=buf)
else:
mat = numpy.ndarray((nkptij,dij,nrow), dtype=dtype, buffer=buf)
mat = int3c(sub_slice, mat)
for k, kptij in enumerate(kptij_lst):
h5dat = fswap['%s/%d'%(dataname,k)]
v = lib.transpose(mat[k], out=buf1)
if not j_only and aosym_s2[k]:
idy = idxb[i0*(i0+1)//2:i1*(i1+1)//2] - i0 * nao
out = numpy.ndarray((nrow,dii), dtype=v.dtype, buffer=mat[k])
v = numpy.take(v, idy, axis=1, out=out)
if gamma_point(kptij):
h5dat[naux0:naux0+nrow] = v.real
else:
h5dat[naux0:naux0+nrow] = v
naux0 += nrow
def _make_eris_incore(myci, mo_coeff=None):
cput0 = (time.clock(), time.time())
eris = _RCISD_ERIs(myci, mo_coeff)
nocc = eris.nocc
nmo = eris.fock.shape[0]
nvir = nmo - nocc
eri1 = ao2mo.incore.full(myci._scf._eri, eris.mo_coeff)
#:eri1 = ao2mo.restore(1, eri1, nmo)
#:eris.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy()
#:eris.vooo = eri1[nocc:,:nocc,:nocc,:nocc].copy()
#:eris.voov = eri1[nocc:,:nocc,:nocc,nocc:].copy()
#:eris.vvoo = eri1[nocc:,nocc:,:nocc,:nocc].copy()
#:vovv = eri1[nocc:,:nocc,nocc:,nocc:].copy()
#:eris.vovv = lib.pack_tril(vovv.reshape(-1,nvir,nvir))
#:eris.vvvv = ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
nvir_pair = nvir * (nvir + 1) // 2
eris.oooo = numpy.empty((nocc, nocc, nocc, nocc))
eris.vooo = numpy.empty((nvir, nocc, nocc, nocc))
eris.voov = numpy.empty((nvir, nocc, nocc, nvir))
eris.vovv = numpy.empty((nvir, nocc, nvir_pair))
eris.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):
eris.oooo[i, j] = eris.oooo[j, i] = buf[j, :nocc, :nocc]
oovv[i, j] = oovv[j, i] = buf[j, nocc:, nocc:]
ij += i + 1
eris.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])
eris.vooo[i - nocc] = buf[:nocc, :nocc, :nocc]
eris.voov[i - nocc] = buf[:nocc, :nocc, nocc:]
lib.pack_tril(_cp(buf[:nocc, nocc:, nocc:]), out=eris.vovv[i - nocc])
dij = i - nocc + 1
lib.pack_tril(_cp(buf[nocc:i + 1, nocc:, nocc:]),
out=eris.vvvv[ij1:ij1 + dij])
ij += i + 1
ij1 += dij
logger.timer(myci, 'CISD integral transformation', *cput0)
return eris
def make_rdm2s(civec_strs, norb, nelec, link_index=None, **kwargs):
ci_coeff, nelec, ci_strs = _unpack(civec_strs, nelec)
if link_index is None:
cd_indexa = cre_des_linkstr(ci_strs[0], norb, nelec[0])
dd_indexa = des_des_linkstr(ci_strs[0], norb, nelec[0])
cd_indexb = cre_des_linkstr(ci_strs[1], norb, nelec[1])
dd_indexb = des_des_linkstr(ci_strs[1], norb, nelec[1])
else:
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = cd_indexa.shape[:2]
nb, nlinkb = cd_indexb.shape[:2]
ma, mlinka = dd_indexa.shape[:2]
mb, mlinkb = dd_indexb.shape[:2]
fcivec = ci_coeff.reshape(na, nb)
# (bb|aa) and (aa|bb)
dm2ab = rdm.make_rdm12_spin1("FCItdm12kern_ab", fcivec, fcivec, norb, nelec, (cd_indexa, cd_indexb), 0)[1]
# (aa|aa)
if nelec[0] > 1:
dm2aa = numpy.empty([norb] * 4)
libfci.SCIrdm2_aaaa(
libfci.SCIrdm2kern_aaaa,
dm2aa.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(na),
ctypes.c_int(nb),
ctypes.c_int(ma),
ctypes.c_int(mlinka),
dd_indexa.ctypes.data_as(ctypes.c_void_p),
)
# (bb|bb)
if nelec[1] > 1:
dm2bb = numpy.empty([norb] * 4)
fcivecT = lib.transpose(fcivec)
libfci.SCIrdm2_aaaa(
libfci.SCIrdm2kern_aaaa,
dm2bb.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(nb),
ctypes.c_int(na),
ctypes.c_int(mb),
ctypes.c_int(mlinkb),
dd_indexb.ctypes.data_as(ctypes.c_void_p),
)
return dm2aa, dm2ab, dm2bb
def make_rdm2s(civec_strs, norb, nelec, link_index=None, **kwargs):
r'''Spin separated 2-particle density matrices.
The return values include three density matrices:
(alpha,alpha,alpha,alpha), (alpha,alpha,beta,beta), (beta,beta,beta,beta)
2pdm[p,q,r,s] = :math:`\langle p^\dagger r^\dagger s q\rangle`
'''
ci_coeff, nelec, ci_strs = _unpack(civec_strs, nelec)
if link_index is None:
cd_indexa = cre_des_linkstr(ci_strs[0], norb, nelec[0])
dd_indexa = des_des_linkstr(ci_strs[0], norb, nelec[0])
cd_indexb = cre_des_linkstr(ci_strs[1], norb, nelec[1])
dd_indexb = des_des_linkstr(ci_strs[1], norb, nelec[1])
else:
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = cd_indexa.shape[:2]
nb, nlinkb = cd_indexb.shape[:2]
ma, mlinka = dd_indexa.shape[:2]
mb, mlinkb = dd_indexb.shape[:2]
fcivec = ci_coeff.reshape(na, nb)
# (bb|aa) and (aa|bb)
dm2ab = rdm.make_rdm12_spin1('FCItdm12kern_ab', fcivec, fcivec, norb,
nelec, (cd_indexa, cd_indexb), 0)[1]
# (aa|aa)
if nelec[0] > 1:
dm2aa = numpy.empty([norb] * 4)
libfci.SCIrdm2_aaaa(libfci.SCIrdm2kern_aaaa,
dm2aa.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(na),
ctypes.c_int(nb), ctypes.c_int(ma),
ctypes.c_int(mlinka),
dd_indexa.ctypes.data_as(ctypes.c_void_p))
# (bb|bb)
if nelec[1] > 1:
dm2bb = numpy.empty([norb] * 4)
fcivecT = lib.transpose(fcivec)
libfci.SCIrdm2_aaaa(libfci.SCIrdm2kern_aaaa,
dm2bb.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(nb),
ctypes.c_int(na), ctypes.c_int(mb),
ctypes.c_int(mlinkb),
dd_indexb.ctypes.data_as(ctypes.c_void_p))
return dm2aa, dm2ab, dm2bb
def make_rdm2s(civec_strs, norb, nelec, link_index=None, **kwargs):
r'''Spin separated 2-particle density matrices.
The return values include three density matrices:
(alpha,alpha,alpha,alpha), (alpha,alpha,beta,beta), (beta,beta,beta,beta)
2pdm[p,q,r,s] = :math:`\langle p^\dagger r^\dagger s q\rangle`
'''
ci_coeff, nelec, ci_strs = _unpack(civec_strs, nelec)
if link_index is None:
cd_indexa = cre_des_linkstr(ci_strs[0], norb, nelec[0])
dd_indexa = des_des_linkstr(ci_strs[0], norb, nelec[0])
cd_indexb = cre_des_linkstr(ci_strs[1], norb, nelec[1])
dd_indexb = des_des_linkstr(ci_strs[1], norb, nelec[1])
else:
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = cd_indexa.shape[:2]
nb, nlinkb = cd_indexb.shape[:2]
fcivec = ci_coeff.reshape(na,nb)
# (bb|aa) and (aa|bb)
dm2ab = rdm.make_rdm12_spin1('FCItdm12kern_ab', fcivec, fcivec,
norb, nelec, (cd_indexa,cd_indexb), 0)[1]
# (aa|aa)
dm2aa = numpy.zeros([norb]*4)
if nelec[0] > 1:
ma, mlinka = dd_indexa.shape[:2]
libfci.SCIrdm2_aaaa(libfci.SCIrdm2kern_aaaa,
dm2aa.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(nb),
ctypes.c_int(ma), ctypes.c_int(mlinka),
dd_indexa.ctypes.data_as(ctypes.c_void_p))
# (bb|bb)
dm2bb = numpy.zeros([norb]*4)
if nelec[1] > 1:
mb, mlinkb = dd_indexb.shape[:2]
fcivecT = lib.transpose(fcivec)
libfci.SCIrdm2_aaaa(libfci.SCIrdm2kern_aaaa,
dm2bb.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(nb), ctypes.c_int(na),
ctypes.c_int(mb), ctypes.c_int(mlinkb),
dd_indexb.ctypes.data_as(ctypes.c_void_p))
return dm2aa, dm2ab, dm2bb
def _trans(mo, ncore, ncas, fload, cvcv=None, ao_loc=None):
nao, nmo = mo.shape
nocc = ncore + ncas
nvir = nmo - nocc
nav = nmo - ncore
if cvcv is None:
cvcv = numpy.zeros((ncore*nvir,ncore*nvir))
pacv = numpy.empty((nmo,ncas,ncore*nvir))
aapp = numpy.empty((ncas,ncas,nmo*nmo))
papa = numpy.empty((nmo,ncas,nmo*ncas))
vcv = numpy.empty((nav,ncore*nvir))
apa = numpy.empty((ncas,nmo*ncas))
vpa = numpy.empty((nav,nmo*ncas))
app = numpy.empty((ncas,nmo*nmo))
for i in range(ncore):
buf = fload(i, i+1)
klshape = (0, ncore, nocc, nmo)
_ao2mo.nr_e2(buf, mo, klshape,
aosym='s4', mosym='s1', out=vcv, ao_loc=ao_loc)
cvcv[i*nvir:(i+1)*nvir] = vcv[ncas:]
pacv[i] = vcv[:ncas]
klshape = (0, nmo, ncore, nocc)
_ao2mo.nr_e2(buf[:ncas], mo, klshape,
aosym='s4', mosym='s1', out=apa, ao_loc=ao_loc)
papa[i] = apa
for i in range(ncas):
buf = fload(ncore+i, ncore+i+1)
klshape = (0, ncore, nocc, nmo)
_ao2mo.nr_e2(buf, mo, klshape,
aosym='s4', mosym='s1', out=vcv, ao_loc=ao_loc)
pacv[ncore:,i] = vcv
klshape = (0, nmo, ncore, nocc)
_ao2mo.nr_e2(buf, mo, klshape,
aosym='s4', mosym='s1', out=vpa, ao_loc=ao_loc)
papa[ncore:,i] = vpa
klshape = (0, nmo, 0, nmo)
_ao2mo.nr_e2(buf[:ncas], mo, klshape,
aosym='s4', mosym='s1', out=app, ao_loc=ao_loc)
aapp[i] = app
#lib.transpose(aapp.reshape(ncas**2, -1), inplace=True)
ppaa = lib.transpose(aapp.reshape(ncas**2,-1))
return (ppaa.reshape(nmo,nmo,ncas,ncas), papa.reshape(nmo,ncas,nmo,ncas),
pacv.reshape(nmo,ncas,ncore,nvir), cvcv)
def _trans(mo, ncore, ncas, fload, cvcv=None, ao_loc=None):
nao, nmo = mo.shape
nocc = ncore + ncas
nvir = nmo - nocc
nav = nmo - ncore
if cvcv is None:
cvcv = numpy.zeros((ncore*nvir,ncore*nvir))
pacv = numpy.empty((nmo,ncas,ncore*nvir))
aapp = numpy.empty((ncas,ncas,nmo*nmo))
papa = numpy.empty((nmo,ncas,nmo*ncas))
vcv = numpy.empty((nav,ncore*nvir))
apa = numpy.empty((ncas,nmo*ncas))
vpa = numpy.empty((nav,nmo*ncas))
app = numpy.empty((ncas,nmo*nmo))
for i in range(ncore):
buf = fload(i, i+1)
klshape = (0, ncore, nocc, nmo)
_ao2mo.nr_e2(buf, mo, klshape,
aosym='s4', mosym='s1', out=vcv, ao_loc=ao_loc)
cvcv[i*nvir:(i+1)*nvir] = vcv[ncas:]
pacv[i] = vcv[:ncas]
klshape = (0, nmo, ncore, nocc)
_ao2mo.nr_e2(buf[:ncas], mo, klshape,
aosym='s4', mosym='s1', out=apa, ao_loc=ao_loc)
papa[i] = apa
for i in range(ncas):
buf = fload(ncore+i, ncore+i+1)
klshape = (0, ncore, nocc, nmo)
_ao2mo.nr_e2(buf, mo, klshape,
aosym='s4', mosym='s1', out=vcv, ao_loc=ao_loc)
pacv[ncore:,i] = vcv
klshape = (0, nmo, ncore, nocc)
_ao2mo.nr_e2(buf, mo, klshape,
aosym='s4', mosym='s1', out=vpa, ao_loc=ao_loc)
papa[ncore:,i] = vpa
klshape = (0, nmo, 0, nmo)
_ao2mo.nr_e2(buf[:ncas], mo, klshape,
aosym='s4', mosym='s1', out=app, ao_loc=ao_loc)
aapp[i] = app
ppaa = lib.transpose(aapp.reshape(ncas**2,-1))
return (ppaa.reshape(nmo,nmo,ncas,ncas), papa.reshape(nmo,ncas,nmo,ncas),
pacv.reshape(nmo,ncas,ncore,nvir), cvcv)
def compress(Lpq):
ncol = Lpq.shape[-1]
auxchgs = numpy.zeros((naochg,ncol), dtype=Lpq.dtype)
for i in range(auxcell.nbas):
l = auxcell.bas_angular(i)
ia = auxcell.bas_atom(i)
p0 = modchg_offset[ia,l]
if p0 >= 0:
nc = auxcell.bas_nctr(i)
i0,i1 = aux_loc[i:i+2]
lchg = numpy.einsum('imn->mn', Lpq[i0:i1].reshape(nc,-1,ncol))
auxchgs[p0:p0+len(lchg)] -= lchg
if Lpq.flags.f_contiguous:
Lpq = lib.transpose(Lpq.T)
Lpq = numpy.vstack((Lpq, auxchgs))
return Lpq
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 _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 make_rdm2s(civec_strs, norb, nelec, link_index=None, **kwargs):
ci_coeff, nelec, ci_strs = _unpack(civec_strs, nelec)
if link_index is None:
cd_indexa = cre_des_linkstr(ci_strs[0], norb, nelec[0])
dd_indexa = des_des_linkstr(ci_strs[0], norb, nelec[0])
cd_indexb = cre_des_linkstr(ci_strs[1], norb, nelec[1])
dd_indexb = des_des_linkstr(ci_strs[1], norb, nelec[1])
else:
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = cd_indexa.shape[:2]
nb, nlinkb = cd_indexb.shape[:2]
ma, mlinka = dd_indexa.shape[:2]
mb, mlinkb = dd_indexb.shape[:2]
fcivec = ci_coeff.reshape(na, nb)
# (bb|aa) and (aa|bb)
dm2ab = rdm.make_rdm12_spin1('FCItdm12kern_ab', fcivec, fcivec, norb,
nelec, (cd_indexa, cd_indexb), 0)[1]
# (aa|aa)
if nelec[0] > 1:
dm2aa = numpy.empty([norb] * 4)
libfci.SCIrdm2_aaaa(libfci.SCIrdm2kern_aaaa,
dm2aa.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
fcivec.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(na),
ctypes.c_int(nb), ctypes.c_int(ma),
ctypes.c_int(mlinka),
dd_indexa.ctypes.data_as(ctypes.c_void_p))
# (bb|bb)
if nelec[1] > 1:
dm2bb = numpy.empty([norb] * 4)
fcivecT = lib.transpose(fcivec)
libfci.SCIrdm2_aaaa(libfci.SCIrdm2kern_aaaa,
dm2bb.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
fcivecT.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(nb),
ctypes.c_int(na), ctypes.c_int(mb),
ctypes.c_int(mlinkb),
dd_indexb.ctypes.data_as(ctypes.c_void_p))
return dm2aa, dm2ab, dm2bb
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 cholesky_eri(mol, auxbasis='weigend+etb', auxmol=None,
int3c='int3c2e', aosym='s2ij', int2c='int2c2e', comp=1,
verbose=0, fauxe2=aux_e2):
'''
Returns:
2D array of (naux,nao*(nao+1)/2) in C-contiguous
'''
assert(comp == 1)
t0 = (time.clock(), time.time())
log = logger.new_logger(mol, verbose)
if auxmol is None:
auxmol = addons.make_auxmol(mol, auxbasis)
j2c = auxmol.intor(int2c, hermi=1)
naux = j2c.shape[0]
log.debug('size of aux basis %d', naux)
t1 = log.timer('2c2e', *t0)
j3c = fauxe2(mol, auxmol, intor=int3c, aosym=aosym).reshape(-1,naux)
t1 = log.timer('3c2e', *t1)
try:
low = scipy.linalg.cholesky(j2c, lower=True)
j2c = None
t1 = log.timer('Cholesky 2c2e', *t1)
cderi = scipy.linalg.solve_triangular(low, j3c.T, lower=True,
overwrite_b=True)
except scipy.linalg.LinAlgError:
w, v = scipy.linalg.eigh(j2c)
idx = w > LINEAR_DEP_THR
v = (v[:,idx] / numpy.sqrt(w[idx]))
cderi = lib.dot(v.T, j3c.T)
j3c = None
if cderi.flags.f_contiguous:
cderi = lib.transpose(cderi.T)
log.timer('cholesky_eri', *t0)
return cderi
def cholesky_eri_debug(mol, auxbasis='weigend+etb', auxmol=None,
int3c='int3c2e', aosym='s2ij', int2c='int2c2e', comp=1,
verbose=0, fauxe2=aux_e2):
'''
Returns:
2D array of (naux,nao*(nao+1)/2) in C-contiguous
'''
assert(comp == 1)
t0 = (logger.process_clock(), logger.perf_counter())
log = logger.new_logger(mol, verbose)
if auxmol is None:
auxmol = addons.make_auxmol(mol, auxbasis)
j2c = auxmol.intor(int2c, hermi=1)
naux = j2c.shape[0]
log.debug('size of aux basis %d', naux)
t1 = log.timer('2c2e', *t0)
j3c = fauxe2(mol, auxmol, intor=int3c, aosym=aosym).reshape(-1,naux)
t1 = log.timer('3c2e', *t1)
try:
low = scipy.linalg.cholesky(j2c, lower=True)
j2c = None
t1 = log.timer('Cholesky 2c2e', *t1)
cderi = scipy.linalg.solve_triangular(low, j3c.T, lower=True,
overwrite_b=True)
except scipy.linalg.LinAlgError:
w, v = scipy.linalg.eigh(j2c)
idx = w > LINEAR_DEP_THR
v = (v[:,idx] / numpy.sqrt(w[idx]))
cderi = lib.dot(v.T, j3c.T)
j3c = None
if cderi.flags.f_contiguous:
cderi = lib.transpose(cderi.T)
log.timer('cholesky_eri', *t0)
return cderi
def _ifftn_blas(g, mesh):
Gx = np.fft.fftfreq(mesh[0])
Gy = np.fft.fftfreq(mesh[1])
Gz = np.fft.fftfreq(mesh[2])
expRGx = np.exp(np.einsum('x,k->xk', 2j * np.pi * np.arange(mesh[0]), Gx))
expRGy = np.exp(np.einsum('x,k->xk', 2j * np.pi * np.arange(mesh[1]), Gy))
expRGz = np.exp(np.einsum('x,k->xk', 2j * np.pi * np.arange(mesh[2]), Gz))
f0 = f = lib.transpose(g.reshape(-1,
mesh[1] * mesh[2])).astype(np.complex128)
f1 = np.empty_like(f0)
f = lib.dot(f.reshape(-1, mesh[0]),
expRGx,
1. / mesh[0],
c=f1.reshape(-1, mesh[0]))
f = lib.dot(f.reshape(mesh[1], -1).T,
expRGy,
1. / mesh[1],
c=f0.reshape(-1, mesh[1]))
f = lib.dot(f.reshape(mesh[2], -1).T,
expRGz,
1. / mesh[2],
c=f1.reshape(-1, mesh[2]))
return f.reshape(-1, *mesh)
def __enter__(self):
self.feri = h5py.File(self.cderi, 'r')
kpti_kptj = numpy.asarray(self.kpti_kptj)
kptij_lst = self.feri['%s-kptij'%self.label].value
dk = numpy.einsum('kij->k', abs(kptij_lst-kpti_kptj))
k_id = numpy.where(dk < 1e-6)[0]
if len(k_id) > 0:
dat = self.feri['%s/%d' % (self.label,k_id[0])]
else:
# swap ki,kj due to the hermiticity
kptji = kpti_kptj[[1,0]]
dk = numpy.einsum('kij->k', abs(kptij_lst-kptji))
k_id = numpy.where(dk < 1e-6)[0]
if len(k_id) == 0:
raise RuntimeError('%s for kpts %s is not initialized.\n'
'Reset attribute .kpts then call '
'.build() to initialize %s.'
% (self.label, kpti_kptj, self.label))
# FIXME: memory usage
dat = self.feri['%s/%d' % (self.label, k_id[0])].value
nao = int(numpy.sqrt(dat.shape[1]))
dat = lib.transpose(dat.reshape(-1,nao,nao), axes=(0,2,1)).conj()
dat = dat.reshape(-1,nao**2)
return dat
def _make_j3c(mydf, cell, auxcell, kptij_lst, cderi_file):
t1 = (time.clock(), time.time())
log = logger.Logger(mydf.stdout, mydf.verbose)
max_memory = max(2000, mydf.max_memory - lib.current_memory()[0])
fused_cell, fuse = fuse_auxcell(mydf, auxcell)
outcore.aux_e2(cell,
fused_cell,
cderi_file,
'int3c2e_sph',
aosym='s2',
kptij_lst=kptij_lst,
dataname='j3c',
max_memory=max_memory)
t1 = log.timer_debug1('3c2e', *t1)
nao = cell.nao_nr()
naux = auxcell.nao_nr()
gs = mydf.gs
Gv, Gvbase, kws = cell.get_Gv_weights(gs)
b = cell.reciprocal_vectors()
gxyz = lib.cartesian_prod([numpy.arange(len(x)) for x in Gvbase])
ngs = gxyz.shape[0]
kptis = kptij_lst[:, 0]
kptjs = kptij_lst[:, 1]
kpt_ji = kptjs - kptis
uniq_kpts, uniq_index, uniq_inverse = unique(kpt_ji)
log.debug('Num uniq kpts %d', len(uniq_kpts))
log.debug2('uniq_kpts %s', uniq_kpts)
# j2c ~ (-kpt_ji | kpt_ji)
j2c = fused_cell.pbc_intor('int2c2e_sph', hermi=1, kpts=uniq_kpts)
feri = h5py.File(cderi_file)
for k, kpt in enumerate(uniq_kpts):
aoaux = ft_ao.ft_ao(fused_cell, Gv, None, b, gxyz, Gvbase, kpt).T
aoaux = fuse(aoaux)
coulG = numpy.sqrt(mydf.weighted_coulG(kpt, False, gs))
kLR = (aoaux.real * coulG).T
kLI = (aoaux.imag * coulG).T
if not kLR.flags.c_contiguous: kLR = lib.transpose(kLR.T)
if not kLI.flags.c_contiguous: kLI = lib.transpose(kLI.T)
j2c_k = fuse(fuse(j2c[k]).T).T.copy()
if is_zero(kpt): # kpti == kptj
j2c_k -= lib.dot(kLR.T, kLR)
j2c_k -= lib.dot(kLI.T, kLI)
else:
# aoaux ~ kpt_ij, aoaux.conj() ~ kpt_kl
j2cR, j2cI = zdotCN(kLR.T, kLI.T, kLR, kLI)
j2c_k -= j2cR + j2cI * 1j
feri['j2c/%d' % k] = j2c_k
aoaux = kLR = kLI = j2cR = j2cI = coulG = None
j2c = None
def make_kpt(uniq_kptji_id): # kpt = kptj - kpti
kpt = uniq_kpts[uniq_kptji_id]
log.debug1('kpt = %s', kpt)
adapted_ji_idx = numpy.where(uniq_inverse == uniq_kptji_id)[0]
adapted_kptjs = kptjs[adapted_ji_idx]
nkptj = len(adapted_kptjs)
log.debug1('adapted_ji_idx = %s', adapted_ji_idx)
Gaux = ft_ao.ft_ao(fused_cell, Gv, None, b, gxyz, Gvbase, kpt).T
Gaux = fuse(Gaux)
Gaux *= mydf.weighted_coulG(kpt, False, gs)
kLR = Gaux.T.real.copy('C')
kLI = Gaux.T.imag.copy('C')
j2c = numpy.asarray(feri['j2c/%d' % uniq_kptji_id])
# Note large difference may be found in results between the CD/eig treatments.
# In some systems, small integral errors can lead to different treatments of
# linear dependency which can be observed in the total energy/orbital energy
# around 4th decimal place.
# try:
# j2c = scipy.linalg.cholesky(j2c, lower=True)
# j2ctag = 'CD'
# except scipy.linalg.LinAlgError as e:
#
# Abandon CD treatment for better numerical stablity
w, v = scipy.linalg.eigh(j2c)
log.debug('MDF metric for kpt %s cond = %.4g, drop %d bfns',
uniq_kptji_id, w[-1] / w[0],
numpy.count_nonzero(w < mydf.linear_dep_threshold))
v = v[:, w > mydf.linear_dep_threshold].T.conj()
v /= numpy.sqrt(w[w > mydf.linear_dep_threshold]).reshape(-1, 1)
j2c = v
j2ctag = 'eig'
naux0 = j2c.shape[0]
if is_zero(kpt): # kpti == kptj
aosym = 's2'
nao_pair = nao * (nao + 1) // 2
vbar = fuse(mydf.auxbar(fused_cell))
ovlp = cell.pbc_intor('int1e_ovlp_sph',
hermi=1,
kpts=adapted_kptjs)
for k, ji in enumerate(adapted_ji_idx):
ovlp[k] = lib.pack_tril(ovlp[k])
else:
aosym = 's1'
nao_pair = nao**2
mem_now = lib.current_memory()[0]
log.debug2('memory = %s', mem_now)
max_memory = max(2000, mydf.max_memory - mem_now)
# nkptj for 3c-coulomb arrays plus 1 Lpq array
buflen = min(
max(int(max_memory * .6 * 1e6 / 16 / naux / (nkptj + 1)), 1),
nao_pair)
shranges = _guess_shell_ranges(cell, buflen, aosym)
buflen = max([x[2] for x in shranges])
# +1 for a pqkbuf
if aosym == 's2':
Gblksize = max(
16, int(max_memory * .2 * 1e6 / 16 / buflen / (nkptj + 1)))
else:
Gblksize = max(
16, int(max_memory * .4 * 1e6 / 16 / buflen / (nkptj + 1)))
Gblksize = min(Gblksize, ngs, 16384)
pqkRbuf = numpy.empty(buflen * Gblksize)
pqkIbuf = numpy.empty(buflen * Gblksize)
# buf for ft_aopair
buf = numpy.empty((nkptj, buflen * Gblksize), dtype=numpy.complex128)
col1 = 0
for istep, sh_range in enumerate(shranges):
log.debug1('int3c2e [%d/%d], AO [%d:%d], ncol = %d', \
istep+1, len(shranges), *sh_range)
bstart, bend, ncol = sh_range
col0, col1 = col1, col1 + ncol
j3cR = []
j3cI = []
for k, idx in enumerate(adapted_ji_idx):
v = fuse(numpy.asarray(feri['j3c/%d' % idx][:, col0:col1]))
if is_zero(kpt):
for i, c in enumerate(vbar):
if c != 0:
v[i] -= c * ovlp[k][col0:col1]
j3cR.append(numpy.asarray(v.real, order='C'))
if is_zero(kpt) and gamma_point(adapted_kptjs[k]):
j3cI.append(None)
else:
j3cI.append(numpy.asarray(v.imag, order='C'))
v = None
if aosym == 's2':
shls_slice = (bstart, bend, 0, bend)
else:
shls_slice = (bstart, bend, 0, cell.nbas)
for p0, p1 in lib.prange(0, ngs, Gblksize):
dat = ft_ao._ft_aopair_kpts(cell,
Gv[p0:p1],
shls_slice,
aosym,
b,
gxyz[p0:p1],
Gvbase,
kpt,
adapted_kptjs,
out=buf)
nG = p1 - p0
for k, ji in enumerate(adapted_ji_idx):
aoao = dat[k].reshape(nG, ncol)
pqkR = numpy.ndarray((ncol, nG), buffer=pqkRbuf)
pqkI = numpy.ndarray((ncol, nG), buffer=pqkIbuf)
pqkR[:] = aoao.real.T
pqkI[:] = aoao.imag.T
lib.dot(kLR[p0:p1].T, pqkR.T, -1, j3cR[k], 1)
lib.dot(kLI[p0:p1].T, pqkI.T, -1, j3cR[k], 1)
if not (is_zero(kpt) and gamma_point(adapted_kptjs[k])):
lib.dot(kLR[p0:p1].T, pqkI.T, -1, j3cI[k], 1)
lib.dot(kLI[p0:p1].T, pqkR.T, 1, j3cI[k], 1)
for k, ji in enumerate(adapted_ji_idx):
if is_zero(kpt) and gamma_point(adapted_kptjs[k]):
v = j3cR[k]
else:
v = j3cR[k] + j3cI[k] * 1j
if j2ctag == 'CD':
v = scipy.linalg.solve_triangular(j2c,
v,
lower=True,
overwrite_b=True)
else:
v = lib.dot(j2c, v)
feri['j3c/%d' % ji][:naux0, col0:col1] = v
del (feri['j2c/%d' % uniq_kptji_id])
for k, ji in enumerate(adapted_ji_idx):
v = feri['j3c/%d' % ji][:naux0]
del (feri['j3c/%d' % ji])
feri['j3c/%d' % ji] = v
for k, kpt in enumerate(uniq_kpts):
make_kpt(k)
feri.close()
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 get_jk(mydf, dm, hermi=1, kpt=numpy.zeros(3),
kpt_band=None, with_j=True, with_k=True, exxdiv=None):
'''JK for given k-point'''
vj = vk = None
if kpt_band is not None and abs(kpt-kpt_band).sum() > 1e-9:
kpt = numpy.reshape(kpt, (1,3))
if with_k:
vk = get_k_kpts(mydf, [dm], hermi, kpt, kpt_band, exxdiv)
if with_j:
vj = get_j_kpts(mydf, [dm], hermi, kpt, kpt_band)
return vj, vk
cell = mydf.cell
log = logger.Logger(mydf.stdout, mydf.verbose)
t1 = (time.clock(), time.time())
if mydf._cderi is None:
mydf.build()
t1 = log.timer_debug1('Init get_jk', *t1)
dm = numpy.asarray(dm, order='C')
dms = _format_dms(dm, [kpt])
nset, _, nao = dms.shape[:3]
dms = dms.reshape(nset,nao,nao)
j_real = gamma_point(kpt)
k_real = gamma_point(kpt) and not numpy.iscomplexobj(dms)
auxcell = mydf.auxcell
naux = auxcell.nao_nr()
kptii = numpy.asarray((kpt,kpt))
kpt_allow = numpy.zeros(3)
if with_j:
vjcoulG = tools.get_coulG(cell, kpt_allow, gs=mydf.gs) / cell.vol
vjR = numpy.zeros((nset,nao**2))
vjI = numpy.zeros((nset,nao**2))
if with_k:
mydf.exxdiv = exxdiv
vkcoulG = tools.get_coulG(cell, kpt_allow, True, mydf, mydf.gs) / cell.vol
vkR = numpy.zeros((nset,nao,nao))
vkI = numpy.zeros((nset,nao,nao))
dmsR = dms.real.reshape(nset,nao,nao)
dmsI = dms.imag.reshape(nset,nao,nao)
max_memory = (mydf.max_memory - lib.current_memory()[0]) * .8
# rho_rs(-G+k_rs) is computed as conj(rho_{rs^*}(G-k_rs))
# == conj(transpose(rho_sr(G+k_sr), (0,2,1)))
for pqkR, pqkI, p0, p1 \
in mydf.pw_loop(cell, mydf.gs, kptii, max_memory=max_memory):
if with_j:
for i in range(nset):
if j_real:
rhoR = numpy.dot(dmsR[i].ravel(), pqkR)
rhoI = numpy.dot(dmsR[i].ravel(), pqkI)
rhoR *= vjcoulG[p0:p1]
rhoI *= vjcoulG[p0:p1]
vjR[i] += numpy.dot(pqkR, rhoR)
vjR[i] += numpy.dot(pqkI, rhoI)
else:
rhoR = numpy.dot(dmsR[i].ravel(), pqkR)
rhoR+= numpy.dot(dmsI[i].ravel(), pqkI)
rhoI = numpy.dot(dmsI[i].ravel(), pqkR)
rhoI-= numpy.dot(dmsR[i].ravel(), pqkI)
rhoR *= vjcoulG[p0:p1]
rhoI *= vjcoulG[p0:p1]
vjR[i] += numpy.dot(pqkR, rhoR)
vjR[i] -= numpy.dot(pqkI, rhoI)
vjI[i] += numpy.dot(pqkR, rhoI)
vjI[i] += numpy.dot(pqkI, rhoR)
if with_k:
coulG = numpy.sqrt(vkcoulG[p0:p1])
pqkR *= coulG
pqkI *= coulG
#:v4 = numpy.einsum('ijL,lkL->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,jk->il', v4, dm)
pLqR = lib.transpose(pqkR.reshape(nao,nao,-1), axes=(0,2,1)).reshape(-1,nao)
pLqI = lib.transpose(pqkI.reshape(nao,nao,-1), axes=(0,2,1)).reshape(-1,nao)
iLkR = numpy.ndarray((nao*(p1-p0),nao), buffer=pqkR)
iLkI = numpy.ndarray((nao*(p1-p0),nao), buffer=pqkI)
for i in range(nset):
iLkR, iLkI = zdotNN(pLqR, pLqI, dmsR[i], dmsI[i], 1, iLkR, iLkI)
vkR[i] += lib.dot(iLkR.reshape(nao,-1), pLqR.reshape(nao,-1).T)
vkR[i] += lib.dot(iLkI.reshape(nao,-1), pLqI.reshape(nao,-1).T)
if not k_real:
vkI[i] += lib.dot(iLkI.reshape(nao,-1), pLqR.reshape(nao,-1).T)
vkI[i] -= lib.dot(iLkR.reshape(nao,-1), pLqI.reshape(nao,-1).T)
pqkR = pqkI = coulG = None
bufR = numpy.empty((mydf.blockdim*nao**2))
bufI = numpy.empty((mydf.blockdim*nao**2))
if with_j:
vjR = vjR.reshape(nset,nao,nao)
vjI = vjI.reshape(nset,nao,nao)
for LpqR, LpqI, j3cR, j3cI in mydf.sr_loop(kptii, max_memory, False, True):
if with_j:
#:rho_coeff = numpy.einsum('Lpq,xqp->xL', Lpq, dms)
#:jaux = numpy.einsum('Lpq,xqp->xL', j3c, dms)
#:vj += numpy.dot(jaux, Lpq.reshape(-1,nao**2))
#:vj += numpy.dot(rho_coeff, j3c.reshape(-1,nao**2))
rhoR = numpy.einsum('pLq,xpq->xL', LpqR, dmsR)
rhoR -= numpy.einsum('pLq,xpq->xL', LpqI, dmsI)
rhoI = numpy.einsum('pLq,xpq->xL', LpqR, dmsI)
rhoI += numpy.einsum('pLq,xpq->xL', LpqI, dmsR)
jauxR = numpy.einsum('pLq,xpq->xL', j3cR, dmsR)
jauxR-= numpy.einsum('pLq,xpq->xL', j3cI, dmsI)
jauxI = numpy.einsum('pLq,xpq->xL', j3cR, dmsI)
jauxI+= numpy.einsum('pLq,xpq->xL', j3cI, dmsR)
vjR += numpy.einsum('xL,pLq->pq', jauxR, LpqR)
vjR -= numpy.einsum('xL,pLq->pq', jauxI, LpqI)
vjI += numpy.einsum('xL,pLq->pq', jauxR, LpqI)
vjI += numpy.einsum('xL,pLq->pq', jauxI, LpqR)
vjR += numpy.einsum('xL,pLq->pq', rhoR, j3cR)
vjR -= numpy.einsum('xL,pLq->pq', rhoI, j3cI)
vjI += numpy.einsum('xL,pLq->pq', rhoR, j3cI)
vjI += numpy.einsum('xL,pLq->pq', rhoI, j3cR)
if with_k:
#:Lpq = LpqR + LpqI*1j
#:j3c = j3cR + j3cI*1j
#:for i in range(nset):
#: tmp = numpy.dot(dms[i], j3c.reshape(nao,-1))
#: vk1 = numpy.dot(Lpq.reshape(-1,nao).conj().T, tmp.reshape(-1,nao))
#: tmp = numpy.dot(dms[i], Lpq.reshape(nao,-1))
#: vk1+= numpy.dot(j3c.reshape(-1,nao).conj().T, tmp.reshape(-1,nao))
#: vkR[i] += vk1.real
#: vkI[i] += vk1.imag
nrow = LpqR.shape[1]
tmpR = numpy.ndarray((nao,nrow*nao), buffer=bufR)
tmpI = numpy.ndarray((nao,nrow*nao), buffer=bufI)
# K ~ 'iLj,lLk*,li->kj' + 'lLk*,iLj,li->kj'
for i in range(nset):
tmpR, tmpI = zdotNN(dmsR[i], dmsI[i], j3cR.reshape(nao,-1),
j3cI.reshape(nao,-1), 1, tmpR, tmpI, 0)
vk1R, vk1I = zdotCN(LpqR.reshape(-1,nao).T, LpqI.reshape(-1,nao).T,
tmpR.reshape(-1,nao), tmpI.reshape(-1,nao))
vkR[i] += vk1R
vkI[i] += vk1I
if hermi:
vkR[i] += vk1R.T
vkI[i] -= vk1I.T
else:
tmpR, tmpI = zdotNN(dmsR[i], dmsI[i], LpqR.reshape(nao,-1),
LpqI.reshape(nao,-1), 1, tmpR, tmpI, 0)
zdotCN(j3cR.reshape(-1,nao).T, j3cI.reshape(-1,nao).T,
tmpR.reshape(-1,nao), tmpI.reshape(-1,nao),
1, vkR[i], vkI[i], 1)
if with_j:
if j_real:
vj = vjR
else:
vj = vjR + vjI * 1j
vj = vj.reshape(dm.shape)
if with_k:
if k_real:
vk = vkR
else:
vk = vkR + vkI * 1j
vk = vk.reshape(dm.shape)
t1 = log.timer('sr jk', *t1)
return vj, vk
def restore_t2_inplace(t2T):
tmp = lib.transpose(t2T.reshape(nvir**2,nocc,nocc), axes=(0,2,1))
t2 = lib.transpose(tmp.reshape(nvir**2,nocc**2), out=t2T)
return t2.reshape(nocc,nocc,nvir,nvir)
def restore_t2_inplace(t2T):
tmp = numpy.zeros((nvir**2,nocc**2), dtype=t2T.dtype)
lib.takebak_2d(tmp, t2T.reshape(nvir**2,nocc**2), vv_idx, oo_idx)
t2 = lib.transpose(tmp.reshape(nvir**2,nocc**2), out=t2T)
return t2.reshape(nocc,nocc,nvir,nvir)
def cholesky_eri(mol,
auxbasis='weigend+etb',
auxmol=None,
int3c='int3c2e',
aosym='s2ij',
int2c='int2c2e',
comp=1,
max_memory=MAX_MEMORY,
verbose=0,
fauxe2=aux_e2):
'''
Returns:
2D array of (naux,nao*(nao+1)/2) in C-contiguous
'''
from pyscf.df.outcore import _guess_shell_ranges
assert (comp == 1)
t0 = (time.clock(), time.time())
log = logger.new_logger(mol, verbose)
if auxmol is None:
auxmol = addons.make_auxmol(mol, auxbasis)
j2c = auxmol.intor(int2c, hermi=1)
try:
low = scipy.linalg.cholesky(j2c, lower=True)
tag = 'cd'
except scipy.linalg.LinAlgError:
w, v = scipy.linalg.eigh(j2c)
idx = w > LINEAR_DEP_THR
low = (v[:, idx] / numpy.sqrt(w[idx]))
v = None
tag = 'eig'
j2c = None
naoaux, naux = low.shape
log.debug('size of aux basis %d', naux)
t1 = log.timer_debug1('2c2e', *t0)
int3c = gto.moleintor.ascint3(mol._add_suffix(int3c))
atm, bas, env = gto.mole.conc_env(mol._atm, mol._bas, mol._env,
auxmol._atm, auxmol._bas, auxmol._env)
ao_loc = gto.moleintor.make_loc(bas, int3c)
nao = ao_loc[mol.nbas]
if aosym == 's1':
nao_pair = nao * nao
else:
nao_pair = nao * (nao + 1) // 2
cderi = numpy.empty((naux, nao_pair))
max_words = max_memory * .98e6 / 8 - low.size - cderi.size
# Divide by 3 because scipy.linalg.solve may create a temporary copy for
# ints and return another copy for results
buflen = min(max(int(max_words / naoaux / comp / 3), 8), nao_pair)
shranges = _guess_shell_ranges(mol, buflen, aosym)
log.debug1('shranges = %s', shranges)
cintopt = gto.moleintor.make_cintopt(atm, bas, env, int3c)
bufs1 = numpy.empty((comp * max([x[2] for x in shranges]), naoaux))
bufs2 = numpy.empty_like(bufs1)
p1 = 0
for istep, sh_range in enumerate(shranges):
log.debug('int3c2e [%d/%d], AO [%d:%d], nrow = %d', istep + 1,
len(shranges), *sh_range)
bstart, bend, nrow = sh_range
shls_slice = (bstart, bend, 0, mol.nbas, mol.nbas,
mol.nbas + auxmol.nbas)
ints = gto.moleintor.getints3c(int3c,
atm,
bas,
env,
shls_slice,
comp,
aosym,
ao_loc,
cintopt,
out=bufs1)
if ints.ndim == 3 and ints.flags.f_contiguous:
ints = lib.transpose(ints.T, axes=(0, 2, 1),
out=bufs2).reshape(naoaux, -1)
bufs1, bufs2 = bufs2, bufs1
else:
ints = ints.reshape((-1, naoaux)).T
p0, p1 = p1, p1 + nrow
if tag == 'cd':
if ints.flags.c_contiguous:
ints = lib.transpose(ints, out=bufs2).T
bufs1, bufs2 = bufs2, bufs1
dat = scipy.linalg.solve_triangular(low,
ints,
lower=True,
overwrite_b=True,
check_finite=False)
if dat.flags.f_contiguous:
dat = lib.transpose(dat.T, out=bufs2)
cderi[:, p0:p1] = dat
else:
dat = numpy.ndarray((naux, ints.shape[1]), buffer=bufs2)
cderi[:, p0:p1] = lib.dot(low.T, ints, c=dat)
dat = ints = None
log.timer('cholesky_eri', *t0)
return cderi
def make_kpt(kpt): # kpt = kptj - kpti
# search for all possible ki and kj that has ki-kj+kpt=0
kk_match = numpy.einsum('ijx->ij', abs(kk_table + kpt)) < 1e-9
kpti_idx, kptj_idx = numpy.where(kk_todo & kk_match)
nkptj = len(kptj_idx)
log.debug1('kpt = %s', kpt)
log.debug1('kpti_idx = %s', kpti_idx)
log.debug1('kptj_idx = %s', kptj_idx)
kk_todo[kpti_idx,kptj_idx] = False
if swap_2e and not is_zero(kpt):
kk_todo[kptj_idx,kpti_idx] = False
max_memory = (mydf.max_memory - lib.current_memory()[0]) * .8
# Use DF object to mimic KRHF/KUHF object in function get_coulG
mydf.exxdiv = exxdiv
vkcoulG = tools.get_coulG(cell, kpt, True, mydf, mydf.gs) / cell.vol
kptjs = kpts[kptj_idx]
# <r|-G+k_rs|s> = conj(<s|G-k_rs|r>) = conj(<s|G+k_sr|r>)
for k, pqkR, pqkI, p0, p1 \
in mydf.ft_loop(cell, mydf.gs, kpt, kptjs, max_memory=max_memory):
ki = kpti_idx[k]
kj = kptj_idx[k]
coulG = numpy.sqrt(vkcoulG[p0:p1])
# case 1: k_pq = (pi|iq)
#:v4 = numpy.einsum('ijL,lkL->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,jk->il', v4, dm)
pqkR *= coulG
pqkI *= coulG
pLqR = lib.transpose(pqkR.reshape(nao,nao,-1), axes=(0,2,1))
pLqI = lib.transpose(pqkI.reshape(nao,nao,-1), axes=(0,2,1))
iLkR = numpy.empty((nao*(p1-p0),nao))
iLkI = numpy.empty((nao*(p1-p0),nao))
for i in range(nset):
iLkR, iLkI = zdotNN(pLqR.reshape(-1,nao), pLqI.reshape(-1,nao),
dmsR[i,kj], dmsI[i,kj], 1, iLkR, iLkI)
zdotNC(iLkR.reshape(nao,-1), iLkI.reshape(nao,-1),
pLqR.reshape(nao,-1).T, pLqI.reshape(nao,-1).T,
1, vkR[i,ki], vkI[i,ki], 1)
# case 2: k_pq = (iq|pi)
#:v4 = numpy.einsum('iLj,lLk->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,li->kj', v4, dm)
if swap_2e and not is_zero(kpt):
iLkR = iLkR.reshape(nao,-1)
iLkI = iLkI.reshape(nao,-1)
for i in range(nset):
iLkR, iLkI = zdotNN(dmsR[i,ki], dmsI[i,ki], pLqR.reshape(nao,-1),
pLqI.reshape(nao,-1), 1, iLkR, iLkI)
zdotCN(pLqR.reshape(-1,nao).T, pLqI.reshape(-1,nao).T,
iLkR.reshape(-1,nao), iLkI.reshape(-1,nao),
1, vkR[i,kj], vkI[i,kj], 1)
pqkR = pqkI = iLkR = iLkI = coulG = None
# Note: kj-ki for electorn 1 and ki-kj for electron 2
# j2c ~ ({kj-ki}|{ks-kr}) ~ ({kj-ki}|-{kj-ki}) ~ ({kj-ki}|{ki-kj})
# j3c ~ (Q|kj,ki) = j3c{ji} = (Q|ki,kj)* = conj(transpose(j3c{ij}, (0,2,1)))
bufR = numpy.empty((mydf.blockdim*nao**2))
bufI = numpy.empty((mydf.blockdim*nao**2))
for ki,kj in zip(kpti_idx,kptj_idx):
kpti = kpts_band[ki]
kptj = kpts[kj]
kptij = numpy.asarray((kpti,kptj))
for LpqR, LpqI, j3cR, j3cI in mydf.sr_loop(kptij, max_memory, False, True):
#:Lpq = LpqR + LpqI*1j
#:j3c = j3cR + j3cI*1j
#:for i in range(nset):
#: dm = dms[i,ki]
#: tmp = numpy.dot(dm, j3c.reshape(nao,-1))
#: vk1 = numpy.dot(Lpq.reshape(-1,nao).conj().T, tmp.reshape(-1,nao))
#: tmp = numpy.dot(dm, Lpq.reshape(nao,-1))
#: vk1+= numpy.dot(j3c.reshape(-1,nao).conj().T, tmp.reshape(-1,nao))
#: vkR[i,kj] += vk1.real
#: vkI[i,kj] += vk1.imag
#:if swap_2e and not is_zero(kpt):
#: # K ~ 'Lij,Llk*,jk->il' + 'Llk*,Lij,jk->il'
#: for i in range(nset):
#: dm = dms[i,kj]
#: tmp = numpy.dot(j3c.reshape(-1,nao), dm)
#: vk1 = numpy.dot(tmp.reshape(nao,-1), Lpq.reshape(nao,-1).conj().T)
#: tmp = numpy.dot(Lpq.reshape(-1,nao), dm)
#: vk1+= numpy.dot(tmp.reshape(nao,-1), j3c.reshape(nao,-1).conj().T)
#: vkR[i,ki] += vk1.real
#: vkI[i,ki] += vk1.imag
nrow = LpqR.shape[1]
tmpR = numpy.ndarray((nao,nrow*nao), buffer=bufR)
tmpI = numpy.ndarray((nao,nrow*nao), buffer=bufI)
# K ~ 'iLj,lLk*,li->kj' + 'lLk*,iLj,li->kj'
for i in range(nset):
tmpR, tmpI = zdotNN(dmsR[i,ki], dmsI[i,ki], j3cR.reshape(nao,-1),
j3cI.reshape(nao,-1), 1, tmpR, tmpI)
vk1R, vk1I = zdotCN(LpqR.reshape(-1,nao).T, LpqI.reshape(-1,nao).T,
tmpR.reshape(-1,nao), tmpI.reshape(-1,nao))
vkR[i,kj] += vk1R
vkI[i,kj] += vk1I
if hermi:
vkR[i,kj] += vk1R.T
vkI[i,kj] -= vk1I.T
else:
tmpR, tmpI = zdotNN(dmsR[i,ki], dmsI[i,ki], LpqR.reshape(nao,-1),
LpqI.reshape(nao,-1), 1, tmpR, tmpI)
zdotCN(j3cR.reshape(-1,nao).T, j3cI.reshape(-1,nao).T,
tmpR.reshape(-1,nao), tmpI.reshape(-1,nao),
1, vkR[i,kj], vkI[i,kj], 1)
if swap_2e and not is_zero(kpt):
tmpR = numpy.ndarray((nao*nrow,nao), buffer=bufR)
tmpI = numpy.ndarray((nao*nrow,nao), buffer=bufI)
# K ~ 'iLj,lLk*,jk->il' + 'lLk*,iLj,jk->il'
for i in range(nset):
tmpR, tmpI = zdotNN(j3cR.reshape(-1,nao), j3cI.reshape(-1,nao),
dmsR[i,kj], dmsI[i,kj], 1, tmpR, tmpI)
vk1R, vk1I = zdotNC(tmpR.reshape(nao,-1), tmpI.reshape(nao,-1),
LpqR.reshape(nao,-1).T, LpqI.reshape(nao,-1).T)
vkR[i,ki] += vk1R
vkI[i,ki] += vk1I
if hermi:
vkR[i,ki] += vk1R.T
vkI[i,ki] -= vk1I.T
else:
tmpR, tmpI = zdotNN(LpqR.reshape(-1,nao), LpqI.reshape(-1,nao),
dmsR[i,kj], dmsI[i,kj], 1, tmpR, tmpI)
zdotNC(tmpR.reshape(nao,-1), tmpI.reshape(nao,-1),
j3cR.reshape(nao,-1).T, j3cI.reshape(nao,-1).T,
1, vkR[i,ki], vkI[i,ki], 1)
return None
def update_amps(cc, t1, t2, eris):
time0 = time.clock(), time.time()
log = logger.Logger(cc.stdout, cc.verbose)
nocc, nvir = t1.shape
nov = nocc*nvir
fock = eris.fock
t1new = numpy.zeros_like(t1)
t2new = numpy.zeros_like(t2)
#** make_inter_F
fov = fock[:nocc,nocc:].copy()
foo = fock[:nocc,:nocc].copy()
foo[range(nocc),range(nocc)] = 0
foo += .5 * numpy.einsum('ia,ja->ij', fock[:nocc,nocc:], t1)
fvv = fock[nocc:,nocc:].copy()
fvv[range(nvir),range(nvir)] = 0
fvv -= .5 * numpy.einsum('ia,ib->ab', t1, fock[:nocc,nocc:])
#: woooo = numpy.einsum('la,ikja->ikjl', t1, eris.ooov)
eris_ooov = _cp(eris.ooov)
foo += numpy.einsum('kc,jikc->ij', 2*t1, eris_ooov)
foo += numpy.einsum('kc,jkic->ij', -t1, eris_ooov)
woooo = lib.dot(eris_ooov.reshape(-1,nvir), t1.T).reshape((nocc,)*4)
woooo = lib.transpose_sum(woooo.reshape(nocc*nocc,-1), inplace=True)
woooo += _cp(eris.oooo).reshape(nocc**2,-1)
woooo = _cp(woooo.reshape(nocc,nocc,nocc,nocc).transpose(0,2,1,3))
time1 = log.timer_debug1('woooo', *time0)
eris_ovvv = _cp(eris.ovvv)
eris_ovvv = unpack_tril(eris_ovvv.reshape(nov,-1))
eris_ovvv = eris_ovvv.reshape(nocc,nvir,nvir,nvir)
fvv += numpy.einsum('kc,kcba->ab', 2*t1, eris_ovvv)
fvv += numpy.einsum('kc,kbca->ab', -t1, eris_ovvv)
#: woVoV = numpy.einsum('ka,ijkb->ijba', t1, eris.ooov)
#: woVoV -= numpy.einsum('jc,icab->ijab', t1, eris_ovvv)
woVoV = lib.dot(_cp(eris_ooov.transpose(0,1,3,2).reshape(-1,nocc)), t1)
woVoV = woVoV.reshape(nocc,nocc,nvir,nvir)
#: tau = t2 + numpy.einsum('ia,jb->ijab', t1, t1)
#: tmp = numpy.einsum('ijcd,kcdb->kijb', tau, eris.ovvv)
#: t2new += numpy.einsum('ka,kijb->jiba', -t1, tmp)
tau = make_tau(t2, t1, t1)
tmp = numpy.empty((nocc,nocc,nocc,nvir))
for k in range(nocc):
tmp[k] = lib.dot(tau.reshape(-1,nvir**2),
eris_ovvv[k].reshape(-1,nvir)).reshape(nocc,nocc,nvir).transpose(1,0,2)
lib.dot(t1, eris_ovvv[k].reshape(nvir,-1), -1, woVoV[k].reshape(nocc,-1), 1)
lib.dot(tmp.reshape(nocc,-1).T, t1, -1, t2new.reshape(-1,nvir), 1)
tmp = None
#: wOVov += numpy.einsum('iabc,jc->ijab', eris.ovvv, t1)
#: wOVov -= numpy.einsum('jbik,ka->jiba', eris.ovoo, t1)
#: t2new += woVoV.transpose()
#: wOVov = -numpy.einsum('jbik,ka->ijba', eris.ovoo, t1)
wOVov, tau = tau, None
lib.dot(_cp(_cp(eris.ooov).transpose(0,2,3,1).reshape(-1,nocc)), t1,
-1, wOVov.reshape(-1,nvir))
#: wOVov += numpy.einsum('iabc,jc->jiab', eris_ovvv, t1)
lib.dot(t1, eris_ovvv.reshape(-1,nvir).T, 1, wOVov.reshape(nocc,-1), 1)
for i in range(nocc):
t2new[i] += wOVov[i].transpose(0,2,1)
#: theta = t2.transpose(0,1,3,2) * 2 - t2
#: t1new += numpy.einsum('ijcb,jcba->ia', theta, eris.ovvv)
theta = numpy.empty((nocc,nocc,nvir,nvir))
for i in range(nocc):
theta[i] = t2[i].transpose(0,2,1) * 2
theta[i] -= t2[i]
lib.dot(_cp(theta[i].transpose(0,2,1).reshape(nocc,-1)),
eris_ovvv[i].reshape(-1,nvir), 1, t1new, 1)
eris_ovvv = None
eris_ovov = _cp(eris.ovov)
for i in range(nocc):
t2new[i] += eris_ovov[i].transpose(1,0,2) * .5
fov += numpy.einsum('kc,iakc->ia', t1, eris_ovov) * 2
fov -= numpy.einsum('kc,icka->ia', t1, eris_ovov)
#: theta = t2.transpose(1,0,2,3) * 2 - t2
#: t1new += numpy.einsum('jb,ijab->ia', fov, theta)
#: t1new -= numpy.einsum('ikjb,kjab->ia', eris.ooov, theta)
t1new += numpy.einsum('jb,jiab->ia', fov, theta)
#: t1new -= numpy.einsum('kijb,kjab->ia', eris.ooov, theta)
lib.dot(_cp(eris_ooov.transpose(1,0,2,3).reshape(nocc,-1)),
theta.reshape(-1,nvir), -1, t1new, 1)
eris_ooov = None
#: wOVov += eris.ovov.transpose(0,1,3,2)
#: theta = t2.transpose(1,0,2,3) * 2 - t2
#: tau = theta - numpy.einsum('ic,kb->ikcb', t1, t1*2)
#: wOVov += .5 * numpy.einsum('jakc,ikcb->jiba', eris.ovov, tau)
#: wOVov -= .5 * numpy.einsum('jcka,ikcb->jiba', eris.ovov, t2)
#: t2new += numpy.einsum('ikca,kjbc->ijba', theta, wOVov)
wOVov = _cp(wOVov.transpose(0,3,1,2))
eris_OVov = lib.transpose(eris_ovov.reshape(-1,nov)).reshape(nocc,nvir,-1,nvir)
eris_OvoV = _cp(eris_OVov.transpose(0,3,2,1))
wOVov += eris_OVov
t2iajb = t2.transpose(0,2,1,3).copy()
#: wOVov[j0:j1] -= .5 * numpy.einsum('iakc,jkbc->jbai', eris_ovov, t2)
lib.dot(t2iajb.reshape(-1,nov), eris_OvoV.reshape(nov,-1),
-.5, wOVov.reshape(nov,-1), 1)
tau, t2iajb = t2iajb, None
for i in range(nocc):
tau[i] = tau[i]*2 - t2[i].transpose(2,0,1)
tau[i] -= numpy.einsum('a,jb->bja', t1[i]*2, t1)
#: wOVov += .5 * numpy.einsum('iakc,jbkc->jbai', eris_ovov, tau)
lib.dot(tau.reshape(-1,nov), eris_OVov.reshape(nov,-1),
.5, wOVov.reshape(nov,-1), 1)
#theta = t2 * 2 - t2.transpose(0,1,3,2)
#: t2new[j0:j1] += numpy.einsum('iack,jbck->jiba', theta, wOVov[j0:j1])
tmp, tau = tau, None
theta = _cp(theta.transpose(0,3,1,2).reshape(nov,-1))
lib.dot(wOVov.reshape(nov,-1), theta.T, 1, tmp.reshape(nov,-1))
for i in range(nocc):
t2new[i] += tmp[i].transpose(1,0,2)
tmp = wOVov = eris_OvoV = eris_OVov = None
#: fvv -= numpy.einsum('ijca,ibjc->ab', theta, eris.ovov)
#: foo += numpy.einsum('iakb,jkba->ij', eris.ovov, theta)
for i in range(nocc):
tau = numpy.einsum('a,jb->jab', t1[i]*.5, t1) + t2[i]
theta = tau.transpose(0,2,1)*2 - tau
lib.dot(_cp(eris_ovov[i].transpose(1,2,0)).reshape(nocc,-1),
theta.reshape(nocc,-1).T, 1, foo, 1)
lib.dot(theta.reshape(-1,nvir).T,
eris_ovov[i].reshape(nvir,-1).T, -1, fvv, 1)
tau = theta = None
eris_oovv = _cp(eris.oovv)
#:tmp = numpy.einsum('ic,jkbc->jibk', t1, eris_oovv)
#:t2new += numpy.einsum('ka,jibk->jiab', -t1, tmp)
#:tmp = numpy.einsum('ic,jbkc->jibk', t1, eris_ovov)
#:t2new += numpy.einsum('ka,jibk->jiba', -t1, tmp)
for j in range(nocc):
tmp = lib.dot(t1, eris_oovv[j].reshape(-1,nvir).T)
tmp = _cp(tmp.reshape(nocc,nocc,nvir).transpose(0,2,1))
t2new[j] += lib.dot(tmp.reshape(-1,nocc), t1,
-1).reshape(nocc,nvir,nvir).transpose(0,2,1)
lib.dot(t1, eris_ovov[j].reshape(-1,nvir).T, 1, tmp.reshape(nocc,-1))
lib.dot(tmp.reshape(-1,nocc), t1, -1, t2new[j].reshape(-1,nvir), 1)
tmp = None
#: g2 = 2 * eris.oOVv - eris.oovv
#: t1new += numpy.einsum('jb,ijba->ia', t1, g2)
t1new += numpy.einsum('jb,iajb->ia', 2*t1, eris_ovov)
t1new += numpy.einsum('jb,ijba->ia', -t1, eris_oovv)
#: tau = t2 + numpy.einsum('ia,jb->ijab', t1, t1)
#: woooo += numpy.einsum('ijba,klab->ijkl', eris.oOVv, tau)
#: woVoV -= eris.oovv
#: tau = .5*t2 + numpy.einsum('ia,jb->ijab', t1, t1)
#: woVoV += numpy.einsum('ka,ijkb->ijab', t1, eris.ooov)
#: woVoV += numpy.einsum('jkca,ikbc->ijab', tau, eris.oOVv)
woVoV -= eris_oovv
woVoV = woVoV.transpose(1,3,0,2).copy()
eris_oVOv = _cp(eris_ovov.transpose(0,3,2,1))
eris_oOvV = _cp(eris_ovov.transpose(0,2,1,3))
tau = make_tau(t2, t1, t1)
#: woooo += numpy.einsum('ijab,klab->ijkl', eris_oOvV, tau)
lib.dot(eris_oOvV.reshape(-1,nvir**2), tau.reshape(-1,nvir**2).T,
1, woooo.reshape(nocc**2,-1), 1)
#: t2new += .5 * numpy.einsum('klij,klab->ijab', woooo, tau)
lib.dot(woooo.reshape(-1,nocc*nocc).T, tau.reshape(-1,nvir*nvir),
.5, t2new.reshape(nocc*nocc,-1), 1)
for i in range(nocc):
tau[i] -= t2[i] * .5
#: woVoV[j0:j1] += numpy.einsum('jkca,ickb->jiab', tau, eris_ovov)
tau = _cp(tau.transpose(0,3,1,2))
lib.dot(tau.reshape(-1,nov), eris_oVOv.reshape(-1,nov).T,
1, woVoV.reshape(nov,-1), 1)
eris_oovv = eris_ovov = eris_oOvV = taubuf = None
tmp, tau = tau, None
t2ibja, eris_oVOv = eris_oVOv, None
for i in range(nocc):
t2ibja[i] = t2[i].transpose(2,0,1)
#: t2new += numpy.einsum('ibkc,kcja->ijab', woVoV, t2ibja)
lib.dot(woVoV.reshape(nov,-1), t2ibja.reshape(-1,nov), 1, tmp.reshape(nov,-1))
for i in range(nocc):
t2new[i] += tmp[i].transpose(1,2,0)
#: t2new[j0:j1] += numpy.einsum('iakc,kcjb->ijab', woVoV[j0:j1], t2iajb)
t2iajb = t2ibja
for i in range(nocc):
t2iajb[i] = t2[i].transpose(1,0,2)
lib.dot(woVoV.reshape(nov,-1), t2iajb.reshape(-1,nov), 1, tmp.reshape(nov,-1))
for i in range(nocc):
t2new[i] += tmp[i].transpose(1,0,2)
t2ibja = t2iajb = woVoV = tmp = None
time1 = log.timer_debug1('contract loop', *time0)
woooo = None
ft_ij = foo + numpy.einsum('ja,ia->ij', .5*t1, fov)
ft_ab = fvv - numpy.einsum('ia,ib->ab', .5*t1, fov)
#: t2new += numpy.einsum('ijac,bc->ijab', t2, ft_ab)
#: t2new -= numpy.einsum('ki,kjab->ijab', ft_ij, t2)
lib.dot(t2.reshape(-1,nvir), ft_ab.T, 1, t2new.reshape(-1,nvir), 1)
lib.dot(ft_ij.T, t2.reshape(nocc,-1),-1, t2new.reshape(nocc,-1), 1)
#: t2new = t2new + t2new.transpose(1,0,3,2)
t2new_tril = numpy.empty((nocc*(nocc+1)//2,nvir,nvir))
ij = 0
for i in range(nocc):
for j in range(i+1):
t2new_tril[ij] = t2new[i,j]
t2new_tril[ij] += t2new[j,i].T
ij += 1
t2new = None
time1 = log.timer_debug1('t2 tril', *time1)
cc.add_wvvVV_(t1, t2, eris, t2new_tril)
time1 = log.timer_debug1('vvvv', *time1)
mo_e = fock.diagonal()
eia = mo_e[:nocc,None] - mo_e[None,nocc:]
p0 = 0
for i in range(nocc):
dajb = (eia[i].reshape(-1,1) + eia[:i+1].reshape(1,-1))
t2new_tril[p0:p0+i+1] /= dajb.reshape(nvir,i+1,nvir).transpose(1,0,2)
p0 += i+1
time1 = log.timer_debug1('g2/dijab', *time1)
t2new = numpy.empty((nocc,nocc,nvir,nvir))
ij = 0
for i in range(nocc):
for j in range(i):
t2new[i,j] = t2new_tril[ij]
t2new[j,i] = t2new_tril[ij].T
ij += 1
t2new[i,i] = t2new_tril[ij]
ij += 1
t2new_tril = None
#** update_amp_t1
t1new += fock[:nocc,nocc:] \
+ numpy.einsum('ib,ab->ia', t1, fvv) \
- numpy.einsum('ja,ji->ia', t1, foo)
mo_e = fock.diagonal()
eia = mo_e[:nocc,None] - mo_e[None,nocc:]
t1new /= eia
#** end update_amp_t1
time0 = log.timer_debug1('update t1 t2', *time0)
return t1new, t2new
def update_amps(cc, t1, t2, eris, max_memory=2000):
time0 = time.clock(), time.time()
log = logger.Logger(cc.stdout, cc.verbose)
nocc, nvir = t1.shape
nov = nocc*nvir
fock = eris.fock
t1new = numpy.zeros_like(t1)
t2new = numpy.zeros_like(t2)
#** make_inter_F
fov = fock[:nocc,nocc:].copy()
foo = fock[:nocc,:nocc].copy()
foo[range(nocc),range(nocc)] = 0
foo += .5 * numpy.einsum('ia,ja->ij', fock[:nocc,nocc:], t1)
fvv = fock[nocc:,nocc:].copy()
fvv[range(nvir),range(nvir)] = 0
fvv -= .5 * numpy.einsum('ia,ib->ab', t1, fock[:nocc,nocc:])
#: woooo = numpy.einsum('la,ikja->ikjl', t1, eris.ooov)
eris_ooov = _cp(eris.ooov)
foo += numpy.einsum('kc,jikc->ij', 2*t1, eris_ooov)
foo += numpy.einsum('kc,jkic->ij', -t1, eris_ooov)
woooo = lib.dot(eris_ooov.reshape(-1,nvir), t1.T).reshape((nocc,)*4)
woooo = lib.transpose_sum(woooo.reshape(nocc*nocc,-1), inplace=True)
woooo += _cp(eris.oooo).reshape(nocc**2,-1)
woooo = _cp(woooo.reshape(nocc,nocc,nocc,nocc).transpose(0,2,1,3))
eris_ooov = None
time1 = log.timer_debug1('woooo', *time0)
unit = _memory_usage_inloop(nocc, nvir)*1e6/8
max_memory = max_memory - lib.current_memory()[0]
blksize = max(BLKMIN, int(max_memory*.95e6/8/unit))
log.debug1('block size = %d, nocc = %d is divided into %d blocks',
blksize, nocc, int((nocc+blksize-1)//blksize))
for p0, p1 in prange(0, nocc, blksize):
# ==== read eris.ovvv ====
eris_ovvv = _cp(eris.ovvv[p0:p1])
eris_ovvv = _ccsd.unpack_tril(eris_ovvv.reshape((p1-p0)*nvir,-1))
eris_ovvv = eris_ovvv.reshape(p1-p0,nvir,nvir,nvir)
fvv += numpy.einsum('kc,kcba->ab', 2*t1[p0:p1], eris_ovvv)
fvv += numpy.einsum('kc,kbca->ab', -t1[p0:p1], eris_ovvv)
#: tau = t2 + numpy.einsum('ia,jb->ijab', t1, t1)
#: tmp = numpy.einsum('ijcd,kdcb->ijbk', tau, eris.ovvv)
#: t2new += numpy.einsum('ka,ijbk->ijba', -t1, tmp)
#: eris_vvov = eris_ovvv.transpose(1,2,0,3).copy()
eris_vvov = _cp(eris_ovvv.transpose(2,1,0,3).reshape(nvir*nvir,-1))
tmp = numpy.empty((nocc,nocc,p1-p0,nvir))
taubuf = numpy.empty((blksize,nocc,nvir,nvir))
for j0, j1 in prange(0, nocc, blksize):
tau = make_tau(t2[j0:j1], t1[j0:j1], t1, 1, out=taubuf[:j1-j0])
lib.dot(tau.reshape(-1,nvir*nvir), eris_vvov, 1,
tmp[j0:j1].reshape((j1-j0)*nocc,-1), 0)
tmp = _cp(tmp.transpose(0,1,3,2).reshape(-1,p1-p0))
lib.dot(tmp, t1[p0:p1], -1, t2new.reshape(-1,nvir), 1)
tau = tmp = eris_vvov = None
#==== mem usage blksize*(nvir**3*2+nvir*nocc**2*2)
#: wOVov += numpy.einsum('iabc,jc->ijab', eris.ovvv, t1)
#: wOVov -= numpy.einsum('jbik,ka->jiba', eris.ovoo, t1)
#: t2new += woVoV.transpose()
#: wOVov = -numpy.einsum('jbik,ka->ijba', eris.ovoo[p0:p1], t1)
tmp = _cp(eris.ovoo[p0:p1].transpose(2,0,1,3))
wOVov = lib.dot(tmp.reshape(-1,nocc), t1, -1)
tmp = None
wOVov = wOVov.reshape(nocc,p1-p0,nvir,nvir)
#: wOVov += numpy.einsum('iabc,jc->jiab', eris_ovvv, t1)
lib.dot(t1, eris_ovvv.reshape(-1,nvir).T, 1, wOVov.reshape(nocc,-1), 1)
t2new[p0:p1] += wOVov.transpose(1,0,2,3)
eris_ooov = _cp(eris.ooov[p0:p1])
#: woVoV = numpy.einsum('ka,ijkb->ijba', t1, eris.ooov[p0:p1])
#: woVoV -= numpy.einsum('jc,icab->ijab', t1, eris_ovvv)
woVoV = lib.dot(_cp(eris_ooov.transpose(0,1,3,2).reshape(-1,nocc)), t1)
woVoV = woVoV.reshape(p1-p0,nocc,nvir,nvir)
for i in range(eris_ovvv.shape[0]):
lib.dot(t1, eris_ovvv[i].reshape(nvir,-1), -1,
woVoV[i].reshape(nocc,-1), 1)
#: theta = t2.transpose(0,1,3,2) * 2 - t2
#: t1new += numpy.einsum('ijcb,jcba->ia', theta, eris.ovvv)
theta = numpy.empty((p1-p0,nocc,nvir,nvir))
for i in range(p1-p0):
theta[i] = t2[p0+i].transpose(0,2,1) * 2
theta[i] -= t2[p0+i]
lib.dot(_cp(theta[i].transpose(0,2,1).reshape(nocc,-1)),
eris_ovvv[i].reshape(-1,nvir), 1, t1new, 1)
eris_ovvv = None
time2 = log.timer_debug1('ovvv [%d:%d]'%(p0, p1), *time1)
#==== mem usage blksize*(nvir**3+nocc*nvir**2*4)
# ==== read eris.ovov ====
eris_ovov = _cp(eris.ovov[p0:p1])
#==== mem usage blksize*(nocc*nvir**2*4)
for i in range(p1-p0):
t2new[p0+i] += eris_ovov[i].transpose(1,0,2) * .5
fov[p0:p1] += numpy.einsum('kc,iakc->ia', t1, eris_ovov) * 2
fov[p0:p1] -= numpy.einsum('kc,icka->ia', t1, eris_ovov)
#: theta = t2.transpose(1,0,2,3) * 2 - t2
#: t1new += numpy.einsum('jb,ijba->ia', fov, theta)
#: t1new -= numpy.einsum('kijb,kjba->ia', eris_ooov, theta)
t1new += numpy.einsum('jb,jiab->ia', fov[p0:p1], theta)
#: t1new -= numpy.einsum('kijb,kjab->ia', eris.ooov[p0:p1], theta)
lib.dot(_cp(eris_ooov.transpose(1,0,2,3).reshape(nocc,-1)),
theta.reshape(-1,nvir), -1, t1new, 1)
eris_ooov = None
#: wOVov += eris.ovov.transpose(0,1,3,2)
#: theta = t2.transpose(1,0,2,3) * 2 - t2
#: tau = theta - numpy.einsum('ic,kb->ikcb', t1, t1*2)
#: wOVov += .5 * numpy.einsum('jakc,ikcb->jiba', eris.ovov, tau)
#: wOVov -= .5 * numpy.einsum('jcka,ikcb->jiba', eris.ovov, t2)
#: t2new += numpy.einsum('ikca,kjbc->ijba', theta, wOVov)
theta = _cp(theta.transpose(0,3,1,2))
wOVov = _cp(wOVov.transpose(0,3,1,2))
eris_OVov = lib.transpose(eris_ovov.reshape(-1,nov)).reshape(nocc,nvir,-1,nvir)
eris_OvoV = _cp(eris_OVov.transpose(0,3,2,1))
wOVov += eris_OVov
for j0, j1 in prange(0, nocc, blksize):
t2iajb = t2[j0:j1].transpose(0,2,1,3).copy()
#: wOVov[j0:j1] -= .5 * numpy.einsum('iack,jkbc->jbai', eris_ovov, t2)
lib.dot(t2iajb.reshape(-1,nov), eris_OvoV.reshape(nov,-1),
-.5, wOVov[j0:j1].reshape((j1-j0)*nvir,-1), 1)
tau, t2iajb = t2iajb, None
for i in range(j1-j0):
tau[i] *= 2
tau[i] -= t2[j0+i].transpose(2,0,1)
tau[i] -= numpy.einsum('a,jb->bja', t1[j0+i]*2, t1)
#: wOVov[j0:j1] += .5 * numpy.einsum('iakc,jbkc->jbai', eris_ovov, tau)
lib.dot(tau.reshape(-1,nov), eris_OVov.reshape(nov,-1),
.5, wOVov[j0:j1].reshape((j1-j0)*nvir,-1), 1)
#theta = t2[p0:p1] * 2 - t2[p0:p1].transpose(0,1,3,2)
#: t2new[j0:j1] += numpy.einsum('iack,jbck->jiba', theta, wOVov[j0:j1])
tmp, tau = tau, None
lib.dot(wOVov[j0:j1].reshape((j1-j0)*nvir,-1), theta.reshape(-1,nov),
1, tmp.reshape(-1,nov))
for i in range(j1-j0):
t2new[j0+i] += tmp[i].transpose(1,0,2)
tmp = None
#==== mem usage blksize*(nocc*nvir**2*8)
theta = wOVov = eris_OvoV = eris_OVov = None
time2 = log.timer_debug1('wOVov [%d:%d]'%(p0, p1), *time2)
#==== mem usage blksize*(nocc*nvir**2*2)
#: fvv -= numpy.einsum('ijca,ibjc->ab', theta, eris.ovov)
#: foo += numpy.einsum('iakb,jkba->ij', eris.ovov, theta)
for i in range(p1-p0):
tau = numpy.einsum('a,jb->jab', t1[p0+i]*.5, t1)
tau += t2[p0+i]
theta = tau.transpose(0,2,1) * 2
theta -= tau
lib.dot(_cp(eris_ovov[i].transpose(1,2,0)).reshape(nocc,-1),
theta.reshape(nocc,-1).T, 1, foo, 1)
lib.dot(theta.reshape(-1,nvir).T,
eris_ovov[i].reshape(nvir,-1).T, -1, fvv, 1)
tau = theta = None
# ==== read eris.oovv ====
eris_oovv = _cp(eris.oovv[p0:p1])
#==== mem usage blksize*(nocc*nvir**2*3)
#:tmp = numpy.einsum('ic,jkbc->jibk', t1, eris_oovv)
#:t2new[p0:p1] += numpy.einsum('ka,jibk->jiab', -t1, tmp)
#:tmp = numpy.einsum('ic,jbkc->jibk', t1, eris_ovov)
#:t2new[p0:p1] += numpy.einsum('ka,jibk->jiba', -t1, tmp)
for j in range(p1-p0):
tmp = lib.dot(t1, eris_oovv[j].reshape(-1,nvir).T)
tmp = _cp(tmp.reshape(nocc,nocc,nvir).transpose(0,2,1))
t2new[p0+j] += lib.dot(tmp.reshape(-1,nocc), t1,
-1).reshape(nocc,nvir,nvir).transpose(0,2,1)
lib.dot(t1, eris_ovov[j].reshape(-1,nvir).T, 1, tmp.reshape(nocc,-1))
lib.dot(tmp.reshape(-1,nocc), t1, -1, t2new[p0+j].reshape(-1,nvir), 1)
tmp = None
#: g2 = 2 * eris.oOVv - eris.oovv
#: t1new += numpy.einsum('jb,ijba->ia', t1, g2)
t1new[p0:p1] += numpy.einsum('jb,iajb->ia', 2*t1, eris_ovov)
t1new[p0:p1] += numpy.einsum('jb,ijba->ia', -t1, eris_oovv)
#: tau = t2 + numpy.einsum('ia,jb->ijab', t1, t1)
#: woooo += numpy.einsum('ijba,klab->ijkl', eris.oOVv, tau)
#: woVoV -= eris.oovv
#: tau = .5*t2 + numpy.einsum('ia,jb->ijab', t1, t1)
#: woVoV += numpy.einsum('ka,ijkb->ijab', t1, eris.ooov)
#: woVoV += numpy.einsum('jkca,ikbc->ijab', tau, eris.oOVv)
woVoV -= eris_oovv
woVoV = woVoV.transpose(1,3,0,2).copy()
eris_oVOv = _cp(eris_ovov.transpose(0,3,2,1))
eris_oOvV = _cp(eris_ovov.transpose(0,2,1,3))
#==== mem usage blksize*(nocc*nvir**2*4)
taubuf = numpy.empty((blksize,nocc,nvir,nvir))
for j0, j1 in prange(0, nocc, blksize):
tau = make_tau(t2[j0:j1], t1[j0:j1], t1, 1, out=taubuf[:j1-j0])
#: woooo[p0:p1,:,j0:j1] += numpy.einsum('ijab,klab->ijkl', eris_oOvV, tau)
lib.numpy_helper._dgemm('N', 'T', (p1-p0)*nocc, (j1-j0)*nocc, nvir*nvir,
eris_oOvV.reshape(-1,nvir*nvir),
tau.reshape(-1,nvir*nvir),
woooo[p0:p1].reshape(-1,nocc*nocc), 1, 1,
0, 0, j0*nocc)
for i in range(j1-j0):
tau[i] -= t2[j0+i] * .5
#: woVoV[j0:j1] += numpy.einsum('jkca,ickb->jiab', tau, eris_ovov)
lib.dot(_cp(tau.transpose(0,3,1,2).reshape(-1,nov)),
eris_oVOv.reshape(-1,nov).T,
1, woVoV[j0:j1].reshape((j1-j0)*nvir,-1), 1)
#==== mem usage blksize*(nocc*nvir**2*6)
time2 = log.timer_debug1('woVoV [%d:%d]'%(p0, p1), *time2)
tau = make_tau(t2[p0:p1], t1[p0:p1], t1, 1, out=taubuf[:p1-p0])
#: t2new += .5 * numpy.einsum('klij,klab->ijab', woooo[p0:p1], tau)
lib.dot(woooo[p0:p1].reshape(-1,nocc*nocc).T, tau.reshape(-1,nvir*nvir),
.5, t2new.reshape(nocc*nocc,-1), 1)
eris_oovv = eris_ovov = eris_oVOv = eris_oOvV = taubuf = tau = None
#==== mem usage blksize*(nocc*nvir**2*1)
t2iajb = _cp(t2[p0:p1].transpose(0,2,1,3))
t2ibja = _cp(t2[p0:p1].transpose(0,3,1,2))
tmp = numpy.empty((blksize,nvir,nocc,nvir))
for j0, j1 in prange(0, nocc, blksize):
#: t2new[j0:j1] += numpy.einsum('ibkc,kcja->ijab', woVoV[j0:j1], t2ibja)
lib.dot(woVoV[j0:j1].reshape((j1-j0)*nvir,-1),
t2ibja.reshape(-1,nov), 1, tmp[:j1-j0].reshape(-1,nov))
for i in range(j1-j0):
t2new[j0+i] += tmp[i].transpose(1,2,0)
#: t2new[j0:j1] += numpy.einsum('iakc,kcjb->ijab', woVoV[j0:j1], t2iajb)
lib.dot(woVoV[j0:j1].reshape((j1-j0)*nvir,-1),
t2iajb.reshape(-1,nov), 1, tmp[:j1-j0].reshape(-1,nov))
for i in range(j1-j0):
t2new[j0+i] += tmp[i].transpose(1,0,2)
t2ibja = t2iajb = woVoV = tmp = None
#==== mem usage blksize*(nocc*nvir**2*3)
time1 = log.timer_debug1('contract occ [%d:%d]'%(p0, p1), *time1)
# ==================
time1 = log.timer_debug1('contract loop', *time0)
woooo = None
ft_ij = foo + numpy.einsum('ja,ia->ij', .5*t1, fov)
ft_ab = fvv - numpy.einsum('ia,ib->ab', .5*t1, fov)
#: t2new += numpy.einsum('ijac,bc->ijab', t2, ft_ab)
#: t2new -= numpy.einsum('ki,kjab->ijab', ft_ij, t2)
lib.dot(t2.reshape(-1,nvir), ft_ab.T, 1, t2new.reshape(-1,nvir), 1)
lib.dot(ft_ij.T, t2.reshape(nocc,-1),-1, t2new.reshape(nocc,-1), 1)
#: t2new = t2new + t2new.transpose(1,0,3,2)
t2new_tril = numpy.empty((nocc*(nocc+1)//2,nvir,nvir))
ij = 0
for i in range(nocc):
for j in range(i+1):
t2new_tril[ij] = t2new[i,j]
t2new_tril[ij] += t2new[j,i].T
ij += 1
t2new = None
time1 = log.timer_debug1('t2 tril', *time1)
cc.add_wvvVV_(t1, t2, eris, t2new_tril, max_memory)
time1 = log.timer_debug1('vvvv', *time1)
mo_e = fock.diagonal()
eia = mo_e[:nocc,None] - mo_e[None,nocc:]
p0 = 0
for i in range(nocc):
dajb = (eia[i].reshape(-1,1) + eia[:i+1].reshape(1,-1))
t2new_tril[p0:p0+i+1] /= dajb.reshape(nvir,i+1,nvir).transpose(1,0,2)
p0 += i+1
time1 = log.timer_debug1('g2/dijab', *time1)
t2new = numpy.empty((nocc,nocc,nvir,nvir))
ij = 0
for i in range(nocc):
for j in range(i):
t2new[i,j] = t2new_tril[ij]
t2new[j,i] = t2new_tril[ij].T
ij += 1
t2new[i,i] = t2new_tril[ij]
ij += 1
t2new_tril = None
#** update_amp_t1
t1new += fock[:nocc,nocc:] \
+ numpy.einsum('ib,ab->ia', t1, fvv) \
- numpy.einsum('ja,ji->ia', t1, foo)
mo_e = fock.diagonal()
eia = mo_e[:nocc,None] - mo_e[None,nocc:]
t1new /= eia
#** end update_amp_t1
time0 = log.timer_debug1('update t1 t2', *time0)
return t1new, t2new
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 get_jk(mydf, dm, hermi=1, kpt=numpy.zeros(3),
kpts_band=None, with_j=True, with_k=True, exxdiv=None):
'''JK for given k-point'''
vj = vk = None
if kpts_band is not None and abs(kpt-kpts_band).sum() > 1e-9:
kpt = numpy.reshape(kpt, (1,3))
if with_k:
vk = get_k_kpts(mydf, dm, hermi, kpt, kpts_band, exxdiv)
if with_j:
vj = get_j_kpts(mydf, dm, hermi, kpt, kpts_band)
return vj, vk
cell = mydf.cell
log = logger.Logger(mydf.stdout, mydf.verbose)
t1 = (time.clock(), time.time())
dm = numpy.asarray(dm, order='C')
dms = _format_dms(dm, [kpt])
nset, _, nao = dms.shape[:3]
dms = dms.reshape(nset,nao,nao)
j_real = gamma_point(kpt)
k_real = gamma_point(kpt) and not numpy.iscomplexobj(dms)
mesh = mydf.mesh
kptii = numpy.asarray((kpt,kpt))
kpt_allow = numpy.zeros(3)
if with_j:
vjcoulG = mydf.weighted_coulG(kpt_allow, False, mesh)
vjR = numpy.zeros((nset,nao,nao))
vjI = numpy.zeros((nset,nao,nao))
if with_k:
mydf.exxdiv = exxdiv
vkcoulG = mydf.weighted_coulG(kpt_allow, True, mesh)
vkR = numpy.zeros((nset,nao,nao))
vkI = numpy.zeros((nset,nao,nao))
dmsR = numpy.asarray(dms.real.reshape(nset,nao,nao), order='C')
dmsI = numpy.asarray(dms.imag.reshape(nset,nao,nao), order='C')
mem_now = lib.current_memory()[0]
max_memory = max(2000, (mydf.max_memory - mem_now)) * .8
log.debug1('max_memory = %d MB (%d in use)', max_memory, mem_now)
t2 = t1
# rho_rs(-G+k_rs) is computed as conj(rho_{rs^*}(G-k_rs))
# == conj(transpose(rho_sr(G+k_sr), (0,2,1)))
blksize = max(int(max_memory*.25e6/16/nao**2), 16)
pLqR = pLqI = None
for pqkR, pqkI, p0, p1 in mydf.pw_loop(mesh, kptii, max_memory=max_memory):
t2 = log.timer_debug1('%d:%d ft_aopair'%(p0,p1), *t2)
pqkR = pqkR.reshape(nao,nao,-1)
pqkI = pqkI.reshape(nao,nao,-1)
if with_j:
#:v4 = numpy.einsum('ijL,lkL->ijkl', pqk, pqk.conj())
#:vj += numpy.einsum('ijkl,lk->ij', v4, dm)
for i in range(nset):
rhoR = numpy.einsum('pq,pqk->k', dmsR[i], pqkR)
rhoR+= numpy.einsum('pq,pqk->k', dmsI[i], pqkI)
rhoI = numpy.einsum('pq,pqk->k', dmsI[i], pqkR)
rhoI-= numpy.einsum('pq,pqk->k', dmsR[i], pqkI)
rhoR *= vjcoulG[p0:p1]
rhoI *= vjcoulG[p0:p1]
vjR[i] += numpy.einsum('pqk,k->pq', pqkR, rhoR)
vjR[i] -= numpy.einsum('pqk,k->pq', pqkI, rhoI)
if not j_real:
vjI[i] += numpy.einsum('pqk,k->pq', pqkR, rhoI)
vjI[i] += numpy.einsum('pqk,k->pq', pqkI, rhoR)
#t2 = log.timer_debug1(' with_j', *t2)
if with_k:
#:v4 = numpy.einsum('ijL,lkL->ijkl', pqk, pqk.conj())
#:vk += numpy.einsum('ijkl,jk->il', v4, dm)
pLqR = lib.transpose(pqkR, axes=(0,2,1), out=pLqR).reshape(-1,nao)
pLqI = lib.transpose(pqkI, axes=(0,2,1), out=pLqI).reshape(-1,nao)
nG = p1 - p0
iLkR = numpy.ndarray((nao,nG,nao), buffer=pqkR)
iLkI = numpy.ndarray((nao,nG,nao), buffer=pqkI)
for i in range(nset):
if k_real:
lib.dot(pLqR, dmsR[i], 1, iLkR.reshape(nao*nG,nao))
lib.dot(pLqI, dmsR[i], 1, iLkI.reshape(nao*nG,nao))
iLkR *= vkcoulG[p0:p1].reshape(1,nG,1)
iLkI *= vkcoulG[p0:p1].reshape(1,nG,1)
lib.dot(iLkR.reshape(nao,-1), pLqR.reshape(nao,-1).T, 1, vkR[i], 1)
lib.dot(iLkI.reshape(nao,-1), pLqI.reshape(nao,-1).T, 1, vkR[i], 1)
else:
zdotNN(pLqR, pLqI, dmsR[i], dmsI[i], 1,
iLkR.reshape(-1,nao), iLkI.reshape(-1,nao))
iLkR *= vkcoulG[p0:p1].reshape(1,nG,1)
iLkI *= vkcoulG[p0:p1].reshape(1,nG,1)
zdotNC(iLkR.reshape(nao,-1), iLkI.reshape(nao,-1),
pLqR.reshape(nao,-1).T, pLqI.reshape(nao,-1).T,
1, vkR[i], vkI[i])
#t2 = log.timer_debug1(' with_k', *t2)
pqkR = pqkI = coulG = pLqR = pLqI = iLkR = iLkI = None
#t2 = log.timer_debug1('%d:%d'%(p0,p1), *t2)
bufR = bufI = None
t1 = log.timer_debug1('aft_jk.get_jk', *t1)
if with_j:
if j_real:
vj = vjR
else:
vj = vjR + vjI * 1j
vj = vj.reshape(dm.shape)
if with_k:
if k_real:
vk = vkR
else:
vk = vkR + vkI * 1j
# Add ewald_exxdiv contribution because G=0 was not included in the
# non-uniform grids
if (exxdiv == 'ewald' and
(cell.dimension < 2 or # 0D and 1D are computed with inf_vacuum
(cell.dimension == 2 and cell.low_dim_ft_type == 'inf_vacuum'))):
_ewald_exxdiv_for_G0(cell, kpt, dms, vk)
vk = vk.reshape(dm.shape)
return vj, vk
def contract(myci, civec, eris):
time0 = time.clock(), time.time()
log = logger.Logger(myci.stdout, myci.verbose)
nocc = myci.nocc
nmo = myci.nmo
nvir = nmo - nocc
nov = nocc * nvir
noo = nocc**2
c0 = civec[0]
c1 = civec[1:nov+1].reshape(nocc,nvir)
c2 = civec[nov+1:].reshape(nocc,nocc,nvir,nvir)
cinew = numpy.zeros_like(civec)
t1 = cinew[1:nov+1].reshape(nocc,nvir)
t2 = cinew[nov+1:].reshape(nocc,nocc,nvir,nvir)
t2new_tril = numpy.zeros((nocc*(nocc+1)//2,nvir,nvir))
myci.add_wvvVV_(c2, eris, t2new_tril)
for i in range(nocc):
for j in range(i+1):
t2[i,j] = t2new_tril[i*(i+1)//2+j]
t2[i,i] *= .5
t2new_tril = None
time1 = log.timer_debug1('vvvv', *time0)
#:t2 += numpy.einsum('iklj,klab->ijab', _cp(eris.oooo)*.5, c2)
oooo = lib.transpose(_cp(eris.oooo).reshape(nocc,noo,nocc), axes=(0,2,1))
lib.ddot(oooo.reshape(noo,noo), c2.reshape(noo,-1), .5, t2.reshape(noo,-1), 1)
foo = eris.fock[:nocc,:nocc].copy()
fov = eris.fock[:nocc,nocc:].copy()
fvv = eris.fock[nocc:,nocc:].copy()
t1+= fov * c0
t1+= numpy.einsum('ib,ab->ia', c1, fvv)
t1-= numpy.einsum('ja,ji->ia', c1, foo)
#:t2 += numpy.einsum('bc,ijac->ijab', fvv, c2)
#:t2 -= numpy.einsum('kj,kiba->ijab', foo, c2)
#:t2 += numpy.einsum('ia,jb->ijab', c1, fov)
lib.ddot(c2.reshape(-1,nvir), fvv, 1, t2.reshape(-1,nvir), 1)
lib.ddot(foo, c2.reshape(nocc,-1),-1, t2.reshape(nocc,-1), 1)
for j in range(nocc):
t2[:,j] += numpy.einsum('ia,b->iab', c1, fov[j])
eris_vovv = lib.unpack_tril(eris.vovv).reshape(nvir,nocc,nvir,-1)
unit = _memory_usage_inloop(nocc, nvir)
max_memory = max(2000, myci.max_memory - lib.current_memory()[0])
blksize = min(nvir, max(ccsd.BLKMIN, int(max_memory/unit)))
log.debug1('max_memory %d MB, nocc,nvir = %d,%d blksize = %d',
max_memory, nocc, nvir, blksize)
nvir_pair = nvir * (nvir+1) // 2
for p0, p1 in lib.prange(0, nvir, blksize):
eris_vvoo = _cp(eris.vvoo[p0:p1])
oovv = lib.transpose(eris_vvoo.reshape(-1,nocc**2))
#:eris_oVoV = eris_vvoo.transpose(2,0,3,1)
eris_oVoV = numpy.ndarray((nocc,p1-p0,nocc,nvir))
eris_oVoV[:] = oovv.reshape(nocc,nocc,p1-p0,nvir).transpose(0,2,1,3)
eris_vvoo = oovv = None
#:tmp = numpy.einsum('ikca,jbkc->jiba', c2, eris_oVoV)
#:t2[:,:,p0:p1] -= tmp*.5
#:t2[:,:,p0:p1] -= tmp.transpose(1,0,2,3)
for i in range(nocc):
tmp = lib.ddot(eris_oVoV.reshape(-1,nov), c2[i].reshape(nov,nvir))
tmp = tmp.reshape(nocc,p1-p0,nvir)
t2[:,i,p0:p1] -= tmp*.5
t2[i,:,p0:p1] -= tmp
eris_voov = _cp(eris.voov[p0:p1])
for i in range(p0, p1):
t2[:,:,i] += eris_voov[i-p0] * (c0 * .5)
t1[:,p0:p1] += numpy.einsum('jb,aijb->ia', c1, eris_voov) * 2
t1[:,p0:p1] -= numpy.einsum('jb,iajb->ia', c1, eris_oVoV)
#:ovov = eris_voov.transpose(2,0,1,3) - eris_vvoo.transpose(2,0,3,1)
ovov = eris_oVoV
ovov *= -.5
for i in range(nocc):
ovov[i] += eris_voov[:,:,i]
eris_oVoV = eris_vvoo = None
#:theta = c2[:,:,p0:p1]
#:theta = theta * 2 - theta.transpose(1,0,2,3)
#:theta = theta.transpose(2,0,1,3)
theta = numpy.ndarray((p1-p0,nocc,nocc,nvir))
for i in range(p0, p1):
theta[i-p0] = c2[:,:,i] * 2
theta[i-p0]-= c2[:,:,i].transpose(1,0,2)
#:t2 += numpy.einsum('ckia,jckb->ijab', theta, ovov)
for j in range(nocc):
tmp = lib.ddot(theta.reshape(-1,nov).T, ovov[j].reshape(-1,nvir))
t2[:,j] += tmp.reshape(nocc,nvir,nvir)
tmp = ovov = None
t1[:,p0:p1] += numpy.einsum('aijb,jb->ia', theta, fov)
eris_vooo = _cp(eris.vooo[p0:p1])
#:t1 -= numpy.einsum('bjka,bjki->ia', theta, eris_vooo)
#:t2[:,:,p0:p1] -= numpy.einsum('ka,bjik->jiba', c1, eris_vooo)
lib.ddot(eris_vooo.reshape(-1,nocc).T, theta.reshape(-1,nvir), -1, t1, 1)
for i in range(p0, p1):
t2[:,:,i] -= lib.ddot(eris_vooo[i-p0].reshape(noo,-1), c1).reshape(nocc,nocc,-1)
eris_vooo = None
eris_vovv = _cp(eris.vovv[p0:p1]).reshape(-1,nvir_pair)
eris_vovv = lib.unpack_tril(eris_vovv).reshape(p1-p0,nocc,nvir,nvir)
#:t1 += numpy.einsum('cjib,cjba->ia', theta, eris_vovv)
#:t2[:,:,p0:p1] += numpy.einsum('jc,aibc->ijab', c1, eris_vovv)
theta = lib.transpose(theta.reshape(-1,nocc,nvir), axes=(0,2,1))
lib.ddot(theta.reshape(-1,nocc).T, eris_vovv.reshape(-1,nvir), 1, t1, 1)
for i in range(p0, p1):
tmp = lib.ddot(c1, eris_vovv[i-p0].reshape(-1,nvir).T)
t2[:,:,i] += tmp.reshape(nocc,nocc,nvir).transpose(1,0,2)
tmp = eris_vovv = None
for i in range(nocc):
for j in range(i+1):
t2[i,j]+= t2[j,i].T
t2[j,i] = t2[i,j].T
cinew[0] += numpy.einsum('ia,ia->', fov, c1) * 2
cinew[0] += numpy.einsum('aijb,ijab->', eris.voov, c2) * 2
cinew[0] -= numpy.einsum('aijb,jiab->', eris.voov, c2)
return cinew
