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

pyscf/dft/numint.py

@@ -176,9 +176,9 @@ def eval_rho(mol, ao, dm, non0tab=None, xctype='LDA', hermi=0,
         if hermi:
             rho[1:4] *= 2  # *2 for + einsum('pi,ij,pj->p', ao[i], dm, ao[0])
         else:
+            c1 = _dot_ao_dm(mol, ao[0], dm.conj().T, non0tab, shls_slice, ao_loc)
             for i in range(1, 4):
-                c1 = _dot_ao_dm(mol, ao[i], dm, non0tab, shls_slice, ao_loc)
-                rho[i] += _contract_rho(c1, ao[0])
+                rho[i] += _contract_rho(c1, ao[i])
     else: # meta-GGA
         if with_lapl:
             # rho[4] = \nabla^2 rho, rho[5] = 1/2 |nabla f|^2
@@ -312,14 +312,14 @@ def eval_rho1(mol, ao, dm, screen_index=None, xctype='LDA', hermi=0,
 
         rho[tau_idx] = 0
         for i in range(1, 4):
-            c1 = _dot_ao_dm_sparse(ao[i], dm.T, nbins, screen_index, pair_mask, ao_loc)
+            c1 = _dot_ao_dm_sparse(ao[i], dm, nbins, screen_index, pair_mask, ao_loc)
             rho[tau_idx] += _contract_rho_sparse(ao[i], c1, screen_index, ao_loc)
 
             rho[i] = _contract_rho_sparse(ao[i], c0, screen_index, ao_loc)
             if hermi:
                 rho[i] *= 2
             else:
-                rho[i] += _contract_rho_sparse(c1, ao[0], screen_index, ao_loc)
+                rho[i] += _contract_rho_sparse(ao[0], c1, screen_index, ao_loc)
 
         # tau = 1/2 (\nabla f)^2
         rho[tau_idx] *= .5
@@ -812,9 +812,8 @@ def _tau_dot(mol, bra, ket, wv, mask, shls_slice, ao_loc):
     mat += _dot_ao_ao(mol, bra[3], aow, mask, shls_slice, ao_loc)
     return mat
 
-def _sparse_enough(screen_index):
+def _sparse_enough(screen_index, threshold=0.5):
     # TODO: improve the turnover threshold
-    threshold = 0.5
     return numpy.count_nonzero(screen_index) < screen_index.size * threshold
 
 def _dot_ao_ao_dense(ao1, ao2, wv, out=None):
@@ -831,13 +830,8 @@ def _dot_ao_ao_dense(ao1, ao2, wv, out=None):
         return lib.ddot(ao1.T, ao2, 1, out, 1)
     else:
         assert wv.dtype == numpy.double
-        libdft.VXCdot_aow_ao_dense(
-            out.ctypes.data_as(ctypes.c_void_p),
-            ao1.ctypes.data_as(ctypes.c_void_p),
-            ao2.ctypes.data_as(ctypes.c_void_p),
-            wv.ctypes.data_as(ctypes.c_void_p),
-            ctypes.c_int(nao), ctypes.c_int(ngrids))
-    return out
+        ao1 = _scale_ao(ao1, wv.ravel())
+        return lib.ddot(ao1.T, ao2, 1, out, 1)
 
 def _dot_ao_ao_sparse(ao1, ao2, wv, nbins, screen_index, pair_mask, ao_loc,
                       hermi=0, out=None):
@@ -2633,7 +2627,7 @@ def get_rho(ni, mol, dm, grids, max_memory=2000):
 class LibXCMixin:
     libxc = libxc
 
-    omega = None  # RSH paramter
+    omega = None  # RSH parameter
 
 ####################
 # Overwrite following functions to use custom XC functional
@@ -2654,6 +2648,10 @@ class LibXCMixin:
         return self.libxc.eval_xc(xc_code, rho, spin, relativity, deriv,
                                   omega, verbose)
 
+    def eval_xc1(self, xc_code, rho, spin=0, deriv=1, omega=None):
+        if omega is None: omega = self.omega
+        return self.libxc.eval_xc1(xc_code, rho, spin, deriv, omega)
+
     def eval_xc_eff(self, xc_code, rho, deriv=1, omega=None, xctype=None,
                     verbose=None):
         r'''Returns the derivative tensor against the density parameters
@@ -2693,12 +2691,12 @@ class LibXCMixin:
         else:
             spin = 0
 
-        out = self.libxc.eval_xc1(xc_code, rho, spin, deriv, omega)
+        out = self.eval_xc1(xc_code, rho, spin, deriv, omega)
         evfk = [out[0]]
         for order in range(1, deriv+1):
             evfk.append(xc_deriv.transform_xc(rho, out, xctype, spin, order))
         if deriv < 3:
-            # The return has at least [e, v, f, k] terms
+            # Returns at least [e, v, f, k] terms
             evfk.extend([None] * (3 - deriv))
         return evfk
 
@@ -2719,9 +2717,12 @@ class LibXCMixin:
         '''
         omega, alpha, beta = self.rsh_coeff(xc_code)
         if self.omega is not None:
+            if omega == 0 and self.omega != 0:
+                raise RuntimeError(f'Not support assigning omega={self.omega}. '
+                                   f'{xc_code} is not a RSH functional')
             omega = self.omega
 
-        if abs(omega) > 1e-10:
+        if omega != 0:
             hyb = alpha + beta
         else:
             hyb = self.hybrid_coeff(xc_code, spin)
@@ -2852,12 +2853,32 @@ class NumInt(lib.StreamObject, LibXCMixin):
                 pair_mask = ovlp_cond < -numpy.log(self.cutoff)
             pair_mask = numpy.asarray(pair_mask, dtype=numpy.uint8)
 
+        if (mo_occ is not None) and (grids is not None):
+            # eval_rho2 is more efficient unless we have a very large system
+            # for which the pair_mask is significantly sparser than the
+            # ratio of occupied to total molecular orbitals. So we use this ratio
+            # to switch between eval_rho1 and eval_rho2.
+            mo_ao_sparsity = max(0.5 * numpy.sum(mo_occ) / nao, 1e-8)
+            wts = mol.ao_loc_nr()
+            wts = (wts[1:] - wts[:-1]) / wts[-1]
+            rho1_rho2_ratio = numpy.dot(wts, pair_mask).dot(wts) / mo_ao_sparsity
+        else:
+            rho1_rho2_ratio = 0.0
+
         def make_rho(idm, ao, sindex, xctype):
-            if sindex is not None and grids is not None:
+            has_screening = sindex is not None and grids is not None
+            has_mo = mo_coeff is not None
+            if xctype == "GGA":
+                # GGA has to do more contractions using rho2 compared to rho1,
+                # so the threshold for switching to rho1 is less strict.
+                is_sparse = rho1_rho2_ratio < 4
+            else:
+                is_sparse = rho1_rho2_ratio < 1
+            if has_screening and (not has_mo or is_sparse):
                 return self.eval_rho1(mol, ao, dms[idm], sindex, xctype, hermi,
                                       with_lapl, cutoff=self.cutoff,
                                       ao_cutoff=grids.cutoff, pair_mask=pair_mask)
-            elif mo_coeff is not None:
+            elif has_mo:
                 return self.eval_rho2(mol, ao, mo_coeff[idm], mo_occ[idm],
                                       sindex, xctype, with_lapl)
             else:

pyscf/dft/radi.py

@@ -21,10 +21,20 @@
 import numpy
 from pyscf.data import radii
 from pyscf.data.elements import charge as elements_proton
+from pyscf import __config__
 
 BRAGG_RADII = radii.BRAGG
 COVALENT_RADII = radii.COVALENT
 
+# The effective atomic radius in Treutler's original paper (JCP 102, 346) was
+# omitted in PySCF versions 2.6 and earlier. This can cause discrepancies in the
+# numerical grids when compared to other software (See issue #2178 for details).
+# Note that using the atom-specific radius may slightly alter the results of
+# numerical integration, potentially leading to differences of ~ 1e-6 per atom
+# in total energy.
+# Disable this flag to make DFT grids consistent with old PySCF versions.
+ATOM_SPECIFIC_TREUTLER_GRIDS = getattr(__config__, 'ATOM_SPECIFIC_TREUTLER_GRIDS', True)
+
 # P.M.W. Gill, B.G. Johnson, J.A. Pople, Chem. Phys. Letters 209 (1993) 506-512
 SG1RADII = numpy.array((
     0,
@@ -37,14 +47,21 @@ SG1RADII = numpy.array((
 def murray(n, *args, **kwargs):
     raise RuntimeError('Not implemented')
 
-# Gauss-Chebyshev of the first kind,  and the transformed interval [0,\infty)
 def becke(n, charge, *args, **kwargs):
     '''Becke, JCP 88, 2547 (1988); DOI:10.1063/1.454033'''
     if charge == 1:
         rm = BRAGG_RADII[charge]
     else:
         rm = BRAGG_RADII[charge] * .5
-    t, w = numpy.polynomial.chebyshev.chebgauss(n)
+
+    # Points and weights for Gauss-Chebyshev quadrature points of the second kind
+    # The weights are adjusted to integrate a function on the interval [-1, 1] with uniform weighting
+    # instead of weighted by sqrt(1 - t^2) = sin(i pi / (n+1)).
+    i = numpy.arange(n) + 1
+    t = numpy.cos(i * numpy.pi / (n + 1))
+    w = numpy.pi / (n + 1) * numpy.sin(i * numpy.pi / (n + 1))
+
+    # Change of variables to map the domain to [0, inf)
     r = (1+t)/(1-t) * rm
     w *= 2/(1-t)**2 * rm
     return r, w
@@ -95,15 +112,41 @@ def gauss_chebyshev(n, *args, **kwargs):
     dr = fac * numpy.sin(x1)**4 * ln2/(1+xi)
     return r, dr
 
-
-def treutler_ahlrichs(n, *args, **kwargs):
+# Individually optimized Treutler/Ahlrichs radius parameter.
+# H - Kr are taken from the original paper JCP 102, 346 (1995)
+# Other elements are copied from Psi4 source code
+_treutler_ahlrichs_xi = [1.0, # Ghost
+    0.8,                               0.9,           # 1s
+    1.8, 1.4, 1.3, 1.1, 0.9, 0.9, 0.9, 0.9,           # 2s2p
+    1.4, 1.3, 1.3, 1.2, 1.1, 1.0, 1.0, 1.0,           # 3s3p
+    1.5, 1.4,                                         # 4s
+    1.3, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.1, 1.1, 1.1, # 3d
+              1.1, 1.0, 0.9, 0.9, 0.9, 0.9,           # 4p
+    2.000, 1.700,                                                         # 5s
+    1.500, 1.500, 1.350, 1.350, 1.250, 1.200, 1.250, 1.300, 1.500, 1.500, # 4d
+                  1.300, 1.200, 1.200, 1.150, 1.150, 1.150,               # 5p
+    2.500, 2.200,                                                         # 6s
+           2.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,               # La, Ce-Eu
+           1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,        # Gd, Tb-Lu
+           1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, # 5d
+                  1.500, 1.500, 1.500, 1.500, 1.500, 1.500,               # 6p
+    2.500, 2.100,                                                         # 7s
+           3.685, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,
+           1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,
+] # noqa: E124
+
+def treutler_ahlrichs(n, chg, *args, **kwargs):
     '''
     Treutler-Ahlrichs [JCP 102, 346 (1995); DOI:10.1063/1.469408] (M4) radial grids
     '''
+    if ATOM_SPECIFIC_TREUTLER_GRIDS:
+        xi = _treutler_ahlrichs_xi[chg]
+    else:
+        xi = 1.
     r = numpy.empty(n)
     dr = numpy.empty(n)
     step = numpy.pi / (n+1)
-    ln2 = 1 / numpy.log(2)
+    ln2 = xi / numpy.log(2)
     for i in range(n):
         x = numpy.cos((i+1)*step)
         r [i] = -ln2*(1+x)**.6 * numpy.log((1-x)/2)
@@ -113,8 +156,6 @@ def treutler_ahlrichs(n, *args, **kwargs):
 treutler = treutler_ahlrichs
 
 
-
-
 def becke_atomic_radii_adjust(mol, atomic_radii):
     '''Becke atomic radii adjust function'''
 # Becke atomic size adjustment.  J. Chem. Phys. 88, 2547

pyscf/dft/rks.py

@@ -92,36 +92,40 @@ def get_veff(ks, mol=None, dm=None, dm_last=0, vhf_last=0, hermi=1):
             logger.debug(ks, 'nelec with nlc grids = %s', n)
         t0 = logger.timer(ks, 'vxc', *t0)
 
+    incremental_jk = (ks._eri is None and ks.direct_scf and
+                      getattr(vhf_last, 'vj', None) is not None)
+    if incremental_jk:
+        _dm = numpy.asarray(dm) - numpy.asarray(dm_last)
+    else:
+        _dm = dm
     if not ni.libxc.is_hybrid_xc(ks.xc):
         vk = None
-        if (ks._eri is None and ks.direct_scf and
-            getattr(vhf_last, 'vj', None) is not None):
-            ddm = numpy.asarray(dm) - numpy.asarray(dm_last)
-            vj = ks.get_j(mol, ddm, hermi)
+        vj = ks.get_j(mol, _dm, hermi)
+        if incremental_jk:
             vj += vhf_last.vj
-        else:
-            vj = ks.get_j(mol, dm, hermi)
         vxc += vj
     else:
         omega, alpha, hyb = ni.rsh_and_hybrid_coeff(ks.xc, spin=mol.spin)
-        if (ks._eri is None and ks.direct_scf and
-            getattr(vhf_last, 'vk', None) is not None):
-            ddm = numpy.asarray(dm) - numpy.asarray(dm_last)
-            vj, vk = ks.get_jk(mol, ddm, hermi)
+        if omega == 0:
+            vj, vk = ks.get_jk(mol, _dm, hermi)
+            vk *= hyb
+        elif alpha == 0: # LR=0, only SR exchange
+            vj = ks.get_j(mol, _dm, hermi)
+            vk = ks.get_k(mol, _dm, hermi, omega=-omega)
+            vk *= hyb
+        elif hyb == 0: # SR=0, only LR exchange
+            vj = ks.get_j(mol, _dm, hermi)
+            vk = ks.get_k(mol, _dm, hermi, omega=omega)
+            vk *= alpha
+        else: # SR and LR exchange with different ratios
+            vj, vk = ks.get_jk(mol, _dm, hermi)
             vk *= hyb
-            if omega != 0:  # For range separated Coulomb
-                vklr = ks.get_k(mol, ddm, hermi, omega=omega)
-                vklr *= (alpha - hyb)
-                vk += vklr
+            vklr = ks.get_k(mol, _dm, hermi, omega=omega)
+            vklr *= (alpha - hyb)
+            vk += vklr
+        if incremental_jk:
             vj += vhf_last.vj
             vk += vhf_last.vk
-        else:
-            vj, vk = ks.get_jk(mol, dm, hermi)
-            vk *= hyb
-            if omega != 0:
-                vklr = ks.get_k(mol, dm, hermi, omega=omega)
-                vklr *= (alpha - hyb)
-                vk += vklr
         vxc += vj - vk * .5
 
         if ground_state:
@@ -228,7 +232,7 @@ def energy_elec(ks, dm=None, h1e=None, vhf=None):
         ks : an instance of DFT class
 
         dm : 2D ndarray
-            one-partical density matrix
+            one-particle density matrix
         h1e : 2D ndarray
             Core hamiltonian
 
@@ -322,6 +326,9 @@ class KohnShamDFT:
 
     _keys = {'xc', 'nlc', 'grids', 'disp', 'nlcgrids', 'small_rho_cutoff'}
 
+    # Use rho to filter grids
+    small_rho_cutoff = getattr(__config__, 'dft_rks_RKS_small_rho_cutoff', 1e-7)
+
     def __init__(self, xc='LDA,VWN'):
         # By default, self.nlc = '' and self.disp = None
         self.xc = xc
@@ -333,9 +340,6 @@ class KohnShamDFT:
         self.nlcgrids = gen_grid.Grids(self.mol)
         self.nlcgrids.level = getattr(
             __config__, 'dft_rks_RKS_nlcgrids_level', self.nlcgrids.level)
-        # Use rho to filter grids
-        self.small_rho_cutoff = getattr(
-            __config__, 'dft_rks_RKS_small_rho_cutoff', 1e-7)
 ##################################################
 # don't modify the following attributes, they are not input options
         self._numint = numint.NumInt()

pyscf/dft/roks.py

@@ -30,12 +30,18 @@ from pyscf.dft import uks
 
 @lib.with_doc(uks.get_veff.__doc__)
 def get_veff(ks, mol=None, dm=None, dm_last=0, vhf_last=0, hermi=1):
-    if getattr(dm, 'mo_coeff', None) is not None:
+    if dm is None:
+        dm = ks.make_rdm1()
+    elif getattr(dm, 'mo_coeff', None) is not None:
         mo_coeff = dm.mo_coeff
         mo_occ_a = (dm.mo_occ > 0).astype(numpy.double)
         mo_occ_b = (dm.mo_occ ==2).astype(numpy.double)
+        if dm.ndim == 2:  # RHF DM
+            dm = numpy.repeat(dm[None]*.5, 2, axis=0)
         dm = lib.tag_array(dm, mo_coeff=(mo_coeff,mo_coeff),
                            mo_occ=(mo_occ_a,mo_occ_b))
+    elif dm.ndim == 2:  # RHF DM
+        dm = numpy.repeat(dm[None]*.5, 2, axis=0)
     return uks.get_veff(ks, mol, dm, dm_last, vhf_last, hermi)
 
 

pyscf/dft/uks.py

@@ -36,7 +36,8 @@ def get_veff(ks, mol=None, dm=None, dm_last=0, vhf_last=0, hermi=1):
     if not isinstance(dm, numpy.ndarray):
         dm = numpy.asarray(dm)
     if dm.ndim == 2:  # RHF DM
-        dm = numpy.asarray((dm*.5,dm*.5))
+        logger.warn(ks, 'Incompatible dm dimension. Treat dm as RHF density matrix.')
+        dm = numpy.repeat(dm[None]*.5, 2, axis=0)
     ks.initialize_grids(mol, dm)
 
     t0 = (logger.process_clock(), logger.perf_counter())
@@ -63,37 +64,44 @@ def get_veff(ks, mol=None, dm=None, dm_last=0, vhf_last=0, hermi=1):
             logger.debug(ks, 'nelec with nlc grids = %s', n)
         t0 = logger.timer(ks, 'vxc', *t0)
 
+    incremental_jk = (ks._eri is None and ks.direct_scf and
+                      getattr(vhf_last, 'vj', None) is not None)
+    if incremental_jk:
+        dm_last = numpy.asarray(dm_last)
+        dm = numpy.asarray(dm)
+        assert dm_last.ndim == 0 or dm_last.ndim == dm.ndim
+        _dm = dm - dm_last
+    else:
+        _dm = dm
     if not ni.libxc.is_hybrid_xc(ks.xc):
         vk = None
-        if (ks._eri is None and ks.direct_scf and
-            getattr(vhf_last, 'vj', None) is not None):
-            ddm = numpy.asarray(dm) - numpy.asarray(dm_last)
-            vj = ks.get_j(mol, ddm[0]+ddm[1], hermi)
+        vj = ks.get_j(mol, _dm[0]+_dm[1], hermi)
+        if incremental_jk:
             vj += vhf_last.vj
-        else:
-            vj = ks.get_j(mol, dm[0]+dm[1], hermi)
         vxc += vj
     else:
         omega, alpha, hyb = ni.rsh_and_hybrid_coeff(ks.xc, spin=mol.spin)
-        if (ks._eri is None and ks.direct_scf and
-            getattr(vhf_last, 'vk', None) is not None):
-            ddm = numpy.asarray(dm) - numpy.asarray(dm_last)
-            vj, vk = ks.get_jk(mol, ddm, hermi)
+        if omega == 0:
+            vj, vk = ks.get_jk(mol, _dm, hermi)
             vk *= hyb
-            if omega != 0:
-                vklr = ks.get_k(mol, ddm, hermi, omega)
-                vklr *= (alpha - hyb)
-                vk += vklr
-            vj = vj[0] + vj[1] + vhf_last.vj
-            vk += vhf_last.vk
-        else:
-            vj, vk = ks.get_jk(mol, dm, hermi)
-            vj = vj[0] + vj[1]
+        elif alpha == 0: # LR=0, only SR exchange
+            vj = ks.get_j(mol, _dm, hermi)
+            vk = ks.get_k(mol, _dm, hermi, omega=-omega)
+            vk *= hyb
+        elif hyb == 0: # SR=0, only LR exchange
+            vj = ks.get_j(mol, _dm, hermi)
+            vk = ks.get_k(mol, _dm, hermi, omega=omega)
+            vk *= alpha
+        else: # SR and LR exchange with different ratios
+            vj, vk = ks.get_jk(mol, _dm, hermi)
             vk *= hyb
-            if omega != 0:
-                vklr = ks.get_k(mol, dm, hermi, omega)
-                vklr *= (alpha - hyb)
-                vk += vklr
+            vklr = ks.get_k(mol, _dm, hermi, omega=omega)
+            vklr *= (alpha - hyb)
+            vk += vklr
+        vj = vj[0] + vj[1]
+        if incremental_jk:
+            vj += vhf_last.vj
+            vk += vhf_last.vk
         vxc += vj - vk
 
         if ground_state:
@@ -178,7 +186,8 @@ class UKS(rks.KohnShamDFT, uhf.UHF):
         ground_state = (isinstance(dm, numpy.ndarray)
                         and dm.ndim == 3 and dm.shape[0] == 2)
         if ground_state:
-            super().initialize_grids(mol, dm[0]+dm[1])
+            dm = numpy.asarray(dm[0] + dm[1])
+            super().initialize_grids(mol, dm)
         else:
             super().initialize_grids(mol)
         return self

pyscf/dft/xc_deriv.py

@@ -455,7 +455,7 @@ def _stack_fggg(fggg, axis=0, rho=None):
 @lru_cache(100)
 def _product_uniq_indices(nvars, order):
     '''
-    Indexing the symmetry unique elements in cartensian product
+    Indexing the symmetry unique elements in cartesian product
     '''
     # n = 0
     # for i range(nvars):

pyscf/dft/xcfun.py

@@ -36,10 +36,61 @@ _itrf = lib.load_library('libxcfun_itrf')
 _itrf.xcfun_splash.restype = ctypes.c_char_p
 _itrf.xcfun_version.restype = ctypes.c_char_p
 _itrf.XCFUN_eval_xc.restype = ctypes.c_int
+_itrf.xcfun_enumerate_parameters.restype = ctypes.c_char_p
+_itrf.XCFUN_xc_type.restype = ctypes.c_int
+_itrf.xcfun_describe_short.restype = ctypes.c_char_p
+_itrf.xcfun_describe_short.argtype = [ctypes.c_char_p]
+_itrf.xcfun_describe_long.restype = ctypes.c_char_p
+_itrf.xcfun_describe_long.argtype = [ctypes.c_char_p]
 
 __version__ = _itrf.xcfun_version().decode("UTF-8")
 __reference__ = _itrf.xcfun_splash().decode("UTF-8")
 
+def print_XC_CODES():
+    '''
+    Dump the built-in xcfun XC_CODES in a readable format.
+    '''
+    lda_ids = []
+    gga_ids = []
+    mgga_ids = []
+    xc_codes = {}
+
+    print('XC = XC_CODES = {')
+    for i in range(78):
+        name = _itrf.xcfun_enumerate_parameters(ctypes.c_int(i))
+        sdescr = _itrf.xcfun_describe_short(name)
+        #ldescr = _itrf.xcfun_describe_long(ctypes.c_int(i))
+        if sdescr is not None:
+            name = name.decode('UTF-8')
+            key = f"'{name}'"
+            sdescr = sdescr.decode('UTF-8')
+            print(f'{key:<16s}: {i:2d},  #{sdescr}')
+            xc_codes[name] = i
+
+        fntype = _itrf.XCFUN_xc_type(ctypes.c_int(i))
+        if fntype == 0:
+            lda_ids.append(i)
+        elif fntype == 1:
+            gga_ids.append(i)
+        elif fntype == 2:
+            mgga_ids.append(i)
+
+    alias = {
+        'SLATER': 'SLATERX',
+        'LDA'   : 'SLATERX',
+        'VWN'   : 'VWN5C',
+        'VWN5'  : 'VWN5C',
+        'B88'   : 'BECKEX',
+        'LYP'   : 'LYPC',
+    }
+    for k, v in alias.items():
+        key = f"'{k}'"
+        print(f'{key:<16s}: {xc_codes[v]:2d},  # {v}')
+    print('}')
+    print('LDA_IDS = %s' % lda_ids)
+    print('GGA_IDS = %s' % gga_ids)
+    print('MGGA_IDS = %s' % mgga_ids)
+
 XC = XC_CODES = {
 'SLATERX'       :  0,  #Slater LDA exchange
 'PW86X'         :  1,  #PW86 exchange
@@ -449,7 +500,7 @@ def parse_xc(description):
                 fac, key = token.split('*')
                 if fac[0].isalpha():
                     fac, key = key, fac
-                fac = sign * float(fac.replace('_', '-'))
+                fac = sign * float(fac.replace('E_', 'E-'))
             else:
                 fac, key = sign, token
 
@@ -833,7 +884,7 @@ XC_D0000003 = 119
 
 def eval_xc(xc_code, rho, spin=0, relativity=0, deriv=1, omega=None, verbose=None):
     r'''Interface to call xcfun library to evaluate XC functional, potential
-    and functional derivatives. Return deriviates following libxc convention.
+    and functional derivatives. Return derivatives following libxc convention.
 
     See also :func:`pyscf.dft.libxc.eval_xc`
     '''

pyscf/eph/eph_fd.py

@@ -101,7 +101,7 @@ def kernel(mf, disp=1e-4, mo_rep=False, cutoff_frequency=CUTOFF_FREQUENCY, keep_
     omega, vec = get_mode(mf, cutoff_frequency, keep_imag_frequency)
     mass = mol.atom_mass_list() * MP_ME
     vec = rhf_eph._freq_mass_weighted_vec(vec, omega, mass)
-    mols_a, mols_b = gen_moles(mol, disp/2.0) # generate a bunch of molecules with disp/2 on each cartesion coord
+    mols_a, mols_b = gen_moles(mol, disp/2.0) # generate a bunch of molecules with disp/2 on each cartesian coord
     mfset = run_mfs(mf, mols_a, mols_b) # run mean field calculations on all these molecules
     vmat = get_vmat(mf, mfset, disp) # extracting <p|dV|q>/dR
     if mo_rep:

pyscf/eph/rhf.py

@@ -23,7 +23,7 @@ Analytical electron-phonon matrix for restricted hartree fock
 import numpy as np
 import scipy.linalg
 from pyscf.hessian import rhf
-from pyscf.lib import logger, chkfile
+from pyscf.lib import logger
 from pyscf.scf._response_functions import _gen_rhf_response
 from pyscf import __config__
 from pyscf.data.nist import HARTREE2WAVENUMBER, MP_ME
@@ -37,16 +37,16 @@ def kernel(ephobj, mo_energy=None, mo_coeff=None, mo_occ=None, mo_rep=False):
     if mo_coeff is None: mo_coeff = ephobj.base.mo_coeff
     if mo_occ is None: mo_occ = ephobj.base.mo_occ
 
-    # chkfile is used to pass first orbitals from hessian methods to eph methods
-    # TODO: Remove the dependence to chfile and return first orbitals from a function
-    assert ephobj.chkfile is not None, 'chkfile is required to save first order orbitals'
+    h1ao = ephobj.make_h1(mo_coeff, mo_occ)
+    mo1, mo_e1 = ephobj.solve_mo1(mo_energy, mo_coeff, mo_occ, h1ao)
 
-    de = ephobj.hess_elec(mo_energy, mo_coeff, mo_occ)
+    de = ephobj.hess_elec(mo_energy, mo_coeff, mo_occ,
+                          mo1=mo1, mo_e1=mo_e1, h1ao=h1ao)
     ephobj.de = de + ephobj.hess_nuc(ephobj.mol)
 
     omega, vec = ephobj.get_mode(ephobj.mol, ephobj.de)
     ephobj.omega, ephobj.vec = omega, vec
-    ephobj.eph = ephobj.get_eph(ephobj.chkfile, omega, vec, mo_rep)
+    ephobj.eph = ephobj.get_eph(mo1, omega, vec, mo_rep)
     return ephobj.eph, ephobj.omega
 
 def solve_hmat(mol, hmat, cutoff_frequency=CUTOFF_FREQUENCY,
@@ -143,10 +143,6 @@ def _freq_mass_weighted_vec(vec, omega, mass):
     return vec
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = chkfile.load(mo1, 'scf_mo1')
-        mo1 = {int(k): mo1[k] for k in mo1}
-
     mol = ephobj.mol
     mf = ephobj.base
     vnuc_deriv = ephobj.vnuc_generator(mol)
@@ -209,29 +205,3 @@ class EPH(rhf.Hessian):
     get_eph = get_eph
     vnuc_generator = vnuc_generator
     kernel = kernel
-
-if __name__ == '__main__':
-    from pyscf import gto, scf
-
-    mol = gto.M()
-    mol.atom = [['O', [0.000000000000,  -0.000000000775,   0.923671924285]],
-                ['H', [-0.000000000000,  -1.432564848017,   2.125164039823]],
-                ['H', [0.000000000000,   1.432564848792,   2.125164035930]]]
-    mol.unit = 'Bohr'
-    mol.basis = 'sto3g'
-    mol.verbose=4
-    mol.build() # this is a pre-computed relaxed geometry
-
-    mf = scf.RHF(mol)
-    mf.conv_tol = 1e-16
-    mf.conv_tol_grad = 1e-10
-    mf.kernel()
-
-    myeph = EPH(mf)
-
-    grad = mf.nuc_grad_method().kernel()
-    print("Force on the atoms/au:")
-    print(grad)
-
-    eph, omega = myeph.kernel(mo_rep=True)
-    print(np.amax(eph))

pyscf/eph/rks.py

@@ -100,10 +100,6 @@ def _get_vxc_deriv1(hessobj, mo_coeff, mo_occ, max_memory):
     return vmat
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1 = {int(k): mo1[k] for k in mo1}
-
     mol = ephobj.mol
     mf = ephobj.base
     ni = mf._numint

pyscf/eph/uhf.py

@@ -54,18 +54,12 @@ def uhf_deriv_generator(mf, mo_coeff, mo_occ):
     return fx
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1a = mo1['0']
-        mo1b = mo1['1']
-        mo1a = {int(k): mo1a[k] for k in mo1a}
-        mo1b = {int(k): mo1b[k] for k in mo1b}
-
     mol = ephobj.mol
     mf = ephobj.base
     vnuc_deriv = ephobj.vnuc_generator(mol)
     aoslices = mol.aoslice_by_atom()
 
+    mo1a, mo1b = mo1
     mo_coeff, mo_occ = mf.mo_coeff, mf.mo_occ
     vind = uhf_deriv_generator(mf, mf.mo_coeff, mf.mo_occ)
     nao, nmo = mo_coeff[0].shape

pyscf/eph/uks.py

@@ -124,13 +124,6 @@ def _get_vxc_deriv1(hessobj, mo_coeff, mo_occ, max_memory):
     return vmata, vmatb
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1a = mo1['0']
-        mo1b = mo1['1']
-        mo1a = {int(k): mo1a[k] for k in mo1a}
-        mo1b = {int(k): mo1b[k] for k in mo1b}
-
     mol = ephobj.mol
     mf = ephobj.base
     ni = mf._numint
@@ -141,6 +134,7 @@ def get_eph(ephobj, mo1, omega, vec, mo_rep):
     vnuc_deriv = ephobj.vnuc_generator(mol)
     aoslices = mol.aoslice_by_atom()
 
+    mo1a, mo1b = mo1
     mo_coeff, mo_occ = mf.mo_coeff, mf.mo_occ
     vind = uhf_deriv_generator(mf, mf.mo_coeff, mf.mo_occ)
     mem_now = lib.current_memory()[0]