pyscf 2.6.2__py3-none-macosx_11_0_arm64.whl → 2.8.0__py3-none-macosx_11_0_arm64.whl

pyscf/df/hessian/rhf.py

@@ -368,16 +368,8 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
     for ia, h1, vj1, vk1 in _gen_jk(hessobj, mo_coeff, mo_occ, chkfile,
                                     atmlst, verbose, True):
         h1 += vj1 - vk1 * .5
-
-        if chkfile is None:
-            h1ao[ia] = h1
-        else:
-            key = 'scf_f1ao/%d' % ia
-            lib.chkfile.save(chkfile, key, h1)
-    if chkfile is None:
-        return h1ao
-    else:
-        return chkfile
+        h1ao[ia] = h1
+    return h1ao
 
 def _gen_jk(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None,
             verbose=None, with_k=True):

pyscf/df/hessian/rks.py

@@ -109,13 +109,7 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
             for ia, h1, vj1, vk1 in df_rhf_hess._gen_jk(
                     hessobj, mo_coeff, mo_occ, chkfile, atmlst, verbose):
                 h1ao[ia] -= .5 * (alpha - hyb) * vk1
-
-    if chkfile is None:
-        return h1ao
-    else:
-        for ia in atmlst:
-            lib.chkfile.save(chkfile, 'scf_f1ao/%d'%ia, h1ao[ia])
-        return chkfile
+    return h1ao
 
 
 class Hessian(rks_hess.Hessian):

pyscf/df/hessian/uhf.py

@@ -398,19 +398,9 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
     for ia, h1, vj1, vk1 in _gen_jk(hessobj, mo_coeff, mo_occ, chkfile,
                                     atmlst, verbose, True):
         vk1a, vk1b = vk1
-        h1a = h1 + vj1 - vk1a
-        h1b = h1 + vj1 - vk1b
-
-        if chkfile is None:
-            h1aoa[ia] = h1a
-            h1aob[ia] = h1b
-        else:
-            lib.chkfile.save(chkfile, 'scf_f1ao/0/%d' % ia, h1a)
-            lib.chkfile.save(chkfile, 'scf_f1ao/1/%d' % ia, h1b)
-    if chkfile is None:
-        return (h1aoa,h1aob)
-    else:
-        return chkfile
+        h1aoa[ia] = h1 + vj1 - vk1a
+        h1aob[ia] = h1 + vj1 - vk1b
+    return (h1aoa,h1aob)
 
 def _gen_jk(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None,
             verbose=None, with_k=True):

pyscf/df/hessian/uks.py

@@ -121,14 +121,7 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
                 vk1a, vk1b = vk1
                 h1aoa[ia] -= (alpha - hyb) * vk1a
                 h1aob[ia] -= (alpha - hyb) * vk1b
-
-    if chkfile is None:
-        return h1aoa, h1aob
-    else:
-        for ia in atmlst:
-            lib.chkfile.save(chkfile, 'scf_f1ao/0/%d'%ia, h1aoa[ia])
-            lib.chkfile.save(chkfile, 'scf_f1ao/1/%d'%ia, h1aob[ia])
-        return chkfile
+    return h1aoa, h1aob
 
 
 class Hessian(uks_hess.Hessian):

pyscf/df/incore.py

@@ -38,22 +38,34 @@ format_aux_basis = addons.make_auxmol
 
 
 def aux_e2(mol, auxmol_or_auxbasis, intor='int3c2e', aosym='s1', comp=None, out=None,
-           cintopt=None):
+           cintopt=None, shls_slice=None):
     '''3-center AO integrals (ij|L), where L is the auxiliary basis.
 
     Kwargs:
-        cintopt : Libcint-3.14 and newer version support to compute int3c2e
-            without the opt for the 3rd index.  It can be precomputed to
-            reduce the overhead of cintopt initialization repeatedly.
+        cintopt :
+            Precomputing certain pair-shell data. It can be created by
 
             cintopt = gto.moleintor.make_cintopt(mol._atm, mol._bas, mol._env, 'int3c2e')
+
+        shls_slice : 6-element tuple
+            Label the start-stop shells for each index in the integral tensor.
+            For the (ij|aux) = intor('int3c2e'), the tuple should be given as
+            (ish_start, ish_end, jsh_start, jsh_end, aux_start, aux_end)
     '''
     if isinstance(auxmol_or_auxbasis, gto.MoleBase):
         auxmol = auxmol_or_auxbasis
     else:
         auxbasis = auxmol_or_auxbasis
         auxmol = addons.make_auxmol(mol, auxbasis)
-    shls_slice = (0, mol.nbas, 0, mol.nbas, mol.nbas, mol.nbas+auxmol.nbas)
+    if shls_slice is None:
+        shls_slice = (0, mol.nbas, 0, mol.nbas,
+                      mol.nbas, mol.nbas+auxmol.nbas)
+    else:
+        assert len(shls_slice) == 6
+        assert shls_slice[5] < auxmol.nbas
+        shls_slice = list(shls_slice)
+        shls_slice[4] += mol.nbas
+        shls_slice[5] += mol.nbas
 
     # Extract the call of the two lines below
     #  pmol = gto.mole.conc_mol(mol, auxmol)
