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

pyscf/adc/uadc_ea.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Samragni Banerjee <samragnibanerjee4@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -287,22 +290,13 @@ def get_imds(adc, eris=None):
             M_ab_a += lib.einsum('mlfd,mled,aebf->ab',t2_1_ab, t2_1_ab, eris_vvvv, optimize=True)
             del eris_vvvv
 
-            temp = np.zeros((nocc_a,nocc_a,nvir_a,nvir_a))
-            temp[:,:,ab_ind_a[0],ab_ind_a[1]] =  adc.imds.t2_1_vvvv[0]
-            temp[:,:,ab_ind_a[1],ab_ind_a[0]] = -adc.imds.t2_1_vvvv[0]
-
-            M_ab_a -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',t2_1_a, temp, optimize=True)
-            del temp
-
+            M_ab_a -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',
+                                                t2_1_a, adc.imds.t2_1_vvvv[0], optimize=True)
         else:
-
-            temp_t2a_vvvv = np.zeros((nocc_a,nocc_a,nvir_a,nvir_a))
-            temp_t2a_vvvv[:,:,ab_ind_a[0],ab_ind_a[1]] = adc.imds.t2_1_vvvv[0][:]
-            temp_t2a_vvvv[:,:,ab_ind_a[1],ab_ind_a[0]] = -adc.imds.t2_1_vvvv[0][:]
-
-            M_ab_a -= 2*0.5*0.25*lib.einsum('mlad,mlbd->ab',  temp_t2a_vvvv, t2_1_a, optimize=True)
-            M_ab_a -= 2*0.5*0.25*lib.einsum('mlaf,mlbf->ab', t2_1_a, temp_t2a_vvvv, optimize=True)
-            del temp_t2a_vvvv
+            M_ab_a -= 2*0.5*0.25*lib.einsum('mlad,mlbd->ab',
+                                            adc.imds.t2_1_vvvv[0], t2_1_a, optimize=True)
+            M_ab_a -= 2*0.5*0.25*lib.einsum('mlaf,mlbf->ab', t2_1_a,
+                                            adc.imds.t2_1_vvvv[0], optimize=True)
 
         if isinstance(eris.vvvv_p, list):
 
@@ -387,18 +381,20 @@ def get_imds(adc, eris=None):
             M_ab_b += lib.einsum('mlfd,mled,eafb->ab',t2_1_ab, t2_1_ab,   eris_vVvV, optimize=True)
 
             eris_vVvV = eris_vVvV.reshape(nvir_a*nvir_b,nvir_a*nvir_b)
-            temp = adc.imds.t2_1_vvvv[1]
-            M_ab_a -= 0.5*lib.einsum('mlaf,mlbf->ab',t2_1_ab, temp, optimize=True)
-            M_ab_b -= 0.5*lib.einsum('mlfa,mlfb->ab',t2_1_ab, temp, optimize=True)
-            del temp
+
+            M_ab_a -= 0.5*lib.einsum('mlaf,mlbf->ab',t2_1_ab, adc.imds.t2_1_vvvv[1], optimize=True)
+            M_ab_b -= 0.5*lib.einsum('mlfa,mlfb->ab',t2_1_ab, adc.imds.t2_1_vvvv[1], optimize=True)
+
         else:
-            t2_vVvV = adc.imds.t2_1_vvvv[1][:]
+            M_ab_a -= 0.5 * lib.einsum('mlad,mlbd->ab',
+                                       adc.imds.t2_1_vvvv[1], t2_1_ab, optimize=True)
+            M_ab_b -= 0.5 * lib.einsum('mlda,mldb->ab',
+                                       adc.imds.t2_1_vvvv[1], t2_1_ab, optimize=True)
+            M_ab_a -= 0.5 * lib.einsum('mlaf,mlbf->ab', t2_1_ab,
+                                       adc.imds.t2_1_vvvv[1], optimize=True)
+            M_ab_b -= 0.5 * lib.einsum('mlfa,mlfb->ab', t2_1_ab,
+                                       adc.imds.t2_1_vvvv[1], optimize=True)
 
