fcdft 1.0.2__tar.gz → 1.1.4__tar.gz

{fcdft-1.0.2 → fcdft-1.1.4}/MANIFEST.in

@@ -2,3 +2,4 @@ include MANIFEST.in
 
 recursive-include fcdft/lib *.so *.c *.pyx *.h CMakeLists.txt dft
 recursive-include fcdft/wbl *.npy
+recursive-include fcdft/solvent *.json

fcdft-1.1.4/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: fcdft
+Version: 1.1.4
+License-File: LICENSE
+License-File: AUTHORS
+Dynamic: license-file

fcdft-1.1.4/fcdft/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.1.4'

{fcdft-1.0.2 → fcdft-1.1.4}/fcdft/df/df_jk.py

@@ -4,6 +4,12 @@ from pyscf.df import df_jk
 from pyscf import lib
 from pyscf.lib import logger
 from fcdft import wbl
+import ctypes
+import os
+import fcdft
+from pyscf.lib.numpy_helper import _dgemm
+
+libdf = lib.load_library(os.path.join(fcdft.__path__[0], 'lib', 'libdf'))
 
 def density_fit(mf, auxbasis=None, with_df=None, only_dfj=False):
     from pyscf import df
@@ -128,13 +134,71 @@ def get_j(dfobj, dm, hermi=0, direct_scf_tol=1e-13):
     logger.timer(dfobj, 'df-vj', *t0)
     return numpy.asarray(vj).reshape(dm_shape)
 
+# numpy.einsum replaced by custom dgemm for computational efficiency. 
+def get_jk(dfobj, dm, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-13):
+    assert (with_j or with_k)
+    if (not with_k and not dfobj.mol.incore_anyway and
+        # 3-center integral tensor is not initialized
+        dfobj._cderi is None):
+        return get_j(dfobj, dm, hermi, direct_scf_tol), None
+
+    t0 = t1 = (logger.process_clock(), logger.perf_counter())
+    log = logger.Logger(dfobj.stdout, dfobj.verbose)
+
+    dms = numpy.asarray(dm)
+    dm_shape = dms.shape
+    nao = dm_shape[-1]
+    dms = dms.reshape(-1,nao,nao)
+    nset = dms.shape[0]
+    vj = 0
+    vk = numpy.zeros_like(dms)
+
+    fdrv = libdf.nr_mapdm1
+
+    if numpy.iscomplexobj(dms):
+        if with_j:
+            vj = numpy.zeros_like(dms)
+        max_memory = dfobj.max_memory - lib.current_memory()[0]
+        blksize = max(4, int(min(dfobj.blockdim, max_memory*.22e6/8/nao**2)))
+        buf = numpy.empty((blksize,nao,nao))
+        for eri1 in dfobj.loop(blksize):
+            naux, nao_pair = eri1.shape
+            eri1 = lib.unpack_tril(eri1, out=buf)
+            if with_j:
+                tmp = numpy.tensordot(eri1, dms.real, axes=([1,2],[2,1]))
+                vj.real += numpy.tensordot(tmp.T, eri1, axes=([1],[0]))
+                tmp = numpy.tensordot(eri1, dms.imag, axes=([1,2],[2,1]))
+                vj.imag += numpy.tensordot(tmp.T, eri1, axes=([1],[0]))
+            buf2 = numpy.empty((naux,nao,nao), dtype=numpy.float64, order='C')
+            for k in range(nset):
+                dmsRe = numpy.asarray(dms[k].real, dtype=numpy.float64, order='C')
+                dmsIm = numpy.asarray(dms[k].imag, dtype=numpy.float64, order='C')
+                fdrv(buf2.ctypes.data_as(ctypes.c_void_p),
+                     eri1.ctypes.data_as(ctypes.c_void_p),
+                     dmsRe.ctypes.data_as(ctypes.c_void_p),
+                     ctypes.c_int(nao), ctypes.c_int(naux))
+                vk[k].real += numpy.tensordot(buf2, eri1, axes=([0,2],[0,1]))
+                fdrv(buf2.ctypes.data_as(ctypes.c_void_p),
+                     eri1.ctypes.data_as(ctypes.c_void_p),
+                     dmsIm.ctypes.data_as(ctypes.c_void_p),
+                     ctypes.c_int(nao), ctypes.c_int(naux))
+                vk[k].imag += numpy.tensordot(buf2, eri1, axes=([0,2],[0,1]))
+            t1 = log.timer_debug1('jk', *t1)
+        if with_j: vj = vj.reshape(dm_shape)
+        if with_k: vk = vk.reshape(dm_shape)
+        logger.timer(dfobj, 'df vj and vk', *t0)
+        return vj, vk
+
+    else:
+        return df_jk.get_jk(dfobj, dm, hermi, with_j, with_k, direct_scf_tol)
+
 class _DFHF(df_jk._DFHF):
     def get_jk(self, mol=None, dm=None, hermi=0, with_j=True, with_k=True, omega=None):
         if dm is None: dm = self.make_rdm1()
         if not with_k:
             return get_j(self.with_df, dm, hermi, self.direct_scf_tol), None
         else:
