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): 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)))