-            M_ab_a -= 0.5 * lib.einsum('mlad,mlbd->ab', t2_vVvV, t2_1_ab, optimize=True)
-            M_ab_b -= 0.5 * lib.einsum('mlda,mldb->ab', t2_vVvV, t2_1_ab, optimize=True)
-            M_ab_a -= 0.5 * lib.einsum('mlaf,mlbf->ab',t2_1_ab, t2_vVvV, optimize=True)
-            M_ab_b -= 0.5 * lib.einsum('mlfa,mlfb->ab',t2_1_ab, t2_vVvV, optimize=True)
-            del t2_vVvV
         del t2_1_a
 
         if isinstance(eris.VVVV_p,np.ndarray):
@@ -409,22 +405,13 @@ def get_imds(adc, eris=None):
             M_ab_b += lib.einsum('mldf,mlde,aebf->ab',t2_1_ab, t2_1_ab, eris_VVVV, optimize=True)
             del eris_VVVV
 
-            temp = np.zeros((nocc_b,nocc_b,nvir_b,nvir_b))
-            temp[:,:,ab_ind_b[0],ab_ind_b[1]] =  adc.imds.t2_1_vvvv[2]
-            temp[:,:,ab_ind_b[1],ab_ind_b[0]] = -adc.imds.t2_1_vvvv[2]
-            M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',t2_1_b, temp, optimize=True)
-            del temp
+            M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',
+                                                t2_1_b, adc.imds.t2_1_vvvv[2], optimize=True)
         else:
-
-            temp_t2b_VVVV = np.zeros((nocc_b,nocc_b,nvir_b,nvir_b))
-            temp_t2b_VVVV[:,:,ab_ind_b[0],ab_ind_b[1]] = adc.imds.t2_1_vvvv[2][:]
-            temp_t2b_VVVV[:,:,ab_ind_b[1],ab_ind_b[0]] = -adc.imds.t2_1_vvvv[2][:]
-
             M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlad,mlbd->ab',
-                                                temp_t2b_VVVV, t2_1_b, optimize=True)
+                                                adc.imds.t2_1_vvvv[2], t2_1_b, optimize=True)
             M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',
-                                                t2_1_b, temp_t2b_VVVV, optimize=True)
-            del temp_t2b_VVVV
+                                                t2_1_b, adc.imds.t2_1_vvvv[2], optimize=True)
 
         if isinstance(eris.vvvv_p, list):
 
@@ -1971,6 +1958,7 @@ class UADCEA(uadc.UADC):
     }
 
     def __init__(self, adc):
+        self.mol = adc.mol
         self.verbose = adc.verbose
         self.stdout = adc.stdout
         self.max_memory = adc.max_memory
@@ -1987,6 +1975,7 @@ class UADCEA(uadc.UADC):
         self._scf = adc._scf
         self._nocc = adc._nocc
         self._nvir = adc._nvir
+        self._nmo = adc._nmo
         self.nocc_a = adc._nocc[0]
         self.nocc_b = adc._nocc[1]
         self.nvir_a = adc._nvir[0]
@@ -1996,14 +1985,14 @@ class UADCEA(uadc.UADC):
         self.mo_energy_b = adc.mo_energy_b
         self.nmo_a = adc._nmo[0]
         self.nmo_b = adc._nmo[1]
-        self.mol = adc.mol
         self.transform_integrals = adc.transform_integrals
         self.with_df = adc.with_df
+        self.compute_properties = adc.compute_properties
+        self.approx_trans_moments = adc.approx_trans_moments
+
         self.spec_factor_print_tol = adc.spec_factor_print_tol
         self.evec_print_tol = adc.evec_print_tol
 
-        self.compute_properties = adc.compute_properties
-        self.approx_trans_moments = adc.approx_trans_moments
         self.E = adc.E
         self.U = adc.U
         self.P = adc.P
@@ -2014,11 +2003,12 @@ class UADCEA(uadc.UADC):
     matvec = matvec
     get_diag = get_diag
     get_trans_moments = get_trans_moments
-    analyze_spec_factor = analyze_spec_factor
     get_properties = get_properties
+
     analyze = analyze
-    compute_dyson_mo = compute_dyson_mo
+    analyze_spec_factor = analyze_spec_factor
     analyze_eigenvector = analyze_eigenvector
