def kernel(self):
'''
This is a simplified version of pyscf.mp.mp2.
'''
# init
nmo = len(self._vhf.mo_energy)
no = self.mol.nelectron // 2
nv = nmo - no
emp2 = 0
co = self._vhf.mo_coeff[:, :no]
cv = self._vhf.mo_coeff[:, no:]
# g
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(self.mol._atm, self.mol._bas, self.mol._env)
eri = ao2mo.incore.general(eri, (co, cv, co, cv))
# mp2
eia = pyscf.lib.direct_sum('i-a->ia', self._vhf.mo_energy[:no], self._vhf.mo_energy[no:])
with ao2mo.load(eri) as g:
for i in xrange(no):
gi = np.asarray(g[i * nv: (i + 1) * nv])
gi = gi.reshape(nv, no, nv).transpose(1,0,2)
#t2[i] = gi / pyscf.lib.direct_sum('jb+a->jba', eia, eia[i])
t2i = gi / pyscf.lib.direct_sum('jb+a->jba', eia, eia[i])
theta = gi * 2 - gi.transpose(0,2,1)
emp2 += (t2i * theta).sum()
self.eMP2 = emp2
def test_nr_transe1incore(self):
eri_ao = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
eriref = ao2mo.restore(1, eri_ao, nao)
eriref = numpy.einsum("ijpl,pk->ijkl", eriref, mo)
eriref = numpy.einsum("ijkp,pl->ijkl", eriref, mo)
eriref = ao2mo.restore(4, eriref, nao)
eri_ao = ao2mo.restore(8, eri_ao, nao)
ftrans1 = f1pointer("AO2MOtranse1_incore_s8")
fmmm = f1pointer("AO2MOmmm_nr_s2_s2")
eri1 = numpy.empty((naopair, naopair))
libao2mo1.AO2MOnr_e1incore_drv(
ftrans1,
fmmm,
eri1.ctypes.data_as(ctypes.c_void_p),
eri_ao.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(0),
ctypes.c_int(naopair),
ctypes.c_int(nao),
ctypes.c_int(0),
ctypes.c_int(nao),
ctypes.c_int(0),
ctypes.c_int(nao),
)
self.assertTrue(numpy.allclose(eri1, eriref))
def ao2mo(self, mo_coeff):
log = logger.Logger(self.stdout, self.verbose)
time0 = (time.clock(), time.time())
log.debug('transform (ia|jb)')
nmo = self.nmo
nocc = self.nocc
nvir = nmo - nocc
co = mo_coeff[:,:nocc]
cv = mo_coeff[:,nocc:]
mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir)
mem_now = pyscf.lib.current_memory()[0]
if (self._scf._eri is not None and
mem_incore+mem_now < self.max_memory or
self.mol.incore_anyway):
if self._scf._eri is None:
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
else:
eri = self._scf._eri
eri = ao2mo.incore.general(eri, (co,cv,co,cv))
else:
max_memory = max(2000, self.max_memory*.9-mem_now)
erifile = tempfile.NamedTemporaryFile()
ao2mo.outcore.general(self.mol, (co,cv,co,cv), erifile.name,
max_memory=max_memory-mem_basic,
verbose=self.verbose)
eri = erifile
time1 = log.timer('Integral transformation', *time0)
return ao2mo.load(eri)
def __init__( self, mol, orbital_coeff, thetype ):
r'''Initializer for the localization procedure
Args:
mol : A molecule which has been built
orbital_coeff: Set of orthonormal orbitals, expressed in terms of the AO, which should be localized
thetype: Which cost function to optimize: 'boys' or 'edmiston'
'''
assert( ( thetype == 'boys' ) or ( thetype == 'edmiston' ) )
self.themol = mol
self.coeff = orbital_coeff
self.Norbs = orbital_coeff.shape[1]
self.numVars = ( self.Norbs * ( self.Norbs - 1 ) ) / 2
self.u = np.eye( self.Norbs, dtype=float )
self.verbose = mol.verbose
self.stdout = mol.stdout
self.__which = thetype
if ( self.__which == 'boys' ):
rvec = self.themol.intor('cint1e_r_sph', 3)
self.x_orig = np.dot( np.dot( self.coeff.T, rvec[0] ) , self.coeff )
self.y_orig = np.dot( np.dot( self.coeff.T, rvec[1] ) , self.coeff )
self.z_orig = np.dot( np.dot( self.coeff.T, rvec[2] ) , self.coeff )
self.x_symm = self.x_orig + self.x_orig.T
self.y_symm = self.x_orig + self.x_orig.T
self.z_symm = self.x_orig + self.x_orig.T
if ( self.__which == 'edmiston' ):
self.eri_orig = ao2mo.incore.full( _vhf.int2e_sph( mol._atm, mol._bas, mol._env ), self.coeff )
self.eri_rot = None
def int4g(xmol, S23 = True):
a, b, e = xmol.conc_env()
eri = _vhf.int2e_sph(a, b, e)
N = xmol.nHMO + xmol.nCMO
eri = ao2mo.incore.full(eri, xmol.Xmo_coeff, compact = False)
if S23:
return np.array(eri).reshape(N, N, N, N).transpose(0,2,1,3)
return np.array(eri).reshape(N, N, N, N)
def write_chk(mc, root, chkfile):
t0 = (time.clock(), time.time())
fh5 = h5py.File(chkfile, "w")
if mc.fcisolver.nroots > 1:
mc.mo_coeff, _, mc.mo_energy = mc.canonicalize(mc.mo_coeff, ci=root)
fh5["mol"] = format(mc.mol.pack())
fh5["mc/mo"] = mc.mo_coeff
fh5["mc/ncore"] = mc.ncore
fh5["mc/ncas"] = mc.ncas
nvirt = mc.mo_coeff.shape[1] - mc.ncas - mc.ncore
fh5["mc/nvirt"] = nvirt
fh5["mc/nelecas"] = mc.nelecas
fh5["mc/root"] = root
fh5["mc/orbe"] = mc.mo_energy
if hasattr(mc, "orbsym"):
fh5.create_dataset("mc/orbsym", data=mc.orbsym)
else:
fh5.create_dataset("mc/orbsym", data=[])
mo_core = mc.mo_coeff[:, : mc.ncore]
mo_cas = mc.mo_coeff[:, mc.ncore : mc.ncore + mc.ncas]
mo_virt = mc.mo_coeff[:, mc.ncore + mc.ncas :]
core_dm = numpy.dot(mo_core, mo_core.T) * 2
core_vhf = mc.get_veff(mc.mol, core_dm)
h1e_Sr = reduce(numpy.dot, (mo_virt.T, mc.get_hcore() + core_vhf, mo_cas))
h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore() + core_vhf, mo_core))
fh5["h1e_Si"] = h1e_Si
fh5["h1e_Sr"] = h1e_Sr
h1e = mc.h1e_for_cas()
fh5["h1e"] = h1e[0]
if mc._scf._eri is None:
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(mc.mol._atm, mol._bas, mol._env)
else:
eri = mc._scf._eri
# FIXME
# add outcore later
h2e = ao2mo.incore.general(eri, [mo_cas, mo_cas, mo_cas, mo_cas], compact=False)
h2e = h2e.reshape(mc.ncas, mc.ncas, mc.ncas, mc.ncas)
fh5["h2e"] = h2e
h2e_Sr = ao2mo.incore.general(eri, [mo_virt, mo_cas, mo_cas, mo_cas], compact=False)
h2e_Sr = h2e_Sr.reshape(nvirt, mc.ncas, mc.ncas, mc.ncas)
fh5["h2e_Sr"] = h2e_Sr
h2e_Si = ao2mo.incore.general(eri, [mo_cas, mo_core, mo_cas, mo_cas], compact=False)
h2e_Si = h2e_Si.reshape(mc.ncas, mc.ncore, mc.ncas, mc.ncas)
fh5["h2e_Si"] = h2e_Si
fh5.close()
logger.timer(mc, "Write MPS NEVPT integral", *t0)
def get_jk(self, mol=None, dm=None, hermi=1):
# Note the incore version, which initializes an _eri array in memory.
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = dot_eri_dm(self._eri, dm, hermi)
else:
vj, vk = SCF.get_jk(self, mol, dm, hermi)
return vj, vk
def get_jk(self, mol=None, dm=None, hermi=1):
# Note the incore version, which initializes an _eri array in memory.
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = dot_eri_dm(self._eri, dm, hermi)
else:
vj, vk = SCF.get_jk(self, mol, dm, hermi)
return vj, vk
def get_jk(self, mol=None, dm=None, hermi=1):
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
cpu0 = (time.clock(), time.time())
if self._eri is not None or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm, hermi)
else:
vj, vk = hf.get_jk(mol, dm, hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj, vk
def get_jk_(self, mol=None, dm=None, hermi=1):
# Note the incore version, which initializes an _eri array in memory.
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
cpu0 = (time.clock(), time.time())
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = dot_eri_dm(self._eri, dm, hermi)
else:
if self.direct_scf:
self.opt = self.init_direct_scf(mol)
vj, vk = get_jk(mol, dm, hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj, vk
def get_jk(self, mol=None, dm=None, hermi=1):
# Note the incore version, which initializes an _eri array in memory.
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
cpu0 = (time.clock(), time.time())
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = dot_eri_dm(self._eri, dm, hermi)
else:
if self.direct_scf:
self.opt = self.init_direct_scf(mol)
vj, vk = get_jk(mol, dm, hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj, vk
def get_jk_(self, mol=None, dm=None, hermi=1):
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
dm = numpy.asarray(dm)
nao = dm.shape[-1]
cpu0 = (time.clock(), time.time())
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm.reshape(-1,nao,nao), hermi)
else:
if self.direct_scf:
self.opt = self.init_direct_scf(mol)
vj, vk = hf.get_jk(mol, dm.reshape(-1,nao,nao), hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj.reshape(dm.shape), vk.reshape(dm.shape)
def get_jk(self, mol=None, dm=None, hermi=1):
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
dm = numpy.asarray(dm)
nao = dm.shape[-1]
cpu0 = (time.clock(), time.time())
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm.reshape(-1, nao, nao), hermi)
else:
if self.direct_scf:
self.opt = self.init_direct_scf(mol)
vj, vk = hf.get_jk(mol, dm.reshape(-1, nao, nao), hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj.reshape(dm.shape), vk.reshape(dm.shape)
def __init__(self, casscf, mo, method='incore'):
mol = casscf.mol
self.ncore = casscf.ncore
self.ncas = casscf.ncas
nmo = mo[0].shape[1]
ncore = self.ncore
ncas = self.ncas
mem_incore, mem_outcore, mem_basic = _mem_usage(ncore, ncas, nmo)
mem_now = pyscf.lib.current_memory()[0]
eri = casscf._scf._eri
if (method == 'incore' and eri is not None and
((mem_incore + mem_now) < casscf.max_memory * .9)
or mol.incore_anyway):
if eri is None:
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
self.jkcpp, self.jkcPP, self.jC_pp, self.jc_PP, \
self.aapp, self.aaPP, self.AApp, self.AAPP, \
self.appa, self.apPA, self.APPA, \
self.Iapcv, self.IAPCV, self.apCV, self.APcv, \
self.Icvcv, self.ICVCV, self.cvCV = \
trans_e1_incore(eri, mo, casscf.ncore, casscf.ncas)
self.vhf_c = (numpy.einsum('ipq->pq', self.jkcpp) + self.jC_pp,
numpy.einsum('ipq->pq', self.jkcPP) + self.jc_PP)
else:
import gc
gc.collect()
log = logger.Logger(casscf.stdout, casscf.verbose)
max_memory = max(2000, casscf.max_memory * .9 - mem_now)
if ((mem_outcore + mem_now) < casscf.max_memory * .9):
if max_memory < mem_basic:
log.warn(
'Calculation needs %d MB memory, over CASSCF.max_memory (%d MB) limit',
(mem_outcore + mem_now) / .9, casscf.max_memory)
self.jkcpp, self.jkcPP, self.jC_pp, self.jc_PP, \
self.aapp, self.aaPP, self.AApp, self.AAPP, \
self.appa, self.apPA, self.APPA, \
self.Iapcv, self.IAPCV, self.apCV, self.APcv, \
self.Icvcv, self.ICVCV, self.cvCV = \
trans_e1_outcore(mol, mo, casscf.ncore, casscf.ncas,
max_memory=max_memory, verbose=log)
self.vhf_c = (numpy.einsum('ipq->pq', self.jkcpp) + self.jC_pp,
numpy.einsum('ipq->pq', self.jkcPP) + self.jc_PP)
else:
raise RuntimeError('.max_memory not enough')
assert (max_memory > mem_basic)
def __init__(self, casscf, mo, method='incore'):
mol = casscf.mol
self.ncore = casscf.ncore
self.ncas = casscf.ncas
nmo = mo[0].shape[1]
ncore = self.ncore
ncas = self.ncas
mem_incore, mem_outcore, mem_basic = _mem_usage(ncore, ncas, nmo)
mem_now = pyscf.lib.current_memory()[0]
eri = casscf._scf._eri
if (method == 'incore' and eri is not None and
((mem_incore+mem_now) < casscf.max_memory*.9) or
mol.incore_anyway):
if eri is None:
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
self.jkcpp, self.jkcPP, self.jC_pp, self.jc_PP, \
self.aapp, self.aaPP, self.AApp, self.AAPP, \
self.appa, self.apPA, self.APPA, \
self.Iapcv, self.IAPCV, self.apCV, self.APcv, \
self.Icvcv, self.ICVCV, self.cvCV = \
trans_e1_incore(eri, mo, casscf.ncore, casscf.ncas)
self.vhf_c = (numpy.einsum('ipq->pq', self.jkcpp) + self.jC_pp,
numpy.einsum('ipq->pq', self.jkcPP) + self.jc_PP)
else:
import gc
gc.collect()
log = logger.Logger(casscf.stdout, casscf.verbose)
max_memory = max(2000, casscf.max_memory*.9-mem_now)
if ((mem_outcore+mem_now) < casscf.max_memory*.9):
if max_memory < mem_basic:
log.warn('Calculation needs %d MB memory, over CASSCF.max_memory (%d MB) limit',
(mem_outcore+mem_now)/.9, casscf.max_memory)
self.jkcpp, self.jkcPP, self.jC_pp, self.jc_PP, \
self.aapp, self.aaPP, self.AApp, self.AAPP, \
self.appa, self.apPA, self.APPA, \
self.Iapcv, self.IAPCV, self.apCV, self.APcv, \
self.Icvcv, self.ICVCV, self.cvCV = \
trans_e1_outcore(mol, mo, casscf.ncore, casscf.ncas,
max_memory=max_memory, verbose=log)
self.vhf_c = (numpy.einsum('ipq->pq', self.jkcpp) + self.jC_pp,
numpy.einsum('ipq->pq', self.jkcPP) + self.jc_PP)
else:
raise RuntimeError('.max_memory not enough')
assert(max_memory > mem_basic)
def get_jk(self, mol=None, dm=None, hermi=1):
'''Hartree-Fock potential matrix for the given density matrix.
See :func:`scf.hf.get_veff`
Note the incore version, which initializes an _eri array in memory.
'''
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
cpu0 = (time.clock(), time.time())
if self._eri is not None or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = dot_eri_dm(self._eri, dm, hermi)
else:
vj, vk = get_jk(mol, dm, hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj, vk
def get_jk(self, mol=None, dm=None, hermi=1):
'''Coulomb (J) and exchange (K)
Args:
dm : a list of 2D arrays or a list of 3D arrays
(alpha_dm, beta_dm) or (alpha_dms, beta_dms)
'''
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
dm = numpy.asarray(dm)
nao = dm.shape[-1] # Get nao from dm shape because the hamiltonian
# might be not defined from mol
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm.reshape(-1,nao,nao), hermi)
else:
vj, vk = hf.SCF.get_jk(self, mol, dm.reshape(-1,nao,nao), hermi)
return vj.reshape(dm.shape), vk.reshape(dm.shape)
def get_jk(self, mol=None, dm=None, hermi=1):
'''Coulomb (J) and exchange (K)
Args:
dm : a list of 2D arrays or a list of 3D arrays
(alpha_dm, beta_dm) or (alpha_dms, beta_dms)
'''
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
dm = numpy.asarray(dm)
nao = dm.shape[-1] # Get nao from dm shape because the hamiltonian
# might be not defined from mol
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm.reshape(-1, nao, nao), hermi)
else:
vj, vk = hf.SCF.get_jk(self, mol, dm.reshape(-1, nao, nao), hermi)
return vj.reshape(dm.shape), vk.reshape(dm.shape)
def test_incore(self):
from pyscf.scf import _vhf
numpy.random.seed(15)
nmo = 12
mo = numpy.random.random((nao,nmo))
eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
eriref = ao2mo.restore(1, eri, nao)
eriref = numpy.einsum('pjkl,pi->ijkl', eriref, mo)
eriref = numpy.einsum('ipkl,pj->ijkl', eriref, mo)
eriref = numpy.einsum('ijpl,pk->ijkl', eriref, mo)
eriref = numpy.einsum('ijkp,pl->ijkl', eriref, mo)
eri1 = ao2mo.incore.full(ao2mo.restore(8,eri,nao), mo)
self.assertTrue(numpy.allclose(ao2mo.restore(1,eri1,nmo), eriref))
eri1 = ao2mo.incore.full(ao2mo.restore(4,eri,nao), mo, compact=False)
self.assertTrue(numpy.allclose(eri1.reshape((nmo,)*4), eriref))
eri1 = ao2mo.incore.general(eri, (mo[:,:2], mo[:,1:3], mo[:,:3], mo[:,2:5]))
eri1 = eri1.reshape(2,2,3,3)
self.assertTrue(numpy.allclose(eri1, eriref[:2,1:3,:3,2:5]))
def __init__(self, mol, orbital_coeff, thetype, use_full_hessian=True):
r'''Initializer for the localization procedure
Args:
mol : A molecule which has been built
orbital_coeff: Set of orthonormal orbitals, expressed in terms of the AO, which should be localized
thetype: Which cost function to optimize: 'boys' or 'edmiston'
use_full_hessian: Whether to do augmented Hessian Newton-Raphson (True) or just -gradient/diag(hessian) (False)
'''
assert ((thetype == 'boys') or (thetype == 'edmiston'))
self.themol = mol
self.coeff = orbital_coeff
self.Norbs = orbital_coeff.shape[1]
self.numVars = (self.Norbs * (self.Norbs - 1)) // 2
self.u = np.eye(self.Norbs, dtype=float)
self.verbose = mol.verbose
self.use_hess = use_full_hessian
self.stdout = mol.stdout
self.gradient = None
self.grd_norm = 1.0
#self.ahnr_cnt = 0
self.__which = thetype
if (self.__which == 'boys'):
rvec = self.themol.intor('cint1e_r_sph', 3)
self.x_orig = np.dot(np.dot(self.coeff.T, rvec[0]), self.coeff)
self.y_orig = np.dot(np.dot(self.coeff.T, rvec[1]), self.coeff)
self.z_orig = np.dot(np.dot(self.coeff.T, rvec[2]), self.coeff)
self.x_symm = self.x_orig + self.x_orig.T
self.y_symm = self.y_orig + self.y_orig.T
self.z_symm = self.z_orig + self.z_orig.T
if (self.__which == 'edmiston'):
self.eri_orig = ao2mo.incore.full(
_vhf.int2e_sph(mol._atm, mol._bas, mol._env), self.coeff)
self.eri_rot = None
def __init__(self, casscf, mo, method='incore', level=1):
mol = casscf.mol
nao, nmo = mo.shape
ncore = casscf.ncore
ncas = casscf.ncas
mem_incore, mem_outcore, mem_basic = _mem_usage(ncore, ncas, nmo)
mem_now = lib.current_memory()[0]
eri = casscf._scf._eri
if (method == 'incore' and eri is not None and
(mem_incore+mem_now < casscf.max_memory*.9) or
mol.incore_anyway):
if eri is None:
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
self.j_pc, self.k_pc, self.ppaa, self.papa = \
trans_e1_incore(eri, mo, casscf.ncore, casscf.ncas)
else:
import gc
gc.collect()
log = logger.Logger(casscf.stdout, casscf.verbose)
self._tmpfile = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
max_memory = max(3000, casscf.max_memory*.9-mem_now)
if max_memory < mem_basic:
log.warn('Calculation needs %d MB memory, over CASSCF.max_memory (%d MB) limit',
(mem_basic+mem_now)/.9, casscf.max_memory)
self.j_pc, self.k_pc = \
trans_e1_outcore(mol, mo, casscf.ncore, casscf.ncas,
self._tmpfile.name,
max_memory=max_memory,
level=level, verbose=log)
self.feri = feri = h5py.File(self._tmpfile.name, 'r')
def __del__():
feri.close()
self.feri.__del__ = __del__
self.ppaa = self.feri['ppaa']
self.papa = self.feri['papa']
dm_core = numpy.dot(mo[:,:ncore], mo[:,:ncore].T)
vj, vk = casscf._scf.get_jk(mol, dm_core)
self.vhf_c = reduce(numpy.dot, (mo.T, vj*2-vk, mo))
def __init__( self, mol, orbital_coeff, thetype, use_full_hessian=True ):
r'''Initializer for the localization procedure
Args:
mol : A molecule which has been built
orbital_coeff: Set of orthonormal orbitals, expressed in terms of the AO, which should be localized
thetype: Which cost function to optimize: 'boys' or 'edmiston'
use_full_hessian: Whether to do augmented Hessian Newton-Raphson (True) or just -gradient/diag(hessian) (False)
'''
assert( ( thetype == 'boys' ) or ( thetype == 'edmiston' ) )
self.themol = mol
self.coeff = orbital_coeff
self.Norbs = orbital_coeff.shape[1]
self.numVars = ( self.Norbs * ( self.Norbs - 1 ) ) // 2
self.u = np.eye( self.Norbs, dtype=float )
self.verbose = mol.verbose
self.use_hess = use_full_hessian
self.stdout = mol.stdout
self.gradient = None
self.grd_norm = 1.0
#self.ahnr_cnt = 0
self.__which = thetype
if ( self.__which == 'boys' ):
rvec = self.themol.intor('cint1e_r_sph', 3)
self.x_orig = np.dot( np.dot( self.coeff.T, rvec[0] ) , self.coeff )
self.y_orig = np.dot( np.dot( self.coeff.T, rvec[1] ) , self.coeff )
self.z_orig = np.dot( np.dot( self.coeff.T, rvec[2] ) , self.coeff )
self.x_symm = self.x_orig + self.x_orig.T
self.y_symm = self.x_orig + self.x_orig.T
self.z_symm = self.x_orig + self.x_orig.T
if ( self.__which == 'edmiston' ):
self.eri_orig = ao2mo.incore.full( _vhf.int2e_sph( mol._atm, mol._bas, mol._env ), self.coeff )
self.eri_rot = None
def __init__(self, casscf, mo, method='incore', level=1):
mol = casscf.mol
nao, nmo = mo.shape
ncore = casscf.ncore
ncas = casscf.ncas
mem_incore, mem_outcore, mem_basic = _mem_usage(ncore, ncas, nmo)
mem_now = lib.current_memory()[0]
eri = casscf._scf._eri
if (method == 'incore' and eri is not None and
(mem_incore + mem_now < casscf.max_memory * .9)
or mol.incore_anyway):
if eri is None:
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
self.j_pc, self.k_pc, self.ppaa, self.papa = \
trans_e1_incore(eri, mo, casscf.ncore, casscf.ncas)
else:
import gc
gc.collect()
log = logger.Logger(casscf.stdout, casscf.verbose)
self._tmpfile = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR)
max_memory = max(3000, casscf.max_memory * .9 - mem_now)
if max_memory < mem_basic:
log.warn(
'Calculation needs %d MB memory, over CASSCF.max_memory (%d MB) limit',
(mem_basic + mem_now) / .9, casscf.max_memory)
self.j_pc, self.k_pc = \
trans_e1_outcore(mol, mo, casscf.ncore, casscf.ncas,
self._tmpfile.name,
max_memory=max_memory,
level=level, verbose=log)
self.feri = lib.H5TmpFile(self._tmpfile.name, 'r')
self.ppaa = self.feri['ppaa']
self.papa = self.feri['papa']
dm_core = numpy.dot(mo[:, :ncore], mo[:, :ncore].T)
vj, vk = casscf._scf.get_jk(mol, dm_core)
self.vhf_c = reduce(numpy.dot, (mo.T, vj * 2 - vk, mo))
def __init__(self, casscf, mo, method="incore", level=1):
mol = casscf.mol
nao, nmo = mo.shape
ncore = casscf.ncore
ncas = casscf.ncas
mem_incore, mem_outcore, mem_basic = _mem_usage(ncore, ncas, nmo)
mem_now = pyscf.lib.current_memory()[0]
eri = casscf._scf._eri
if (
method == "incore"
and eri is not None
and (mem_incore + mem_now < casscf.max_memory * 0.9)
or mol.incore_anyway
):
if eri is None:
from pyscf.scf import _vhf
eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
self.j_pc, self.k_pc, self.ppaa, self.papa = trans_e1_incore(eri, mo, casscf.ncore, casscf.ncas)
else:
import gc
gc.collect()
log = logger.Logger(casscf.stdout, casscf.verbose)
self._tmpfile = tempfile.NamedTemporaryFile()
max_memory = max(3000, casscf.max_memory * 0.9 - mem_now)
if max_memory < mem_basic:
log.warn("Not enough memory! You need increase CASSCF.max_memory")
self.j_pc, self.k_pc = trans_e1_outcore(
mol, mo, casscf.ncore, casscf.ncas, self._tmpfile.name, max_memory=max_memory, level=level, verbose=log
)
self.feri = h5py.File(self._tmpfile.name, "r")
self.ppaa = self.feri["ppaa"]
self.papa = self.feri["papa"]
dm_core = numpy.dot(mo[:, :ncore], mo[:, :ncore].T)
vj, vk = casscf._scf.get_jk(mol, dm_core)
self.vhf_c = reduce(numpy.dot, (mo.T, vj * 2 - vk, mo))
def test_nr_transe2(self):
eri_ao = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
eri1 = ao2mo.restore(1, eri_ao, nao)
eriref = numpy.einsum('ijpl,pk->ijkl', eri1, mo)
eriref = numpy.einsum('ijkp,pl->ijkl', eriref, mo)
orbs_slice = (0, nao, 0, nao)
def e2drv(ftrans2, fmmm, eri1, eri2):
libao2mo1.AO2MOnr_e2_drv(ftrans2, fmmm,
eri2.ctypes.data_as(ctypes.c_void_p),
eri1.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nao*nao), ctypes.c_int(nao),
(ctypes.c_int*4)(*orbs_slice),
ctypes.c_void_p(), nbas)
return eri2
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s1')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s1_iltj')
eri2 = numpy.zeros((nao,nao,nao,nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s1')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s1_igtj')
eri2 = numpy.zeros((nao,nao,nao,nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_iltj')
eri2 = numpy.zeros((nao,nao,nao,nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:,:,tril[0],tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_igtj')
eri2 = numpy.zeros((nao,nao,nao,nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:,:,tril[0],tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_s2')
eri2 = numpy.zeros((nao,nao,naopair))
eri2 = e2drv(ftrans2, fmmm, eri1[:,:,tril[0],tril[1]].copy(), eri2)
eri2 = s2kl_to_s1(eri2, nao)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_s2')
eri1p = ao2mo.restore(4, eri1, nao)
eri2 = numpy.zeros((naopair,naopair))
orbs_slice = (0, nao, 0, nao)
libao2mo1.AO2MOnr_e2_drv(ftrans2, fmmm,
eri2.ctypes.data_as(ctypes.c_void_p),
eri1p.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(naopair), ctypes.c_int(nao),
(ctypes.c_int*4)(*orbs_slice),
ctypes.c_void_p(), nbas)
self.assertTrue(numpy.allclose(eri2, ao2mo.restore(4,eriref,nao)))
###########################################################
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s1_iltj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao,nao,nao,nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s1_igtj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao,nao,nao,nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s2_iltj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao,nao,nao,nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:,:,tril[0],tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s2_igtj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao,nao,nao,nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:,:,tril[0],tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s2_s2')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao,nao,naopair))
eri2 = e2drv(ftrans2, fmmm, eri1[:,:,tril[0],tril[1]].copy(), eri2)
eri2 = s2kl_to_s1(eri2, nao)
self.assertTrue(numpy.allclose(eri2, eriref))
def test_nr_transe2(self):
eri_ao = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
eri1 = ao2mo.restore(1, eri_ao, nao)
eriref = numpy.einsum('ijpl,pk->ijkl', eri1, mo)
eriref = numpy.einsum('ijkp,pl->ijkl', eriref, mo)
orbs_slice = (0, nao, 0, nao)
def e2drv(ftrans2, fmmm, eri1, eri2):
libao2mo1.AO2MOnr_e2_drv(ftrans2, fmmm,
eri2.ctypes.data_as(ctypes.c_void_p),
eri1.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nao * nao),
ctypes.c_int(nao),
(ctypes.c_int * 4)(*orbs_slice),
ctypes.c_void_p(), nbas)
return eri2
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s1')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s1_iltj')
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s1')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s1_igtj')
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_iltj')
eri2 = numpy.zeros((nao, nao, nao, nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:, :, tril[0], tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_igtj')
eri2 = numpy.zeros((nao, nao, nao, nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:, :, tril[0], tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_s2')
eri2 = numpy.zeros((nao, nao, naopair))
eri2 = e2drv(ftrans2, fmmm, eri1[:, :, tril[0], tril[1]].copy(), eri2)
eri2 = s2kl_to_s1(eri2, nao)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtranse2_nr_s2kl')
fmmm = getattr(libao2mo1, 'AO2MOmmm_nr_s2_s2')
eri1p = ao2mo.restore(4, eri1, nao)
eri2 = numpy.zeros((naopair, naopair))
orbs_slice = (0, nao, 0, nao)
libao2mo1.AO2MOnr_e2_drv(ftrans2, fmmm,
eri2.ctypes.data_as(ctypes.c_void_p),
eri1p.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(naopair), ctypes.c_int(nao),
(ctypes.c_int * 4)(*orbs_slice),
ctypes.c_void_p(), nbas)
self.assertTrue(numpy.allclose(eri2, ao2mo.restore(4, eriref, nao)))
###########################################################
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s1_iltj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s1_igtj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri1, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s2_iltj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao, nao, nao, nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:, :, tril[0], tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s2_igtj')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao, nao, nao, nao))
tril = numpy.tril_indices(nao)
eri2 = e2drv(ftrans2, fmmm, eri1[:, :, tril[0], tril[1]].copy(), eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = getattr(libao2mo1, 'AO2MOtrans_nr_s2_s2')
fmmm = ctypes.c_void_p()
eri2 = numpy.zeros((nao, nao, naopair))
eri2 = e2drv(ftrans2, fmmm, eri1[:, :, tril[0], tril[1]].copy(), eri2)
eri2 = s2kl_to_s1(eri2, nao)
self.assertTrue(numpy.allclose(eri2, eriref))
def test_nr_transe2(self):
eri_ao = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
eri1 = ao2mo.restore(1, eri_ao, nao)
eriref = numpy.einsum("ijpl,pk->ijkl", eri1, mo)
eriref = numpy.einsum("ijkp,pl->ijkl", eriref, mo)
def e2drv(ftrans2, fmmm, eri2):
libao2mo1.AO2MOnr_e2_drv(
ftrans2,
fmmm,
eri2.ctypes.data_as(ctypes.c_void_p),
eri1.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nao * nao),
ctypes.c_int(nao),
ctypes.c_int(0),
ctypes.c_int(nao),
ctypes.c_int(0),
ctypes.c_int(nao),
)
return eri2
ftrans2 = f1pointer("AO2MOtranse2_nr_s1")
fmmm = f1pointer("AO2MOmmm_nr_s1_iltj")
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = f1pointer("AO2MOtranse2_nr_s1")
fmmm = f1pointer("AO2MOmmm_nr_s1_igtj")
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = f1pointer("AO2MOtranse2_nr_s1")
fmmm = f1pointer("AO2MOmmm_nr_s2_iltj")
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = f1pointer("AO2MOtranse2_nr_s1")
fmmm = f1pointer("AO2MOmmm_nr_s2_igtj")
eri2 = numpy.zeros((nao, nao, nao, nao))
eri2 = e2drv(ftrans2, fmmm, eri2)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = f1pointer("AO2MOtranse2_nr_s1")
fmmm = f1pointer("AO2MOmmm_nr_s2_s2")
eri2 = numpy.zeros((nao, nao, naopair))
eri2 = e2drv(ftrans2, fmmm, eri2)
eri2 = s2kl_to_s1(eri2, nao)
self.assertTrue(numpy.allclose(eri2, eriref))
ftrans2 = f1pointer("AO2MOtranse2_nr_s2kl")
fmmm = f1pointer("AO2MOmmm_nr_s2_s2")
eri1 = ao2mo.restore(4, eri1, nao)
eri2 = numpy.zeros((naopair, naopair))
libao2mo1.AO2MOnr_e2_drv(
ftrans2,
fmmm,
eri2.ctypes.data_as(ctypes.c_void_p),
eri1.ctypes.data_as(ctypes.c_void_p),
mo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(naopair),
ctypes.c_int(nao),
ctypes.c_int(0),
ctypes.c_int(nao),
ctypes.c_int(0),
ctypes.c_int(nao),
)
self.assertTrue(numpy.allclose(eri2, ao2mo.restore(4, eriref, nao)))
