pyscf 2.10.0__py3-none-macosx_11_0_arm64.whl → 2.11.0__py3-none-macosx_11_0_arm64.whl

pyscf/__init__.py

@@ -35,7 +35,7 @@ to try out the package::
 
 '''
 
-__version__ = '2.10.0'
+__version__ = '2.11.0'
 
 import os
 import sys

pyscf/cc/eom_rccsd.py

@@ -58,6 +58,9 @@ def kernel(eom, nroots=1, koopmans=False, guess=None, left=False,
     # GHF or customized RHF/UHF may be of complex type
     real_system = (eom._cc._scf.mo_coeff[0].dtype == np.double)
 
+    mem_now = lib.current_memory()[0]
+    max_memory = max(0, eom.max_memory - mem_now)
+
     eig = lib.davidson_nosym1
     if user_guess or koopmans:
         assert len(guess) == nroots
@@ -69,14 +72,14 @@ def kernel(eom, nroots=1, koopmans=False, guess=None, left=False,
             return lib.linalg_helper._eigs_cmplx2real(w, v, idx, real_system)
         conv, es, vs = eig(matvec, guess, precond, pick=eig_close_to_init_guess,
                            tol=eom.conv_tol, max_cycle=eom.max_cycle,
-                           max_space=eom.max_space, nroots=nroots, verbose=log)
+                           max_space=eom.max_space, max_memory=max_memory, nroots=nroots, verbose=log)
     else:
         def pickeig(w, v, nroots, envs):
             real_idx = np.where(abs(w.imag) < 1e-3)[0]
             return lib.linalg_helper._eigs_cmplx2real(w, v, real_idx, real_system)
         conv, es, vs = eig(matvec, guess, precond, pick=pickeig,
                            tol=eom.conv_tol, max_cycle=eom.max_cycle,
-                           max_space=eom.max_space, nroots=nroots, verbose=log)
+                           max_space=eom.max_space, max_memory=max_memory, nroots=nroots, verbose=log)
 
     if eom.verbose >= logger.INFO:
         for n, en, vn, convn in zip(range(nroots), es, vs, conv):

pyscf/df/df.py

@@ -42,16 +42,18 @@ class DF(lib.StreamObject):
     r'''
     Object to hold 3-index tensor
 
-    Attributes:
+    Input Attributes:
         auxbasis : str or dict
-            Same input format as :attr:`Mole.basis`
-
-        auxmol : Mole object
-            Read only Mole object to hold the auxiliary basis.  auxmol is
-            generated automatically in the initialization step based on the
-            given auxbasis.  It is used in the rest part of the code to
-            determine the problem size, the integral batches etc.  This object
-            should NOT be modified.
+            Same format as the input attribute mol.basis. If auxbasis is set to
+            None, an optimal auxiliary basis set will be selected based on the
+            AO basis set, according to the records in the basis set exchange
+            database and the predefined mappings in `pyscf.df.addons.DEFAULT_AUXBASIS`.
+            For DFT methods, the selection of auxiliary basis sets is also
+            influenced by the xc functional. The J-FIT basis set will be used for
+            local and semi-local functionals (LDA, GGA, and meta-GGA). JK-FIT
+            basis set will be employed for hybrid and RSH functionals.
+            If optimal auxiliary basis sets are not available, the PySCF built-in
+            even-tempered Gaussian basis set will be used.
         _cderi_to_save : str
             If _cderi_to_save is specified, the DF integral tensor will be
             saved in this file.
@@ -68,9 +70,27 @@ class DF(lib.StreamObject):
             in the DF integral tensor.  Thus the shape of DF integral tensor
             is (M,N*(N+1)/2), where M is the number of auxbasis functions and
             N is the number of basis functions of the orbital basis.
+            This attribute is not compatible between the CPU and GPU implementations.
+            It will not be transferred during the to_cpu() and to_gpu() calls.
         blockdim : int
             When reading DF integrals from disk the chunk size to load.  It is
             used to improve IO performance.