-            return super().get_jk(mol, dm, hermi, with_j, with_k, omega)
+            return get_jk(self.with_df, dm, hermi, with_j, with_k, self.direct_scf_tol)
 
     def nuc_grad_method(self):
         from fcdft.df.grad import rks, uks
@@ -152,4 +216,3 @@ class _DFHF(df_jk._DFHF):
     
     def to_gpu(self):
         raise NotImplementedError
-

{fcdft-1.0.2 → fcdft-1.1.4}/fcdft/df/grad/rks.py

@@ -15,7 +15,7 @@ LINEAR_DEP_THRESHOLD = LINEAR_DEP_THR
 
 def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
            decompose_j2c='CD', lindep=LINEAR_DEP_THRESHOLD):
-    """Copied from pyscf.df.grad.rhf and modified some parts to allow complex density matrix."""
+    """Copied from pyscf.df.grad.rhf and some parts modified to handle complex density matrices."""
     assert (with_j or with_k)
     if not with_k:
         return get_j (mf_grad, mol=mol, dm=dm, hermi=hermi), None
@@ -57,7 +57,7 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
     vk = numpy.zeros((nset,3,nao,nao), dtype=numpy.complex128)
     get_int3c_ip1 = df_rhf_grad._int3c_wrapper(mol, auxmol, 'int3c2e_ip1', 's1')
     max_memory = mf_grad.max_memory - lib.current_memory()[0]
-    blksize = int(min(max(max_memory * .5e6/8 / (nao**2*3), 20), naux, 240))
+    blksize = int(min(max(max_memory * .5e6/8 / (nao**2*3), 20), naux, 80)) # 240 -> 80 for handling complex128
     ao_ranges = df_rhf_grad.balance_partition(aux_loc, blksize)
     fmmm = _ao2mo.libao2mo.AO2MOmmm_bra_nr_s1 # MO output index slower than AO output index; input AOs are asymmetric
     fdrv = _ao2mo.libao2mo.AO2MOnr_e2_drv # comp and aux indices are slower
@@ -74,10 +74,11 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
             vj[i,1] += numpy.dot (rhoj[i,p0:p1], int3c[1].reshape (p1-p0, -1)).reshape (nao, nao).T
             vj[i,2] += numpy.dot (rhoj[i,p0:p1], int3c[2].reshape (p1-p0, -1)).reshape (nao, nao).T
             t2 = logger.timer_debug1 (mf_grad, "df grad einsum rho_P (P|mn') rho_P", *t2)
+            tmp = numpy.empty ((3,p1-p0,nocc[i],nao), dtype=numpy.complex128)
             tmpRe = numpy.empty ((3,p1-p0,nocc[i],nao), dtype=numpy.float64)
             tmpIm = numpy.empty ((3,p1-p0,nocc[i],nao), dtype=numpy.float64)
             orbolRe = numpy.asarray(orbol[i].real, order='F')
