gpu4pyscf 1.4.0__tar.gz → 1.4.2__tar.gz

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/CHANGELOG

@@ -1,3 +1,45 @@
+v1.4.2 (2025-07-20)
+-------------------
+* New Features
+  - Raman spectrum calculations.
+  - Non-adiabatic coupling vector for time-dependent RKS, including the coupling.
+    between ground state and excited states as well as among excited states.
+  - DFT+U for molecule and PBC systems.
+  - ALMO EDA 2 method.
+  - Analytical gradients for TDDFT-ris method.
+  - Analytical gradients for PBC k-point DFT.
+  - Efficient analytical gradients for PBC Gamma-point DFT using the multigrid algorithm.
+  - A custom CuPy memory pool to reduce GPU memory usage.
+* Improvements
+  - Improved PBC GDF integral computation at the Gamma point, including reduced.
+    GPU memory usage and enhanced computational efficiency.
+  - Set the J engine as the defult Coulomb matrix algorithm in the direct SCF driver.
+  - Efficient Multigrid integral algorithm for various functions in PBC DFT.
+    Gamma point computation such as get_nuc, get_pp, and GGA functionals.
+  - Supporting xc='HF' setting in DFT.
+* Fixes
+  - Ensured compatibility with CUDA 12.3.
+  - Issues related to the combination of density fitting, PCM solvent, and TDDFT.
+
+v1.4.1 (2025-05-20)
+-------------------
+* New Features
+  - Analytical hessian for VV10 functionals
+  - DFT polarizability with VV10 functionals
+  - TDDFT for VV10 functionals
+  - Non-adiabatic coupling constants for TDDFT states
+  - TDDFT gradients and geometry optimization solver for excited states
+  - LR-PCM for TDDFT and TDDFT gradients
+  - TDDFT-ris method
+* Improvements
+  - Optimization CUDA kernel and integral screening for MD J-engine. The MD
+    J-engine is utilized by default for large system HF and DFT computation.
+  - Optimization for PBC gaussian density fitting at gamma point.
+  - ECP gradients CUDA kernel
+  - Reduced atomicAdd overhead in Rys JK kernel
+* Fixes
+  - MINAO initial guess for ghost atoms
+
 v1.4.0 (2025-03-27)
 -------------------
 * New Features