+
+    Intermediate Attributes (These attributes are generated during calculations
+    and should not be modified. Additionally, they may not be compatible between
+    GPU and CPU implementations.)
+        auxmol : Mole object
+            Read only Mole object to hold the auxiliary basis.  auxmol is
+            generated automatically in the initialization step based on the
+            given auxbasis.  It is used in the rest part of the code to
+            determine the problem size, the integral batches etc.  This object
+            should NOT be modified.
+        _vjopt : _VHFOpt instance
+            An instance that caches precomputation variables to optimize the
+            computation of the Coulomb matrix.
+        _rsh_df : dict
+            For range-separated DFT functionals, this object stores the density fitting
+            instances for long-range or short-range Coulomb integrals.
     '''
 
     blockdim = getattr(__config__, 'df_df_DF_blockdim', 240)

pyscf/df/df_jk.py

@@ -37,9 +37,16 @@ def density_fit(mf, auxbasis=None, with_df=None, only_dfj=False):
 
     Kwargs:
         auxbasis : str or basis dict
-            Same format to the input attribute mol.basis.  If auxbasis is
-            None, optimal auxiliary basis based on AO basis (if possible) or
-            even-tempered Gaussian basis will be used.
+            Same format as the input attribute mol.basis. If auxbasis is set to
+            None, an optimal auxiliary basis set will be selected based on the
+            AO basis set, according to the records in the basis set exchange
+            database and the predefined mappings in `pyscf.df.addons.DEFAULT_AUXBASIS`.
+            For DFT methods, the selection of auxiliary basis sets is also
+            influenced by the xc functional. The J-FIT basis set will be used for
+            local and semi-local functionals (LDA, GGA, and meta-GGA). JK-FIT
+            basis set will be employed for hybrid and RSH functionals.
+            If optimal auxiliary basis sets are not available, the PySCF built-in
+            even-tempered Gaussian basis set will be used.
 
         only_dfj : str
             Compute Coulomb integrals only and no approximation for HF

pyscf/dft/gen_grid.py

@@ -183,7 +183,32 @@ def original_becke(g):
 
 def gen_atomic_grids(mol, atom_grid={}, radi_method=radi.gauss_chebyshev,
                      level=3, prune=nwchem_prune, **kwargs):
-    '''Generate number of radial grids and angular grids for the given molecule.
+    '''Generate radial and angular grids for each atom within a molecule
+
+    Kwargs:
+        atom_grid : dict or tuple
+            A dict {atom: (n_rad, n_ang)} to define the grid settings for each
+            atom within the molecule. For atoms in mol.atom that are not
+            included in the dict, the radial and angular configuration
+            associated with `level` will be used as the default setting.
+            The dict can also accept a "default" key to specify default
+            configurations. atom_grid can be provided as a tuple (n_rad, n_ang).
+            In this case, the same grid setting will apply apply to all atoms.
+        radi_method : function
+            The method to generate radial grids. Supported functions include the
+            treutler_ahlrichs, delley, mura_knowles, gauss_chebeshev in the
+            `dft.radi` module.
+        level : integer
+            Predefined configurations for radial and angular grids based on
+            the period of the elements. The number of radial and angular grids
+            for each level can be found in dft.gen_grid.RAD_GRIDS and
+            dft.gen_grid.ANG_ORDER.
+        prune : function
+            The pruning scheme to reduce angular grids for radial griads.
+            Available functions include the nwchem_prune, sg1_prune,
+            and treutler_prune, implemented in the `dft.gen_grid` module.
+            If None is provided for this argument, no pruning scheme will
+            be applied.
 
     Returns:
         A dict, with the atom symbol for the dict key.  For each atom type,
@@ -191,16 +216,18 @@ def gen_atomic_grids(mol, atom_grid={}, radi_method=radi.gauss_chebyshev,
         atom center; the second is the volume of that grid.
     '''
     if isinstance(atom_grid, (list, tuple)):
-        atom_grid = {mol.atom_symbol(ia): atom_grid
-                          for ia in range(mol.natm)}
+        atom_grid = {mol.atom_symbol(ia): atom_grid for ia in range(mol.natm)}
+
+    default = atom_grid.get('default', None)
     atom_grids_tab = {}
     for ia in range(mol.natm):
         symb = mol.atom_symbol(ia)
 
         if symb not in atom_grids_tab:
             chg = gto.charge(symb)
-            if symb in atom_grid:
-                n_rad, n_ang = atom_grid[symb]
+            atom_config = atom_grid.get(symb, default)
+            if atom_config is not None:
+                n_rad, n_ang = atom_config
                 if n_ang not in LEBEDEV_NGRID:
                     if n_ang in LEBEDEV_ORDER:
                         logger.warn(mol, 'n_ang %d for atom %d %s is not '
@@ -383,7 +410,7 @@ def _load_conf(mod, name, default):
         return var
 
 class Grids(lib.StreamObject):
-    '''DFT mesh grids
+    '''Atomic grids for DFT numerical integration
 
     Attributes for Grids:
         level : int
@@ -434,7 +461,25 @@ class Grids(lib.StreamObject):
             Eg, grids.atom_grid = {'H': (20,110)} will generate 20 radial
             grids and 110 angular grids for H atom.
 
-        Examples:
+    Saved results:
+        coords : ndarray
+            Coordinates of the integration grids.
+        weights : ndarray
+            Integration weights of the integration grids.
+
+    Intermediate Attributes (These attributes are generated during calculations
+    and should not be modified. Additionally, they may not be compatible between
+    GPU and CPU implementations):
+        non0tab :
+            The important grids for each AO shell.
+        screen_index :
+            An estimation of the AO values on the grids.
+        atm_idx :
+            Atom ID for each grid.
+        quadrature_weights :
+            Volume of each grid, not scaled by the Becke partitioning.
+
+    Examples:
 
         >>> mol = gto.M(atom='H 0 0 0; H 0 0 1.1')
         >>> grids = dft.gen_grid.Grids(mol)