def kernel(cc,
eris,
t1=None,
t2=None,
max_cycle=50,
tol=1e-8,
tolnormt=1e-6,
max_memory=2000,
verbose=logger.INFO):
"""Exactly the same as pyscf.cc.ccsd.kernel, which calls a
*local* energy() function."""
if isinstance(verbose, logger.Logger):
log = verbose
else:
log = logger.Logger(cc.stdout, verbose)
if t1 is None and t2 is None:
t1, t2 = cc.init_amps(eris)[1:]
elif t1 is None:
nocc = cc.nocc()
nvir = cc.nmo() - nocc
nkpts = cc.nkpts
t1 = numpy.zeros((nkpts, nocc, nvir), numpy.complex128)
elif t2 is None:
t2 = cc.init_amps(eris)[2]
cput1 = cput0 = (time.clock(), time.time())
nkpts, nocc, nvir = t1.shape
eold = 0
eccsd = 0
if cc.diis:
adiis = lib.diis.DIIS(cc, cc.diis_file)
adiis.space = cc.diis_space
else:
adiis = lambda t1, t2, *args: (t1, t2)
conv = False
for istep in range(max_cycle):
t1new, t2new = cc.update_amps(t1, t2, eris, max_memory)
normt = numpy.linalg.norm(t1new - t1) + numpy.linalg.norm(t2new - t2)
t1, t2 = t1new, t2new
t1new = t2new = None
if cc.diis:
t1, t2 = cc.diis(t1, t2, istep, normt, eccsd - eold, adiis)
eold, eccsd = eccsd, energy(cc, t1, t2, eris)
log.info('istep = %d E(CCSD) = %.15g dE = %.9g norm(t1,t2) = %.6g',
istep, eccsd, eccsd - eold, normt)
cput1 = log.timer('CCSD iter', *cput1)
if abs(eccsd - eold) < tol and normt < tolnormt:
conv = True
break
log.timer('CCSD', *cput0)
return conv, eccsd, t1, t2
def kernel(cc, eris, t1=None, t2=None, max_cycle=50, tol=1e-8, tolnormt=1e-6,
max_memory=2000, verbose=logger.INFO):
"""Exactly the same as pyscf.cc.ccsd.kernel, which calls a
*local* energy() function."""
if isinstance(verbose, logger.Logger):
log = verbose
else:
log = logger.Logger(cc.stdout, verbose)
if t1 is None and t2 is None:
t1, t2 = cc.init_amps(eris)[1:]
elif t1 is None:
nocc = cc.nocc()
nvir = cc.nmo() - nocc
nkpts = cc.nkpts
t1 = numpy.zeros((nkpts,nocc,nvir), numpy.complex128)
elif t2 is None:
t2 = cc.init_amps(eris)[2]
cput1 = cput0 = (time.clock(), time.time())
nkpts, nocc, nvir = t1.shape
eold = 0
eccsd = 0
if cc.diis:
adiis = lib.diis.DIIS(cc, cc.diis_file)
adiis.space = cc.diis_space
else:
adiis = lambda t1,t2,*args: (t1,t2)
conv = False
for istep in range(max_cycle):
t1new, t2new = cc.update_amps(t1, t2, eris, max_memory)
normt = numpy.linalg.norm(t1new-t1) + numpy.linalg.norm(t2new-t2)
t1, t2 = t1new, t2new
t1new = t2new = None
if cc.diis:
t1, t2 = cc.diis(t1, t2, istep, normt, eccsd-eold, adiis)
eold, eccsd = eccsd, energy(cc, t1, t2, eris)
log.info('istep = %d E(CCSD) = %.15g dE = %.9g norm(t1,t2) = %.6g',
istep, eccsd, eccsd - eold, normt)
cput1 = log.timer('CCSD iter', *cput1)
if abs(eccsd-eold) < tol and normt < tolnormt:
conv = True
break
log.timer('CCSD', *cput0)
return conv, eccsd, t1, t2
def __init__(self,
cc,
mo_coeff=None,
method='incore',
ao2mofn=pyscf.ao2mo.outcore.general_iofree):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(cc.mo_energy.size, dtype=numpy.bool)
if isinstance(cc.frozen, (int, numpy.integer)):
moidx[:cc.frozen] = False
elif len(cc.frozen) > 0:
moidx[numpy.asarray(cc.frozen)] = False
if mo_coeff is None:
self.mo_coeff = mo_coeff = cc.mo_coeff[:, moidx]
self.fock = numpy.diag(cc.mo_energy[moidx]).astype(mo_coeff.dtype)
else: # If mo_coeff is not canonical orbital
self.mo_coeff = mo_coeff = mo_coeff[:, moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = cc.nocc()
nmo = cc.nmo()
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir)
mem_now = pyscf.lib.current_memory()[0]
log = logger.Logger(cc.stdout, cc.verbose)
if (method == 'incore' and (mem_incore + mem_now < cc.max_memory)
or cc.mol.incore_anyway):
eri = ao2mofn(cc._scf.mol,
(mo_coeff, mo_coeff, mo_coeff, mo_coeff),
compact=0)
if mo_coeff.dtype == np.float: eri = eri.real
eri = eri.reshape((nmo, ) * 4)
# <ij|kl> = (ik|jl)
eri = eri.transpose(0, 2, 1, 3)
self.dtype = eri.dtype
self.oooo = eri[:nocc, :nocc, :nocc, :nocc].copy()
self.ooov = eri[:nocc, :nocc, :nocc, nocc:].copy()
self.oovv = eri[:nocc, :nocc, nocc:, nocc:].copy()
self.ovov = eri[:nocc, nocc:, :nocc, nocc:].copy()
self.voov = eri[nocc:, :nocc, :nocc, nocc:].copy()
self.vovv = eri[nocc:, :nocc, nocc:, nocc:].copy()
self.vvvv = eri[nocc:, nocc:, nocc:, nocc:].copy()
else:
_tmpfile1 = tempfile.NamedTemporaryFile()
self.feri1 = h5py.File(_tmpfile1.name)
orbo = mo_coeff[:, :nocc]
orbv = mo_coeff[:, nocc:]
if mo_coeff.dtype == np.complex: ds_type = 'c16'
else: ds_type = 'f8'
self.oooo = self.feri1.create_dataset('oooo',
(nocc, nocc, nocc, nocc),
ds_type)
self.ooov = self.feri1.create_dataset('ooov',
(nocc, nocc, nocc, nvir),
ds_type)
self.oovv = self.feri1.create_dataset('oovv',
(nocc, nocc, nvir, nvir),
ds_type)
self.ovov = self.feri1.create_dataset('ovov',
(nocc, nvir, nocc, nvir),
ds_type)
self.voov = self.feri1.create_dataset('voov',
(nvir, nocc, nocc, nvir),
ds_type)
self.vovv = self.feri1.create_dataset('vovv',
(nvir, nocc, nvir, nvir),
ds_type)
self.vvvv = self.feri1.create_dataset('vvvv',
(nvir, nvir, nvir, nvir),
ds_type)
cput1 = time.clock(), time.time()
# <ij|pq> = (ip|jq)
buf = ao2mofn(cc._scf.mol, (orbo, mo_coeff, orbo, mo_coeff),
compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc, nmo, nocc, nmo)).transpose(0, 2, 1, 3)
cput1 = log.timer_debug1('transforming oopq', *cput1)
self.dtype = buf.dtype
self.oooo[:, :, :, :] = buf[:, :, :nocc, :nocc]
self.ooov[:, :, :, :] = buf[:, :, :nocc, nocc:]
self.oovv[:, :, :, :] = buf[:, :, nocc:, nocc:]
cput1 = time.clock(), time.time()
# <ia|pq> = (ip|aq)
buf = ao2mofn(cc._scf.mol, (orbo, mo_coeff, orbv, mo_coeff),
compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc, nmo, nvir, nmo)).transpose(0, 2, 1, 3)
cput1 = log.timer_debug1('transforming ovpq', *cput1)
self.ovov[:, :, :, :] = buf[:, :, :nocc, nocc:]
self.vovv[:, :, :, :] = buf[:, :, nocc:,
nocc:].transpose(1, 0, 3, 2)
self.voov[:, :, :, :] = buf[:, :,
nocc:, :nocc].transpose(1, 0, 3, 2)
for a in range(nvir):
orbva = orbv[:, a].reshape(-1, 1)
buf = ao2mofn(cc._scf.mol, (orbva, orbv, orbv, orbv),
compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((1, nvir, nvir, nvir)).transpose(0, 2, 1, 3)
self.vvvv[a] = buf[:]
cput1 = log.timer_debug1('transforming vvvv', *cput1)
log.timer('CCSD integral transformation', *cput0)
def __init__(self, cc, mo_coeff=None, method='incore'):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(shape=cc.mo_energy.shape, dtype=numpy.bool)
nkpts = cc.nkpts
nmo = cc.nmo()
# TODO change this for k-points ... seems like it should work
if isinstance(cc.frozen, (int, numpy.integer)):
for k in range(nkpts):
moidx[k,:cc.frozen] = False
elif len(cc.frozen) > 0:
for k in range(nkpts):
moidx[k,numpy.asarray(cc.frozen)] = False
if mo_coeff is None:
# TODO make this work for frozen maybe... seems like it should work
self.mo_coeff = numpy.zeros((nkpts,nmo,nmo),dtype=numpy.complex128)
for k in range(nkpts):
self.mo_coeff[k] = cc.mo_coeff[k][:,moidx[k]]
mo_coeff = self.mo_coeff
self.fock = numpy.zeros((nkpts,nmo,nmo))
for k in range(nkpts):
self.fock[k] = numpy.diag(cc.mo_energy[k][moidx[k]])
else: # If mo_coeff is not canonical orbital
# TODO does this work for k-points? changed to conjugate.
self.mo_coeff = mo_coeff = mo_coeff[:,moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot, (numpy.conj(mo_coeff.T), fockao, mo_coeff))
nocc = cc.nocc()
nmo = cc.nmo()
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = pyscf.cc.ccsd._mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
# Convert to spin-orbitals and anti-symmetrize
so_coeff = numpy.zeros((nkpts,nmo/2,nmo),dtype=numpy.complex128)
so_coeff[:,:,::2] = so_coeff[:,:,1::2] = mo_coeff[:,:nmo/2,::2]
log = logger.Logger(cc.stdout, cc.verbose)
if (method == 'incore' and cc._scf._eri is None and
(mem_incore+mem_now < cc.max_memory) or cc.mol.incore_anyway):
kconserv = tools.get_kconserv(cc._scf.cell,cc.kpts)
eri = numpy.zeros((nkpts,nkpts,nkpts,nmo,nmo,nmo,nmo), dtype=numpy.complex128)
for kp in range(nkpts):
for kq in range(nkpts):
for kr in range(nkpts):
ks = kconserv[kp,kq,kr]
eri_kpt = pyscf.pbc.ao2mo.general(cc._scf.cell,
(so_coeff[kp,:,:],so_coeff[kq,:,:],so_coeff[kr,:,:],so_coeff[ks,:,:]),
(cc.kpts[kp],cc.kpts[kq],cc.kpts[kr],cc.kpts[ks]))
eri_kpt = eri_kpt.reshape(nmo,nmo,nmo,nmo)
eri[kp,kq,kr] = eri_kpt.copy()
eri[:,:,:,::2,1::2] = eri[:,:,:,1::2,::2] = eri[:,:,:,:,:,::2,1::2] = eri[:,:,:,:,:,1::2,::2] = 0.
# Checking some things...
maxdiff = 0.0
for kp in range(nkpts):
for kq in range(nkpts):
for kr in range(nkpts):
ks = kconserv[kp,kq,kr]
for p in range(nmo):
for q in range(nmo):
for r in range(nmo):
for s in range(nmo):
pqrs = eri[kp,kq,kr,p,q,r,s]
rspq = eri[kr,ks,kp,r,s,p,q]
diff = numpy.linalg.norm(pqrs - rspq).real
if diff > 1e-5:
print "** Warning: ERI diff at ",
print "kp,kq,kr,ks,p,q,r,s =", kp, kq, kr, ks, p, q, r, s
maxdiff = max(maxdiff,diff)
print "Max difference in (pq|rs) - (rs|pq) = %.15g" % maxdiff
#print "ERI ="
#print eri
# Antisymmetrizing (pq|rs)-(ps|rq), where the latter integral is equal to
# (rq|ps); done since we aren't tracking the kpoint of orbital 's'
eri1 = eri - eri.transpose(2,1,0,5,4,3,6)
# Chemist -> physics notation
eri1 = eri1.transpose(0,2,1,3,5,4,6)
self.dtype = eri1.dtype
self.oooo = eri1[:,:,:,:nocc,:nocc,:nocc,:nocc].copy() / nkpts
self.ooov = eri1[:,:,:,:nocc,:nocc,:nocc,nocc:].copy() / nkpts
self.ovoo = eri1[:,:,:,:nocc,nocc:,:nocc,:nocc].copy() / nkpts
self.oovv = eri1[:,:,:,:nocc,:nocc,nocc:,nocc:].copy() / nkpts
self.ovov = eri1[:,:,:,:nocc,nocc:,:nocc,nocc:].copy() / nkpts
self.ovvv = eri1[:,:,:,:nocc,nocc:,nocc:,nocc:].copy() / nkpts
self.vvvv = eri1[:,:,:,nocc:,nocc:,nocc:,nocc:].copy() / nkpts
#ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy()
#self.ovvv = numpy.empty((nocc,nvir,nvir*(nvir+1)//2))
#for i in range(nocc):
# for j in range(nvir):
# self.ovvv[i,j] = lib.pack_tril(ovvv[i,j])
#self.vvvv = pyscf.ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
log.timer('CCSD integral transformation', *cput0)
def __init__(self, cc, mo_coeff=None, method='incore'):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(shape=cc.mo_energy.shape, dtype=numpy.bool)
nkpts = cc.nkpts
nmo = cc.nmo()
# TODO change this for k-points ... seems like it should work
if isinstance(cc.frozen, (int, numpy.integer)):
for k in range(nkpts):
moidx[k, :cc.frozen] = False
elif len(cc.frozen) > 0:
for k in range(nkpts):
moidx[k, numpy.asarray(cc.frozen)] = False
assert (numpy.count_nonzero(moidx) % 2 == 0
) # works for restricted CCSD only
if mo_coeff is None:
# TODO make this work for frozen maybe... seems like it should work
nao = cc._scf.cell.nao_nr()
self.mo_coeff = numpy.zeros((nkpts, nao * 2, nmo),
dtype=numpy.complex128)
for k in range(nkpts):
self.mo_coeff[k] = cc.mo_coeff[k][:, moidx[k]]
mo_coeff = self.mo_coeff
self.fock = numpy.zeros((nkpts, nmo, nmo))
for k in range(nkpts):
self.fock[k] = numpy.diag(cc.mo_energy[k][moidx[k]])
else: # If mo_coeff is not canonical orbital
# TODO does this work for k-points? changed to conjugate.
self.mo_coeff = mo_coeff = mo_coeff[:, moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot,
(numpy.conj(mo_coeff.T), fockao, mo_coeff))
nocc = cc.nocc()
nmo = cc.nmo()
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = pyscf.cc.ccsd._mem_usage(
nocc, nvir)
mem_now = lib.current_memory()[0]
# Convert to spin-orbitals and anti-symmetrize
nao = cc._scf.cell.nao_nr()
so_coeff = numpy.zeros((nkpts, nao, nmo), dtype=numpy.complex128)
so_coeff[:, :, ::2] = so_coeff[:, :, 1::2] = mo_coeff[:, :nao, ::2]
log = logger.Logger(cc.stdout, cc.verbose)
if (method == 'incore' and cc._scf._eri is None and
(mem_incore + mem_now < cc.max_memory) or cc.mol.incore_anyway):
kconserv = tools.get_kconserv(cc._scf.cell, cc.kpts)
eri = numpy.zeros((nkpts, nkpts, nkpts, nmo, nmo, nmo, nmo),
dtype=numpy.complex128)
fao2mo = cc._scf.with_df.ao2mo
for kp in range(nkpts):
for kq in range(nkpts):
for kr in range(nkpts):
ks = kconserv[kp, kq, kr]
eri_kpt = fao2mo((so_coeff[kp], so_coeff[kq],
so_coeff[kr], so_coeff[ks]),
(cc.kpts[kp], cc.kpts[kq],
cc.kpts[kr], cc.kpts[ks]),
compact=False)
eri_kpt = eri_kpt.reshape(nmo, nmo, nmo, nmo)
eri[kp, kq, kr] = eri_kpt.copy()
eri[:, :, :, ::2,
1::2] = eri[:, :, :,
1::2, ::2] = eri[:, :, :, :, :, ::2,
1::2] = eri[:, :, :, :, :,
1::2, ::2] = 0.
# Checking some things...
maxdiff = 0.0
for kp in range(nkpts):
for kq in range(nkpts):
for kr in range(nkpts):
ks = kconserv[kp, kq, kr]
for p in range(nmo):
for q in range(nmo):
for r in range(nmo):
for s in range(nmo):
pqrs = eri[kp, kq, kr, p, q, r, s]
rspq = eri[kr, ks, kp, r, s, p, q]
diff = numpy.linalg.norm(pqrs -
rspq).real
if diff > 1e-5:
print "** Warning: ERI diff at ",
print "kp,kq,kr,ks,p,q,r,s =", kp, kq, kr, ks, p, q, r, s
maxdiff = max(maxdiff, diff)
print "Max difference in (pq|rs) - (rs|pq) = %.15g" % maxdiff
#print "ERI ="
#print eri
# Antisymmetrizing (pq|rs)-(ps|rq), where the latter integral is equal to
# (rq|ps); done since we aren't tracking the kpoint of orbital 's'
eri1 = eri - eri.transpose(2, 1, 0, 5, 4, 3, 6)
# Chemist -> physics notation
eri1 = eri1.transpose(0, 2, 1, 3, 5, 4, 6)
self.dtype = eri1.dtype
self.oooo = eri1[:, :, :, :nocc, :nocc, :nocc, :nocc].copy(
) / nkpts
self.ooov = eri1[:, :, :, :nocc, :nocc, :nocc,
nocc:].copy() / nkpts
self.ovoo = eri1[:, :, :, :nocc,
nocc:, :nocc, :nocc].copy() / nkpts
self.oovv = eri1[:, :, :, :nocc, :nocc, nocc:,
nocc:].copy() / nkpts
self.ovov = eri1[:, :, :, :nocc, nocc:, :nocc,
nocc:].copy() / nkpts
self.ovvv = eri1[:, :, :, :nocc, nocc:, nocc:,
nocc:].copy() / nkpts
self.vvvv = eri1[:, :, :, nocc:, nocc:, nocc:,
nocc:].copy() / nkpts
#ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy()
#self.ovvv = numpy.empty((nocc,nvir,nvir*(nvir+1)//2))
#for i in range(nocc):
# for j in range(nvir):
# self.ovvv[i,j] = lib.pack_tril(ovvv[i,j])
#self.vvvv = pyscf.ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
log.timer('CCSD integral transformation', *cput0)
def __init__(self, cc, mo_coeff=None, method='incore',
ao2mofn=pyscf.ao2mo.outcore.general_iofree):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(cc.mo_energy.size, dtype=numpy.bool)
if isinstance(cc.frozen, (int, numpy.integer)):
moidx[:cc.frozen] = False
elif len(cc.frozen) > 0:
moidx[numpy.asarray(cc.frozen)] = False
if mo_coeff is None:
self.mo_coeff = mo_coeff = cc.mo_coeff[:,moidx]
self.fock = numpy.diag(cc.mo_energy[moidx]).astype(mo_coeff.dtype)
else: # If mo_coeff is not canonical orbital
self.mo_coeff = mo_coeff = mo_coeff[:,moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = cc.nocc()
nmo = cc.nmo()
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = pyscf.cc.ccsd._mem_usage(nocc, nvir)
mem_now = pyscf.lib.current_memory()[0]
# Convert to spin-orbitals and anti-symmetrize
so_coeff = np.zeros((nmo/2,nmo), dtype=mo_coeff.dtype)
so_coeff[:,::2] = so_coeff[:,1::2] = mo_coeff[:nmo/2,::2]
log = logger.Logger(cc.stdout, cc.verbose)
if (method == 'incore' and cc._scf._eri is not None and
(mem_incore+mem_now < cc.max_memory) or cc.mol.incore_anyway):
eri = ao2mofn(cc._scf.mol, (so_coeff,so_coeff,so_coeff,so_coeff), compact=0)
eri = eri.reshape((nmo,)*4)
eri[::2,1::2] = eri[1::2,::2] = eri[:,:,::2,1::2] = eri[:,:,1::2,::2] = 0.
eri1 = eri - eri.transpose(0,3,2,1)
eri1 = eri1.transpose(0,2,1,3)
self.dtype = eri1.dtype
self.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy()
self.ooov = eri1[:nocc,:nocc,:nocc,nocc:].copy()
self.ovoo = eri1[:nocc,nocc:,:nocc,:nocc].copy()
self.oovv = eri1[:nocc,:nocc,nocc:,nocc:].copy()
self.ovov = eri1[:nocc,nocc:,:nocc,nocc:].copy()
self.ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy()
self.vvvv = eri1[nocc:,nocc:,nocc:,nocc:].copy()
#ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy()
#self.ovvv = numpy.empty((nocc,nvir,nvir*(nvir+1)//2))
#for i in range(nocc):
# for j in range(nvir):
# self.ovvv[i,j] = lib.pack_tril(ovvv[i,j])
#self.vvvv = pyscf.ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
else:
print "*** Using HDF5 ERI storage ***"
_tmpfile1 = tempfile.NamedTemporaryFile()
self.feri1 = h5py.File(_tmpfile1.name)
orbo = so_coeff[:,:nocc]
orbv = so_coeff[:,nocc:]
if mo_coeff.dtype == np.complex: ds_type = 'c16'
else: ds_type = 'f8'
self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), ds_type)
self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), ds_type)
self.ovoo = self.feri1.create_dataset('ovoo', (nocc,nvir,nocc,nocc), ds_type)
self.oovv = self.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), ds_type)
self.ovov = self.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), ds_type)
self.ovvv = self.feri1.create_dataset('ovvv', (nocc,nvir,nvir,nvir), ds_type)
cput1 = time.clock(), time.time()
buf = ao2mofn(cc._scf.mol, (orbo,so_coeff,so_coeff,so_coeff), compact=0)
buf = buf.reshape((nocc,nmo,nmo,nmo))
buf[::2,1::2] = buf[1::2,::2] = buf[:,:,::2,1::2] = buf[:,:,1::2,::2] = 0.
buf1 = buf - buf.transpose(0,3,2,1)
buf1 = buf1.transpose(0,2,1,3)
cput1 = log.timer_debug1('transforming oppp', *cput1)
self.dtype = buf1.dtype
self.oooo[:,:,:,:] = buf1[:,:nocc,:nocc,:nocc]
self.ooov[:,:,:,:] = buf1[:,:nocc,:nocc,nocc:]
self.ovoo[:,:,:,:] = buf1[:,nocc:,:nocc,:nocc]
self.oovv[:,:,:,:] = buf1[:,:nocc,nocc:,nocc:]
self.ovov[:,:,:,:] = buf1[:,nocc:,:nocc,nocc:]
self.ovvv[:,:,:,:] = buf1[:,nocc:,nocc:,nocc:]
self.vvvv = self.feri1.create_dataset('vvvv', (nvir,nvir,nvir,nvir), ds_type)
for a in range(nvir):
orbva = orbv[:,a].reshape(-1,1)
buf = ao2mofn(cc._scf.mol, (orbva,orbv,orbv,orbv), compact=0)
buf = buf.reshape((1,nvir,nvir,nvir))
if a%2 == 0:
buf[0,1::2,:,:] = 0.
else:
buf[0,0::2,:,:] = 0.
buf[:,:,::2,1::2] = buf[:,:,1::2,::2] = 0.
buf1 = buf - buf.transpose(0,3,2,1)
buf1 = buf1.transpose(0,2,1,3)
self.vvvv[a] = buf1[:]
cput1 = log.timer_debug1('transforming vvvv', *cput1)
log.timer('CCSD integral transformation', *cput0)
def __init__(self, cc, mo_coeff=None, method='incore',
ao2mofn=pyscf.ao2mo.outcore.general_iofree):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(cc.mo_energy.size, dtype=numpy.bool)
if isinstance(cc.frozen, (int, numpy.integer)):
moidx[:cc.frozen] = False
elif len(cc.frozen) > 0:
moidx[numpy.asarray(cc.frozen)] = False
if mo_coeff is None:
self.mo_coeff = mo_coeff = cc.mo_coeff[:,moidx]
self.fock = numpy.diag(cc.mo_energy[moidx]).astype(mo_coeff.dtype)
else: # If mo_coeff is not canonical orbital
self.mo_coeff = mo_coeff = mo_coeff[:,moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = cc.nocc()
nmo = cc.nmo()
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir)
mem_now = pyscf.lib.current_memory()[0]
log = logger.Logger(cc.stdout, cc.verbose)
if (method == 'incore' and (mem_incore+mem_now < cc.max_memory)
or cc.mol.incore_anyway):
eri = ao2mofn(cc._scf.mol, (mo_coeff,mo_coeff,mo_coeff,mo_coeff), compact=0)
if mo_coeff.dtype == np.float: eri = eri.real
eri = eri.reshape((nmo,)*4)
# <ij|kl> = (ik|jl)
eri = eri.transpose(0,2,1,3)
self.dtype = eri.dtype
self.oooo = eri[:nocc,:nocc,:nocc,:nocc].copy()
self.ooov = eri[:nocc,:nocc,:nocc,nocc:].copy()
self.oovv = eri[:nocc,:nocc,nocc:,nocc:].copy()
self.ovov = eri[:nocc,nocc:,:nocc,nocc:].copy()
self.voov = eri[nocc:,:nocc,:nocc,nocc:].copy()
self.vovv = eri[nocc:,:nocc,nocc:,nocc:].copy()
self.vvvv = eri[nocc:,nocc:,nocc:,nocc:].copy()
else:
_tmpfile1 = tempfile.NamedTemporaryFile()
self.feri1 = h5py.File(_tmpfile1.name)
orbo = mo_coeff[:,:nocc]
orbv = mo_coeff[:,nocc:]
if mo_coeff.dtype == np.complex: ds_type = 'c16'
else: ds_type = 'f8'
self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), ds_type)
self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), ds_type)
self.oovv = self.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), ds_type)
self.ovov = self.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), ds_type)
self.voov = self.feri1.create_dataset('voov', (nvir,nocc,nocc,nvir), ds_type)
self.vovv = self.feri1.create_dataset('vovv', (nvir,nocc,nvir,nvir), ds_type)
self.vvvv = self.feri1.create_dataset('vvvv', (nvir,nvir,nvir,nvir), ds_type)
cput1 = time.clock(), time.time()
# <ij|pq> = (ip|jq)
buf = ao2mofn(cc._scf.mol, (orbo,mo_coeff,orbo,mo_coeff), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc,nmo,nocc,nmo)).transpose(0,2,1,3)
cput1 = log.timer_debug1('transforming oopq', *cput1)
self.dtype = buf.dtype
self.oooo[:,:,:,:] = buf[:,:,:nocc,:nocc]
self.ooov[:,:,:,:] = buf[:,:,:nocc,nocc:]
self.oovv[:,:,:,:] = buf[:,:,nocc:,nocc:]
cput1 = time.clock(), time.time()
# <ia|pq> = (ip|aq)
buf = ao2mofn(cc._scf.mol, (orbo,mo_coeff,orbv,mo_coeff), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc,nmo,nvir,nmo)).transpose(0,2,1,3)
cput1 = log.timer_debug1('transforming ovpq', *cput1)
self.ovov[:,:,:,:] = buf[:,:,:nocc,nocc:]
self.vovv[:,:,:,:] = buf[:,:,nocc:,nocc:].transpose(1,0,3,2)
self.voov[:,:,:,:] = buf[:,:,nocc:,:nocc].transpose(1,0,3,2)
for a in range(nvir):
orbva = orbv[:,a].reshape(-1,1)
buf = ao2mofn(cc._scf.mol, (orbva,orbv,orbv,orbv), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((1,nvir,nvir,nvir)).transpose(0,2,1,3)
self.vvvv[a] = buf[:]
cput1 = log.timer_debug1('transforming vvvv', *cput1)
log.timer('CCSD integral transformation', *cput0)
def __init__(self, cc, mo_coeff=None, method="incore", ao2mofn=pyscf.ao2mo.outcore.general_iofree):
cput0 = (time.clock(), time.time())
moidx = numpy.ones(cc.mo_energy.shape, dtype=numpy.bool)
nkpts = cc.nkpts
nmo = cc.nmo()
# TODO check that this and kccsd work for frozen...
if isinstance(cc.frozen, (int, numpy.integer)):
moidx[:, : cc.frozen] = False
elif len(cc.frozen) > 0:
moidx[:, numpy.asarray(cc.frozen)] = False
if mo_coeff is None:
self.mo_coeff = numpy.zeros((nkpts, nmo, nmo), dtype=cc.mo_coeff.dtype)
for kp in range(nkpts):
self.mo_coeff[kp] = cc.mo_coeff[kp][:, moidx[kp]]
mo_coeff = self.mo_coeff
self.fock = numpy.zeros((nkpts, nmo, nmo), dtype=cc.mo_coeff.dtype)
for kp in range(nkpts):
self.fock[kp] = numpy.diag(cc.mo_energy[kp][moidx[kp]]).astype(mo_coeff.dtype)
else: # If mo_coeff is not canonical orbital
self.mo_coeff = mo_coeff = mo_coeff[:, :, moidx]
dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ)
fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm)
self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff))
nocc = cc.nocc()
nmo = cc.nmo()
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = pyscf.cc.ccsd._mem_usage(nocc, nvir)
mem_now = lib.current_memory()[0]
log = logger.Logger(cc.stdout, cc.verbose)
if method == "incore" and (mem_incore + mem_now < cc.max_memory) or cc.mol.incore_anyway:
kconserv = cc.kconserv
khelper = cc.khelper # kpoint_helper.unique_pqr_list(cc._scf.cell,cc.kpts)
unique_klist = khelper.get_uniqueList()
nUnique_klist = khelper.nUnique
eri = numpy.zeros((nkpts, nkpts, nkpts, nmo, nmo, nmo, nmo), dtype=numpy.complex128)
#
#
# Looping over unique list of k-vectors
#
#
for pqr in range(nUnique_klist):
kp, kq, kr = unique_klist[pqr]
ks = kconserv[kp, kq, kr]
eri_kpt = pyscf.pbc.ao2mo.general(
cc._scf.cell,
(mo_coeff[kp, :, :], mo_coeff[kq, :, :], mo_coeff[kr, :, :], mo_coeff[ks, :, :]),
(cc.kpts[kp], cc.kpts[kq], cc.kpts[kr], cc.kpts[ks]),
)
eri_kpt = eri_kpt.reshape(nmo, nmo, nmo, nmo)
eri[kp, kq, kr] = eri_kpt.copy()
for kp in range(nkpts):
for kq in range(nkpts):
for kr in range(nkpts):
ikp, ikq, ikr = khelper.get_irrVec(kp, kq, kr)
irr_eri = eri[ikp, ikq, ikr]
eri[kp, kq, kr] = khelper.transform_irr2full(irr_eri, kp, kq, kr)
# Checking some things...
maxdiff = 0.0
for kp in range(nkpts):
for kq in range(nkpts):
for kr in range(nkpts):
ks = kconserv[kp, kq, kr]
for p in range(nmo):
for q in range(nmo):
for r in range(nmo):
for s in range(nmo):
pqrs = eri[kp, kq, kr, p, q, r, s]
rspq = eri[kr, ks, kp, r, s, p, q]
diff = numpy.linalg.norm(pqrs - rspq).real
if diff > 1e-5:
print "** Warning: ERI diff at ",
print "kp,kq,kr,ks,p,q,r,s =", kp, kq, kr, ks, p, q, r, s
maxdiff = max(maxdiff, diff)
print "Max difference in (pq|rs) - (rs|pq) = %.15g" % maxdiff
# print "ERI ="
# print eri
# Chemist -> physics notation
eri = eri.transpose(0, 2, 1, 3, 5, 4, 6)
self.dtype = eri.dtype
self.oooo = eri[:, :, :, :nocc, :nocc, :nocc, :nocc].copy() / nkpts
self.ooov = eri[:, :, :, :nocc, :nocc, :nocc, nocc:].copy() / nkpts
self.ovoo = eri[:, :, :, :nocc, nocc:, :nocc, :nocc].copy() / nkpts
self.oovv = eri[:, :, :, :nocc, :nocc, nocc:, nocc:].copy() / nkpts
self.ovov = eri[:, :, :, :nocc, nocc:, :nocc, nocc:].copy() / nkpts
self.ovvv = eri[:, :, :, :nocc, nocc:, nocc:, nocc:].copy() / nkpts
self.vvvv = eri[:, :, :, nocc:, nocc:, nocc:, nocc:].copy() / nkpts
# ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy()
# self.ovvv = numpy.empty((nocc,nvir,nvir*(nvir+1)//2))
# for i in range(nocc):
# for j in range(nvir):
# self.ovvv[i,j] = lib.pack_tril(ovvv[i,j])
# self.vvvv = pyscf.ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir)
# TODO: Avoid this.
# Store all for now, while DEBUGGING
self.voov = eri[:, :, :, nocc:, :nocc, :nocc, nocc:].copy() / nkpts
self.vovo = eri[:, :, :, nocc:, :nocc, nocc:, :nocc].copy() / nkpts
self.vovv = eri[:, :, :, nocc:, :nocc, nocc:, nocc:].copy() / nkpts
self.oovo = eri[:, :, :, :nocc, :nocc, nocc:, :nocc].copy() / nkpts
self.vvov = eri[:, :, :, nocc:, nocc:, :nocc, nocc:].copy() / nkpts
self.vooo = eri[:, :, :, nocc:, :nocc, :nocc, :nocc].copy() / nkpts
log.timer("CCSD integral transformation", *cput0)
def __init__(self, cc, mo_coeff=None, method='incore',
ao2mofn=pyscf.ao2mo.outcore.general_iofree):
cput0 = (time.clock(), time.time())
if mo_coeff is None:
self.mo_coeff = mo_coeff = cc.mo_coeff
self.fock = numpy.diag(np.append(cc.mo_energy[np.array(cc.mo_occ,dtype=bool)],
cc.mo_energy[np.logical_not(np.array(cc.mo_occ,dtype=bool))])).astype(mo_coeff.dtype)
nocc = cc.nocc()
nmo = cc.nmo()
nvir = nmo - nocc
mem_incore, mem_outcore, mem_basic = pyscf.cc.rccsd._mem_usage(nocc, nvir)
mem_now = pyscf.lib.current_memory()[0]
# Convert to spin-orbitals and anti-symmetrize
so_coeff = np.zeros((nmo/2,nmo), dtype=mo_coeff.dtype)
nocc_a = int(sum(cc.mo_occ[0]))
nocc_b = int(sum(cc.mo_occ[1]))
nvir_a = nmo/2 - nocc_a
#nvir_b = nmo/2 - nocc_b
spin = np.zeros(nmo, dtype=int)
spin[:nocc_a] = 0
spin[nocc_a:nocc] = 1
spin[nocc:nocc+nvir_a] = 0
spin[nocc+nvir_a:nmo] = 1
so_coeff[:,:nocc_a] = mo_coeff[0][:,:nocc_a]
so_coeff[:,nocc_a:nocc] = mo_coeff[1][:,:nocc_b]
so_coeff[:,nocc:nocc+nvir_a] = mo_coeff[0][:,nocc_a:nmo/2]
so_coeff[:,nocc+nvir_a:nmo] = mo_coeff[1][:,nocc_b:nmo/2]
log = logger.Logger(cc.stdout, cc.verbose)
if (method == 'incore' and (mem_incore+mem_now < cc.max_memory)
or cc.mol.incore_anyway):
eri = ao2mofn(cc._scf.mol, (so_coeff,so_coeff,so_coeff,so_coeff), compact=0)
if mo_coeff.dtype == np.float: eri = eri.real
eri = eri.reshape((nmo,)*4)
for i in range(nmo):
for j in range(i):
if spin[i] != spin[j]:
eri[i,j,:,:] = eri[j,i,:,:] = 0.
eri[:,:,i,j] = eri[:,:,j,i] = 0.
eri1 = eri - eri.transpose(0,3,2,1)
eri1 = eri1.transpose(0,2,1,3)
self.dtype = eri1.dtype
self.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy()
self.ooov = eri1[:nocc,:nocc,:nocc,nocc:].copy()
self.ovoo = eri1[:nocc,nocc:,:nocc,:nocc].copy()
self.oovv = eri1[:nocc,:nocc,nocc:,nocc:].copy()
self.ovov = eri1[:nocc,nocc:,:nocc,nocc:].copy()
self.ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy()
self.vvvv = eri1[nocc:,nocc:,nocc:,nocc:].copy()
else:
_tmpfile1 = tempfile.NamedTemporaryFile()
self.feri1 = h5py.File(_tmpfile1.name)
orbo = so_coeff[:,:nocc]
orbv = so_coeff[:,nocc:]
if mo_coeff.dtype == np.complex: ds_type = 'c16'
else: ds_type = 'f8'
self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), ds_type)
self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), ds_type)
self.ovoo = self.feri1.create_dataset('ovoo', (nocc,nvir,nocc,nocc), ds_type)
self.oovv = self.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), ds_type)
self.ovov = self.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), ds_type)
self.ovvv = self.feri1.create_dataset('ovvv', (nocc,nvir,nvir,nvir), ds_type)
self.vvvv = self.feri1.create_dataset('vvvv', (nvir,nvir,nvir,nvir), ds_type)
cput1 = time.clock(), time.time()
# <ij||pq> = <ij|pq> - <ij|qp> = (ip|jq) - (iq|jp)
buf = ao2mofn(cc._scf.mol, (orbo,so_coeff,orbo,so_coeff), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc,nmo,nocc,nmo))
for i in range(nocc):
for p in range(nmo):
if spin[i] != spin[p]:
buf[i,p,:,:] = 0.
buf[:,:,i,p] = 0.
buf1 = buf - buf.transpose(0,3,2,1)
buf1 = buf1.transpose(0,2,1,3)
cput1 = log.timer_debug1('transforming oopq', *cput1)
self.dtype = buf1.dtype
self.oooo[:,:,:,:] = buf1[:,:,:nocc,:nocc]
self.ooov[:,:,:,:] = buf1[:,:,:nocc,nocc:]
self.oovv[:,:,:,:] = buf1[:,:,nocc:,nocc:]
cput1 = time.clock(), time.time()
# <ia||pq> = <ia|pq> - <ia|qp> = (ip|aq) - (iq|ap)
buf = ao2mofn(cc._scf.mol, (orbo,so_coeff,orbv,so_coeff), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((nocc,nmo,nvir,nmo))
for p in range(nmo):
for i in range(nocc):
if spin[i] != spin[p]:
buf[i,p,:,:] = 0.
for a in range(nvir):
if spin[nocc+a] != spin[p]:
buf[:,:,a,p] = 0.
buf1 = buf - buf.transpose(0,3,2,1)
buf1 = buf1.transpose(0,2,1,3)
cput1 = log.timer_debug1('transforming ovpq', *cput1)
self.ovoo[:,:,:,:] = buf1[:,:,:nocc,:nocc]
self.ovov[:,:,:,:] = buf1[:,:,:nocc,nocc:]
self.ovvv[:,:,:,:] = buf1[:,:,nocc:,nocc:]
for a in range(nvir):
orbva = orbv[:,a].reshape(-1,1)
buf = ao2mofn(cc._scf.mol, (orbva,orbv,orbv,orbv), compact=0)
if mo_coeff.dtype == np.float: buf = buf.real
buf = buf.reshape((1,nvir,nvir,nvir))
for b in range(nvir):
if spin[nocc+a] != spin[nocc+b]:
buf[0,b,:,:] = 0.
for c in range(nvir):
if spin[nocc+b] != spin[nocc+c]:
buf[:,:,b,c] = buf[:,:,c,b] = 0.
buf1 = buf - buf.transpose(0,3,2,1)
buf1 = buf1.transpose(0,2,1,3)
self.vvvv[a] = buf1[:]
cput1 = log.timer_debug1('transforming vvvv', *cput1)
log.timer('CCSD integral transformation', *cput0)