+    compute_dyson_mo = compute_dyson_mo
 
     def get_init_guess(self, nroots=1, diag=None, ascending=True):
         if diag is None :

pyscf/adc/uadc_ip.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Samragni Banerjee <samragnibanerjee4@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -1849,6 +1852,7 @@ class UADCIP(uadc.UADC):
     }
 
     def __init__(self, adc):
+        self.mol = adc.mol
         self.verbose = adc.verbose
         self.stdout = adc.stdout
         self.max_memory = adc.max_memory
@@ -1865,6 +1869,7 @@ class UADCIP(uadc.UADC):
         self._scf = adc._scf
         self._nocc = adc._nocc
         self._nvir = adc._nvir
+        self._nmo = adc._nmo
         self.nocc_a = adc._nocc[0]
         self.nocc_b = adc._nocc[1]
         self.nvir_a = adc._nvir[0]
@@ -1874,14 +1879,14 @@ class UADCIP(uadc.UADC):
         self.mo_energy_b = adc.mo_energy_b
         self.nmo_a = adc._nmo[0]
         self.nmo_b = adc._nmo[1]
-        self.mol = adc.mol
         self.transform_integrals = adc.transform_integrals
         self.with_df = adc.with_df
+        self.compute_properties = adc.compute_properties
+        self.approx_trans_moments = adc.approx_trans_moments
+
         self.spec_factor_print_tol = adc.spec_factor_print_tol
         self.evec_print_tol = adc.evec_print_tol
 
-        self.compute_properties = adc.compute_properties
-        self.approx_trans_moments = adc.approx_trans_moments
         self.E = adc.E
         self.U = adc.U
         self.P = adc.P

pyscf/adc/uadc_ip_cvs.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Abdelrahman Ahmed <abdelrahman.maa.ahmed@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 

pyscf/agf2/__init__.py

@@ -17,8 +17,8 @@
 #
 
 '''
-Auxiliary second-order Green's function perturbation therory
-============================================================
+Auxiliary second-order Green's function perturbation theory
+===========================================================
 
 The AGF2 method permits the computation of quasiparticle excitations and 
 ground-state properties at the AGF2(None,0) level. 

pyscf/agf2/aux_space.py

@@ -446,7 +446,7 @@ def combine(*auxspcs):
     '''
 
     nphys = [auxspc.nphys for auxspc in auxspcs]
-    if not all([x == nphys[0] for x in nphys]):
+    if not all(x == nphys[0] for x in nphys):
         raise ValueError('Size of physical space must be the same to '
                          'combine AuxiliarySpace objects.')
     nphys = nphys[0]

pyscf/agf2/chkfile.py

@@ -111,7 +111,7 @@ def load_agf2(chkfile):
 def dump_agf2(agf2, chkfile=None, key='agf2',
               gf=None, se=None, frozen=None, nmom=None,
               mo_energy=None, mo_coeff=None, mo_occ=None):