-            orbolIm = numpy.asarray(orbol[i].imag, order='F')            
+            orbolIm = numpy.asarray(orbol[i].imag, order='F')
             fdrv(ftrans, fmmm, # lib.einsum ('xpmn,mi->xpin', int3c, orbol[i])
                  tmpRe.ctypes.data_as(ctypes.c_void_p),
                  int3c.ctypes.data_as(ctypes.c_void_p),
@@ -85,6 +86,7 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
                  ctypes.c_int (3*(p1-p0)), ctypes.c_int (nao),
                  (ctypes.c_int*4)(0, nocc[i], 0, nao),
                  null, ctypes.c_int(0))
+            orbolRe = None
             fdrv(ftrans, fmmm, # lib.einsum ('xpmn,mi->xpin', int3c, orbol[i])
                  tmpIm.ctypes.data_as(ctypes.c_void_p),
                  int3c.ctypes.data_as(ctypes.c_void_p),
@@ -92,10 +94,13 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
                  ctypes.c_int (3*(p1-p0)), ctypes.c_int (nao),
                  (ctypes.c_int*4)(0, nocc[i], 0, nao),
                  null, ctypes.c_int(0))
-            tmp = tmpRe + 1.0j * tmpIm
+            # tmp = tmpRe + 1.0j * tmpIm
+            orbolIm = None
+            tmp.real, tmp.imag = tmpRe, tmpIm
+            tmpRe = tmpIm = None
             t2 = logger.timer_debug1 (mf_grad, "df grad einsum (P|mn') u_mi = dg_Pin", *t2)
             rhok = get_rhok (i, p0, p1)
-            vk[i] += lib.einsum('xpoi,pok->xik', tmp, rhok)
+            vk[i] += numpy.tensordot(tmp, rhok, axes=([1,2],[0,1]))
             t2 = logger.timer_debug1 (mf_grad, "df grad einsum D_Pim dg_Pin = v_ij", *t2)
             rhok = tmp = None
         int3c = None
@@ -114,10 +119,12 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
     # dPiu C_uj -> dPij. *Not* symmetric i<->j: "i" has an occupancy
     # factor and "j" must not.
     max_memory = mf_grad.max_memory - lib.current_memory()[0]
-    blksize = int(min(max(max_memory * .5e6/8 / (nao*max (nocc)), 20), naux))
+    # blksize = int(min(max(max_memory * .5e6/8 / (nao*max (nocc)), 20), naux))
+    # In principe, all occupation numbers are non-zero for open quantum systems.
+    blksize = int(min(max(max_memory * .5e6/8 / (nao*nao), 20), naux) / 3) # Divided by 3 for handling complex128
     rhok_oo = []
     for i, j in product (range (nset), repeat=2):
-        tmp = numpy.empty ((naux,nocc[i],nocc[j]), numpy.complex128)
+        tmp = numpy.empty ((naux,nocc[i],nocc[j]), dtype=numpy.complex128)
         for p0, p1 in lib.prange(0, naux, blksize):
             rhok = get_rhok (i, p0, p1).reshape ((p1-p0)*nocc[i], nao)
             tmp[p0:p1] = lib.dot (rhok, orbol[j]).reshape (p1-p0, nocc[i], nocc[j])
@@ -147,8 +154,9 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
         #                  Here, the sparse matrix int3c is transformed into the smaller MO
         #                  basis. The latter approach is obviously more performant.
         for i in range (nset):
-            bufRe = numpy.empty ((3, p1-p0, nocc[i], nao), dtype=numpy.float64)
-            bufIm = numpy.empty ((3, p1-p0, nocc[i], nao), dtype=numpy.float64)
+            buf = numpy.empty((3, p1-p0, nocc[i], nao), dtype=numpy.complex128)
+            bufRe = numpy.empty((3, p1-p0, nocc[i], nao), dtype=numpy.float64)
+            bufIm = numpy.empty((3, p1-p0, nocc[i], nao), dtype=numpy.float64)
             orbolRe = numpy.asarray(orbol[i].real, order='F')
             orbolIm = numpy.asarray(orbol[i].imag, order='F')
             fdrv(ftrans, fmmm, # lib.einsum ('pmn,ni->pim', int3c, orbol[i])
@@ -165,14 +173,18 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
                     ctypes.c_int (3*(p1-p0)), ctypes.c_int (nao),
                     (ctypes.c_int*4)(0, nocc[i], 0, nao),
                     null, ctypes.c_int(0))
