pyscf 2.7.0__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):
@@ -2723,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)
@@ -2856,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

@@ -47,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

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:
@@ -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/fci/direct_spin1.py

@@ -775,7 +775,6 @@ class FCIBase(lib.StreamObject):
 
     def __init__(self, mol=None):
         if mol is None:
-            self.stdout = sys.stdout
             self.verbose = logger.NOTE
             self.max_memory = lib.param.MAX_MEMORY
         else:

pyscf/grad/ccsd.py

@@ -33,7 +33,7 @@ from pyscf.cc import ccsd_rdm
 from pyscf.ao2mo import _ao2mo
 from pyscf.scf import cphf
 from pyscf.grad import rhf as rhf_grad
-from pyscf.grad.mp2 import _shell_prange, _index_frozen_active
+from pyscf.grad.mp2 import _shell_prange, _index_frozen_active, has_frozen_orbitals
 
 
 #
@@ -71,9 +71,7 @@ def grad_elec(cc_grad, t1=None, t2=None, l1=None, l2=None, eris=None, atmlst=Non
     mo_energy = mycc._scf.mo_energy
     nao, nmo = mo_coeff.shape
     nocc = numpy.count_nonzero(mycc.mo_occ > 0)
-    with_frozen = not ((mycc.frozen is None)
-                       or (isinstance(mycc.frozen, (int, numpy.integer)) and mycc.frozen == 0)
-                       or (len(mycc.frozen) == 0))
+    with_frozen = has_frozen_orbitals(mycc)
     OA, VA, OF, VF = _index_frozen_active(mycc.get_frozen_mask(), mycc.mo_occ)
 
     log.debug('symmetrized rdm2 and MO->AO transformation')
@@ -267,9 +265,7 @@ class CCSD_GradScanner(lib.GradScanner):
 def _response_dm1(mycc, Xvo, eris=None):
     nvir, nocc = Xvo.shape
     nmo = nocc + nvir
-    with_frozen = not ((mycc.frozen is None)
-                       or (isinstance(mycc.frozen, (int, numpy.integer)) and mycc.frozen == 0)
-                       or (len(mycc.frozen) == 0))
+    with_frozen = has_frozen_orbitals(mycc)
     if eris is None or with_frozen:
         mo_energy = mycc._scf.mo_energy
         mo_occ = mycc.mo_occ

pyscf/grad/ccsd_slow.py

@@ -29,6 +29,7 @@ from pyscf import lib
 from pyscf import ao2mo
 from pyscf.cc import ccsd_rdm
 from pyscf.grad import ccsd as ccsd_grad
+from pyscf.grad.mp2 import has_frozen_orbitals
 
 def kernel(cc, t1, t2, l1, l2, eris=None):
     if eris is None:
@@ -40,9 +41,7 @@ def kernel(cc, t1, t2, l1, l2, eris=None):
     nocc = numpy.count_nonzero(cc.mo_occ > 0)
     mo_e_o = mo_energy[:nocc]
     mo_e_v = mo_energy[nocc:]
-    with_frozen = not ((cc.frozen is None)
-                       or (isinstance(cc.frozen, (int, numpy.integer)) and cc.frozen == 0)
-                       or (len(cc.frozen) == 0))
+    with_frozen = has_frozen_orbitals(cc)
 
     d1 = _gamma1_intermediates(cc, t1, t2, l1, l2)
     d2 = _gamma2_intermediates(cc, t1, t2, l1, l2)

pyscf/grad/mp2.py

@@ -46,9 +46,7 @@ def grad_elec(mp_grad, t2, atmlst=None, verbose=logger.INFO):
 # nocc, nvir should be updated to include the frozen orbitals when proceeding
 # the 1-particle quantities later.
     mol = mp_grad.mol
-    with_frozen = not ((mp.frozen is None)
-                       or (isinstance(mp.frozen, (int, numpy.integer)) and mp.frozen == 0)
-                       or (len(mp.frozen) == 0))
+    with_frozen = has_frozen_orbitals(mp)
     OA, VA, OF, VF = _index_frozen_active(mp.get_frozen_mask(), mp.mo_occ)
     orbo = mp.mo_coeff[:,OA]
     orbv = mp.mo_coeff[:,VA]
@@ -188,6 +186,17 @@ def grad_elec(mp_grad, t2, atmlst=None, verbose=logger.INFO):
     log.timer('%s gradients' % mp.__class__.__name__, *time0)
     return de
 
+def has_frozen_orbitals(post_hf):
+    '''Test if frozen orbitlas are enabled in a post-HF object.'''
+    with_frozen = False
+    if getattr(post_hf, 'frozen', None) is not None:
+        if isinstance(post_hf.frozen, (int, numpy.integer)):
+            with_frozen = post_hf.frozen != 0
+        elif hasattr(post_hf.frozen, '__len__'):
+            with_frozen = len(post_hf.frozen) != 0
+        else:
+            raise TypeError(f'Unsupported .frozen attribute {post_hf.frozen}')
+    return with_frozen
 
 def as_scanner(grad_mp):
     '''Generating a nuclear gradients scanner/solver (for geometry optimizer).

pyscf/grad/uccsd.py

@@ -33,7 +33,7 @@ from pyscf.ao2mo import _ao2mo
 from pyscf.scf import ucphf
 from pyscf.grad import rhf as rhf_grad
 from pyscf.grad import ccsd as ccsd_grad
-
+from pyscf.grad.mp2 import has_frozen_orbitals
 
 #
 # Note: only works with canonical orbitals
@@ -72,9 +72,7 @@ def grad_elec(cc_grad, t1=None, t2=None, l1=None, l2=None, eris=None, atmlst=Non
     nmob = mo_b.shape[1]
     nocca = numpy.count_nonzero(mycc.mo_occ[0] > 0)
     noccb = numpy.count_nonzero(mycc.mo_occ[1] > 0)
-    with_frozen = not ((mycc.frozen is None)
-                       or (isinstance(mycc.frozen, (int, numpy.integer)) and mycc.frozen == 0)
-                       or (len(mycc.frozen) == 0))
+    with_frozen = has_frozen_orbitals(mycc)
     moidx = mycc.get_frozen_mask()
     OA_a, VA_a, OF_a, VF_a = ccsd_grad._index_frozen_active(moidx[0], mycc.mo_occ[0])
     OA_b, VA_b, OF_b, VF_b = ccsd_grad._index_frozen_active(moidx[1], mycc.mo_occ[1])
@@ -249,9 +247,7 @@ def _response_dm1(mycc, Xvo, eris=None):
     nmoa = nocca + nvira
     nmob = noccb + nvirb
     nova = nocca * nvira
-    with_frozen = not ((mycc.frozen is None)
-                       or (isinstance(mycc.frozen, (int, numpy.integer)) and mycc.frozen == 0)
-                       or (len(mycc.frozen) == 0))
+    with_frozen = has_frozen_orbitals(mycc)
     if eris is None or with_frozen:
         mo_energy = mycc._scf.mo_energy
         mo_occ = mycc.mo_occ

pyscf/grad/ump2.py

@@ -30,7 +30,7 @@ from pyscf.ao2mo import _ao2mo
 from pyscf.mp import ump2
 from pyscf.grad import rhf as rhf_grad
 from pyscf.grad import mp2 as mp2_grad
-
+from pyscf.grad.mp2 import has_frozen_orbitals
 
 def grad_elec(mp_grad, t2, atmlst=None, verbose=logger.INFO):
     mp = mp_grad.base
@@ -43,9 +43,7 @@ def grad_elec(mp_grad, t2, atmlst=None, verbose=logger.INFO):
     log.debug('Build ump2 rdm2 intermediates')
 
     mol = mp_grad.mol
-    with_frozen = not ((mp.frozen is None)
-                       or (isinstance(mp.frozen, (int, numpy.integer)) and mp.frozen == 0)
-                       or (len(mp.frozen) == 0))
+    with_frozen = has_frozen_orbitals(mp)
     moidx = mp.get_frozen_mask()
     OA_a, VA_a, OF_a, VF_a = mp2_grad._index_frozen_active(moidx[0], mp.mo_occ[0])
     OA_b, VA_b, OF_b, VF_b = mp2_grad._index_frozen_active(moidx[1], mp.mo_occ[1])

pyscf/gto/basis/__init__.py

@@ -158,6 +158,8 @@ ALIAS = {
     'def2tzvppd' : 'def2-tzvppd.dat',
     'def2tzvpp'  : 'def2-tzvpp.dat' ,
     'def2tzvp'   : 'def2-tzvp.dat'  ,
+    'def2mtzvpp' : 'def2-mtzvpp.dat',
+    'def2mtzvp'  : 'def2-mtzvp.dat' ,
     'def2qzvpd'  : 'def2-qzvpd.dat' ,
     'def2qzvppd' : 'def2-qzvppd.dat',
     'def2qzvpp'  : 'def2-qzvpp.dat' ,
@@ -183,6 +185,12 @@ ALIAS = {
     'def2qzvpri'     : 'def2-qzvp-ri.dat'    ,
     'def2qzvppri'    : 'def2-qzvpp-ri.dat'   ,
     'def2qzvppdri'   : 'def2-qzvppd-ri.dat'  ,
+    'madef2svpp'   : 'ma-def2-svpp.dat'  ,
+    'madef2svp'    : 'ma-def2-svp.dat'   ,
+    'madef2tzvpp'  : 'ma-def2-tzvpp.dat' ,
+    'madef2tzvp'   : 'ma-def2-tzvp.dat'  ,
+    'madef2qzvpp'  : 'ma-def2-qzvpp.dat' ,
+    'madef2qzvp'   : 'ma-def2-qzvp.dat'  ,
     'tzv'        : 'tzv.dat'        ,
     'weigend'     : 'def2-universal-jfit.dat',
     'weigend+etb' : 'def2-universal-jfit.dat',
@@ -647,8 +655,7 @@ def load(filename_or_basisname, symb, optimize=OPTIMIZE_CONTRACTION):
                     filename_or_basisname, elements=symb)
             except KeyError:
                 raise BasisNotFoundError(filename_or_basisname)
-            else:
-                return bse._orbital_basis(bse_obj)[0]
+            return bse._orbital_basis(bse_obj)[0][symb]
 
         raise BasisNotFoundError(f'Unknown basis format or basis name for {filename_or_basisname}')
 
@@ -701,8 +708,7 @@ def load_ecp(filename_or_basisname, symb):
                 filename_or_basisname, elements=symb)
         except KeyError:
             raise BasisNotFoundError(filename_or_basisname)
-        else:
-            return bse._ecp_basis(bse_obj)[0]
+        return bse._ecp_basis(bse_obj)[0][symb]
 
     raise BasisNotFoundError('Unknown ECP format or ECP name')