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

pyscf/df/autoaux.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python
+# Copyright 2024 The PySCF Developers. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+'''
+The AutoAux algorithm by ORCA
+
+Ref:
+    JCTC, 13 (2016), 554
+'''
+
+from math import factorial
+import numpy as np
+from pyscf import gto
+
+F_LAUX   = np.array([20 , 7.0, 4.0, 4.0, 3.5, 2.5, 2.0, 2.0])
+BETA_BIG = np.array([1.8, 2.0, 2.2, 2.2, 2.2, 2.3, 3.0, 3.0])
+BETA_SMALL = 1.8
+
+def _primitive_emin_emax(basis):
+    l_max = max(b[0] for b in basis)
+    emin_by_l = [1e99] * (l_max+1)
+    emax_by_l = [0] * (l_max+1)
+    e_eff_by_l = [0] * (l_max+1)
+
+    for b in basis:
+        l = b[0]
+        if isinstance(b[1], int):
+            e_c = np.array(b[2:])
+        else:
+            e_c = np.array(b[1:])
+        es = e_c[:,0]
+        emax_by_l[l] = max(es.max(), emax_by_l[l])
+        emin_by_l[l] = min(es.min(), emin_by_l[l])
+
+        cs = e_c[:,1:]
+        cs = np.einsum('pi,p->pi', cs, gto.gto_norm(l, es)) # normalize GTOs
+        cs = gto.mole._nomalize_contracted_ao(l, es, cs) # prefactors in r_ints
+        ee = es[:,None] + es
+        r_ints = gto.gaussian_int(l*2+3, ee) # \int \chi^2 r dr
+        r_exp = np.einsum('pi,pq,qi->i', cs, r_ints, cs)
+
+        k = 2**(2*l+1) * factorial(l+1)**2 / factorial(2*l+2)
+        # Eq (9) in the paper, e_eff = 2 * k**2 / (np.pi * r_exp) is a typo.
+        # See also https://github.com/MolSSI-BSE/basis_set_exchange/issues/317
+        # For primitive functions, following expression leads to
+        # e_eff = exponent of the basis
+        e_eff = 2 * k**2 / (np.pi * r_exp**2)
+        # For primitive functions, e_eff may be slightly different to the
+        # exponent due to the rounding errors in gaussian_int function.
+        # When a particular shell has only one primitive function, one auxiliary
+        # function should be generated. This error can introduce an additional
+        # auxiliary function.
+        # Slightly reduce e_eff to remove the extra auxiliary functions.
+        e_eff -= 1e-8
+        e_eff_by_l[l] = max(e_eff.max(), e_eff_by_l[l])
+    return np.array(emax_by_l), np.array(emin_by_l), np.array(e_eff_by_l)
+
+def _auto_aux_element(Z, basis, ecp_core=0):
+    a_max_by_l, a_min_by_l, a_eff_by_l = _primitive_emin_emax(basis)
+    a_min_prim = a_min_by_l[:,None] + a_min_by_l
+    a_max_prim = a_max_by_l[:,None] + a_max_by_l
+    a_max_aux = a_eff_by_l[:,None] + a_eff_by_l
+
+    l_max1 = a_max_by_l.size
+    l_max = l_max1 - 1
+    # TODO: handle ECP
+    if Z <= 2:
+        l_val = 0
+    elif Z <= 20:
+        l_val = 1
+    elif Z <= 56:
+        l_val = 2
+    else:
+        l_val = 3
+    l_inc = 1
+    if Z > 18:
+        l_inc = 2
+    l_max_aux = min(max(l_val*2, l_max+l_inc), l_max*2)
+
+    liljsum = np.arange(l_max1)[:,None] + np.arange(l_max1)
+    liljsub = abs(np.arange(l_max1)[:,None] - np.arange(l_max1))
+    a_min_by_l = [a_min_prim[(liljsub<=ll) & (ll<=liljsum)].min() for ll in range(l_max_aux+1)]
+    a_max_by_l = [a_max_prim[(liljsub<=ll) & (ll<=liljsum)].max() for ll in range(l_max_aux+1)]
+    a_aux_by_l = [a_max_aux [(liljsub<=ll) & (ll<=liljsum)].max() for ll in range(l_max_aux+1)]
+
+    a_max_adjust = [min(F_LAUX[l] * a_aux_by_l[l], a_max_by_l[l])
+                    for l in range(l_val*2+1)]
+    a_max_adjust = a_max_adjust + a_aux_by_l[l_val*2+1 : l_max_aux+1]
+
+    emin = np.array(a_min_by_l)
+    emax = np.array(a_max_adjust)
+
+    ns_small = np.log(a_max_adjust[:l_val*2+1] / emin[:l_val*2+1]) / np.log(BETA_SMALL)
+    etb = []
+    # ns_small+1 to ensure the largest exponent in etb > emax
+    for l, n in enumerate(np.ceil(ns_small).astype(int) + 1):
+        if n > 0:
+            etb.append((l, n, emin[l], BETA_SMALL))
+
+    if l_max_aux > l_val*2:
+        ns_big = (np.log(emax[l_val*2+1:] / emin[l_val*2+1:])
+                  / np.log(BETA_BIG[l_val*2+1:l_max_aux+1]))
+        for l, n in enumerate(np.ceil(ns_big).astype(int) + 1):
+            if n > 0:
+                l = l + l_val*2+1
+                beta = BETA_BIG[l]
+                etb.append((l, n, emin[l], beta))
+    return etb
+
+def autoaux(mol):
+    '''
+    Create an auxiliary basis set for the given orbital basis set using
+    the Auto-Aux algorithm.
+
+    See also: G. L. Stoychev, A. A. Auer, and F. Neese
+    Automatic Generation of Auxiliary Basis Sets
+    J. Chem. Theory Comput. 13, 554 (2017)
+    http://doi.org/10.1021/acs.jctc.6b01041
+    '''
+    from pyscf.gto.basis import bse
+
+    def expand(symb):
+        Z = gto.charge(symb)
+        etb = _auto_aux_element(Z, mol._basis[symb])
+        if etb:
+            return gto.expand_etbs(etb)
+        raise RuntimeError(f'Failed to generate even-tempered auxbasis for {symb}')
+
+    uniq_atoms = {a[0] for a in mol._atom}
+    if bse.basis_set_exchange is None:
+        return {symb: expand(symb) for symb in uniq_atoms}
+
+    if isinstance(mol.basis, str):
+        try:
+            elements = [gto.charge(symb) for symb in uniq_atoms]
+            newbasis = bse.autoaux(mol.basis, elements)
+        except KeyError:
+            newbasis = {symb: expand(symb) for symb in uniq_atoms}
+    else:
+        newbasis = {}
+        for symb in uniq_atoms:
+            if symb in mol.basis and isinstance(mol.basis[symb], str):
+                try:
+                    auxbs = bse.autoaux(mol.basis[symb], gto.charge(symb))
+                    newbasis[symb] = next(iter(auxbs.values()))
+                except KeyError:
+                    newbasis[symb] = expand(symb)
+            else:
+                newbasis[symb] = expand(symb)
+    return newbasis
+
+def autoabs(mol):
+    '''
+    Create a Coulomb fitting basis set for the given orbital basis set.
+    See also:
+    R. Yang, A. P. Rendell, and M. J. Frisch
+    Automatically generated Coulomb fitting basis sets: Design and accuracy for systems containing H to Kr
+    J. Chem. Phys. 127, 074102 (2007)
+    http://doi.org/10.1063/1.2752807
+    '''
+    from pyscf.gto.basis import bse
+    if bse is None:
+        print('Package basis-set-exchange not available')
+        raise ImportError
+
+    uniq_atoms = {a[0] for a in mol._atom}
+    if isinstance(mol.basis, str):
+        elements = [gto.charge(symb) for symb in uniq_atoms]
+        newbasis = bse.autoabs(mol.basis, elements)
+    else:
+        newbasis = {}
+        for symb in uniq_atoms:
+            if symb in mol.basis and isinstance(mol.basis[symb], str):
+                auxbs = bse.autoabs(mol.basis[symb], gto.charge(symb))
+                newbasis[symb] = next(iter(auxbs.values()))
+            else:
+                raise NotImplementedError
+    return newbasis

pyscf/df/df.py

@@ -98,6 +98,10 @@ class DF(lib.StreamObject):
         self._vjopt = None
         self._rsh_df = {}  # Range separated Coulomb DF objects
 
+    __getstate__, __setstate__ = lib.generate_pickle_methods(
+            excludes=('_cderi_to_save', '_cderi', '_vjopt', '_rsh_df'),
+            reset_state=True)
+
     @property
     def auxbasis(self):
         return self._auxbasis
@@ -166,7 +170,7 @@ class DF(lib.StreamObject):
                                      max_memory=max_memory, verbose=log)
             else:
                 # Store DF tensor in blocks. This is to reduce the
-                # initiailzation overhead
+                # initialization overhead
                 outcore.cholesky_eri_b(mol, cderi, dataname=self._dataname,
                                        int3c=int3c, int2c=int2c, auxmol=auxmol,
                                        max_memory=max_memory, verbose=log)

pyscf/df/grad/casscf.py

@@ -227,44 +227,3 @@ class Gradients(casci_grad.Gradients):
     to_gpu = lib.to_gpu
 
 Grad = Gradients
-
-#from pyscf import mcscf
-#mcscf.mc1step.CASSCF.Gradients = lib.class_as_method(Gradients)
-
-
-if __name__ == '__main__':
-    from pyscf import scf
-    from pyscf import mcscf
-    from pyscf import df
-    #from pyscf.grad import numeric
-
-    mol = gto.Mole()
-    mol.atom = 'N 0 0 0; N 0 0 1.2; H 1 1 0; H 1 1 1.2'
-    mol.basis = '631g'
-    mol.build()
-    aux = df.aug_etb (mol)
-    mf = scf.RHF(mol).density_fit (auxbasis=aux).run()
-    mc = mcscf.CASSCF(mf, 4, 4).run()
-    mc.conv_tol = 1e-10
-    de = Gradients (mc).kernel()
-    #de_num = numeric.Gradients (mc).kernel ()
-    #print(lib.finger(de) - 0.019602220578635747)
-    #print(lib.finger(de) - lib.finger (de_num))
-
-    mol = gto.Mole()
-    mol.verbose = 0
-    mol.atom = 'N 0 0 0; N 0 0 1.2'
-    mol.basis = 'sto3g'
-    mol.build()
-    mf = scf.RHF(mol).density_fit (auxbasis=aux).run()
-    mc = mcscf.CASSCF(mf, 4, 4)
-    mc.conv_tol = 1e-10
-    mc.kernel ()
-    de = Gradients (mc).kernel()
-
-    mcs = mc.as_scanner()
-    mol.set_geom_('N 0 0 0; N 0 0 1.201')
-    e1 = mcs(mol)
-    mol.set_geom_('N 0 0 0; N 0 0 1.199')
-    e2 = mcs(mol)
-    print(de[1,2], (e1-e2)/0.002*lib.param.BOHR)

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)

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