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

pyscf/cc/uccsd.py

@@ -396,12 +396,12 @@ def vector_to_amplitudes(vector, nmo, nocc):
     nvir = nvira + nvirb
     nov = nocc * nvir
     size = nov + nocc*(nocc-1)//2*nvir*(nvir-1)//2
-    if vector.size == size:
+    sizea = nocca * nvira + nocca*(nocca-1)//2*nvira*(nvira-1)//2
+    sizeb = noccb * nvirb + noccb*(noccb-1)//2*nvirb*(nvirb-1)//2
+    if vector.size == size and sizea > 0 and sizeb > 0:
         #return ccsd.vector_to_amplitudes_s4(vector, nmo, nocc)
-        raise RuntimeError('Input vector is GCCSD vecotr')
+        raise RuntimeError('Input vector is GCCSD vector')
     else:
-        sizea = nocca * nvira + nocca*(nocca-1)//2*nvira*(nvira-1)//2
-        sizeb = noccb * nvirb + noccb*(noccb-1)//2*nvirb*(nvirb-1)//2
         sections = np.cumsum([sizea, sizeb])
         veca, vecb, t2ab = np.split(vector, sections)
         t1a, t2aa = ccsd.vector_to_amplitudes_s4(veca, nmoa, nocca)
@@ -574,9 +574,9 @@ class UCCSD(ccsd.CCSDBase):
         eris_ovov = np.asarray(eris.ovov)
         eris_OVOV = np.asarray(eris.OVOV)
         eris_ovOV = np.asarray(eris.ovOV)
-        t2aa = eris_ovov.transpose(0,2,1,3) / lib.direct_sum('ia+jb->ijab', eia_a, eia_a)
-        t2ab = eris_ovOV.transpose(0,2,1,3) / lib.direct_sum('ia+jb->ijab', eia_a, eia_b)
-        t2bb = eris_OVOV.transpose(0,2,1,3) / lib.direct_sum('ia+jb->ijab', eia_b, eia_b)
+        t2aa = eris_ovov.transpose(0,2,1,3).conj() / lib.direct_sum('ia+jb->ijab', eia_a, eia_a)
+        t2ab = eris_ovOV.transpose(0,2,1,3).conj() / lib.direct_sum('ia+jb->ijab', eia_a, eia_b)
+        t2bb = eris_OVOV.transpose(0,2,1,3).conj() / lib.direct_sum('ia+jb->ijab', eia_b, eia_b)
         t2aa = t2aa - t2aa.transpose(0,1,3,2)
         t2bb = t2bb - t2bb.transpose(0,1,3,2)
         e  =      np.einsum('iJaB,iaJB', t2ab, eris_ovOV)

pyscf/cc/uccsd_rdm.py

@@ -625,8 +625,8 @@ def _make_rdm2(mycc, d1, d2, with_dm1=True, with_frozen=True, ao_repr=False):
 
 
 def _dm2ab_mo2ao(dm2, mo_a, mo_b):
-    return lib.einsum('ijkl,pi,qj,rk,sl->pqrs', dm2, mo_a, mo_a.conj(),
-                      mo_b, mo_b.conj())
+    return lib.einsum('ijkl,pi,qj,rk,sl->pqrs', dm2, mo_a.conj(), mo_a,
+                      mo_b.conj(), mo_b)
 
 
 if __name__ == '__main__':

pyscf/data/elements.py

@@ -827,7 +827,7 @@ NRSRHFS_CONFIGURATION = [
     [14,36,40,28],     #118  Og
 ]
 
-# This is No. of shells, not the atomic configuations
+# This is No. of shells, not the atomic configurations
 #     core       core+valence
 # core+valence = lambda nuc, l: \
 #            int(numpy.ceil(pyscf.lib.parameters.ELEMENTS[nuc][2][l]/(4*l+2.)))

pyscf/df/__init__.py

@@ -34,7 +34,8 @@ Simple usage::
 from . import incore
 from . import outcore
 from . import addons