-    ''' Save the AGF2 calculatuion to a chkfile.
+    ''' Save the AGF2 calculation to a chkfile.
     '''
 
     if mpi_helper.rank != 0:

pyscf/ao2mo/outcore.py

@@ -487,15 +487,17 @@ def _load_from_h5g(h5group, row0, row1, out=None):
         col1 = 0
         for key in range(nkeys):
             col0, col1 = col1, col1 + h5group[str(key)].shape[1]
-            h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,col0:col1],
-                                          source_sel=numpy.s_[row0:row1])
+            if col1 > col0:
+                h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,col0:col1],
+                                            source_sel=numpy.s_[row0:row1])
     else:  # multiple components
         out = numpy.ndarray((dat.shape[0], row1-row0, ncol), dat.dtype, buffer=out)
         col1 = 0
         for key in range(nkeys):
             col0, col1 = col1, col1 + h5group[str(key)].shape[2]
-            h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,:,col0:col1],
-                                          source_sel=numpy.s_[:,row0:row1])
+            if col1 > col0:
+                h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,:,col0:col1],
+                                            source_sel=numpy.s_[:,row0:row1])
     return out
 
 def _transpose_to_h5g(h5group, key, dat, blksize, chunks=None):

pyscf/cc/__init__.py

@@ -23,7 +23,7 @@ Simple usage::
     >>> mf = scf.RHF(mol).run()
     >>> cc.CCSD(mf).run()
 
-:func:`cc.CCSD` returns an instance of CCSD class.  Followings are parameters
+:func:`cc.CCSD` returns an instance of CCSD class.  Following are parameters
 to control CCSD calculation.
 
     verbose : int
@@ -54,8 +54,8 @@ to control CCSD calculation.
 
 Saved results
 
-    converged : bool
-        CCSD converged or not
+    iterinfo : common.IterationInfo
+        Information about iteration (see pyscf.common.Iteration in detail)
     e_tot : float
         Total CCSD energy (HF + correlation)
     t1, t2 :
@@ -216,3 +216,21 @@ def FNOCCSD(mf, thresh=1e-6, pct_occ=None, nvir_act=None, frozen=None):
         return self
     mycc._finalize = _finalize.__get__(mycc, mycc.__class__)
     return mycc
+
+def BCCD(mf, frozen=None, u=None, conv_tol_normu=1e-5, max_cycle=20, diis=True,
+         canonicalization=True):
+    from pyscf.cc.bccd import bccd_kernel_
+    from pyscf.lib import StreamObject
+    mycc = CCSD(mf, frozen=frozen)
+
+    class BCCD(mycc.__class__):
+        def kernel(self):
+            obj = self.view(mycc.__class__)
+            obj.conv_tol = 1e-3
+            obj.kernel()
+            bccd_kernel_(obj, u, conv_tol_normu, max_cycle, diis,
+                         canonicalization, self.verbose)
+            self.__dict__.update(obj.__dict__)
+            return self.e_tot
+
+    return mycc.view(BCCD)

pyscf/cc/bccd.py

@@ -313,49 +313,3 @@ def bccd_kernel_(mycc, u=None, conv_tol_normu=1e-5, max_cycle=20, diis=True,
         mycc.t2 = t2
 
     return mycc
-
-if __name__ == "__main__":
-    import pyscf
-    from pyscf import cc
-
-    np.set_printoptions(3, linewidth=1000, suppress=True)
-    mol = pyscf.M(
-        atom = 'H 0 0 0; F 0 0 1.1',
-        basis = 'ccpvdz',
-        verbose = 4,
-        spin = 0,
-    )
-
-    myhf = mol.HF()
-    myhf.kernel()
-    E_ref = myhf.e_tot
-    rdm1_mf = myhf.make_rdm1()
-
-    mycc = cc.CCSD(myhf, frozen=None)
-    #mycc.frozen = [0]
-    mycc.kernel()
-    mycc.conv_tol = 1e-3
-
-    mycc = bccd_kernel_(mycc, diis=True, verbose=4)
-    e_r = mycc.e_tot
-    e_ccsd_t = mycc.ccsd_t()
-    # PSI4 reference
-    assert abs(e_ccsd_t - -0.002625521337000) < 1e-5
-
-    print (la.norm(mycc.t1))
-    assert la.norm(mycc.t1) < 1e-5
-
-    myhf = mol.UHF()
-    myhf.kernel()
-    myucc = cc.CCSD(myhf, frozen=None)
-    myucc.frozen = [0]
-    myucc.kernel()
-
-    mybcc = bccd_kernel_(myucc)
-    e_u = mybcc.e_tot
-
-    mygcc = cc.addons.convert_to_gccsd(mycc)
-    mybcc = bccd_kernel_(mygcc)
-    e_g = mybcc.e_tot
-    print (abs(e_g - e_r))
-    assert abs(e_g - e_r) < 1e-6

pyscf/cc/ccsd.py

@@ -65,7 +65,8 @@ def kernel(mycc, eris=None, t1=None, t2=None, max_cycle=50, tol=1e-8,
     else:
         adiis = None
 
-    conv = False
+    converged = False
+    mycc.cycles = 0
     for istep in range(max_cycle):
         t1new, t2new = mycc.update_amps(t1, t2, eris)
         if callback is not None:
@@ -83,14 +84,15 @@ def kernel(mycc, eris=None, t1=None, t2=None, max_cycle=50, tol=1e-8,
         t1new = t2new = None
         t1, t2 = mycc.run_diis(t1, t2, istep, normt, eccsd-eold, adiis)
         eold, eccsd = eccsd, mycc.energy(t1, t2, eris)
+        mycc.cycles = istep + 1
         log.info('cycle = %d  E_corr(%s) = %.15g  dE = %.9g  norm(t1,t2) = %.6g',
                  istep+1, name, eccsd, eccsd - eold, normt)
         cput1 = log.timer(f'{name} iter', *cput1)
         if abs(eccsd-eold) < tol and normt < tolnormt:
-            conv = True
+            converged = True
             break
     log.timer(name, *cput0)
-    return conv, eccsd, t1, t2
+    return converged, eccsd, t1, t2
 
 
 def update_amps(mycc, t1, t2, eris):
@@ -582,7 +584,7 @@ def _contract_s4vvvv_t2(mycc, mol, vvvv, t2, out=None, verbose=None):
         tril2sq = lib.square_mat_in_trilu_indices(nvira)
         loadbuf = numpy.empty((blksize,blksize,nvirb,nvirb))
 
-        slices = [(i0, i1) for i0, i1 in lib.prange(0, nvira, blksize)]
+        slices = list(lib.prange(0, nvira, blksize))
         for istep, wwbuf in enumerate(fmap(load, lib.prange(0, nvira, blksize))):
             i0, i1 = slices[istep]
             off0 = i0*(i0+1)//2
@@ -870,7 +872,7 @@ class CCSDBase(lib.StreamObject):
         incore_complete : bool
             Avoid all I/O (also for DIIS). Default is False.
         level_shift : float
-            A shift on virtual orbital energies to stablize the CCSD iteration
+            A shift on virtual orbital energies to stabilize the CCSD iteration
         frozen : int or list
             If integer is given, the inner-most orbitals are frozen from CC
             amplitudes.  Given the orbital indices (0-based) in a list, both
@@ -891,10 +893,10 @@ class CCSDBase(lib.StreamObject):
             callback function can access all local variables in the current
             environment.
 
-    Saved results
+    Saved results:
 
         converged : bool
-            CCSD converged or not
+            Whether the CCSD iteration converged
         e_corr : float
             CCSD correlation correction
         e_tot : float
@@ -903,6 +905,8 @@ class CCSDBase(lib.StreamObject):
             T amplitudes t1[i,a], t2[i,j,a,b]  (i,j in occ, a,b in virt)
         l1, l2 :
             Lambda amplitudes l1[i,a], l2[i,j,a,b]  (i,j in occ, a,b in virt)
+        cycles : int
+            The number of iteration cycles performed
     '''
 
     max_cycle = getattr(__config__, 'cc_ccsd_CCSD_max_cycle', 50)