{gpu4pyscf-1.4.0/gpu4pyscf.egg-info → gpu4pyscf-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gpu4pyscf
-Version: 1.4.0
+Version: 1.4.2
 Summary: GPU extensions for PySCF
 Author: PySCF developers
 License: Apache-2.0

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/README.md

@@ -9,16 +9,32 @@ Installation
 > [!NOTE]
 > The compiled binary packages support compute capability 7.0 and later (Volta and later, such as Tesla V100, RTX 20 series and later).
 
-Run ```nvcc --version``` in your terminal to check the installed CUDA toolkit version. Then, choose the proper package based on your CUDA toolkit version.
+To check your installed CUDA Toolkit version, run
+```sh
+nvcc --version
+```
+Then, install the appropriate package based on your CUDA version:
 
 | Platform      | Command                               | cutensor (**highly recommended**)|
 ----------------| --------------------------------------|----------------------------------|
 | **CUDA 11.x** |  ```pip3 install gpu4pyscf-cuda11x``` | ```pip3 install cutensor-cu11``` |
 | **CUDA 12.x** |  ```pip3 install gpu4pyscf-cuda12x``` | ```pip3 install cutensor-cu12``` |
 
+The versions of CuPy and cuTENSOR are strongly interdependent and should not be combined arbitrarily.
+The recommended combinations include:
+1. CuPy 13.3.0 + cuTENSOR 2.0.2
+2. CuPy 13.4.1 + cuTENSOR 2.2.0
+
+Using other versions or combinations may lead to failures in functionality. 
+We **recommend** creating a dedicated environment using:
+```sh
+pip3 install --no-cache-dir -r requirements.txt
+```
+This ensures compatibility and reproducibility, especially since this configuration is used in our nightly benchmarks.
+
 Compilation
 --------
-One can compile the package with
+To compile the package, run the following commands:
 ```sh
 git clone https://github.com/pyscf/gpu4pyscf.git
 cd gpu4pyscf
@@ -36,19 +52,17 @@ There shouldn't be cupy or cutensor compilation during pip install process. If y
 <repo_path>/gpu4pyscf/lib/cutensor.py:<line_number>: UserWarning: using cupy as the tensor contraction engine.
 ```
 
-The package also provides multiple dockerfiles in ```dockerfiles```. One can use them as references to create the compilation envrionment.
-
 Features
 --------
 - Density fitting scheme and direct SCF scheme;
 - SCF, analytical gradient, and analytical Hessian calculations for Hartree-Fock and DFT;
 - LDA, GGA, mGGA, hybrid, and range-separated functionals via [libXC](https://gitlab.com/libxc/libxc/-/tree/master/);
-- Spin-conserved and spin-flip TDA and TDDFT for excitated states
+- Spin-conserved and spin-flip TDA and TDDFT for excitated states;
 - Geometry optimization and transition state search via [geomeTRIC](https://geometric.readthedocs.io/en/latest/);
 - Atomic Simulation Environment ([ASE](https://gitlab.com/ase/ase)) interface;
 - Dispersion corrections via [DFTD3](https://github.com/dftd3/simple-dftd3) and [DFTD4](https://github.com/dftd4/dftd4);
-- Nonlocal functional correction (vv10) for SCF and gradient;
-- ECP is supported and calculated on GPU;
+- Analytical gradient and analytical Hessian for nonlocal functional correction (vv10);
+- GPU accelerated ECP;
 - PCM models, their analytical gradients, and analytical Hessian matrix;
 - SMD solvent model;
 - Unrestricted Hartree-Fock and unrestricted DFT, gradient, and Hessian;
@@ -57,9 +71,12 @@ Features
 The following features are still in the experimental stage
 - MP2/DF-MP2 and CCSD;
 - Polarizability, IR, and NMR shielding;
+- Raman spectrum;
 - QM/MM with PBC;
-- Multi-GPU for both direct SCF and density fitting
-- SCF and DFT with periodic boundary condition
+- Multi-GPU for both direct SCF and density fitting;
+- SCF and DFT with periodic boundary condition;
+- Non-adiabatic coupling for TDDFT;
+- Energy decomposition analysis;
 
 Limitations
 --------

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/gpu4pyscf/__config__.py

@@ -24,10 +24,10 @@ for device_id in range(num_devices):
 
 props = cupy.cuda.runtime.getDeviceProperties(0)
 GB = 1024*1024*1024
-min_ao_blksize = 128
-min_grid_blksize = 128*128
-ao_aligned = 32
-grid_aligned = 256
+min_ao_blksize = 256        # maxisum batch size of AOs
+min_grid_blksize = 64*64    # maximum batch size of grids for DFT
+ao_aligned = 32             # global AO alignment for slicing
+grid_aligned = 256          # 256 alignment for grids globally
 
 # Use smaller blksize for old gaming GPUs
 if props['totalGlobalMem'] < 16 * GB:

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/gpu4pyscf/__init__.py

@@ -12,6 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = '1.4.0'
+__version__ = '1.4.2'
 
-from . import lib, grad, hessian, solvent, scf, dft, tdscf
+from . import lib, grad, hessian, solvent, scf, dft, tdscf, nac
+
+# Overwrite the cupy memory allocator. Make memory pool manage small-sized
+# arrays only.
+lib.cupy_helper.set_conditional_mempool_malloc()

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/gpu4pyscf/df/df.py

@@ -20,8 +20,9 @@ import numpy as np
 from cupyx.scipy.linalg import solve_triangular
 from pyscf import lib
 from pyscf.df import df, addons, incore
-from gpu4pyscf.lib.cupy_helper import (cholesky, tag_array, get_avail_mem, 
-                                       cart2sph, p2p_transfer, copy_array)
+from gpu4pyscf.lib.cupy_helper import (
+    cholesky, tag_array, get_avail_mem, cart2sph, p2p_transfer, copy_array,
+    asarray)
 from gpu4pyscf.df import int3c2e, df_jk
 from gpu4pyscf.df import int3c2e_bdiv
 from gpu4pyscf.lib import logger
@@ -88,35 +89,10 @@ class DF(lib.StreamObject):
             self.intopt = intopt = int3c2e_bdiv.Int3c2eOpt(mol, auxmol)
             self._cderi = {}
             self._cderi[0] = _cholesky_eri_bdiv(intopt, omega=omega)
-            ao_pair_mapping = intopt.create_ao_pair_mapping(cart=mol.cart)
-            rows, cols = divmod(cupy.asarray(ao_pair_mapping), mol.nao)
+            rows, cols, diags = intopt.orbital_pair_nonzero_indices()
             intopt.cderi_row = rows
             intopt.cderi_col = cols
-
-            # intopt.cderi_diag stores the indices for cderi_row that
-            # corresponds to the diagonal blocks. Note this index array can
-            # contain some of the off-diagonal elements which happen to be the
-            # off-diagonal elements while within the diagonal blocks.
-            uniq_l = intopt.uniq_l_ctr[:,0]
-            if mol.cart:
-                nf = (uniq_l + 1) * (uniq_l + 2) // 2
-            else:
-                nf = uniq_l * 2 + 1
-            n_groups = len(uniq_l)
-            ij_tasks = ((i, j) for i in range(n_groups) for j in range(i+1))
-            nbas = intopt.sorted_mol.nbas
-            offset = 0
-            cderi_diag = []
-            for (i, j), bas_ij_idx in zip(ij_tasks, intopt.shl_pair_idx):
-                nfi = nf[i]
-                nfj = nf[j]
-                if i == j: # the diagonal blocks
-                    ish, jsh = divmod(bas_ij_idx, nbas)
-                    idx = np.where(ish == jsh)[0]
-                    addr = offset + idx[:,None] * (nfi*nfi) + np.arange(nfi*nfi)
-                    cderi_diag.append(addr.ravel())
-                offset += bas_ij_idx.size * nfi * nfj
-            intopt.cderi_diag = cupy.asarray(np.hstack(cderi_diag))
+            intopt.cderi_diag = diags
             log.timer_debug1('cholesky_eri', *t0)
             return self
 
@@ -125,7 +101,7 @@ class DF(lib.StreamObject):
                 j2c_cpu = auxmol.intor('int2c2e', hermi=1)
         else:
             j2c_cpu = auxmol.intor('int2c2e', hermi=1)
-        j2c = cupy.asarray(j2c_cpu, order='C')
+        j2c = asarray(j2c_cpu)
         t0 = log.timer_debug1('2c2e', *t0)
         intopt = int3c2e.VHFOpt(mol, auxmol, 'int2e')
         intopt.build(direct_scf_tol, diag_block_with_triu=False, aosym=True,
@@ -161,6 +137,7 @@ class DF(lib.StreamObject):
         assert omega >= 0.0
 
         # A temporary treatment for RSH-DF integrals
+        # TODO: use the range_coulomb context from pyscf
         key = '%.6f' % omega
         if key in self._rsh_df:
             rsh_df = self._rsh_df[key]
@@ -205,7 +182,7 @@ class DF(lib.StreamObject):
             if isinstance(cderi_sparse, np.ndarray):
                 # first block
                 if buf_prefetch is None:
-                    buf = cupy.asarray(cderi_sparse[p0:p1,:])
+                    buf = asarray(cderi_sparse[p0:p1,:])
                 buf_prefetch = cupy.empty([p2-p1,cderi_sparse.shape[1]])
             if isinstance(cderi_sparse, np.ndarray) and p1 < p2:
                 buf_prefetch.set(cderi_sparse[p1:p2,:])
@@ -322,7 +299,7 @@ def _cderi_task(intopt, cd_low, task_list, _cderi, aux_blksize,
         log = logger.new_logger(mol, mol.verbose)
         t1 = log.init_timer()
         cd_low_tag = cd_low.tag
-        cd_low = cupy.asarray(cd_low)
+        cd_low = asarray(cd_low)
 
         cart_ao_loc = intopt.cart_ao_loc
         aux_ao_loc = intopt.aux_ao_loc
@@ -407,11 +384,11 @@ def _cderi_task(intopt, cd_low, task_list, _cderi, aux_blksize,
 def _cholesky_eri_bdiv(intopt, omega=None):
     assert isinstance(intopt, int3c2e_bdiv.Int3c2eOpt)
     assert omega is None
-    eri3c = intopt.int3c2e_bdiv_kernel()
+    eri3c = next(intopt.int3c2e_bdiv_generator())
     if intopt.mol.cart:
         eri3c = intopt.orbital_pair_cart2sph(eri3c)
     auxmol = intopt.auxmol
-    j2c = cupy.asarray(auxmol.intor('int2c2e', hermi=1), order='C')
+    j2c = asarray(auxmol.intor('int2c2e', hermi=1), order='C')
     cd_low = cholesky(j2c)
     aux_coeff = cupy.array(intopt.aux_coeff, copy=True)
     cd_low = solve_triangular(cd_low, aux_coeff.T, lower=True, overwrite_b=True)

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/gpu4pyscf/df/df_jk.py

@@ -22,7 +22,8 @@ import numpy
 from pyscf import lib, __config__
 from pyscf.scf import dhf
 from gpu4pyscf.lib import logger
-from gpu4pyscf.lib.cupy_helper import contract, transpose_sum, reduce_to_device
+from gpu4pyscf.lib.cupy_helper import (
+    contract, transpose_sum, reduce_to_device, tag_array)
 from gpu4pyscf.dft import rks, uks, numint
 from gpu4pyscf.scf import hf, uhf
 from gpu4pyscf.df import df, int3c2e
@@ -34,35 +35,6 @@ def _pin_memory(array):
     ret[...] = array
     return ret
 
-def init_workflow(mf, dm0=None):
-    # build CDERI for omega = 0 and omega ! = 0
-    def build_df():
-        mf.with_df.build()
-        if hasattr(mf, '_numint'):
-            omega, _, _ = mf._numint.rsh_and_hybrid_coeff(mf.xc, spin=mf.mol.spin)
-            if abs(omega) <= 1e-10: return
-            key = '%.6f' % omega
-            if key in mf.with_df._rsh_df:
-                rsh_df = mf.with_df._rsh_df[key]
-            else:
-                rsh_df = mf.with_df._rsh_df[key] = mf.with_df.copy().reset()
-            rsh_df.build(omega=omega)
-        return
-
-    mf.h1e = cupy.asarray(mf.get_hcore(mf.mol))
-    mf.s1e = cupy.asarray(mf.get_ovlp(mf.mol))
-    # pre-compute h1e and s1e and cderi for async workflow
-    with lib.call_in_background(build_df) as build:
-        build()
-        # for DFT object
-        if hasattr(mf, '_numint'):
-            ni = mf._numint
-            rks.initialize_grids(mf, mf.mol, dm0)
-            ni.build(mf.mol, mf.grids.coords)
-            mf._numint.xcfuns = numint._init_xcfuns(mf.xc, dm0.ndim==3)
-    dm0 = cupy.asarray(dm0)
-    return
-
 def _density_fit(mf, auxbasis=None, with_df=None, only_dfj=False):
     '''For the given SCF object, update the J, K matrix constructor with
     corresponding density fitting integrals.
@@ -143,7 +115,8 @@ class _DFHF:
         self.with_df.reset(mol)
         return super().reset(mol)
 
-    init_workflow = init_workflow
+    def get_j(self, mol=None, dm=None, hermi=1, omega=None):
+        return self.with_df.get_jk(dm, hermi, True, False, self.direct_scf_tol, omega)[0]
 
     def get_jk(self, mol=None, dm=None, hermi=1, with_j=True, with_k=True,
                omega=None):
@@ -151,8 +124,7 @@ class _DFHF:
         if self.with_df and self.only_dfj:
             vj = vk = None
             if with_j:
-                vj, vk = self.with_df.get_jk(dm, hermi, True, False,
-                                             self.direct_scf_tol, omega)
+                vj = self.get_j(mol, dm, hermi, omega)
             if with_k:
                 vk = super().get_jk(mol, dm, hermi, False, True, omega)[1]
         elif self.with_df:
@@ -163,6 +135,11 @@ class _DFHF:
         return vj, vk
 
     def nuc_grad_method(self):
+        if self.istype('_Solvation'):
+            raise NotImplementedError(
+                'Gradients of solvent are not computed. '
+                'Solvent must be applied after density fitting method, e.g.\n'
+                'mf = mol.RKS().to_gpu().density_fit().PCM()')
         if isinstance(self, rks.RKS):
             from gpu4pyscf.df.grad import rks as rks_grad
             return rks_grad.Gradients(self)
@@ -180,6 +157,11 @@ class _DFHF:
     Gradients = nuc_grad_method
 
     def Hessian(self):
+        if self.istype('_Solvation'):
+            raise NotImplementedError(
+                'Hessian of solvent are not computed. '
+                'Solvent must be applied after density fitting method, e.g.\n'
+                'mf = mol.RKS().to_gpu().density_fit().PCM()')
         from gpu4pyscf.dft.rks import KohnShamDFT
         if isinstance(self, hf.RHF):
             if isinstance(self, KohnShamDFT):
@@ -208,32 +190,84 @@ class _DFHF:
         '''
         if mol is None: mol = self.mol
         if dm is None: dm = self.make_rdm1()
+        assert not self.direct_scf
 
         # for DFT
         if isinstance(self, rks.KohnShamDFT):
-            if dm.ndim == 2:
-                return rks.get_veff(self, dm=dm)
-            elif dm.ndim == 3:
-                return uks.get_veff(self, dm=dm)
+            t0 = logger.init_timer(self)
+            rks.initialize_grids(self, mol, dm)
+            ni = self._numint
+            if dm.ndim == 2: # RKS
+                n, exc, vxc = ni.nr_rks(mol, self.grids, self.xc, dm)
+                logger.debug(self, 'nelec by numeric integration = %s', n)
+                if self.do_nlc():
+                    if ni.libxc.is_nlc(self.xc):
+                        xc = self.xc
+                    else:
+                        assert ni.libxc.is_nlc(self.nlc)
+                        xc = self.nlc
+                    n, enlc, vnlc = ni.nr_nlc_vxc(mol, self.nlcgrids, xc, dm)
+                    exc += enlc
+                    vxc += vnlc
+                    logger.debug(self, 'nelec with nlc grids = %s', n)
+                t0 = logger.timer_debug1(self, 'vxc tot', *t0)
+
+                if not ni.libxc.is_hybrid_xc(self.xc):
+                    vj = self.get_j(mol, dm, hermi)
+                    vxc += vj
+                else:
+                    omega, alpha, hyb = ni.rsh_and_hybrid_coeff(self.xc, spin=mol.spin)
+                    vj, vk = self.get_jk(mol, dm, hermi)
+                    vxc += vj
+                    vk *= hyb
+                    if omega != 0:
+                        vklr = self.get_k(mol, dm, hermi, omega=abs(omega))
+                        vklr *= (alpha - hyb)
+                        vk += vklr
+                    vxc -= vk * .5
+                    exc -= cupy.einsum('ij,ji', dm, vk).real * .25
+                ecoul = cupy.einsum('ij,ji', dm, vj).real * .5
+
+            elif dm.ndim == 3: # UKS
+                n, exc, vxc = ni.nr_uks(mol, self.grids, self.xc, dm)
+                logger.debug(self, 'nelec by numeric integration = %s', n)
+                if self.do_nlc():
+                    if ni.libxc.is_nlc(self.xc):
+                        xc = self.xc
+                    else:
+                        assert ni.libxc.is_nlc(self.nlc)
+                        xc = self.nlc
+                    n, enlc, vnlc = ni.nr_nlc_vxc(mol, self.nlcgrids, xc, dm[0]+dm[1])
+                    exc += enlc
+                    vxc += vnlc
+                    logger.debug(self, 'nelec with nlc grids = %s', n)
+                t0 = logger.timer(self, 'vxc', *t0)
+
+                if not ni.libxc.is_hybrid_xc(self.xc):
+                    vj = self.get_j(mol, dm[0]+dm[1], hermi)
+                    vxc += vj
+                else:
+                    omega, alpha, hyb = ni.rsh_and_hybrid_coeff(self.xc, spin=mol.spin)
+                    vj, vk = self.get_jk(mol, dm, hermi)
+                    vj = vj[0] + vj[1]
+                    vxc += vj
+                    vk *= hyb
+                    if abs(omega) > 1e-10:
+                        vklr = self.get_k(mol, dm, hermi, omega=omega)
+                        vklr *= (alpha - hyb)
+                        vk += vklr
+                    vxc -= vk
+                    exc -= cupy.einsum('sij,sji->', dm, vk).real * .5
+                ecoul = cupy.einsum('sij,ji->', dm, vj).real * .5
+            t0 = logger.timer_debug1(self, 'jk total', *t0)
+            return tag_array(vxc, ecoul=ecoul, exc=exc, vj=None, vk=None)
 
         if dm.ndim == 2:
-            if self.direct_scf:
-                ddm = cupy.asarray(dm) - dm_last
-                vj, vk = self.get_jk(mol, ddm, hermi=hermi)
-                return vhf_last + vj - vk * .5
-            else:
-                vj, vk = self.get_jk(mol, dm, hermi=hermi)
-                return vj - vk * .5
+            vj, vk = self.get_jk(mol, dm, hermi=hermi)
+            return vj - vk * .5
         elif dm.ndim == 3:
-            if self.direct_scf:
-                ddm = cupy.asarray(dm) - dm_last
-                vj, vk = self.get_jk(mol, ddm, hermi=hermi)
-                vhf = vj[0] + vj[1] - vk
-                vhf += cupy.asarray(vhf_last)
-                return vhf
-            else:
-                vj, vk = self.get_jk(mol, dm, hermi=hermi)
-                return vj[0] + vj[1] - vk
+            vj, vk = self.get_jk(mol, dm, hermi=hermi)
+            return vj[0] + vj[1] - vk
         else:
             raise NotImplementedError("Please check the dimension of the density matrix, it should not reach here.")
 
@@ -278,7 +312,7 @@ def _jk_task_with_mo(dfobj, dms, mo_coeff, mo_occ,
             for i in range(nset):
                 occ_idx = mo_occ[i] > 0
                 occ_coeff[i] = mo_coeff[i][:,occ_idx] * mo_occ[i][occ_idx]**0.5
-                nocc += mo_occ[i].sum()
+                nocc += int(mo_occ[i].sum())
             blksize = dfobj.get_blksize(extra=nao*nocc)
             if with_j:
                 vj_packed = cupy.zeros_like(dm_sparse)
@@ -443,7 +477,6 @@ def get_jk(dfobj, dms_tag, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-
     intopt = dfobj.intopt
     dms = intopt.sort_orbitals(dms, axis=[1,2])
 
-    cupy.cuda.get_current_stream().synchronize()
     if getattr(dms_tag, 'mo_coeff', None) is not None:
         mo_occ = dms_tag.mo_occ
         mo_coeff = dms_tag.mo_coeff
@@ -451,6 +484,7 @@ def get_jk(dfobj, dms_tag, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-
         mo_coeff = mo_coeff.reshape(-1,nao,nmo)
         mo_occ   = mo_occ.reshape(-1,nmo)
         mo_coeff = intopt.sort_orbitals(mo_coeff, axis=[1])
+        cupy.cuda.get_current_stream().synchronize()
 
         futures = []
         with ThreadPoolExecutor(max_workers=num_devices) as executor:
@@ -472,6 +506,7 @@ def get_jk(dfobj, dms_tag, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-
             mo1s = [mo1s]
         occ_coeffs = [intopt.sort_orbitals(occ_coeff, axis=[0]) for occ_coeff in occ_coeffs]
         mo1s = [intopt.sort_orbitals(mo1, axis=[1]) for mo1 in mo1s]
+        cupy.cuda.get_current_stream().synchronize()
 
         futures = []
         with ThreadPoolExecutor(max_workers=num_devices) as executor:
@@ -485,6 +520,7 @@ def get_jk(dfobj, dms_tag, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-
 
     # general K matrix with density matrix
     else:
+        cupy.cuda.Stream.null.synchronize()
         futures = []
         with ThreadPoolExecutor(max_workers=num_devices) as executor:
             for device_id in range(num_devices):
@@ -517,23 +553,6 @@ def get_jk(dfobj, dms_tag, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-
             vk = vk.get()
         return vj, vk
 
-def _get_jk(dfobj, dm, hermi=1, with_j=True, with_k=True,
-            direct_scf_tol=getattr(__config__, 'scf_hf_SCF_direct_scf_tol', 1e-13),
-            omega=None):
-    if omega is None:
-        return get_jk(dfobj, dm, hermi, with_j, with_k, direct_scf_tol)
-
-    # A temporary treatment for RSH-DF integrals
-    key = '%.6f' % omega
-    if key in dfobj._rsh_df:
-        rsh_df = dfobj._rsh_df[key]
-    else:
-        rsh_df = dfobj._rsh_df[key] = dfobj.copy().reset()
-        logger.info(dfobj, 'Create RSH-DF object %s for omega=%s', rsh_df, omega)
-
-    with rsh_df.mol.with_range_coulomb(omega):
-        return get_jk(rsh_df, dm, hermi, with_j, with_k, direct_scf_tol)
-
 def get_j(dfobj, dm, hermi=1, direct_scf_tol=1e-13):
     intopt = getattr(dfobj, 'intopt', None)
     if intopt is None:

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/gpu4pyscf/df/grad/rks.py

@@ -40,15 +40,6 @@ def get_veff(ks_grad, mol=None, dm=None, verbose=None):
     if grids.coords is None:
         grids.build(with_non0tab=False)
 
-    nlcgrids = None
-    if mf.do_nlc():
-        if ks_grad.nlcgrids is not None:
-            nlcgrids = ks_grad.nlcgrids
-        else:
-            nlcgrids = mf.nlcgrids
-        if nlcgrids.coords is None:
-            nlcgrids.build(with_non0tab=False)
-
     #enabling range-separated hybrids
     omega, alpha, hyb = ni.rsh_and_hybrid_coeff(mf.xc, spin=mol.spin)
 
@@ -59,26 +50,22 @@ def get_veff(ks_grad, mol=None, dm=None, verbose=None):
                 ni, mol, grids, mf.xc, dm,
                 max_memory=max_memory, verbose=ks_grad.verbose)
         #logger.debug1(ks_grad, 'sum(grids response) %s', exc.sum(axis=0))
-        if mf.do_nlc():
-            raise NotImplementedError
     else:
         exc, exc1 = rks_grad.get_exc(
                 ni, mol, grids, mf.xc, dm,
                 max_memory=max_memory, verbose=ks_grad.verbose)
-        if mf.do_nlc():
-            if ni.libxc.is_nlc(mf.xc):
-                xc = mf.xc
-            else:
-                xc = mf.nlc
-            enlc, exc1_nlc = rks_grad.get_nlc_exc(
-                ni, mol, nlcgrids, xc, dm,
-                max_memory=max_memory, verbose=ks_grad.verbose)
-            exc1 += exc1_nlc
     t0 = logger.timer(ks_grad, 'vxc total', *t0)
 
     aoslices = mol.aoslice_by_atom()
     exc1 = [exc1[:,p0:p1].sum(axis=1) for p0, p1 in aoslices[:,2:]]
     exc1 = cupy.asarray(exc1)
+
+    if mf.do_nlc():
+        enlc1_per_atom, enlc1_grid = rks_grad._get_denlc(ks_grad, mol, dm, max_memory)
+        exc1 += enlc1_per_atom
+        if ks_grad.grid_response:
+            exc += enlc1_grid
+
     if abs(hyb) < 1e-10 and abs(alpha) < 1e-10:
         ej, ejaux = ks_grad.get_j(mol, dm)
         exc1 += ej

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/gpu4pyscf/df/grad/tdrhf.py

@@ -53,13 +53,18 @@ def get_jk(mf_grad, mol=None, dm0=None, hermi=0, with_j=True, with_k=True, omega
     In the CPU version, get_jk returns the first order derivatives of J/K matrices.
     '''
     if mol is None: mol = mf_grad.mol
-    if isinstance(mf_grad.base, scf_gpu.rohf.ROHF):
-        raise NotImplementedError()
-    elif isinstance(mf_grad.base, scf_gpu.hf.SCF):
-        mf = mf_grad.base
+    if getattr(mf_grad, "base", None) is not None:
+        if isinstance(mf_grad.base, scf_gpu.rohf.ROHF):
+            raise NotImplementedError()
+        elif isinstance(mf_grad.base, scf_gpu.hf.SCF):
+            mf = mf_grad.base
+        else:
+            mf = mf_grad.base._scf 
     else:
-        mf = mf_grad.base._scf 
-
+        if isinstance(mf_grad, scf_gpu.hf.SCF):
+            mf = mf_grad
+        else:
+            raise RuntimeError("Should not reach here.")
     if(dm0 is None): dm0 = mf.make_rdm1()
     if omega is None:
         with_df = mf.with_df

{gpu4pyscf-1.4.0 → gpu4pyscf-1.4.2}/gpu4pyscf/df/hessian/rks.py

@@ -26,6 +26,7 @@ from pyscf import lib
 from gpu4pyscf.grad import rhf as rhf_grad
 from gpu4pyscf.hessian import rhf as rhf_hess
 from gpu4pyscf.hessian import rks as rks_hess
+from gpu4pyscf.hessian.rks import _get_enlc_deriv2, _get_vnlc_deriv1
 from gpu4pyscf.df.hessian import rhf as df_rhf_hess
 from gpu4pyscf.df.hessian.rhf import _get_jk_ip, _partial_hess_ejk
 from gpu4pyscf.lib import logger
@@ -46,9 +47,6 @@ def partial_hess_elec(hessobj, mo_energy=None, mo_coeff=None, mo_occ=None,
     mocc = mo_coeff[:,mo_occ>0]
     dm0 = numpy.dot(mocc, mocc.T) * 2
 
-    if mf.do_nlc():
-        raise NotImplementedError("2nd derivative of NLC is not implemented.")
-
     omega, alpha, hyb = mf._numint.rsh_and_hybrid_coeff(mf.xc, spin=mol.spin)
     with_k = mf._numint.libxc.is_hybrid_xc(mf.xc)
     de2, ej, ek = _partial_hess_ejk(hessobj, mo_energy, mo_coeff, mo_occ,
@@ -81,6 +79,10 @@ def partial_hess_elec(hessobj, mo_energy=None, mo_coeff=None, mo_occ=None,
             de2[i0,j0] += 2.0*cupy.sum(veff_dm[:,:,q0:q1], axis=2)
         for j0 in range(i0):
             de2[j0,i0] = de2[i0,j0].T
+
+    if mf.do_nlc():
+        de2 += _get_enlc_deriv2(hessobj, mo_coeff, mo_occ, max_memory)
+
     log.timer('RKS partial hessian', *time0)
     return de2
 
@@ -111,6 +113,8 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
 
     h1mo += rhf_grad.get_grad_hcore(hessobj.base.nuc_grad_method())
     h1mo += rks_hess._get_vxc_deriv1(hessobj, mo_coeff, mo_occ, max_memory)
+    if mf.do_nlc():
+        h1mo += _get_vnlc_deriv1(hessobj, mo_coeff, mo_occ, max_memory)
     return h1mo
 
 class Hessian(rks_hess.Hessian):