gpu4pyscf 1.0__tar.gz → 1.0.2__tar.gz

{gpu4pyscf-1.0/gpu4pyscf.egg-info → gpu4pyscf-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gpu4pyscf
-Version: 1.0
+Version: 1.0.2
 Summary: GPU extensions for PySCF
 Home-page: UNKNOWN
 Author: Qiming Sun

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/README.md

@@ -1,6 +1,5 @@
 GPU plugin for PySCF
 ====================
-[![arXiv](https://img.shields.io/badge/arXiv-2404.09452-b31b1b.svg)](https://arxiv.org/abs/2404.09452)
 ![nightly](https://github.com/pyscf/gpu4pyscf/actions/workflows/nightly_build.yml/badge.svg)
 [![PyPI version](https://badge.fury.io/py/gpu4pyscf-cuda11x.svg)](https://badge.fury.io/py/gpu4pyscf-cuda11x)
 
@@ -28,9 +27,13 @@ cmake --build build/temp.gpu4pyscf -j 4
 CURRENT_PATH=`pwd`
 export PYTHONPATH="${PYTHONPATH}:${CURRENT_PATH}"
 ```
-Then install cutensor for acceleration
+Then install cutensor and cupy for acceleration (please switch the versions according to your nvcc version!)
 ```sh
-pip3 install cutensor-cu11
+pip3 install cutensor-cu12 cupy-cuda12x
+```
+There shouldn't be cupy or cutensor compilation during pip install process. If you see the following warning at the beginning of a gpu4pyscf job, it implies problems with cupy and cutensor installation (likely a version mismatch, or multiple versions of same package installed).
+```
+<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.
@@ -125,3 +128,26 @@ Speedup with GPU4PySCF v0.6.0 on A100-80G over Q-Chem 6.1 on 32-cores CPU (Desit
 
 Find more benchmarks in [gpu4pyscf/benchmarks](https://github.com/pyscf/gpu4pyscf/tree/master/benchmarks)
 
+References
+---------
+```
+@misc{li2024introducting,
+      title={Introducing GPU-acceleration into the Python-based Simulations of Chemistry Framework}, 
+      author={Rui Li and Qiming Sun and Xing Zhang and Garnet Kin-Lic Chan},
+      year={2024},
+      eprint={2407.09700},
+      archivePrefix={arXiv},
+      primaryClass={physics.comp-ph},
+      url={https://arxiv.org/abs/2407.09700}, 
+}
+
+@misc{wu2024enhancing,
+      title={Enhancing GPU-acceleration in the Python-based Simulations of Chemistry Framework}, 
+      author={Xiaojie Wu and Qiming Sun and Zhichen Pu and Tianze Zheng and Wenzhi Ma and Wen Yan and Xia Yu and Zhengxiao Wu and Mian Huo and Xiang Li and Weiluo Ren and Sheng Gong and Yumin Zhang and Weihao Gao},
+      year={2024},
+      eprint={2404.09452},
+      archivePrefix={arXiv},
+      primaryClass={physics.comp-ph},
+      url={https://arxiv.org/abs/2404.09452}, 
+}
+```

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/gpu4pyscf/__init__.py

@@ -1,6 +1,6 @@
 from . import lib, grad, hessian, solvent, scf, dft
 
-__version__ = '1.0'
+__version__ = '1.0.2'
 
 # monkey patch libxc reference due to a bug in nvcc
 from pyscf.dft import libxc

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/gpu4pyscf/df/df.py

@@ -273,12 +273,15 @@ def cholesky_eri_gpu(intopt, mol, auxmol, cd_low, omega=None, sr_only=False):
         row = intopt.ao_pairs_row[cp_ij_id] - i0
         col = intopt.ao_pairs_col[cp_ij_id] - j0
 
-        ints_slices = ints_slices[:,col,row]
+        ints_slices_f= cupy.empty([naoaux,len(row)], order='F')
+        ints_slices_f[:] = ints_slices[:,col,row]
+        ints_slices = None
+
         if cd_low.tag == 'eig':
-            cderi_block = cupy.dot(cd_low.T, ints_slices)
+            cderi_block = cupy.dot(cd_low.T, ints_slices_f)
             ints_slices = None
         elif cd_low.tag == 'cd':
-            cderi_block = solve_triangular(cd_low_f, ints_slices, lower=True, overwrite_b=True)
+            cderi_block = solve_triangular(cd_low_f, ints_slices_f, lower=True, overwrite_b=True)
         ij0, ij1 = count, count+cderi_block.shape[1]
         count = ij1
         if isinstance(cderi, cupy.ndarray):
@@ -288,6 +291,7 @@ def cholesky_eri_gpu(intopt, mol, auxmol, cd_low, omega=None, sr_only=False):
                 for i in range(naux):
                     cderi_block[i].get(out=cderi[i,ij0:ij1])
         t1 = log.timer_debug1(f'solve {cp_ij_id} / {nq}', *t1)
+
     if not use_gpu_memory:
         cupy.cuda.Device().synchronize()
     return cderi

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/gpu4pyscf/df/grad/rhf.py

@@ -268,8 +268,10 @@ class Gradients(rhf_grad.Gradients):
     auxbasis_response = True
     get_jk = get_jk
     grad_elec = rhf_grad.grad_elec
-    check_sanity = NotImplemented
-
+    
+    def check_sanity(self):
+        assert isinstance(self.base, df.df_jk._DFHF)
+    
     def get_j(self, mol=None, dm=None, hermi=0):
         vj, _, vjaux, _ = self.get_jk(mol, dm, with_k=False)
         return vj, vjaux

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/gpu4pyscf/df/int3c2e.py

@@ -632,15 +632,17 @@ def get_aux2atom(intopt, auxslices):
         aux2atom[p0:p1,ia] = 1.0
     return aux2atom[aux_ao_idx,:]
 
-def get_j_int3c2e_pass1(intopt, dm0):
+def get_j_int3c2e_pass1(intopt, dm0, sort_j=True):
     '''
     get rhoj pass1 for int3c2e
     '''
     n_dm = 1
 
-    naux = len(intopt.cart_aux_idx)
+    naux = intopt.cart_aux_loc[-1]#len(intopt.cart_aux_idx)
     rhoj = cupy.zeros([naux])
     coeff = intopt.coeff
+    if dm0.ndim == 3:
+        dm0 = dm0[0] + dm0[1]
     dm_cart = coeff @ dm0 @ coeff.T
 
     num_cp_ij = [len(log_qs) for log_qs in intopt.log_qs]
@@ -666,8 +668,9 @@ def get_j_int3c2e_pass1(intopt, dm0):
     if err != 0:
         raise RuntimeError('CUDA error in get_j_pass1')
 
-    aux_coeff = intopt.aux_coeff
-    rhoj = cupy.dot(rhoj, aux_coeff)
+    if sort_j:
+        aux_coeff = intopt.aux_coeff
+        rhoj = cupy.dot(rhoj, aux_coeff)
     return rhoj
 
 def get_j_int3c2e_pass2(intopt, rhoj):

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/gpu4pyscf/dft/gen_grid.py

@@ -30,14 +30,15 @@ import ctypes
 import numpy
 import cupy
 from pyscf import lib
-from pyscf.lib import logger
 from pyscf import gto
 from pyscf.gto.eval_gto import BLKSIZE, NBINS, CUTOFF, make_screen_index
 from pyscf import __config__
 from cupyx.scipy.spatial.distance import cdist
+from gpu4pyscf.lib import logger
 from gpu4pyscf.dft import radi
 from gpu4pyscf.lib.cupy_helper import load_library
 from gpu4pyscf import __config__ as __gpu4pyscf_config__
+
 libdft = lib.load_library('libdft')
 libgdft = load_library('libgdft')
 
@@ -189,7 +190,7 @@ def gen_grids_partition(atm_coords, coords, a):
     assert ngrids < 65535 * 16
 
     pbecke = cupy.empty([natm, ngrids], order='C')
-    atm_coords = cupy.asarray(atm_coords, order='F')
+    #atm_coords = cupy.asarray(atm_coords, order='F')
     err = libgdft.GDFTgen_grid_partition(
         ctypes.cast(stream.ptr, ctypes.c_void_p),
         ctypes.cast(pbecke.data.ptr, ctypes.c_void_p),
@@ -200,7 +201,7 @@ def gen_grids_partition(atm_coords, coords, a):
         ctypes.c_int(natm)
     )
     if err != 0:
-        raise RuntimeError('CUDA Error')
+        raise RuntimeError('CUDA Error in grids_partition kernel')
     return pbecke
 
 def gen_atomic_grids(mol, atom_grid={}, radi_method=radi.gauss_chebyshev,
@@ -334,6 +335,7 @@ def get_partition(mol, atom_grids_tab,
     assert radii_adjust == radi.treutler_atomic_radii_adjust
     a = -radi.get_treutler_fac(mol, atomic_radii)
     #a = -radi.get_becke_fac(mol, atomic_radii)
+    atm_coords = cupy.asarray(atm_coords, order='F')
     for ia in range(mol.natm):
         coords, vol = atom_grids_tab[mol.atom_symbol(ia)]
         coords = coords + atm_coords[ia]
@@ -341,7 +343,6 @@ def get_partition(mol, atom_grids_tab,
         weights = vol * pbecke[ia] * (1./pbecke.sum(axis=0))
         coords_all.append(coords)
         weights_all.append(weights)
-
     if concat:
         coords_all = cupy.vstack(coords_all)
         weights_all = cupy.hstack(weights_all)
@@ -403,7 +404,6 @@ def atomic_group_grids(mol, coords):
         next_node = numpy.argmin(distances_to_unvisited)
         path.append(next_node)
         current_node = next_node
-
     atom_coords = cupy.asarray(atom_coords[path])
 
     coords = cupy.asarray(coords, order='F')
@@ -420,7 +420,6 @@ def atomic_group_grids(mol, coords):
     )
     if err != 0:
         raise RuntimeError('CUDA Error')
-
     idx = group_ids.argsort()
     return idx
 
@@ -505,7 +504,6 @@ class Grids(lib.StreamObject):
             mol, self.atom_grid, self.radi_method, self.level, self.prune, **kwargs)
         self.coords, self.weights = self.get_partition(
             mol, atom_grids_tab, self.radii_adjust, self.atomic_radii, self.becke_scheme)
-
         if self.alignment > 1:
             padding = _padding_size(self.size, self.alignment)
             logger.debug(self, 'Padding %d grids', padding)
@@ -514,7 +512,6 @@ class Grids(lib.StreamObject):
                 self.coords = cupy.vstack(
                     [self.coords, numpy.repeat([[1e4]*3], padding, axis=0)])
                 self.weights = cupy.hstack([self.weights, numpy.zeros(padding)])
-
         if sort_grids:
             #idx = arg_group_grids(mol, self.coords)
             idx = atomic_group_grids(mol, self.coords)

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/gpu4pyscf/dft/libxc.py

@@ -20,8 +20,12 @@ import numpy as np
 import ctypes
 import ctypes.util
 import cupy
+import copy
+from ctypes import POINTER
 from pyscf import dft
-from gpu4pyscf.dft.libxc_structs import xc_func_type
+from gpu4pyscf.dft.libxc_structs import xc_func_type, xc_lda_out_params, xc_gga_out_params, xc_mgga_out_params
+from gpu4pyscf.lib.cupy_helper import load_library
+from gpu4pyscf.dft import libxc_structs
 
 import site
 path_list = [os.path.abspath(os.path.join(__file__, '..', '..', '..'))] + site.getsitepackages()
@@ -33,14 +37,44 @@ is_hybrid_xc     = dft.libxc.is_hybrid_xc
 test_deriv_order = dft.libxc.test_deriv_order
 
 for path in path_list:
+    libxc_path = os.path.abspath(os.path.join(path, 'gpu4pyscf', 'lib', 'deps', 'lib'))
     try:
-        _libxc = np.ctypeslib.load_library(
-            'libxc', os.path.abspath(os.path.join(path, 'gpu4pyscf', 'lib', 'deps', 'lib')))
+        _libxc = np.ctypeslib.load_library('libxc', libxc_path)
     except Exception:
         _libxc = None
+
     if _libxc is not None:
         break
 
+libgdft = load_library('libgdft')
+libgdft.GDFT_xc_lda.argtypes = (
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_int,
+    ctypes.c_void_p,
+    POINTER(xc_lda_out_params),
+    POINTER(xc_lda_out_params))
+
+libgdft.GDFT_xc_gga.argtypes = (
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_int,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    POINTER(xc_gga_out_params),
+    POINTER(xc_gga_out_params))
+
+libgdft.GDFT_xc_mgga.argtypes = (
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_int,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    POINTER(xc_mgga_out_params),
+    POINTER(xc_mgga_out_params))
+
 if _libxc is None:
     import warnings
     warnings.warn(
@@ -51,6 +85,43 @@ if _libxc is None:
         `pip3 install gpu4pyscf-libxc-cuda12x`"
     )
 
+LDA_OUTPUT_LABELS = [
+                "zk",       # 1, 1
+                "vrho",     # 1, 2
+                "v2rho2",   # 1, 3
+                "v3rho3",   # 1, 4
+                "v4rho4"    # 1, 5
+            ]
+
+GGA_OUTPUT_LABELS = [
+                "zk",                                                               # 1, 1
+                "vrho", "vsigma",                                                   # 2, 3
+                "v2rho2", "v2rhosigma", "v2sigma2",                                 # 3, 6
+                "v3rho3", "v3rho2sigma", "v3rhosigma2", "v3sigma3",                 # 4, 10
+                "v4rho4", "v4rho3sigma", "v4rho2sigma2", "v4rhosigma3", "v4sigma4"  # 5, 15
+            ]
+
+MGGA_OUTPUT_LABELS =         [
+                "zk",                                                                # 1, 1
+                "vrho", "vsigma", "vlapl", "vtau",                                   # 4, 5
+                "v2rho2", "v2rhosigma", "v2rholapl", "v2rhotau", "v2sigma2",         # 10, 15
+                "v2sigmalapl", "v2sigmatau", "v2lapl2", "v2lapltau",  "v2tau2",
+                "v3rho3", "v3rho2sigma", "v3rho2lapl", "v3rho2tau", "v3rhosigma2",   # 20, 35
+                "v3rhosigmalapl", "v3rhosigmatau", "v3rholapl2", "v3rholapltau",
+                "v3rhotau2", "v3sigma3", "v3sigma2lapl", "v3sigma2tau",
+                "v3sigmalapl2", "v3sigmalapltau", "v3sigmatau2", "v3lapl3",
+                "v3lapl2tau", "v3lapltau2", "v3tau3",
+                "v4rho4", "v4rho3sigma", "v4rho3lapl", "v4rho3tau", "v4rho2sigma2",  # 35, 70
+                "v4rho2sigmalapl", "v4rho2sigmatau", "v4rho2lapl2", "v4rho2lapltau",
+                "v4rho2tau2", "v4rhosigma3", "v4rhosigma2lapl", "v4rhosigma2tau",
+                "v4rhosigmalapl2", "v4rhosigmalapltau", "v4rhosigmatau2",
+                "v4rholapl3", "v4rholapl2tau", "v4rholapltau2", "v4rhotau3",
+                "v4sigma4", "v4sigma3lapl", "v4sigma3tau", "v4sigma2lapl2",
+                "v4sigma2lapltau", "v4sigma2tau2", "v4sigmalapl3", "v4sigmalapl2tau",
+                "v4sigmalapltau2", "v4sigmatau3", "v4lapl4", "v4lapl3tau",
+                "v4lapl2tau2", "v4lapltau3", "v4tau4"
+            ]
+
 def _check_arrays(current_arrays, fields, sizes, factor, required):
     """
     A specialized function built to construct and check the sizes of arrays given to the LibXCFunctional class.
@@ -78,7 +149,6 @@ if _libxc is not None:
     _libxc.xc_func_init.argtypes = (_xc_func_p, ctypes.c_int, ctypes.c_int)
     _libxc.xc_func_end.argtypes = (_xc_func_p, )
     _libxc.xc_func_free.argtypes = (_xc_func_p, )
-    _libxc.xc_func_alloc()
 
 class XCfun:
     def __init__(self, xc, spin):
@@ -100,9 +170,9 @@ class XCfun:
     def __del__(self):
         if self.xc_func is None:
             return
-        # TODO: deallocate xc func
-        #_libxc.xc_func_end(self.xc_func)
-        #_libxc.xc_func_free(self.xc_func)
+        if _libxc is not None:
+            _libxc.xc_func_end(self.xc_func)
+            _libxc.xc_func_free(self.xc_func)
 
     def needs_laplacian(self):
         return dft.libxc.needs_laplacian(self.func_id)
@@ -128,14 +198,7 @@ class XCfun:
         if self._family == 'LDA':
             input_labels   = ["rho"]
             input_num_args = 1
-
-            output_labels = [
-                "zk",       # 1, 1
-                "vrho",     # 1, 2
-                "v2rho2",   # 1, 3
-                "v3rho3",   # 1, 4
-                "v4rho4"    # 1, 5
-            ]
+            output_labels = LDA_OUTPUT_LABELS
 
             # Build input args
             output = _check_arrays(output, output_labels[0:1], xc_func_sizes, npoints, do_exc)
@@ -151,18 +214,30 @@ class XCfun:
                 if(isinstance(arg, cupy.ndarray)):
                     arg = ctypes.cast(arg.data.ptr, ctypes.c_void_p)
                 cuda_args.append(arg)
-            _libxc.xc_lda(*cuda_args)
+            #_libxc.xc_lda(*cuda_args)
+
+            out_params = xc_lda_out_params()
+            buf_params = xc_lda_out_params()
+            buf = copy.deepcopy(output)
+            for i, label in enumerate(output_labels):
+                if output[label] is not None:
+                    setattr(buf_params, label, buf[label].data.ptr)
+                    setattr(out_params, label, output[label].data.ptr)
+            stream = cupy.cuda.get_current_stream()
+            err = libgdft.GDFT_xc_lda(
+                stream.ptr,
+                self.xc_func,
+                npoints,
+                inp['rho'].data.ptr,
+                ctypes.byref(out_params),
+                ctypes.byref(buf_params)
+            )
+            if err != 0:
+                raise RuntimeError('Failed in xc_gga')
         elif self._family == 'GGA':
             input_labels   = ["rho", "sigma"]
             input_num_args = 2
-
-            output_labels = [
-                "zk",                                                               # 1, 1
-                "vrho", "vsigma",                                                   # 2, 3
-                "v2rho2", "v2rhosigma", "v2sigma2",                                 # 3, 6
-                "v3rho3", "v3rho2sigma", "v3rhosigma2", "v3sigma3",                 # 4, 10
-                "v4rho4", "v4rho3sigma", "v4rho2sigma2", "v4rhosigma3", "v4sigma4"  # 5, 15
-            ]
+            output_labels = GGA_OUTPUT_LABELS
 
             # Build input args
             output = _check_arrays(output, output_labels[0:1], xc_func_sizes, npoints, do_exc)
@@ -178,7 +253,28 @@ class XCfun:
                 if(isinstance(arg, cupy.ndarray)):
                     arg = ctypes.cast(arg.data.ptr, ctypes.c_void_p)
                 cuda_args.append(arg)
-            _libxc.xc_gga(*cuda_args)
+            #_libxc.xc_gga(*cuda_args)
+
+            out_params = xc_gga_out_params()
+            buf_params = xc_gga_out_params()
+            buf = copy.deepcopy(output)
+            for i, label in enumerate(output_labels):
+                if output[label] is not None:
+                    setattr(buf_params, label, buf[label].data.ptr)
+                    setattr(out_params, label, output[label].data.ptr)
+
+            stream = cupy.cuda.get_current_stream()
+            err = libgdft.GDFT_xc_gga(
+                stream.ptr,
+                self.xc_func,
+                npoints,
+                inp['rho'].data.ptr,
+                inp['sigma'].data.ptr,
+                ctypes.byref(out_params),
+                ctypes.byref(buf_params)
+            )
+            if err != 0:
+                raise RuntimeError('Failed in xc_gga')
 
         elif self._family == 'MGGA':
             # Build input args
@@ -187,27 +283,7 @@ class XCfun:
             else:
                 input_labels = ["rho", "sigma", "tau"]
             input_num_args = 4
-
-            output_labels = [
-                "zk",                                                                # 1, 1
-                "vrho", "vsigma", "vlapl", "vtau",                                   # 4, 5
-                "v2rho2", "v2rhosigma", "v2rholapl", "v2rhotau", "v2sigma2",         # 10, 15
-                "v2sigmalapl", "v2sigmatau", "v2lapl2", "v2lapltau",  "v2tau2",
-                "v3rho3", "v3rho2sigma", "v3rho2lapl", "v3rho2tau", "v3rhosigma2",   # 20, 35
-                "v3rhosigmalapl", "v3rhosigmatau", "v3rholapl2", "v3rholapltau",
-                "v3rhotau2", "v3sigma3", "v3sigma2lapl", "v3sigma2tau",
-                "v3sigmalapl2", "v3sigmalapltau", "v3sigmatau2", "v3lapl3",
-                "v3lapl2tau", "v3lapltau2", "v3tau3",
-                "v4rho4", "v4rho3sigma", "v4rho3lapl", "v4rho3tau", "v4rho2sigma2",  # 35, 70
-                "v4rho2sigmalapl", "v4rho2sigmatau", "v4rho2lapl2", "v4rho2lapltau",
-                "v4rho2tau2", "v4rhosigma3", "v4rhosigma2lapl", "v4rhosigma2tau",
-                "v4rhosigmalapl2", "v4rhosigmalapltau", "v4rhosigmatau2",
-                "v4rholapl3", "v4rholapl2tau", "v4rholapltau2", "v4rhotau3",
-                "v4sigma4", "v4sigma3lapl", "v4sigma3tau", "v4sigma2lapl2",
-                "v4sigma2lapltau", "v4sigma2tau2", "v4sigmalapl3", "v4sigmalapl2tau",
-                "v4sigmalapltau2", "v4sigmatau3", "v4lapl4", "v4lapl3tau",
-                "v4lapl2tau2", "v4lapltau3", "v4tau4"
-            ]
+            output_labels = MGGA_OUTPUT_LABELS
 
             # Build input args
             output = _check_arrays(output, output_labels[0:1], xc_func_sizes, npoints, do_exc)
@@ -226,10 +302,31 @@ class XCfun:
                 if(isinstance(arg, cupy.ndarray)):
                     arg = ctypes.cast(arg.data.ptr, ctypes.c_void_p)
                 cuda_args.append(arg)
-            _libxc.xc_mgga(*cuda_args)
+            #_libxc.xc_mgga(*cuda_args)
+
+            out_params = xc_mgga_out_params()
+            buf_params = xc_mgga_out_params()
+            buf = copy.deepcopy(output)
+            for i, label in enumerate(output_labels):
+                if output[label] is not None:
+                    setattr(buf_params, label, buf[label].data.ptr)
+                    setattr(out_params, label, output[label].data.ptr)
+            stream = cupy.cuda.get_current_stream()
+            err = libgdft.GDFT_xc_mgga(
+                stream.ptr,
+                self.xc_func,
+                npoints,
+                inp['rho'].data.ptr,
+                inp['sigma'].data.ptr,
+                cupy.empty(1).data.ptr,
+                inp['tau'].data.ptr,
+                ctypes.byref(out_params),
+                ctypes.byref(buf_params)
+            )
+            if err != 0:
+                raise RuntimeError('Failed in xc_mgga')
         else:
             raise KeyError("Functional kind not recognized!")
 
         return {k: v for k, v in zip(output_labels, args[2+input_num_args:]) if v is not None}
 
-

{gpu4pyscf-1.0 → gpu4pyscf-1.0.2}/gpu4pyscf/dft/libxc_structs.py

@@ -24,6 +24,14 @@ Modified source code from libXC
 import ctypes
 import numpy as np
 
+XC_FAMILY_LDA     =      1
+XC_FAMILY_GGA     =      2
+XC_FAMILY_MGGA    =      4
+XC_FAMILY_LCA     =      8
+XC_FAMILY_OEP     =     16
+XC_FAMILY_HYB_GGA =     32
+XC_FAMILY_HYB_MGGA=     64
+XC_FAMILY_HYB_LDA =    128
 
 class func_reference_type(ctypes.Structure):
     """
@@ -78,7 +86,7 @@ class xc_dimensions(ctypes.Structure):
          ("vrho", ctypes.c_int),
          ("vsigma", ctypes.c_int),
          ("vlapl", ctypes.c_int),
-         ("vtau", ctypes.c_int),
+         ("vtau", ctypes.c_int), 
 
          ("v2rho2", ctypes.c_int),
          ("v2rhosigma", ctypes.c_int),
@@ -146,7 +154,7 @@ class xc_dimensions(ctypes.Structure):
          ("v4lapl3tau", ctypes.c_int),
          ("v4lapl2tau2", ctypes.c_int),
          ("v4lapltau3", ctypes.c_int),
-         ("v4tau4", ctypes.c_int),]
+         ("v4tau4", ctypes.c_int)]
 
 
 class xc_func_type(ctypes.Structure):
@@ -162,10 +170,9 @@ class xc_func_type(ctypes.Structure):
         ("mix_coef", ctypes.POINTER(ctypes.c_double)),
 
         # Hybrids
-        ("hyb_number_terms", ctypes.c_int),
-        ("hyb_type", ctypes.POINTER(ctypes.c_int)),
-        ("hyb_coeff", ctypes.POINTER(ctypes.c_double)),
-        ("hyb_omega", ctypes.POINTER(ctypes.c_double)),
+        ("cam_omega", ctypes.c_double),
+        ("cam_alpha", ctypes.c_double),
+        ("cam_beta", ctypes.c_double),
 
         # VV10
         ("nlc_b", ctypes.c_double),
@@ -174,6 +181,126 @@ class xc_func_type(ctypes.Structure):
         ("dim", xc_dimensions),
 
         # parameters
+        ("ext_params", ctypes.POINTER(ctypes.c_double)),
         ("params", ctypes.c_void_p),  # void *params;
+        
         ("dens_threshold", ctypes.c_double),
+        ("zeta_threshold", ctypes.c_double),
+        ("sigma_threshold", ctypes.c_double),
+        ("tau_threshold", ctypes.c_double)
+    ]
+
+class xc_lda_out_params(ctypes.Structure):
+    """
+    Holds the output parameters for LDA functions
+    """
+    _fields_ = [
+        ("zk", ctypes.c_void_p),
+        ("vrho", ctypes.c_void_p),
+        ("v2rho2", ctypes.c_void_p),
+        ("v3rho3", ctypes.c_void_p),
+        ("v4rho4", ctypes.c_void_p),
+    ]
+
+class xc_gga_out_params(ctypes.Structure):
+    """
+    Holds the output parameters for GGA functions
+    """
+    _fields_ = [
+        ("zk", ctypes.c_void_p),
+        ("vrho", ctypes.c_void_p),
+        ("vsigma", ctypes.c_void_p),
+        ("v2rho2", ctypes.c_void_p),
+        ("v2rhosigma", ctypes.c_void_p),
+        ("v2sigma2", ctypes.c_void_p),
+        ("v3rho3", ctypes.c_void_p),
+        ("v3rho2sigma", ctypes.c_void_p),
+        ("v3rhosigma2", ctypes.c_void_p),
+        ("v3sigma3", ctypes.c_void_p),
+        ("v4rho4", ctypes.c_void_p),
+        ("v4rho3sigma", ctypes.c_void_p),
+        ("v4rho2sigma2", ctypes.c_void_p),
+        ("v4rhosigma3", ctypes.c_void_p),
+        ("v4sigma4", ctypes.c_void_p),
+    ]
+
+class xc_mgga_out_params(ctypes.Structure):
+    """
+    Holds the output parameters for MGGA functions
+    """
+    _fields_ = [
+        ("zk", ctypes.c_void_p),
+
+        ("vrho", ctypes.c_void_p),
+        ("vsigma", ctypes.c_void_p),
+        ("vlapl", ctypes.c_void_p),
+        ("vtau", ctypes.c_void_p),
+
+        ("v2rho2", ctypes.c_void_p),
+        ("v2rhosigma", ctypes.c_void_p),
+        ("v2rholapl", ctypes.c_void_p),
+        ("v2rhotau", ctypes.c_void_p),
+        ("v2sigma2", ctypes.c_void_p),
+        ("v2sigmalapl", ctypes.c_void_p),
+        ("v2sigmatau", ctypes.c_void_p),
+        ("v2lapl2", ctypes.c_void_p),
+        ("v2lapltau", ctypes.c_void_p),
+        ("v2tau2", ctypes.c_void_p),
+
+        ("v3rho3", ctypes.c_void_p),
+        ("v3rho2sigma", ctypes.c_void_p),
+        ("v3rho2lapl", ctypes.c_void_p),
+        ("v3rho2tau", ctypes.c_void_p),
+        ("v3rhosigma2", ctypes.c_void_p),
+        ("v3rhosigmalapl", ctypes.c_void_p),
+        ("v3rhosigmatau", ctypes.c_void_p),
+        ("v3rholapl2", ctypes.c_void_p),
+        ("v3rholapltau", ctypes.c_void_p),
+        ("v3rhotau2", ctypes.c_void_p),
+        ("v3sigma3", ctypes.c_void_p),
+        ("v3sigma2lapl", ctypes.c_void_p),
+        ("v3sigma2tau", ctypes.c_void_p),
+        ("v3sigmalapl2", ctypes.c_void_p),
+        ("v3sigmalapltau", ctypes.c_void_p),
+        ("v3sigmatau2", ctypes.c_void_p),
+        ("v3lapl3", ctypes.c_void_p),
+        ("v3lapl2tau", ctypes.c_void_p),
+        ("v3lapltau2", ctypes.c_void_p),
+        ("v3tau3", ctypes.c_void_p),
+
+        ("v4rho4", ctypes.c_void_p),
+        ("v4rho3sigma", ctypes.c_void_p),
+        ("v4rho3lapl", ctypes.c_void_p),
+        ("v4rho3tau", ctypes.c_void_p),
+        ("v4rho2sigma2", ctypes.c_void_p),
+        ("v4rho2sigmalapl", ctypes.c_void_p),
+        ("v4rho2sigmatau", ctypes.c_void_p),
+        ("v4rho2lapl2", ctypes.c_void_p),
+        ("v4rho2lapltau", ctypes.c_void_p),
+        ("v4rho2tau2", ctypes.c_void_p),
+        ("v4rhosigma3", ctypes.c_void_p),
+        ("v4rhosigma2lapl", ctypes.c_void_p),
+        ("v4rhosigma2tau", ctypes.c_void_p),
+        ("v4rhosigmalapl2", ctypes.c_void_p),
+        ("v4rhosigmalapltau", ctypes.c_void_p),
+        ("v4rhosigmatau2", ctypes.c_void_p),
+        ("v4rholapl3", ctypes.c_void_p),
+        ("v4rholapl2tau", ctypes.c_void_p),
+        ("v4rholapltau2", ctypes.c_void_p),
+        ("v4rhotau3", ctypes.c_void_p),
+        ("v4sigma4", ctypes.c_void_p),
+        ("v4sigma3lapl", ctypes.c_void_p),
+        ("v4sigma3tau", ctypes.c_void_p),
+        ("v4sigma2lapl2", ctypes.c_void_p),
+        ("v4sigma2lapltau", ctypes.c_void_p),
+        ("v4sigma2tau2", ctypes.c_void_p),
+        ("v4sigmalapl3", ctypes.c_void_p),
+        ("v4sigmalapl2tau", ctypes.c_void_p),
+        ("v4sigmalapltau2", ctypes.c_void_p),
+        ("v4sigmatau3", ctypes.c_void_p),
+        ("v4lapl4", ctypes.c_void_p),
+        ("v4lapl3tau", ctypes.c_void_p),
+        ("v4lapl2tau2", ctypes.c_void_p),
+        ("v4lapltau3", ctypes.c_void_p),
+        ("v4tau4", ctypes.c_void_p),
     ]