-from .addons import load, aug_etb, DEFAULT_AUXBASIS, make_auxbasis, make_auxmol
+from .addons import (load, aug_etb, autoaux, autoabs,
+                     DEFAULT_AUXBASIS, make_auxbasis, make_auxmol)
 from .df import DF, GDF, DF4C, GDF4C
 
 from . import r_incore

pyscf/df/addons.py

@@ -16,6 +16,7 @@
 # Author: Qiming Sun <osirpt.sun@gmail.com>
 #
 
+
 import sys
 import numpy
 from pyscf.lib import logger
@@ -23,12 +24,18 @@ from pyscf import gto
 from pyscf import ao2mo
 from pyscf.data import elements
 from pyscf.lib.exceptions import BasisNotFoundError
+from pyscf.df.autoaux import autoaux, autoabs
 from pyscf import __config__
 
 DFBASIS = getattr(__config__, 'df_addons_aug_etb_beta', 'weigend')
 ETB_BETA = getattr(__config__, 'df_addons_aug_dfbasis', 2.0)
 FIRST_ETB_ELEMENT = getattr(__config__, 'df_addons_aug_start_at', 36)  # 'Rb'
 
+# TODO: Switch to other default scheme for auxiliary basis generation.
+# The auxiliary basis set generated by version 2.6 (and earlier) lacks compact
+# functions. It may cause higher errors in ERI integrals.
+USE_VERSION_26_AUXBASIS = True
+
 # Obtained from http://www.psicode.org/psi4manual/master/basissets_byfamily.html
 DEFAULT_AUXBASIS = {
     # AO basis       JK-fit                     MP2-fit
@@ -72,6 +79,58 @@ class load(ao2mo.load):
     def __init__(self, eri, dataname='j3c'):
         ao2mo.load.__init__(self, eri, dataname)
 
+def _aug_etb_element(nuc_charge, basis, beta):
+    l_max = max(b[0] for b in basis)
+    emin_by_l = [1e99] * (l_max+1)
+    emax_by_l = [0] * (l_max+1)
+    for b in basis:
+        l = b[0]
+        if isinstance(b[1], int):
+            e_c = numpy.array(b[2:])
+        else:
+            e_c = numpy.array(b[1:])
+        es = e_c[:,0]
+        cs = e_c[:,1:]
+        es = es[abs(cs).max(axis=1) > 1e-3]
+        emax_by_l[l] = max(es.max(), emax_by_l[l])
+        emin_by_l[l] = min(es.min(), emin_by_l[l])
+
+    conf = elements.CONFIGURATION[nuc_charge]
+    # 1: H - Be, 2: B - Ca, 3: Sc - La, 4: Ce -
+    max_shells = 4 - conf.count(0)
+
+    if USE_VERSION_26_AUXBASIS:
+        # This is the method that version 2.6 (and earlier) generates auxiliary
+        # basis. It estimates the exponents ranges by geometric average.
+        # This method is not recommended because it tends to generate diffuse
+        # functions. Important compact functions might be improperly excluded.
+        l_max = min(l_max, max_shells)
+        l_max_aux = l_max * 2
+        l_max1 = l_max + 1
+        emin_by_l = numpy.array(emin_by_l[:l_max1])
+        emax_by_l = numpy.array(emax_by_l[:l_max1])
+        emax = (emax_by_l[:,None] * emax_by_l) ** .5 * 2
+        emin = (emin_by_l[:,None] * emin_by_l) ** .5 * 2
+    else:
+        # Using normal average, more auxiliary functions, especially compact
+        # functions, will be generated.
+        l_max_aux = min(l_max, max_shells) * 2
+        l_max1 = l_max + 1
+        emin_by_l = numpy.array(emin_by_l)
+        emax_by_l = numpy.array(emax_by_l)
+        emax = emax_by_l[:,None] + emax_by_l
+        emin = emin_by_l[:,None] + emin_by_l
+
+    liljsum = numpy.arange(l_max1)[:,None] + numpy.arange(l_max1)
+    emax_by_l = numpy.array([emax[liljsum==ll].max() for ll in range(l_max_aux+1)])
+    emin_by_l = numpy.array([emin[liljsum==ll].min() for ll in range(l_max_aux+1)])
+
+    ns = numpy.log((emax_by_l+emin_by_l)/emin_by_l) / numpy.log(beta)
+    etb = []
+    for l, n in enumerate(numpy.ceil(ns).astype(int)):
+        if n > 0:
+            etb.append((l, n, emin_by_l[l], beta))
+    return etb
 
 def aug_etb_for_dfbasis(mol, dfbasis=DFBASIS, beta=ETB_BETA,
                         start_at=FIRST_ETB_ELEMENT):
@@ -86,50 +145,14 @@ def aug_etb_for_dfbasis(mol, dfbasis=DFBASIS, beta=ETB_BETA,
         nuc_charge = gto.charge(symb)
         if nuc_charge < nuc_start:
             newbasis[symb] = dfbasis
-        #?elif symb in mol._ecp:
         else:
-            conf = elements.CONFIGURATION[nuc_charge]
-            max_shells = 4 - conf.count(0)
-            emin_by_l = [1e99] * 8
-            emax_by_l = [0] * 8
-            l_max = 0
-            for b in mol._basis[symb]:
-                l = b[0]
-                l_max = max(l_max, l)
-                if l >= max_shells+1:
-                    continue
-
-                if isinstance(b[1], int):
-                    e_c = numpy.array(b[2:])
-                else:
-                    e_c = numpy.array(b[1:])
-                es = e_c[:,0]
-                cs = e_c[:,1:]
-                es = es[abs(cs).max(axis=1) > 1e-3]
-                emax_by_l[l] = max(es.max(), emax_by_l[l])
-                emin_by_l[l] = min(es.min(), emin_by_l[l])
-
-            l_max1 = l_max + 1
-            emin_by_l = numpy.array(emin_by_l[:l_max1])
-            emax_by_l = numpy.array(emax_by_l[:l_max1])
-
-# Estimate the exponents ranges by geometric average
-            emax = numpy.sqrt(numpy.einsum('i,j->ij', emax_by_l, emax_by_l))
-            emin = numpy.sqrt(numpy.einsum('i,j->ij', emin_by_l, emin_by_l))
-            liljsum = numpy.arange(l_max1)[:,None] + numpy.arange(l_max1)
-            emax_by_l = [emax[liljsum==ll].max() for ll in range(l_max1*2-1)]
-            emin_by_l = [emin[liljsum==ll].min() for ll in range(l_max1*2-1)]
-            # Tune emin and emax
-            emin_by_l = numpy.array(emin_by_l) * 2  # *2 for alpha+alpha on same center
-            emax_by_l = numpy.array(emax_by_l) * 2  #/ (numpy.arange(l_max1*2-1)*.5+1)
-
-            ns = numpy.log((emax_by_l+emin_by_l)/emin_by_l) / numpy.log(beta)
-            etb = []
-            for l, n in enumerate(numpy.ceil(ns).astype(int)):
-                if n > 0:
-                    etb.append((l, n, emin_by_l[l], beta))
+            basis = mol._basis[symb]
+            etb = _aug_etb_element(nuc_charge, basis, beta)
             if etb:
                 newbasis[symb] = gto.expand_etbs(etb)
+                for l, n, emin, beta in etb:
+                    logger.info(mol, 'ETB for %s: l = %d, exps = %s * %g^n , n = 0..%d',
+                                symb, l, emin, beta, n-1)
             else:
                 raise RuntimeError(f'Failed to generate even-tempered auxbasis for {symb}')
 
@@ -182,12 +205,13 @@ def make_auxbasis(mol, mp2fit=False):
         auxbasis.update(auxdefault)
         aux_etb = set(auxbasis) - set(auxdefault)
         if aux_etb:
-            logger.info(mol, 'Even tempered Gaussians are generated as '
+            logger.warn(mol, 'Even tempered Gaussians are generated as '
                         'DF auxbasis for  %s', ' '.join(aux_etb))
             for k in aux_etb:
                 logger.debug(mol, '  ETB auxbasis for %s  %s', k, auxbasis[k])
     return auxbasis
 
+# TODO: add auxbasis keyword etb and auto
 def make_auxmol(mol, auxbasis=None):
     '''Generate a fake Mole object which uses the density fitting auxbasis as
     the basis sets.  If auxbasis is not specified, the optimized auxiliary fitting
@@ -198,26 +222,30 @@ def make_auxmol(mol, auxbasis=None):
     even-tempered Gaussian basis set will be generated.
 
     See also the paper JCTC, 13, 554 about generating auxiliary fitting basis.
+
+    Kwargs:
+        auxbasis : str, list, tuple
+            Similar to the input of orbital basis in Mole object.
     '''
     pmol = mol.copy(deep=False)
 
     if auxbasis is None:
         auxbasis = make_auxbasis(mol)
-    elif isinstance(auxbasis, str) and '+etb' in auxbasis:
-        dfbasis = auxbasis[:-4]
-        auxbasis = aug_etb_for_dfbasis(mol, dfbasis)
     pmol.basis = auxbasis
 
     if isinstance(auxbasis, (str, list, tuple)):
         uniq_atoms = {a[0] for a in mol._atom}
         _basis = {a: auxbasis for a in uniq_atoms}
-    elif 'default' in auxbasis:
-        uniq_atoms = {a[0] for a in mol._atom}
-        _basis = {a: auxbasis['default'] for a in uniq_atoms}
-        _basis.update(auxbasis)
-        del (_basis['default'])
     else:
-        _basis = auxbasis
+        assert isinstance(auxbasis, dict)
+        if 'default' in auxbasis:
+            uniq_atoms = {a[0] for a in mol._atom}
+            _basis = {a: auxbasis['default'] for a in uniq_atoms}
+            _basis.update(auxbasis)
+            del (_basis['default'])
+        else:
+            _basis = auxbasis
+
     pmol._basis = pmol.format_basis(_basis)
 
     # Note: To pass parameters like gauge origin, rsh-omega to auxmol,

pyscf/df/autoaux.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python
+# Copyright 2024 The PySCF Developers. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+'''
+The AutoAux algorithm by ORCA
+
+Ref:
+    JCTC, 13 (2016), 554
+'''
+
+from math import factorial
+import numpy as np
+from pyscf import gto
+from pyscf.lib import logger
+
+F_LAUX   = np.array([20 , 7.0, 4.0, 4.0, 3.5, 2.5, 2.0, 2.0])
+BETA_BIG = np.array([1.8, 2.0, 2.2, 2.2, 2.2, 2.3, 3.0, 3.0])
+BETA_SMALL = 1.8
+
+def _primitive_emin_emax(basis):
+    l_max = max(b[0] for b in basis)
+    emin_by_l = [1e99] * (l_max+1)
+    emax_by_l = [0] * (l_max+1)
+    e_eff_by_l = [0] * (l_max+1)
+
+    for b in basis:
+        l = b[0]
+        if isinstance(b[1], int):
+            e_c = np.array(b[2:])
+        else:
+            e_c = np.array(b[1:])
+        es = e_c[:,0]
+        emax_by_l[l] = max(es.max(), emax_by_l[l])
+        emin_by_l[l] = min(es.min(), emin_by_l[l])
+
+        cs = e_c[:,1:]
+        cs = np.einsum('pi,p->pi', cs, gto.gto_norm(l, es)) # normalize GTOs
+        cs = gto.mole._nomalize_contracted_ao(l, es, cs) # prefactors in r_ints
+        ee = es[:,None] + es
+        r_ints = gto.gaussian_int(l*2+3, ee) # \int \chi^2 r dr
+        r_exp = np.einsum('pi,pq,qi->i', cs, r_ints, cs)
+
+        k = 2**(2*l+1) * factorial(l+1)**2 / factorial(2*l+2)
+        # Eq (9) in the paper, e_eff = 2 * k**2 / (np.pi * r_exp) is a typo.
+        # See also https://github.com/MolSSI-BSE/basis_set_exchange/issues/317
+        # For primitive functions, following expression leads to
+        # e_eff = exponent of the basis
+        e_eff = 2 * k**2 / (np.pi * r_exp**2)
+        # For primitive functions, e_eff may be slightly different to the
+        # exponent due to the rounding errors in gaussian_int function.
+        # When a particular shell has only one primitive function, one auxiliary
+        # function should be generated. This error can introduce an additional
+        # auxiliary function.
+        # Slightly reduce e_eff to remove the extra auxiliary functions.
+        e_eff -= 1e-8
+        e_eff_by_l[l] = max(e_eff.max(), e_eff_by_l[l])
+    return np.array(emax_by_l), np.array(emin_by_l), np.array(e_eff_by_l)
+
+def _auto_aux_element(Z, basis, ecp_core=0):
+    a_max_by_l, a_min_by_l, a_eff_by_l = _primitive_emin_emax(basis)
+    a_min_prim = a_min_by_l[:,None] + a_min_by_l
+    a_max_prim = a_max_by_l[:,None] + a_max_by_l
+    a_max_aux = a_eff_by_l[:,None] + a_eff_by_l
+
+    l_max1 = a_max_by_l.size
+    l_max = l_max1 - 1
+    # TODO: handle ECP
+    if Z <= 2:
+        l_val = 0
+    elif Z <= 20:
+        l_val = 1
+    elif Z <= 56:
+        l_val = 2
+    else:
+        l_val = 3
+    l_inc = 1
+    if Z > 18:
+        l_inc = 2
+    l_max_aux = min(max(l_val*2, l_max+l_inc), l_max*2)
+
+    liljsum = np.arange(l_max1)[:,None] + np.arange(l_max1)
+    liljsub = abs(np.arange(l_max1)[:,None] - np.arange(l_max1))
+    a_min_by_l = [a_min_prim[(liljsub<=ll) & (ll<=liljsum)].min() for ll in range(l_max_aux+1)]
+    a_max_by_l = [a_max_prim[(liljsub<=ll) & (ll<=liljsum)].max() for ll in range(l_max_aux+1)]
+    a_aux_by_l = [a_max_aux [(liljsub<=ll) & (ll<=liljsum)].max() for ll in range(l_max_aux+1)]
+
+    a_max_adjust = [min(F_LAUX[l] * a_aux_by_l[l], a_max_by_l[l])
+                    for l in range(l_val*2+1)]
+    a_max_adjust = a_max_adjust + a_aux_by_l[l_val*2+1 : l_max_aux+1]
+
+    emin = np.array(a_min_by_l)
+    emax = np.array(a_max_adjust)
+
+    ns_small = np.log(a_max_adjust[:l_val*2+1] / emin[:l_val*2+1]) / np.log(BETA_SMALL)
+    etb = []
+    # ns_small+1 to ensure the largest exponent in etb > emax
+    for l, n in enumerate(np.ceil(ns_small).astype(int) + 1):
+        if n > 0:
+            etb.append((l, n, emin[l], BETA_SMALL))
+
+    if l_max_aux > l_val*2:
+        ns_big = (np.log(emax[l_val*2+1:] / emin[l_val*2+1:])
+                  / np.log(BETA_BIG[l_val*2+1:l_max_aux+1]))
+        for l, n in enumerate(np.ceil(ns_big).astype(int) + 1):
+            if n > 0:
+                l = l + l_val*2+1
+                beta = BETA_BIG[l]
+                etb.append((l, n, emin[l], beta))
+    return etb
+
+def autoaux(mol):
+    '''
+    Create an auxiliary basis set for the given orbital basis set using
+    the Auto-Aux algorithm.
+
+    See also: G. L. Stoychev, A. A. Auer, and F. Neese
+    Automatic Generation of Auxiliary Basis Sets
+    J. Chem. Theory Comput. 13, 554 (2017)
+    http://doi.org/10.1021/acs.jctc.6b01041
+    '''
+    from pyscf.gto.basis import bse
+
+    def expand(symb):
+        Z = gto.charge(symb)
+        etb = _auto_aux_element(Z, mol._basis[symb])
+        if etb:
+            for l, n, emin, beta in etb:
+                logger.info(mol, 'ETB for %s: l = %d, exps = %s * %g^n , n = 0..%d',
+                            symb, l, emin, beta, n-1)
+            return gto.expand_etbs(etb)
+        raise RuntimeError(f'Failed to generate even-tempered auxbasis for {symb}')
+
+    uniq_atoms = {a[0] for a in mol._atom}
+    if bse.basis_set_exchange is None:
+        return {symb: expand(symb) for symb in uniq_atoms}
+
+    if isinstance(mol.basis, str):
+        try:
+            elements = [gto.charge(symb) for symb in uniq_atoms]
+            newbasis = bse.autoaux(mol.basis, elements)
+        except KeyError:
+            newbasis = {symb: expand(symb) for symb in uniq_atoms}
+    else:
+        newbasis = {}
+        for symb in uniq_atoms:
+            if symb in mol.basis and isinstance(mol.basis[symb], str):
+                try:
+                    auxbs = bse.autoaux(mol.basis[symb], gto.charge(symb))
+                    newbasis[symb] = next(iter(auxbs.values()))
+                except KeyError:
+                    newbasis[symb] = expand(symb)
+            else:
+                newbasis[symb] = expand(symb)
+    return newbasis
+
+def autoabs(mol):
+    '''
+    Create a Coulomb fitting basis set for the given orbital basis set.
+    See also:
+    R. Yang, A. P. Rendell, and M. J. Frisch
+    Automatically generated Coulomb fitting basis sets: Design and accuracy for systems containing H to Kr
+    J. Chem. Phys. 127, 074102 (2007)
+    http://doi.org/10.1063/1.2752807
+    '''
+    from pyscf.gto.basis import bse
+    if bse is None:
+        print('Package basis-set-exchange not available')
+        raise ImportError
+
+    uniq_atoms = {a[0] for a in mol._atom}
+    if isinstance(mol.basis, str):
+        elements = [gto.charge(symb) for symb in uniq_atoms]
+        newbasis = bse.autoabs(mol.basis, elements)
+    else:
+        newbasis = {}
+        for symb in uniq_atoms:
+            if symb in mol.basis and isinstance(mol.basis[symb], str):
+                auxbs = bse.autoabs(mol.basis[symb], gto.charge(symb))
+                newbasis[symb] = next(iter(auxbs.values()))
+            else:
+                raise NotImplementedError
+    return newbasis

pyscf/df/df.py

@@ -98,6 +98,10 @@ class DF(lib.StreamObject):
         self._vjopt = None
         self._rsh_df = {}  # Range separated Coulomb DF objects
 
+    __getstate__, __setstate__ = lib.generate_pickle_methods(
+            excludes=('_cderi_to_save', '_cderi', '_vjopt', '_rsh_df'),
+            reset_state=True)
+
     @property
     def auxbasis(self):
         return self._auxbasis
@@ -166,7 +170,7 @@ class DF(lib.StreamObject):
                                      max_memory=max_memory, verbose=log)
             else:
                 # Store DF tensor in blocks. This is to reduce the
-                # initiailzation overhead
+                # initialization overhead
                 outcore.cholesky_eri_b(mol, cderi, dataname=self._dataname,
                                        int3c=int3c, int2c=int2c, auxmol=auxmol,
                                        max_memory=max_memory, verbose=log)

pyscf/df/df_jk.py

@@ -132,28 +132,31 @@ class _DFHF:
 
     def get_jk(self, mol=None, dm=None, hermi=1, with_j=True, with_k=True,
                omega=None):
+        assert (with_j or with_k)
         if dm is None: dm = self.make_rdm1()
         if not self.with_df:
             return super().get_jk(mol, dm, hermi, with_j, with_k, omega)
 
+        vj = vk = None
         with_dfk = with_k and not self.only_dfj
-        if isinstance(self, scf.ghf.GHF):
-            def jkbuild(mol, dm, hermi, with_j, with_k, omega=None):
-                vj, vk = self.with_df.get_jk(dm.real, hermi, with_j, with_k,
-                                             self.direct_scf_tol, omega)
-                if dm.dtype == numpy.complex128:
-                    vjI, vkI = self.with_df.get_jk(dm.imag, hermi, with_j, with_k,
-                                                   self.direct_scf_tol, omega)
-                    if with_j:
-                        vj = vj + vjI * 1j
-                    if with_k:
-                        vk = vk + vkI * 1j
-                return vj, vk
-            vj, vk = scf.ghf.get_jk(mol, dm, hermi, with_j, with_dfk,
-                                    jkbuild, omega)
-        else:
-            vj, vk = self.with_df.get_jk(dm, hermi, with_j, with_dfk,
-                                         self.direct_scf_tol, omega)
+        if with_j or with_dfk:
+            if isinstance(self, scf.ghf.GHF):
+                def jkbuild(mol, dm, hermi, with_j, with_k, omega=None):
+                    vj, vk = self.with_df.get_jk(dm.real, hermi, with_j, with_k,
+                                                self.direct_scf_tol, omega)
+                    if dm.dtype == numpy.complex128:
+                        vjI, vkI = self.with_df.get_jk(dm.imag, hermi, with_j, with_k,
+                                                    self.direct_scf_tol, omega)
+                        if with_j:
+                            vj = vj + vjI * 1j
+                        if with_k:
+                            vk = vk + vkI * 1j
+                    return vj, vk
+                vj, vk = scf.ghf.get_jk(mol, dm, hermi, with_j, with_dfk,
+                                        jkbuild, omega)
+            else:
+                vj, vk = self.with_df.get_jk(dm, hermi, with_j, with_dfk,
+                                            self.direct_scf_tol, omega)
         if with_k and not with_dfk:
             vk = super().get_jk(mol, dm, hermi, False, True, omega)[1]
         return vj, vk
@@ -233,7 +236,7 @@ class _DFHF:
         return lib.to_gpu(self, obj)
 
 
-def get_jk(dfobj, dm, hermi=1, with_j=True, with_k=True, direct_scf_tol=1e-13):
+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
@@ -263,8 +266,7 @@ def get_jk(dfobj, dm, hermi=1, with_j=True, with_k=True, direct_scf_tol=1e-13):
     if not with_k:
         for eri1 in dfobj.loop():
             # uses numpy.matmul
-            vj += (dmtril @ eri1.T) @ eri1
-
+            vj += dmtril.dot(eri1.T).dot(eri1)
 
     elif getattr(dm, 'mo_coeff', None) is not None:
         #TODO: test whether dm.mo_coeff matching dm
@@ -294,7 +296,8 @@ def get_jk(dfobj, dm, hermi=1, with_j=True, with_k=True, direct_scf_tol=1e-13):
             assert (nao_pair == nao*(nao+1)//2)
             if with_j:
                 # uses numpy.matmul
-                vj += (dmtril @ eri1.T) @ eri1
+                vj += dmtril.dot(eri1.T).dot(eri1)
+
             for k in range(nset):
                 nocc = orbo[k].shape[1]
                 if nocc > 0:
@@ -321,8 +324,7 @@ def get_jk(dfobj, dm, hermi=1, with_j=True, with_k=True, direct_scf_tol=1e-13):
             naux, nao_pair = eri1.shape
             if with_j:
                 # uses numpy.matmul
-                vj += (dmtril @ eri1.T) @ eri1
-
+                vj += dmtril.dot(eri1.T).dot(eri1)
 
             for k in range(nset):
                 buf1 = buf[0,:naux]
@@ -341,7 +343,7 @@ def get_jk(dfobj, dm, hermi=1, with_j=True, with_k=True, direct_scf_tol=1e-13):
     logger.timer(dfobj, 'df vj and vk', *t0)
     return vj, vk
 
-def get_j(dfobj, dm, hermi=1, direct_scf_tol=1e-13):
+def get_j(dfobj, dm, hermi=0, direct_scf_tol=1e-13):
     from pyscf.scf import _vhf
     from pyscf.scf import jk
     from pyscf.df import addons
@@ -434,7 +436,7 @@ def get_j(dfobj, dm, hermi=1, direct_scf_tol=1e-13):
     return numpy.asarray(vj).reshape(dm_shape)
 
 
-def r_get_jk(dfobj, dms, hermi=1, with_j=True, with_k=True):
+def r_get_jk(dfobj, dms, hermi=0, with_j=True, with_k=True):
     '''Relativistic density fitting JK'''
     t0 = (logger.process_clock(), logger.perf_counter())
     mol = dfobj.mol

pyscf/df/grad/casscf.py

@@ -227,44 +227,3 @@ class Gradients(casci_grad.Gradients):
     to_gpu = lib.to_gpu
 
 Grad = Gradients
-
-#from pyscf import mcscf
-#mcscf.mc1step.CASSCF.Gradients = lib.class_as_method(Gradients)
-
-
-if __name__ == '__main__':
-    from pyscf import scf
-    from pyscf import mcscf
-    from pyscf import df
-    #from pyscf.grad import numeric
-
-    mol = gto.Mole()
-    mol.atom = 'N 0 0 0; N 0 0 1.2; H 1 1 0; H 1 1 1.2'
-    mol.basis = '631g'
-    mol.build()
-    aux = df.aug_etb (mol)
-    mf = scf.RHF(mol).density_fit (auxbasis=aux).run()
-    mc = mcscf.CASSCF(mf, 4, 4).run()
-    mc.conv_tol = 1e-10
-    de = Gradients (mc).kernel()
-    #de_num = numeric.Gradients (mc).kernel ()
-    #print(lib.finger(de) - 0.019602220578635747)
-    #print(lib.finger(de) - lib.finger (de_num))
-
-    mol = gto.Mole()
-    mol.verbose = 0
-    mol.atom = 'N 0 0 0; N 0 0 1.2'
-    mol.basis = 'sto3g'
-    mol.build()
-    mf = scf.RHF(mol).density_fit (auxbasis=aux).run()
-    mc = mcscf.CASSCF(mf, 4, 4)
-    mc.conv_tol = 1e-10
-    mc.kernel ()
-    de = Gradients (mc).kernel()
-
-    mcs = mc.as_scanner()
-    mol.set_geom_('N 0 0 0; N 0 0 1.201')
-    e1 = mcs(mol)
-    mol.set_geom_('N 0 0 0; N 0 0 1.199')
-    e2 = mcs(mol)
-    print(de[1,2], (e1-e2)/0.002*lib.param.BOHR)

pyscf/df/grad/rhf.py

@@ -94,7 +94,10 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
     dm_tril[:,idx] *= .5
 
     # For k
-    orbol, orbor = _decompose_rdm1 (mf_grad, mol, dm)
+    if hermi == 1:
+        orbol, orbor = _decompose_rdm1 (mf_grad, mol, dm)
+    else:
+        orbol, orbor = _decompose_rdm1_svd (mf_grad, mol, dm)
     nocc = [o.shape[-1] for o in orbor]
 
     # Coulomb: (P|Q) D_Q = (P|uv) D_uv for D_Q ("rhoj")
@@ -320,6 +323,33 @@ def _int3c_wrapper(mol, auxmol, intor, aosym):
                        aosym=aosym, cintopt=opt)
     return get_int3c
 
+def _decompose_rdm1_svd (mf_grad, mol, dm):
+    '''Decompose dms as U.Vh using SVD
+
+    Args:
+        mf_grad : instance of :class:`Gradients`
+        mol : instance of :class:`gto.Mole`
+        dm : ndarray or sequence of ndarrays of shape (nao,nao)
+            Density matrices
+
+    Returns:
+        orbol : list of ndarrays of shape (nao,*)
+            Contains non-null eigenvectors of density matrix
+        orbor : list of ndarrays of shape (nao,*)
+            Contains orbol * eigenvalues (occupancies)
+    '''
+    nao = mol.nao
+    dms = numpy.asarray(dm).reshape (-1,nao,nao)
+    orbor = []
+    orbol = []
+    for dm in dms:
+        u, s, vh = numpy.linalg.svd (dm)
+        idx = numpy.abs (s)>1e-8
+        orbol.append (numpy.asfortranarray (u[:,idx]))
+        orbor.append (numpy.asfortranarray (lib.einsum('i,ip->pi', s[idx], vh[idx])))
+
+    return orbol, orbor
+
 def _decompose_rdm1 (mf_grad, mol, dm):
     '''Decompose dms as U.Vh, where
     U = orbol = eigenvectors