@@ -143,7 +155,7 @@ def cholesky_eri(mol, auxbasis='weigend+etb', auxmol=None,
     atm, bas, env = gto.mole.conc_env(mol._atm, mol._bas, mol._env,
                                       auxmol._atm, auxmol._bas, auxmol._env)
     ao_loc = gto.moleintor.make_loc(bas, int3c)
-    nao = ao_loc[mol.nbas]
+    nao = int(ao_loc[mol.nbas])
 
     if aosym == 's1':
         nao_pair = nao * nao

pyscf/df/outcore.py

@@ -146,8 +146,8 @@ def cholesky_eri_b(mol, erifile, auxbasis='weigend+etb', dataname='j3c',
     atm, bas, env = gto.mole.conc_env(mol._atm, mol._bas, mol._env,
                                       auxmol._atm, auxmol._bas, auxmol._env)
     ao_loc = gto.moleintor.make_loc(bas, int3c)
-    nao = ao_loc[mol.nbas]
-    naoaux = ao_loc[-1] - nao
+    nao = int(ao_loc[mol.nbas])
+    naoaux = int(ao_loc[-1] - nao)
     if aosym == 's1':
         nao_pair = nao * nao
         buflen = min(max(int(max_memory*.24e6/8/naoaux/comp), 1), nao_pair)
@@ -289,12 +289,12 @@ def general(mol, mo_coeffs, erifile, auxbasis='weigend+etb', dataname='eri_mo',
 
 def _guess_shell_ranges(mol, buflen, aosym, start=0, stop=None):
     from pyscf.ao2mo.outcore import balance_partition
-    ao_loc = mol.ao_loc_nr()
+    ao_loc_long = mol.ao_loc_nr().astype(numpy.int64)
     if 's2' in aosym:
-        return balance_partition(ao_loc*(ao_loc+1)//2, buflen, start, stop)
+        return balance_partition(ao_loc_long*(ao_loc_long+1)//2, buflen, start, stop)
     else:
-        nao = ao_loc[-1]
-        return balance_partition(ao_loc*nao, buflen, start, stop)
+        nao = ao_loc_long[-1]
+        return balance_partition(ao_loc_long*nao, buflen, start, stop)
 
 def _create_h5file(erifile, dataname):
     if isinstance(getattr(erifile, 'name', None), str):

pyscf/dft/dks.py

@@ -46,7 +46,7 @@ def energy_elec(ks, dm=None, h1e=None, vhf=None):
         ks : an instance of DFT class
 
         dm : 2D ndarray
-            one-partical density matrix
+            one-particle density matrix
         h1e : 2D ndarray
             Core hamiltonian
 

pyscf/dft/gks.py

@@ -89,36 +89,40 @@ def get_veff(ks, mol=None, dm=None, dm_last=0, vhf_last=0, hermi=1):
             logger.debug(ks, 'nelec with nlc grids = %s', n)
         t0 = logger.timer(ks, 'vxc', *t0)
 
+    incremental_jk = (ks._eri is None and ks.direct_scf and
+                      getattr(vhf_last, 'vj', None) is not None)
+    if incremental_jk:
+        _dm = numpy.asarray(dm) - numpy.asarray(dm_last)
+    else:
+        _dm = dm
     if not ni.libxc.is_hybrid_xc(ks.xc):
         vk = None
-        if (ks._eri is None and ks.direct_scf and
-            getattr(vhf_last, 'vj', None) is not None):
-            ddm = numpy.asarray(dm) - numpy.asarray(dm_last)
-            vj = ks.get_j(mol, ddm, hermi)
+        vj = ks.get_j(mol, _dm, hermi)
+        if incremental_jk:
             vj += vhf_last.vj
-        else:
-            vj = ks.get_j(mol, dm, hermi)
         vxc += vj
     else:
         omega, alpha, hyb = ni.rsh_and_hybrid_coeff(ks.xc, spin=mol.spin)
-        if (ks._eri is None and ks.direct_scf and
-            getattr(vhf_last, 'vk', None) is not None):
-            ddm = numpy.asarray(dm) - numpy.asarray(dm_last)
-            vj, vk = ks.get_jk(mol, ddm, hermi)
+        if omega == 0:
+            vj, vk = ks.get_jk(mol, _dm, hermi)
+            vk *= hyb
+        elif alpha == 0: # LR=0, only SR exchange
+            vj = ks.get_j(mol, _dm, hermi)
+            vk = ks.get_k(mol, _dm, hermi, omega=-omega)
             vk *= hyb
-            if omega != 0:
-                vklr = ks.get_k(mol, ddm, hermi, omega=omega)
-                vklr *= (alpha - hyb)
-                vk += vklr
+        elif hyb == 0: # SR=0, only LR exchange
+            vj = ks.get_j(mol, _dm, hermi)
+            vk = ks.get_k(mol, _dm, hermi, omega=omega)
+            vk *= alpha
+        else: # SR and LR exchange with different ratios
+            vj, vk = ks.get_jk(mol, _dm, hermi)
+            vk *= hyb
+            vklr = ks.get_k(mol, _dm, hermi, omega=omega)
+            vklr *= (alpha - hyb)
+            vk += vklr
+        if incremental_jk:
             vj += vhf_last.vj
             vk += vhf_last.vk
-        else:
-            vj, vk = ks.get_jk(mol, dm, hermi)
-            vk *= hyb
-            if omega != 0:
-                vklr = ks.get_k(mol, dm, hermi, omega=omega)
-                vklr *= (alpha - hyb)
-                vk += vklr
         vxc += vj - vk
 
         if ground_state: