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

pyscf/fci/direct_spin1.py

@@ -50,7 +50,7 @@ from pyscf.fci import rdm
 from pyscf.fci import spin_op
 from pyscf.fci import addons
 from pyscf.fci.spin_op import contract_ss
-from pyscf.fci.addons import _unpack_nelec
+from pyscf.fci.addons import _unpack_nelec, civec_spinless_repr
 from pyscf import __config__
 
 libfci = cistring.libfci
@@ -371,6 +371,46 @@ def make_rdm12(fcivec, norb, nelec, link_index=None, reorder=True):
         dm1, dm2 = rdm.reorder_rdm(dm1, dm2, inplace=True)
     return dm1, dm2
 
+def make_rdm123(fcivec, norb, nelec, link_index=None, reorder=True):
+    '''Spin traced 1-, 2-, and 3-particle density matrices.'''
+    dm1, dm2, dm3 = rdm.make_dm123('FCI3pdm_kern_sf', fcivec, fcivec, norb, nelec)
+    if reorder:
+        dm1, dm2, dm3 = rdm.reorder_dm123(dm1, dm2, dm3, inplace=True)
+    return dm1, dm2, dm3
+
+def make_rdm123s(fcivec, norb, nelec, link_index=None, reorder=True):
+    r'''Spin separated 1-, 2-, and 3-particle density matrices.
+
+    1pdm[p,q] = :math:`\langle q_\alpha^\dagger p_\alpha \rangle +
+                       \langle q_\beta^\dagger  p_\beta \rangle`;
+    2pdm[p,q,r,s] = :math:`\langle p_\alpha^\dagger r_\alpha^\dagger s_\alpha q_\alpha\rangle +
+                           \langle p_\beta^\dagger  r_\alpha^\dagger s_\alpha q_\beta\rangle +
+                           \langle p_\alpha^\dagger r_\beta^\dagger  s_\beta  q_\alpha\rangle +
+                           \langle p_\beta^\dagger  r_\beta^\dagger  s_\beta  q_\beta\rangle`.
+    '''
+    if (not reorder):
+        raise NotImplementedError('reorder=False not currently supported')
+    ci_spinless = civec_spinless_repr([fcivec,], norb, [nelec,])
+    rdm1, rdm2, rdm3 = make_rdm123(ci_spinless, norb*2, (nelec[0]+nelec[1],0))
+
+    rdm1a = rdm1[:norb,:norb]
+    rdm1b = rdm1[norb:,norb:]
+    # assert np.allclose(rdm1a+rdm1b, rdm1)
+
+    rdm2aa = rdm2[:norb,:norb,:norb,:norb]
+    rdm2ab = rdm2[:norb,:norb,norb:,norb:]
+    rdm2bb = rdm2[norb:,norb:,norb:,norb:]
+    # assert np.allclose(rdm2aa+rdm2bb+rdm2ab+rdm2ab.transpose(2,3,0,1), rdm2)
+
+    rdm3aaa = rdm3[:norb,:norb,:norb,:norb,:norb,:norb]
+    rdm3aab = rdm3[:norb,:norb,:norb,:norb,norb:,norb:]
+    rdm3abb = rdm3[:norb,:norb,norb:,norb:,norb:,norb:]
+    rdm3bbb = rdm3[norb:,norb:,norb:,norb:,norb:,norb:]
+    # assert np.allclose(rdm3aaa+rdm3bbb+rdm3aab+rdm3aab.transpose(0,1,4,5,2,3)+\
+    # rdm3aab.transpose(4,5,0,1,2,3)+rdm3abb+rdm3abb.transpose(2,3,0,1,4,5)+rdm3abb.transpose(2,3,4,5,0,1), rdm3)
+    return (rdm1a, rdm1b), (rdm2aa, rdm2ab, rdm2bb), (rdm3aaa, rdm3aab, rdm3abb, rdm3bbb)
+
+
 def trans_rdm1s(cibra, ciket, norb, nelec, link_index=None):
     r'''Spin separated transition 1-particle density matrices.
     The return values include two density matrices: (alpha,alpha), (beta,beta).
@@ -440,8 +480,11 @@ def _get_init_guess(na, nb, nroots, hdiag, nelec):
     ci0 = []
     neleca, nelecb = _unpack_nelec(nelec)
     if neleca == nelecb and na == nb:
-        hdiag = hdiag.reshape(na, na)
-        addrs = numpy.argpartition(lib.pack_tril(hdiag), nroots-1)[:nroots]
+        hdiag = lib.pack_tril(hdiag.reshape(na, na))
+        if hdiag.size <= nroots:
+            addrs = numpy.arange(hdiag.size)
+        else:
+            addrs = numpy.argpartition(hdiag, nroots-1)[:nroots]
         for addr in addrs:
             addra = (int)((2*addr+.25)**.5 - .5 + 1e-7)
             addrb = addr - addra*(addra+1)//2
@@ -449,7 +492,10 @@ def _get_init_guess(na, nb, nroots, hdiag, nelec):
             x[addra,addrb] = 1
             ci0.append(x.ravel().view(FCIvector))
     else:
-        addrs = numpy.argpartition(hdiag, nroots-1)[:nroots]
+        if hdiag.size <= nroots:
+            addrs = numpy.arange(hdiag.size)
+        else:
+            addrs = numpy.argpartition(hdiag, nroots-1)[:nroots]
         for addr in addrs:
             x = numpy.zeros((na*nb))
             x[addr] = 1
@@ -505,8 +551,8 @@ def kernel_ms1(fci, h1e, eri, norb, nelec, ci0=None, link_index=None,
         nroots: int
             Number of states to solve
         davidson_only: bool
-            Whether to call subspace diagonlization (davidson solver) or do a
-            full diagonlization (lapack eigh) for small systems
+            Whether to call subspace diagonalization (davidson solver) or do a
+            full diagonalization (lapack eigh) for small systems
         pspace_size: int
             Number of determinants as the threshold of "small systems",
         hop: function(c) => array_like_c
@@ -663,7 +709,7 @@ class FCIBase(lib.StreamObject):
             problems being solved by Davidson subspace algorithm.  This flag
             should be enabled when initial guess is given or particular spin
             symmetry or point-group symmetry is required because the initial
-            guess or symmetry are completely ignored in the direct diagonlization.
+            guess or symmetry are completely ignored in the direct diagonalization.
         pspace_size : int
             The dimension of Hamiltonian matrix over which Davidson iteration
             algorithm will be used for the eigenvalue problem.  Default is 400.
@@ -710,8 +756,8 @@ class FCIBase(lib.StreamObject):
     # dependence basis in davidson diagonalization solver
     level_shift = getattr(__config__, 'fci_direct_spin1_FCI_level_shift', 1e-3)
 
-    # force the diagonlization use davidson iteration.  When the CI space
-    # is small, the solver exactly diagonlizes the Hamiltonian.  But this
+    # force the diagonalization use davidson iteration.  When the CI space
+    # is small, the solver exactly diagonalizes the Hamiltonian.  But this
     # solution will ignore the initial guess.  Setting davidson_only can
     # enforce the solution on the initial guess state
     davidson_only = getattr(__config__, 'fci_direct_spin1_FCI_davidson_only', False)
@@ -884,6 +930,16 @@ class FCIBase(lib.StreamObject):
         nelec = _unpack_nelec(nelec, self.spin)
         return make_rdm12(fcivec, norb, nelec, link_index, reorder)
 
+    @lib.with_doc(make_rdm123s.__doc__)
+    def make_rdm123s(self, fcivec, norb, nelec, link_index=None, reorder=True):
+        nelec = _unpack_nelec(nelec, self.spin)
+        return make_rdm123s(fcivec, norb, nelec, link_index, reorder)
+
+    @lib.with_doc(make_rdm123.__doc__)
+    def make_rdm123(self, fcivec, norb, nelec, link_index=None, reorder=True):
+        nelec = _unpack_nelec(nelec, self.spin)
+        return make_rdm123(fcivec, norb, nelec, link_index, reorder)
+
     def make_rdm2(self, fcivec, norb, nelec, link_index=None, reorder=True):
         r'''Spin traced 2-particle density matrice
 

pyscf/fci/direct_spin1_symm.py

@@ -217,22 +217,28 @@ def _get_init_guess(airreps, birreps, nroots, hdiag, nelec, orbsym, wfnsym=0):
     neleca, nelecb = _unpack_nelec(nelec)
     na = len(airreps)
     nb = len(birreps)
-    hdiag = hdiag.reshape(na,nb)
     sym_allowed = airreps[:,None] == wfnsym ^ birreps
     if neleca == nelecb and na == nb:
         idx = np.arange(na)
         sym_allowed[idx[:,None] < idx] = False
     idx_a, idx_b = np.where(sym_allowed)
 
+    hdiag = hdiag.reshape(na,nb)[idx_a,idx_b]
+    if hdiag.size <= nroots:
+        hdiag_indices = np.arange(hdiag.size)
+    else:
+        hdiag_indices = np.argpartition(hdiag, nroots-1)[:nroots]
+
     ci0 = []
-    for k in np.argpartition(hdiag[idx_a,idx_b], nroots-1)[:nroots]:
+    for k in hdiag_indices:
         addra, addrb = idx_a[k], idx_b[k]
         x = np.zeros((na, nb))
         x[addra,addrb] = 1
         ci0.append(x.ravel().view(direct_spin1.FCIvector))
 
     if len(ci0) == 0:
-        raise RuntimeError(f'Initial guess for symmetry {wfnsym} not found')
+        raise lib.exceptions.WfnSymmetryError(
+            f'Initial guess for symmetry {wfnsym} not found')
     return ci0
 
 def get_init_guess(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
@@ -248,13 +254,18 @@ def get_init_guess(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
         return _get_init_guess(airreps, birreps, nroots, hdiag, nelec, orbsym, wfnsym)
 
     ci0 = []
-    for k in np.argpartition(hdiag, nroots-1)[:nroots]:
+    if hdiag.size <= nroots:
+        hdiag_indices = np.arange(hdiag.size)
+    else:
+        hdiag_indices = np.argpartition(hdiag, nroots-1)[:nroots]
+    for k in hdiag_indices:
         x = np.zeros_like(hdiag)
         x[k] = 1.
         ci0.append(x.ravel().view(direct_spin1.FCIvector))
 
     if len(ci0) == 0:
-        raise RuntimeError(f'Initial guess for symmetry {wfnsym} not found')
+        raise lib.exceptions.WfnSymmetryError(
+            f'Initial guess for symmetry {wfnsym} not found')
     return ci0
 
 def _validate_degen_mapping(mapping, norb):
@@ -301,6 +312,13 @@ def get_init_guess_cyl_sym(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
             addra1, sign_a = _sv_associated_det(strsa[addra], degen_mapping)
             addrb1, sign_b = _sv_associated_det(strsb[addrb], degen_mapping)
             if wfnsym in (1, 4) and addra == addra1 and addrb == addrb1:
+                # Remove the A1 repr from initial guess.
+                # The product of two E reprs can produce A1, A2 and another E repr.
+                # addra == addra1 and addrb == addrb1  can be found in the A1 repr.
+                # However, this may also incorrectly remove the A2 repr, see the
+                # explanation in issue #2291.
+                # In this case, the direct_spin1_cyl_sym solver can be used to
+                # solve A2. See example mcscf/18-o2_spatial_spin_symmetry.py
                 continue
             x = ca[:,None] * cb
 
@@ -339,7 +357,8 @@ def get_init_guess_cyl_sym(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
             break
 
     if len(ci0) == 0:
-        raise RuntimeError(f'Initial guess for symmetry {wfnsym} not found')
+        raise lib.exceptions.WfnSymmetryError(
+            f'Initial guess for symmetry {wfnsym} not found')
     return ci0
 
 def _cyl_sym_csf2civec(strs, addr, orbsym, degen_mapping):
@@ -500,19 +519,34 @@ def _guess_wfnsym_cyl_sym(civec, strsa, strsb, orbsym):
     if wfn_momentum == 0:
         # For A1g and A1u, CI coefficient and its sigma_v associated one have
         # the same sign
-        if (sign_a*sign_b * c_max[0,0].real * c_max[1,1].real > 1e-6 or
-            sign_a*sign_b * c_max[0,0].imag * c_max[1,1].imag > 1e-6):  # A1
+        if (sign_a*sign_b * c_max[0,0].real * c_max[1,1].real > 1e-4 or
+            sign_a*sign_b * c_max[0,0].imag * c_max[1,1].imag > 1e-4):  # A1
             if wfn_ungerade:
                 wfnsym = 5
             else:
                 wfnsym = 0
-        else:
+        elif (sign_a*sign_b * c_max[0,0].real * c_max[1,1].real < -1e-4 or
+              sign_a*sign_b * c_max[0,0].imag * c_max[1,1].imag < -1e-4):  # A2
             # For A2g and A2u, CI coefficient and its sigma_v associated one
             # have opposite signs
             if wfn_ungerade:
                 wfnsym = 4
             else:
                 wfnsym = 1
+        elif abs(c_max[0,1] - c_max[1,0]) < 1e-4: # Off-diagonal terms only
+            # (E+)(E-') + (E-)(E+') => A1
+            if wfn_ungerade:
+                wfnsym = 5
+            else:
+                wfnsym = 0
+        elif abs(c_max[0,1] + c_max[1,0]) < 1e-4:
+            # (E+)(E-') - (E-)(E+') => A2
+            if wfn_ungerade:
+                wfnsym = 4
+            else:
+                wfnsym = 1
+        else:
+            raise RuntimeError('Symmetry broken wavefunction')
 
     elif wfn_momentum % 2 == 1:
         if abs(c_max[idx_a,idx_b].real) > 1e-6:  # Ex
@@ -582,8 +616,9 @@ def guess_wfnsym(solver, norb, nelec, fcivec=None, orbsym=None, wfnsym=None, **k
                 fcivec = fcivec[0]
             wfnsym1 = _guess_wfnsym_cyl_sym(fcivec, strsa, strsb, orbsym)
             if wfnsym1 != _id_wfnsym(solver, norb, nelec, orbsym, wfnsym):
-                raise RuntimeError(f'Input wfnsym {wfnsym} is not consistent with '
-                                   f'fcivec symmetry {wfnsym1}')
+                raise lib.exceptions.WfnSymmetryError(
+                    f'Input wfnsym {wfnsym} is not consistent with '
+                    f'fcivec symmetry {wfnsym1}')
             wfnsym = wfnsym1
         else:
             na, nb = strsa.size, strsb.size
@@ -601,8 +636,8 @@ def guess_wfnsym(solver, norb, nelec, fcivec=None, orbsym=None, wfnsym=None, **k
             if isinstance(fcivec, np.ndarray) and fcivec.ndim <= 2:
                 fcivec = [fcivec]
             if all(abs(c.reshape(na, nb)[mask]).max() < 1e-5 for c in fcivec):
-                raise RuntimeError('Input wfnsym {wfnsym} is not consistent with '
-                                   'fcivec coefficients')
+                raise lib.exceptions.WfnSymmetryError(
+                    'Input wfnsym {wfnsym} is not consistent with fcivec coefficients')
     return wfnsym
 
 def sym_allowed_indices(nelec, orbsym, wfnsym):
@@ -771,7 +806,7 @@ class FCISolver(direct_spin1.FCISolver):
         logger.debug(self, 'Num symmetry allowed elements %d',
                      sum([x.size for x in self.sym_allowed_idx]))
         if s_idx.size == 0:
-            raise RuntimeError(
+            raise lib.exceptions.WfnSymmetryError(
                 f'Symmetry allowed determinants not found for wfnsym {wfnsym}')
 
         if wfnsym_ir > 7:

pyscf/fci/direct_uhf.py

@@ -41,7 +41,7 @@ from pyscf.fci.spin_op import spin_square
 
 libfci = direct_spin1.libfci
 
-# When the spin-orbitals do not have the degeneracy on spacial part,
+# When the spin-orbitals do not have the degeneracy on spatial part,
 # there is only one version of FCI which is close to _spin1 solver.
 # The inputs: h1e has two parts (h1e_a, h1e_b),
 # h2e has three parts (h2e_aa, h2e_ab, h2e_bb)
@@ -198,7 +198,7 @@ def pspace(h1e, eri, norb, nelec, hdiag=None, np=400):
     na = cistring.num_strings(norb, neleca)
     nb = cistring.num_strings(norb, nelecb)
     assert hdiag.size == na * nb
-    if hdiag.size < np:
+    if hdiag.size <= np:
         addr = numpy.arange(hdiag.size)
     else:
         try:
@@ -245,14 +245,14 @@ def energy(h1e, eri, fcivec, norb, nelec, link_index=None):
 # dm_pq = <|p^+ q|>
 make_rdm1s = direct_spin1.make_rdm1s
 
-# spacial part of DM, dm_pq = <|p^+ q|>
+# spatial part of DM, dm_pq = <|p^+ q|>
 def make_rdm1(fcivec, norb, nelec, link_index=None):
     raise ValueError('Spin trace for UHF-FCI density matrices.')
 
 make_rdm12s = direct_spin1.make_rdm12s
 trans_rdm1s = direct_spin1.trans_rdm1s
 
-# spacial part of DM
+# spatial part of DM
 def trans_rdm1(cibra, ciket, norb, nelec, link_index=None):
     raise ValueError('Spin trace for UHF-FCI density matrices.')
 

pyscf/fci/selected_ci_symm.py

@@ -178,7 +178,7 @@ class SelectedCI(selected_ci.SelectedCI):
                 wfnsym = [addons._guess_wfnsym(c, strsa, strsb, orbsym)
                           for c in fcivec]
                 if any(wfnsym[0] != x for x in wfnsym):
-                    warnings.warn('Different wfnsym %s found in different CI vecotrs' % wfnsym)
+                    warnings.warn('Different wfnsym %s found in different CI vectors' % wfnsym)
                 wfnsym = wfnsym[0]
 
         else:

pyscf/grad/lagrange.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 import numpy as np
+import scipy
 from scipy import linalg, optimize
 from scipy.sparse import linalg as sparse_linalg
 from pyscf import lib, __config__
@@ -126,9 +127,9 @@ class Gradients (rhf_grad.GradientsBase):
         prec_obj = sparse_linalg.LinearOperator ((self.nlag,self.nlag), matvec=precond,
                                                  dtype=bvec.dtype)
         x0_guess = self.get_init_guess (bvec, Adiag, Aop, precond)
-        Lvec, info_int = sparse_linalg.cg(Aop_obj, -bvec, x0=x0_guess,
-                                          tol=self.conv_rtol, atol=self.conv_atol,
-                                          maxiter=self.max_cycle, callback=my_call, M=prec_obj)
+        Lvec, info_int = _cg(Aop_obj, -bvec, x0=x0_guess,
+                             tol=self.conv_rtol, atol=self.conv_atol,
+                             maxiter=self.max_cycle, callback=my_call, M=prec_obj)
         logger.info (self, ('Lagrange multiplier determination {} after {} iterations\n'
                             '   |geff| = {}, |Lvec| = {}').format (
                                 'converged' if info_int == 0 else 'not converged',
@@ -190,3 +191,10 @@ class LagPrec :
         Adiagd[abs(Adiagd)<1e-8] = 1e-8
         x /= Adiagd
         return x
+
+if int (scipy.__version__.split('.')[1]) >= 14: # scipy 1.14
+    def _cg(A, b, x0=None, *, tol=1e-05, atol=0.0, maxiter=None, M=None, callback=None):
+        return sparse_linalg.cg(A, b, x0, rtol=tol, atol=atol, maxiter=maxiter,
+                                M=M, callback=callback)
+else:
+    _cg = sparse_linalg.cg

pyscf/grad/mp2.py

@@ -42,7 +42,7 @@ def grad_elec(mp_grad, t2, atmlst=None, verbose=logger.INFO):
     doo, dvv = d1
     time1 = log.timer_debug1('rdm1 intermediates', *time0)
 
-# Set nocc, nvir for half-transformation of 2pdm.  Frozen orbitals are exculded.
+# Set nocc, nvir for half-transformation of 2pdm.  Frozen orbitals are excluded.
 # nocc, nvir should be updated to include the frozen orbitals when proceeding
 # the 1-particle quantities later.
     mol = mp_grad.mol

pyscf/grad/sacasscf.py

@@ -876,7 +876,7 @@ class SACASLagPrec (lagrange.LagPrec):
                 except Exception as e:
                     print (i, j, desort_spin)
                     raise (e)
-        assert (all ([i is not None for i in Mxci]))
+        assert (all (i is not None for i in Mxci))
         return Mxci
 
 mcscf.addons.StateAverageMCSCFSolver.Gradients = lib.class_as_method(Gradients)

pyscf/grad/tdrks.py

@@ -307,7 +307,7 @@ def _contract_xc_kernel(td_grad, xc_code, dmvo, dmoo=None, with_vxc=True,
             rho *= .5
             rho = numpy.repeat(rho[numpy.newaxis], 2, axis=0)
             vxc, fxc, kxc = ni.eval_xc_eff(xc_code, rho, deriv, xctype=xctype)[1:]
-            # fxc_t couples triplet excitation amplitues
+            # fxc_t couples triplet excitation amplitudes
             # 1/2 int (tia - tIA) fxc (tjb - tJB) = tia fxc_t tjb
             fxc_t = fxc[:,:,0] - fxc[:,:,1]
             fxc_t = fxc_t[0] - fxc_t[1]

pyscf/gto/basis/__init__.py

@@ -413,6 +413,11 @@ PP_ALIAS = {
     'gthhfrev'   : 'gth-hf-rev.dat' ,
 }
 
+SAP_ALIAS = {
+    'sapgraspsmall'   : 'sap_grasp_small.dat',
+    'sapgrasplarge'   : 'sap_grasp_large.dat',
+}
+
 def _is_pople_basis(basis):
     return (basis.startswith('631') or
             basis.startswith('321') or
@@ -603,6 +608,8 @@ def load(filename_or_basisname, symb, optimize=OPTIMIZE_CONTRACTION):
         basis_dir = _GTH_BASIS_DIR
     elif _is_pople_basis(name):
         basmod = _parse_pople_basis(name, symb)
+    elif name in SAP_ALIAS:
+        basmod = SAP_ALIAS[name]
     else:
         try:
             return parse_nwchem.parse(filename_or_basisname, symb,

pyscf/gto/basis/bse.py

@@ -11,13 +11,16 @@ except ImportError:
     basis_set_exchange = None
 
 
-def _orbital_basis(basis):
+def _orbital_basis(basis, make_general=False):
     '''Extracts the orbital basis from the BSE format in PySCF format'''
 
     r = {}
 
-    basis = manip.make_general(basis, False, True)
-    basis = sort.sort_basis(basis, False)
+    if make_general:
+        basis = manip.make_general(basis, False, use_copy=True)
+        basis = sort.sort_basis(basis, use_copy=False)
+    else:
+        basis = sort.sort_basis(basis, use_copy=True)
 
     # Elements for which we have electron basis
     electron_elements = [k for k, v in basis['elements'].items() if 'electron_shells' in v]
@@ -40,21 +43,29 @@ def _orbital_basis(basis):
                 ncontr = len(coefficients)
                 nprim = len(exponents)
                 am = shell['angular_momentum']
-                assert len(am) == 1
-
-                shell_data = [am[0]]
-                for iprim in range(nprim):
-                    row = [float(coefficients[ic][iprim]) for ic in range(ncontr)]
-                    row.insert(0, float(exponents[iprim]))
-                    shell_data.append(row)
-                atom_shells.append(shell_data)
+                if len(am) == len(coefficients): # SP basis
+                    for l, c in zip(am, coefficients):
+                        shell_data = [l]
+                        for iprim in range(nprim):
+                            row = [float(exponents[iprim]), float(c[iprim])]
+                            shell_data.append(row)
+                        atom_shells.append(shell_data)
+                else:
+                    assert len(am) == 1
+                    shell_data = [am[0]]
+                    for iprim in range(nprim):
+                        row = [float(coefficients[ic][iprim]) for ic in range(ncontr)]
+                        row.insert(0, float(exponents[iprim]))
+                        shell_data.append(row)
+                    atom_shells.append(shell_data)
             r[sym] = atom_shells
 
             # Collect the literature references
-            for ref in data['references']:
-                for key in ref['reference_keys']:
-                    if key not in reference_list:
-                        reference_list.append(key)
+            if 'references' in data:
+                for ref in data['references']:
+                    for key in ref['reference_keys']:
+                        if key not in reference_list:
+                            reference_list.append(key)
 
     return r, reference_list
 
@@ -110,6 +121,48 @@ def _print_basis_information(basis):
     print('Last revised on {}'.format(revision_date))
     print('Revision description: {}'.format(revision_description))
 
+def get_basis(name, elements):
+    '''
+    Obtain a basis set
+
+    Args:
+        name : str
+            Name of the basis set, case insensitive.
+        elements : str, int or list
+
+    Returns:
+        A dict of basis set in PySCF internal basis format.
+    '''
+    basis = basis_set_exchange.api.get_basis(name, elements)
+    return _orbital_basis(basis)[0]
+
+def autoaux(name, elements):
+    '''
+    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
+    '''
+    obs = basis_set_exchange.api.get_basis(name, elements)
+    auxbs = manip.autoaux_basis(obs)
+    return _orbital_basis(auxbs)[0]
+
+def autoabs(name, elements):
+    '''
+    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
+    '''
+    obs = basis_set_exchange.api.get_basis(name, elements)
+    auxbs = manip.autoabs_basis(obs)
+    return _orbital_basis(auxbs)[0]
+
 if __name__ == '__main__':
     from basis_set_exchange import api, references
 

pyscf/gto/basis/parse_cp2k_pp.py

@@ -84,7 +84,7 @@ def _parse(plines):
             for h in plines.pop(0).split():
                 hproj_p_ij.append(float(h))
         hproj_p = np.zeros((nproj[-1],nproj[-1]))
-        hproj_p[np.triu_indices(nproj[-1])] = [ h for h in hproj_p_ij ]
+        hproj_p[np.triu_indices(nproj[-1])] = list(hproj_p_ij)
         hproj_p_symm = hproj_p + hproj_p.T - np.diag(hproj_p.diagonal())
         hproj.append(hproj_p_symm.tolist())
 

pyscf/gto/basis/parse_nwchem.py

@@ -212,7 +212,7 @@ def optimize_contraction(basis):
             key = tuple(b[:1])
             ec = numpy.array(b[1:]).T
         es = ec[0]
-        cs = [c for c in ec[1:]]
+        cs = list(ec[1:])
 
         if key not in basdic:
             basdic[key] = []

pyscf/gto/basis/parse_nwchem_ecp.py

@@ -109,7 +109,8 @@ def _parse_ecp(raw_ecp):
                     coef = list(eval(','.join(line[1:])))
             except Exception:
                 raise BasisNotFoundError('Not basis data')
-            by_ang[l].append(coef)
+            if any(x != 0 for x in coef[1:]):
+                by_ang[l].append(coef)
 
     if nelec is None:
         return []