-            buf = bufRe + 1.0j * bufIm
+            buf.real, buf.imag = bufRe, bufIm
             for j in range (nset): # lib.einsum ('pim,mj->pij', buf, orbor[j])
                 int3c_ij = lib.dot (buf.reshape (-1, nao), orbor[j])
                 int3c_ij = int3c_ij.reshape (3, p1-p0, nocc[i], nocc[j])
                 rhok_oo_ij = rhok_oo[(i*nset)+j][p0:p1]
                 vkaux[i,j,:,p0:p1] += lib.einsum('xpij,pij->xp', int3c_ij,
                                                  rhok_oo_ij)
+        int3c = None
         t2 = logger.timer_debug1 (mf_grad, "df grad vk aux (P'|mn) eval", *t2)
+    orbol = orbor = None
+    buf = bufRe = bufIm = orbolRe = orbolIm = None
+    dm_tril = None
     int3c = tmp = None
     t1 = logger.timer_debug1 (mf_grad, "df grad vj and vk aux (P'|mn) eval", *t1)
 
@@ -182,7 +194,9 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
     for i, j in product (range (nset), repeat=2):
         k = (i*nset) + j
         l = (j*nset) + i
-        tmp = lib.einsum('pij,qji->pq', rhok_oo[k], rhok_oo[l])
+        tmp = numpy.zeros((naux,naux), dtype=numpy.complex128)
+        for p0, p1 in lib.prange(0, nao, blksize):
+            tmp += numpy.tensordot(rhok_oo[k][:,p0:p1,:], rhok_oo[l][:,:,p0:p1], axes=([1,2], [2,1]))
         vkaux[i,j] -= lib.einsum('xpq,pq->xp', int2c_e1, tmp)
     t1 = logger.timer_debug1 (mf_grad, "df grad vj and vk aux (P'|Q) eval", *t1)
 
@@ -229,7 +243,7 @@ def get_j(mf_grad, mol=None, dm=None, hermi=0):
 
     aux_loc = auxmol.ao_loc
     max_memory = mf_grad.max_memory - lib.current_memory()[0]
-    blksize = int(min(max(max_memory * .5e6/8 / (nao**2*3), 20), naux, 240))
+    blksize = int(min(max(max_memory * .5e6/8 / (nao**2*3), 20), naux, 80)) # 240 -> 80 for handling complex128
     ao_ranges = df_rhf_grad.balance_partition(aux_loc, blksize)    
 
     # (ij|P), (nao, nao, naux)