@@ -929,7 +933,7 @@ class CCSDBase(lib.StreamObject):
         'diis_start_cycle', 'diis_start_energy_diff', 'direct',
         'async_io', 'incore_complete', 'cc2', 'callback',
         'mol', 'verbose', 'stdout', 'frozen', 'level_shift',
-        'mo_coeff', 'mo_occ', 'converged', 'converged_lambda', 'emp2', 'e_hf',
+        'mo_coeff', 'mo_occ', 'cycles', 'converged_lambda', 'emp2', 'e_hf',
         'e_corr', 't1', 't2', 'l1', 'l2', 'chkfile',
     }
 
@@ -959,6 +963,7 @@ class CCSDBase(lib.StreamObject):
         self.mo_coeff = mo_coeff
         self.mo_occ = mo_occ
         self.converged = False
+        self.cycles = None
         self.converged_lambda = False
         self.emp2 = None
         self.e_hf = None
@@ -971,6 +976,9 @@ class CCSDBase(lib.StreamObject):
         self._nmo = None
         self.chkfile = mf.chkfile
 
+    __getstate__, __setstate__ = lib.generate_pickle_methods(
+            excludes=('chkfile', 'callback'))
+
     @property
     def ecc(self):
         return self.e_corr

pyscf/cc/uccsd.py

@@ -398,7 +398,7 @@ def vector_to_amplitudes(vector, nmo, nocc):
     size = nov + nocc*(nocc-1)//2*nvir*(nvir-1)//2
     if vector.size == size:
         #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

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, 'l = %d, exps = %s * %g^n for n = 0..%d',
+                                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,