@@ -292,7 +306,7 @@ def _cho_solve_rhojk (mf_grad, mol, auxmol, orbol, orbor,
     f_rhok = lib.H5TmpFile()
     t1 = (logger.process_clock (), logger.perf_counter ())
     max_memory = mf_grad.max_memory - lib.current_memory()[0]
-    blksize = max_memory * .5e6/8 / (naux*nao)
+    blksize = max_memory * .5e6/8 / (naux*nao) / 3 # Divided by 3 for handling complex128 safely (complex + buffer)
     mol_ao_ranges = df_rhf_grad.balance_partition(ao_loc, blksize)
     nsteps = len(mol_ao_ranges)
     t2 = t1

fcdft-1.1.4/fcdft/dft/gen_grid.py

@@ -0,0 +1,88 @@
+import numpy
+from pyscf.dft import gen_grid
+from pyscf.dft import radi
+from pyscf.lib import logger
+from fcdft.gto.mole import split_mol
+import ipdb
+
+# Grid for equilibrium DFT object.
+
+def get_partition(mol, atom_slice, *args, **kwargs):
+    mol1, mol2 = split_mol(mol, atom_slice)
+    coords1, weights1 = gen_grid.get_partition(mol1, *args, **kwargs)
+    coords2, weights2 = gen_grid.get_partition(mol2, *args, **kwargs)
+    coords_all = [coords1, coords2]
+    weights_all = [weights1, weights2]
+    return coords_all, weights_all
+
+class Grids(gen_grid.Grids):
+    _keys = {'atom_slice'}
+
+    def __init__(self, mol, atom_slice):
+        gen_grid.Grids.__init__(self, mol)
+        self.atom_slice = atom_slice
+
+    def build(self, mol=None, with_non0tab=False, sort_grids=True, **kwargs):
+        if mol is None: mol = self.mol
+        if self.verbose >= logger.WARN:
+            self.check_sanity()
+        atom_grids_tab = self.gen_atomic_grids(
+            mol, self.atom_grid, self.radi_method, self.level, self.prune, **kwargs)
+        self.coords, self.weights = self.get_partition(
+            mol, self.atom_slice, atom_grids_tab, self.radii_adjust, self.atomic_radii, self.becke_scheme)
+        mol1, mol2 = split_mol(mol, self.atom_slice)
+        mol = [mol1, mol2]
+        atm_idx1 = numpy.empty(self.coords[0].shape[0], dtype=numpy.int32)
+        atm_idx2 = numpy.empty(self.coords[1].shape[0], dtype=numpy.int32)
+        atm_idx = [atm_idx1, atm_idx2]
+        quad_weights1 = numpy.empty(self.coords[0].shape[0])
+        quad_weights2 = numpy.empty(self.coords[1].shape[0])
+        quadrature_weights = [quad_weights1, quad_weights2]
+        for i in range(2):
+            p0 = p1 = 0
+            for ia in range(mol[i].natm):
+                r, vol = atom_grids_tab[mol[i].atom_symbol(ia)]
+                p0, p1 = p1, p1 + vol.size
+                atm_idx[i][p0:p1] = ia
+                quadrature_weights[i][p0:p1] = vol
+        self.atm_idx = atm_idx
+        self.quadrature_weights = quadrature_weights
+        if sort_grids:
+            for i in range(2):
+                idx = gen_grid.arg_group_grids(mol[i], self.coords[i])
+                self.coords[i] = self.coords[i][idx]
+                self.weights[i] = self.weights[i][idx]
+                self.atm_idx[i] = self.atm_idx[i][idx]
+                self.quadrature_weights[i] = self.quadrature_weights[i][idx]
+        # ??
+        if self.alignment > 1:
+            padding = gen_grid._padding_size(self.size, self.alignment)
+            logger.debug(self, 'Padding %d grids', padding)
+            if padding > 0:
+                self.coords = numpy.vstack(
+                    [self.coords, numpy.repeat([[1e-4]*3], padding, axis=0)])
+                self.weights = numpy.hstack([self.weights, numpy.zeros(padding)])
+                self.atm_idx = numpy.hstack([self.atm_idx, numpy.full(padding, -1, dtype=numpy.int32)])
+                self.quadrature_weights = numpy.hstack([self.quadrature_weights, numpy.zeros(padding)])
+        if with_non0tab:
+            non0tab = []
+            for i in range(2):
+                non0tab.append(self.make_mask(mol[i], self.coords[i]))
+            self.non0tab = non0tab
+            self.screen_index = self.non0tab
+        else:
+            self.screen_index = self.non0tab = None
+        logger.info(self, 'tot grids = %d', len(self.weights[0]) + len(self.weights[1]))
+        return self
+    
+    def kernel(self, **kwargs):
+        self.dump_flags()
+        return self.build(**kwargs)
+
+    def get_partition(self, mol, atom_slice, atom_grids_tab=None,
+                      radii_adjust=None, atomic_radii=radi.BRAGG_RADII,
+                      becke_scheme=gen_grid.original_becke, concat=True):
+        if atom_grids_tab is None:
+            atom_grids_tab = self.gen_atomic_grids(mol)
+        return get_partition(mol, atom_slice, atom_grids_tab, radii_adjust, atomic_radii,
+                             becke_scheme, concat=concat)

{fcdft-1.0.2 → fcdft-1.1.4}/fcdft/grad/rks.py

@@ -42,10 +42,10 @@ def grad_elec(mf_grad, mo_energy=None, mo_coeff=None, mo_occ=None, atmlst=None):
     for k, ia in enumerate(atmlst):
         p0, p1 = aoslices [ia,2:]
         h1ao = hcore_deriv(ia)
-        de[k] += numpy.einsum('xij,ij->x', h1ao, dm0)
+        de[k] += numpy.tensordot(h1ao, dm0, axes=([1,2], [0,1]))
 # nabla was applied on bra in vhf, *2 for the contributions of nabla|ket>
-        de[k] += numpy.einsum('xij,ij->x', vhf[:,p0:p1], dm0[p0:p1]) * 2
-        de[k] -= numpy.einsum('xij,ij->x', s1[:,p0:p1], dme0[p0:p1]) * 2
+        de[k] += numpy.tensordot(vhf[:,p0:p1], dm0[p0:p1], axes=([1,2], [0,1])) * 2
+        de[k] -= numpy.tensordot(s1[:,p0:p1], dme0[p0:p1], axes=([1,2], [0,1])) * 2
 
         de[k] += mf_grad.extra_force(ia, locals())
 

fcdft-1.1.4/fcdft/gto/mole.py

@@ -0,0 +1,110 @@
+from pyscf.gto.mole import Mole
+from pyscf.lib import logger
+
+# def split_env(mol, atm, bas, env, atom_id):
+#     symbols = [mol.atom_symbol(i) for i in range(mol.natm)]
+#     sym1 = symbols[:atom_id]
+#     from pyscf.gto.mole import make_bas_env
+#     len_env = 0
+#     for symb, basis_add in mol._basis.items():
+#         if symb in sym1:
+#             _, env0 = make_bas_env(basis_add, 0, 0)
+#             len_env += len(env0)
+
+#     env1, env2 = [numpy.zeros(PTR_ENV_START)], [numpy.zeros(PTR_ENV_START)]
+#     env1.append(env[PTR_ENV_START:PTR_ENV_START+4*atom_id])
+#     env2.append(env[PTR_ENV_START+4*atom_id:PTR_ENV_START+4*len(atm)])
+#     env1, env2 = env[:len_env], env[len_env:]
+#     idx = numpy.where(bas[:,0] == atom_id)[0][0]
+#     bas1, bas2 = bas[:idx].copy(), bas[idx:].copy()
+#     off = len(env1)
+#     natm_off = atom_id
+#     atm1, atm2 = atm[:atom_id].copy(), atm[atom_id:].copy()
+#     atm2[:,PTR_COORD] -= off
+#     atm2[:,PTR_ZETA ] -= off
+#     bas2[:,ATOM_OF  ] -= natm_off
+#     bas2[:,PTR_EXP  ] -= off
+#     bas2[:,PTR_COEFF] -= off
+#     return atm1, bas1, env1, atm2, bas2, env2
+
+def conc_mol(mol1, mol2):
+    from pyscf.gto import mole
+    mol = mole.conc_mol(mol1, mol2)
+    if mol1.basis == mol2.basis:
+        mol.basis = mol1.basis
+    return mol
+
+def split_mol(mol, atom_id):
+    '''Split the molecule into two Mole objects.
+    Reverse of conc_mol in pyscf.gto.mole
+    '''
+    if not mol._built:
+        logger.warn(mol, 'Warning: object %s not initialized. Initializing %s',
+                    mol, mol)
+        mol.build()
+
+    # TODO: mol.stdout for logger
+    mol1, mol2 = Mole(), Mole()
+    mol1.basis = mol2.basis = mol.basis
+    mol1.verbose = mol2.verbose = mol.verbose
+    mol1.stdout = mol2.stdout = mol.stdout
+    mol1.output = mol2.output = mol.output
+    mol1.max_memory = mol2.max_memory = mol.max_memory
+    mol1.spin = mol2.spin = 0
+    mol1.symmetry = mol2.symmetry = False
+    mol1.symmetry_subgroup = mol2.symmetry_subgroup = None
+    mol1.cart = mol2.cart = mol.cart
+    mol1._atom = mol._atom[:atom_id]
+    mol2._atom = mol._atom[atom_id:]
+    mol1.unit = mol2.unit = 'Bohr'
+    mol1.build(), mol2.build()
+
+    return mol1, mol2
+
+if __name__=='__main__':
+    from pyscf import gto
+    mol1 = gto.M(
+        atom='''
+C       -1.1367537947      0.1104289172      2.4844663896
+C       -1.1385831318      0.1723328088      3.8772156394
+C        0.0819843127      0.0788096973      1.7730802291
+H       -2.0846565855      0.1966185690      4.4236084687
+C        0.0806058727      0.2041086872      4.5921211233
+C        1.2993389981      0.1104289172      2.4844663896
+H        2.2526138470      0.0865980845      1.9483127672
+C        1.2994126658      0.1723829840      3.8783367991
+H        2.2453411518      0.1966879024      4.4251589385
+H       -2.0869454458      0.0863720324      1.9432143952
+C        0.0810980584      0.2676328718      6.0213144069
+N        0.0819851974      0.3199013851      7.1972568519
+S        0.0000000000      0.0000000000      0.0000000000
+H        1.3390319419     -0.0095801980     -0.2157234144''',
+        charge=0, basis='6-31g**', verbose=5)
+    mol2 = gto.M(
+        atom='''
+C       -0.8476079365    0.0026700202   -3.5281035617
+C       -2.0218283577   -0.2604683627   -2.8073958219
+C        0.3353012600    0.2642432684   -2.8231212050
+H       -2.9520951875   -0.4549635668   -3.3338745954
+H        1.2611570861    0.4600128780   -3.3568350109
+C       -2.0073245682   -0.2604462093   -1.4139657047
+C        0.3383704802    0.2619859179   -1.4285927349
+H       -2.9349818456   -0.4420746761   -0.8791308006
+H        1.2732326220    0.4430128273   -0.9060391242
+C       -0.8293545128    0.0002996322   -0.6916543989
+C       -0.8192397451   -0.0006201775    0.7937732451
+C       -1.5616839183   -0.9482725602    1.5218647171
+C       -0.0671411632    0.9462610490    1.5129186979
+C       -1.5541603792   -0.9481485004    2.9180008413
+C       -0.0558307025    0.9446630867    2.9090260355
+C       -0.8001707945   -0.0022152441    3.6187748549
+H       -2.1295491966   -1.7060626237    0.9896596517
+H        0.4930453218    1.7050509252    0.9740007250
+H       -2.1296311282   -1.6947234290    3.4583587491
+H        0.5267024257    1.6907508988    3.4424644381
+H       -0.7929373074   -0.0027907562    4.7049223527
+S       -0.9353266992   -0.0162143726   -5.3112847893
+H        0.3533301599    0.3018611373   -5.5386460312''',
+charge=0, basis='6-31g**', verbose=5)
+    mol = gto.conc_mol(mol1, mol2)
+    _mol1, _mol2 = split_mol(mol, 14)

{fcdft-1.0.2 → fcdft-1.1.4}/fcdft/lib/CMakeLists.txt

@@ -102,6 +102,7 @@ endif()
 #add_subdirectory(vhf)
 add_subdirectory(dft)
 add_subdirectory(pbe)
+add_subdirectory(df)
 #configure_file(
 #  "${PYSCF_LIB_PATH}/config.h.in"
 #  "${PYSCF_LIB_PATH}/config.h")

fcdft-1.1.4/fcdft/lib/df/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_library(df SHARED nr_contract_k.c)
+
+find_package(LAPACK REQUIRED)
+
+set_target_properties(df PROPERTIES
+  LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR})
+
+target_link_libraries(df ${OPENMP_C_PROPERTIES} ${LAPACK_LIBRARIES})

fcdft-1.1.4/fcdft/lib/df/nr_contract_k.c

@@ -0,0 +1,13 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <omp.h>
+#include "cblas.h"
+
+void nr_mapdm1(double *buf, double *eri, double *dms, int nao, int naux) {
+    // vk shape: (nao, nao), (155,155)
+    // eri shape: (naux, nao, nao) (240,155,155)
+    // dms shape: (nao, nao) (155,155)
+    // buf shape: (naux, nao, nao) (240,155,155)
+    cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, naux*nao, nao, nao, 1.0, eri, nao, dms, nao, 0.0, buf, nao);
+}

{fcdft-1.0.2 → fcdft-1.1.4}/fcdft/lib/dft/quadrature.c

@@ -4,6 +4,8 @@
 #include <omp.h>
 #include <stdio.h>
 
+double const TWO_PI = 2.0 * M_PI;
+
 void roots_legendre(int n, double *abscissas, double *weights){
     double z, z1, pp, p1, p2, p3;
     int m = (n + 1) / 2;
@@ -34,26 +36,64 @@ void roots_legendre(int n, double *abscissas, double *weights){
 
 double occ_drv(double sampling, double moe_energy, double fermi, double broad, double smear) {
     double dist = 1 / (exp((sampling - fermi)/smear) + 1);
-    return dist * broad / (pow(sampling - moe_energy, 2) + pow(broad / 2, 2)) / 2.0 / M_PI;
+    double a = sampling - moe_energy;
+    double b = broad / 2.0;
+    return dist * broad / (a*a + b*b) / TWO_PI;
 }
 
 double occ_grad_drv(double sampling, double moe_energy, double fermi, double broad, double smear) {
     double dist = 1 / (exp((sampling - fermi)/smear) + 1);
-    return dist * (1 - dist) * broad / (pow(sampling - moe_energy, 2) + pow(broad / 2, 2)) / 2.0 / M_PI / smear;
+    double a = sampling - moe_energy;
+    double b = broad / 2.0;
+    return dist * (1 - dist) * broad / (a*a + b*b) / TWO_PI / smear;
 }
 
 void fermi_level_drv(double *moe_energy, double *abscissas, double *weights, double fermi, double broad, double smear, double window, int pts, int nbas, double *mo_occ, double *mo_grad) {
     int i, n;
     double sampling;
     double _mo_grad = 0.0;
+    double *window_weights = (double *)malloc(sizeof(double) * pts);
+
+    #pragma omp parallel for private(n)
+    for (n = 0; n < pts; n++) {
+        window_weights[n] = window * weights[n];
+    }
+
     #pragma omp parallel for private(n, sampling) reduction(+:_mo_grad)
     for (i = 0; i < nbas; i++) {
         mo_occ[i] = 0;
         for (n = 0; n < pts; n++) {
             sampling = abscissas[n] * window + moe_energy[i];
-            mo_occ[i] += window * weights[n] * occ_drv(sampling, moe_energy[i], fermi, broad, smear);
-            _mo_grad += window * weights[n] * occ_grad_drv(sampling, moe_energy[i], fermi, broad, smear);
+            mo_occ[i] += window_weights[n] * occ_drv(sampling, moe_energy[i], fermi, broad, smear);
+            _mo_grad += window_weights[n] * occ_grad_drv(sampling, moe_energy[i], fermi, broad, smear);
         }
     }
     *mo_grad = _mo_grad;
+    free(window_weights);
 }
+
+void occupation_drv(double *moe_energy, double *abscissas, double *weights, double fermi, double broad, double smear, double window, int pts, int nbas, double *mo_occ) {
+    int i, n;
+    double sampling;
+    #pragma omp parallel for private(n, sampling)
+    for (i = 0; i < nbas; i++) {
+        mo_occ[i] = 0;
+        for (n = 0; n < pts; n++) {
+            sampling = abscissas[n] * window + moe_energy[i];
+            mo_occ[i] += window * weights[n] * occ_drv(sampling, moe_energy[i], fermi, broad, smear);
+        }
+    }
+}
+
+void occupation_grad_drv(double *moe_energy, double *abscissas, double *weights, double fermi, double broad, double smear, double window, int pts, int nbas, double *occ_grad) {
+    int i, n;
+    double sampling;
+    #pragma omp parallel for private(n, sampling)
+    for (i = 0; i < nbas; i++) {
+        occ_grad[i] = 0;
+        for (n = 0; n < pts; n++) {
+            sampling = abscissas[n] * window + moe_energy[i];
+            occ_grad[i] += window * weights[n] * occ_grad_drv(sampling, moe_energy[i], fermi, broad, smear);
+        }
+    }        
+}