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

pyscf/gto/eval_gto.py

@@ -121,7 +121,7 @@ def eval_gto(mol, eval_name, coords, comp=None, shls_slice=None, non0tab=None,
     if shls_slice is None:
         shls_slice = (0, nbas)
     sh0, sh1 = shls_slice
-    nao = ao_loc[sh1] - ao_loc[sh0]
+    nao = int(ao_loc[sh1] - ao_loc[sh0])
     if 'spinor' in eval_name:
         ao = numpy.ndarray((2,comp,nao,ngrids), dtype=numpy.complex128,
                            buffer=out).transpose(0,1,3,2)

pyscf/gto/ft_ao.py

@@ -72,13 +72,13 @@ def ft_aopair(mol, Gv, shls_slice=None, aosym='s1', b=numpy.eye(3),
             fill = 'fill_s1hermi'
         else:
             fill = 'fill_s1'
-        ni = ao_loc[shls_slice[1]] - ao_loc[shls_slice[0]]
-        nj = ao_loc[shls_slice[3]] - ao_loc[shls_slice[2]]
+        ni = int(ao_loc[shls_slice[1]] - ao_loc[shls_slice[0]])
+        nj = int(ao_loc[shls_slice[3]] - ao_loc[shls_slice[2]])
         shape = (nj, ni, nGv)
     else:
         fill = 'fill_s2'
-        i0 = ao_loc[shls_slice[0]]
-        i1 = ao_loc[shls_slice[1]]
+        i0 = int(ao_loc[shls_slice[0]])
+        i1 = int(ao_loc[shls_slice[1]])
         nij = i1*(i1+1)//2 - i0*(i0+1)//2
         shape = (nij, nGv)
     if comp != 1:
@@ -179,9 +179,9 @@ def ft_ao(mol, Gv, shls_slice=None, b=numpy.eye(3),
     atm, bas, env = gto.conc_env(mol._atm, mol._bas, mol._env,
                                  ghost_atm, ghost_bas, ghost_env)
     ao_loc = mol.ao_loc_nr()
-    nao = ao_loc[mol.nbas]
+    nao = int(ao_loc[mol.nbas])
     ao_loc = numpy.asarray(numpy.hstack((ao_loc, [nao+1])), dtype=numpy.int32)
-    ni = ao_loc[shls_slice[1]] - ao_loc[shls_slice[0]]
+    ni = int(ao_loc[shls_slice[1]] - ao_loc[shls_slice[0]])
     shape = (ni, nGv)
     mat = numpy.zeros(shape, order='C', dtype=numpy.complex128)
     phase = 0

pyscf/gto/mole.py

@@ -97,6 +97,7 @@ BASE = getattr(__config__, 'BASE', 0)
 NORMALIZE_GTO = getattr(__config__, 'NORMALIZE_GTO', True)
 DISABLE_EVAL = getattr(__config__, 'DISABLE_EVAL', False)
 ARGPARSE = getattr(__config__, 'ARGPARSE', False)
+DUMPINPUT = getattr(__config__, 'DUMPINPUT', True)
 
 def M(*args, **kwargs):
     r'''This is a shortcut to build up Mole object.
@@ -319,7 +320,7 @@ def format_atom(atoms, origin=0, axes=None,
     coordinates to AU, rotate and shift the molecule.
     If the :attr:`~Mole.atom` is a string, it takes ";" and "\\n"
     for the mark to separate atoms;  "," and arbitrary length of blank space
-    to spearate the individual terms for an atom.  Blank line will be ignored.
+    to separate the individual terms for an atom.  Blank line will be ignored.
 
     Args:
         atoms : list or str
@@ -459,7 +460,7 @@ def format_basis(basis_tab, sort_basis=True):
         if len(_basis) == 0:
             raise BasisNotFoundError('Basis not found for  %s' % symb)
 
-        # Sort basis accroding to angular momentum. This is important for method
+        # Sort basis according to angular momentum. This is important for method
         # decontract_basis, which assumes that basis functions with the same
         # angular momentum are grouped together. Related to issue #1620 #1770
         if sort_basis:
@@ -497,7 +498,7 @@ def _generate_basis_converter():
             _basis = load(raw_basis, _std_symbol_without_ghost(symb))
         elif (any(isinstance(x, str) for x in raw_basis)
               # The first element is the basis of internal format
-              or not isinstance(raw_basis[0][0], int)):
+              or not isinstance(raw_basis[0][0], (numpy.integer, int))):
             stdsymb = _std_symbol_without_ghost(symb)
             _basis = []
             for rawb in raw_basis:
@@ -572,7 +573,7 @@ def to_uncontracted_cartesian_basis(mol):
     '''
     return decontract_basis(mol, to_cart=True)
 
-def decontract_basis(mol, atoms=None, to_cart=False):
+def decontract_basis(mol, atoms=None, to_cart=False, aggregate=False):
     '''Decontract the basis of a Mole or a Cell.  Returns a Mole (Cell) object
     with the uncontracted basis environment and a list of coefficients that
     transform the uncontracted basis to the original basis. Each element in
@@ -584,6 +585,9 @@ def decontract_basis(mol, atoms=None, to_cart=False):
             are decontracted
         to_cart: bool
             Decontract basis and transfer to Cartesian basis
+        aggregate: bool
+            Whether to aggregate the transformation coefficients into a giant
+            transformation matrix
 
     Examples:
 
@@ -602,17 +606,27 @@ def decontract_basis(mol, atoms=None, to_cart=False):
     bas_exps = mol.bas_exps()
     def _to_full_contraction(mol, bas_idx):
         es = numpy.hstack([bas_exps[i] for i in bas_idx])
-        cs = scipy.linalg.block_diag(*[mol._libcint_ctr_coeff(ib) for ib in bas_idx])
-
-        es, e_idx, rev_idx = numpy.unique(es.round(9), True, True)
-        cs_new = numpy.zeros((es.size, cs.shape[1]))
-        for i, j in enumerate(rev_idx):
-            cs_new[j] += cs[i]
-        return es[::-1], cs_new[::-1]
+        _, e_idx, rev_idx = numpy.unique(es.round(9), True, True)
+        if aggregate:
+            cs = scipy.linalg.block_diag(
+                *[mol._libcint_ctr_coeff(i) for i in bas_idx])
+            if len(es) != len(e_idx):
+                cs_new = numpy.zeros((e_idx.size, cs.shape[1]))
+                for i, j in enumerate(rev_idx):
+                    cs_new[j] += cs[i]
+                es = es[e_idx][::-1]
+                cs = cs_new[::-1]
+            yield es, cs
+        else:
+            if len(es) != len(e_idx):
+                raise RuntimeError('Duplicated pGTOs across shells')
+            for i in bas_idx:
+                yield bas_exps[i], mol._libcint_ctr_coeff(i)
 
     _bas = []
-    _env = mol._env.copy()
+    env = [mol._env.copy()]
     contr_coeff = []
+    pexp = env[0].size
 
     lmax = mol._bas[:,ANG_OF].max()
     if mol.cart:
@@ -648,7 +662,7 @@ def decontract_basis(mol, atoms=None, to_cart=False):
                 continue
 
         lmax = mol._bas[ib0:ib1,ANG_OF].max()
-        pexp = mol._bas[ib0,PTR_EXP]
+
         for l in range(lmax+1):
             bas_idx = ib0 + numpy.where(mol._bas[ib0:ib1,ANG_OF] == l)[0]
             if len(bas_idx) == 0:
@@ -656,30 +670,27 @@ def decontract_basis(mol, atoms=None, to_cart=False):
             if bas_idx[0] + len(bas_idx) != bas_idx[-1] + 1:
                 raise NotImplementedError('Discontinuous bases of same angular momentum')
 
-            mol_exps, b_coeff = _to_full_contraction(mol, bas_idx)
-            nprim, nc = b_coeff.shape
-            bs = numpy.zeros((nprim, BAS_SLOTS), dtype=numpy.int32)
-            bs[:,ATOM_OF] = ia
-            bs[:,ANG_OF ] = l
-            bs[:,NCTR_OF] = bs[:,NPRIM_OF] = 1
-            norm = gto_norm(l, mol_exps)
-            if atoms is None:
+            for mol_exps, b_coeff in _to_full_contraction(mol, bas_idx):
+                nprim, nc = b_coeff.shape
+                bs = numpy.zeros((nprim, BAS_SLOTS), dtype=numpy.int32)
+                bs[:,ATOM_OF] = ia
+                bs[:,ANG_OF ] = l
+                bs[:,NCTR_OF] = bs[:,NPRIM_OF] = 1
                 bs[:,PTR_EXP] = pexp + numpy.arange(nprim)
                 bs[:,PTR_COEFF] = pexp + numpy.arange(nprim, nprim*2)
-                _env[pexp:pexp+nprim] = mol_exps
-                _env[pexp+nprim:pexp+nprim*2] = norm
+                norm = gto_norm(l, mol_exps)
+                env.append(mol_exps)
+                env.append(norm)
                 pexp += nprim * 2
-            else:
-                bs[:,PTR_EXP] = _env.size + numpy.arange(nprim)
-                bs[:,PTR_COEFF] = _env.size + numpy.arange(nprim, nprim*2)
-                _env = np.hstack([_env, mol_exps, norm])
-            _bas.append(bs)
+                _bas.append(bs)
 
-            c = numpy.einsum('pi,p,xm->pxim', b_coeff, 1./norm, c2s[l])
-            contr_coeff.append(c.reshape(nprim * c2s[l].shape[0], -1))
+                c = numpy.einsum('pi,p,xm->pxim', b_coeff, 1./norm, c2s[l])
+                contr_coeff.append(c.reshape(nprim * c2s[l].shape[0], -1))
 
     pmol._bas = numpy.asarray(numpy.vstack(_bas), dtype=numpy.int32)
-    pmol._env = _env
+    pmol._env = numpy.hstack(env)
+    if aggregate:
+        contr_coeff = scipy.linalg.block_diag(*contr_coeff)
     return pmol, contr_coeff
 
 def format_ecp(ecp_tab):
@@ -1244,19 +1255,15 @@ def unpack(moldic):
 def dumps(mol):
     '''Serialize Mole object to a JSON formatted str.
     '''
-    exclude_keys = {'output', 'stdout', '_keys',
-                        # Constructing in function loads
-                        'symm_orb', 'irrep_id', 'irrep_name'}
-    # FIXME: nparray and kpts for cell objects may need to be excluded
-    nparray_keys = {'_atm', '_bas', '_env', '_ecpbas',
-                        '_symm_orig', '_symm_axes'}
-
+    exclude_keys = {'output', 'stdout', '_keys', '_ctx_lock',
+                    # Constructing in function loads
+                    'symm_orb', 'irrep_id', 'irrep_name'}
     moldic = dict(mol.__dict__)
     for k in exclude_keys:
         if k in moldic:
             del (moldic[k])
-    for k in nparray_keys:
-        if isinstance(moldic[k], numpy.ndarray):
+    for k in moldic:
+        if isinstance(moldic[k], (numpy.ndarray, numpy.generic)):
             moldic[k] = moldic[k].tolist()
     moldic['atom'] = repr(mol.atom)
     moldic['basis']= repr(mol.basis)
@@ -1278,6 +1285,8 @@ def dumps(mol):
                     dic1[k] = list(v)
                 elif isinstance(v, dict):
                     dic1[k] = skip_value(v)
+                elif isinstance(v, np.generic):
+                    dic1[k] = v.tolist()
                 else:
                     msg =('Function mol.dumps drops attribute %s because '
                           'it is not JSON-serializable' % k)
@@ -1367,9 +1376,9 @@ def npgto_nr(mol, cart=None):
         cart = mol.cart
     l = mol._bas[:,ANG_OF]
     if cart:
-        return ((l+1)*(l+2)//2 * mol._bas[:,NPRIM_OF]).sum()
+        return int(((l+1)*(l+2)//2 * mol._bas[:,NPRIM_OF]).sum())
     else:
-        return ((l*2+1) * mol._bas[:,NPRIM_OF]).sum()
+        return int(((l*2+1) * mol._bas[:,NPRIM_OF]).sum())
 def nao_nr(mol, cart=None):
     '''Total number of contracted GTOs for the given :class:`Mole` object'''
     if cart is None:
@@ -1377,11 +1386,11 @@ def nao_nr(mol, cart=None):
     if cart:
         return nao_cart(mol)
     else:
-        return ((mol._bas[:,ANG_OF]*2+1) * mol._bas[:,NCTR_OF]).sum()
+        return int(((mol._bas[:,ANG_OF]*2+1) * mol._bas[:,NCTR_OF]).sum())
 def nao_cart(mol):
     '''Total number of contracted cartesian GTOs for the given :class:`Mole` object'''
     l = mol._bas[:,ANG_OF]
-    return ((l+1)*(l+2)//2 * mol._bas[:,NCTR_OF]).sum()
+    return int(((l+1)*(l+2)//2 * mol._bas[:,NCTR_OF]).sum())
 
 # nao_id0:nao_id1 corresponding to bas_id0:bas_id1
 def nao_nr_range(mol, bas_id0, bas_id1):
@@ -1406,8 +1415,8 @@ def nao_nr_range(mol, bas_id0, bas_id1):
     (2, 6)
     '''
     ao_loc = moleintor.make_loc(mol._bas[:bas_id1], 'sph')
-    nao_id0 = ao_loc[bas_id0]
-    nao_id1 = ao_loc[-1]
+    nao_id0 = int(ao_loc[bas_id0])
+    nao_id1 = int(ao_loc[-1])
     return nao_id0, nao_id1
 
 def nao_2c(mol):
@@ -1417,7 +1426,7 @@ def nao_2c(mol):
     dims = (l*4+2) * mol._bas[:,NCTR_OF]
     dims[kappa<0] = (l[kappa<0] * 2 + 2) * mol._bas[kappa<0,NCTR_OF]
     dims[kappa>0] = (l[kappa>0] * 2) * mol._bas[kappa>0,NCTR_OF]
-    return dims.sum()
+    return int(dims.sum())
 
 # nao_id0:nao_id1 corresponding to bas_id0:bas_id1
 def nao_2c_range(mol, bas_id0, bas_id1):
@@ -1442,8 +1451,8 @@ def nao_2c_range(mol, bas_id0, bas_id1):
     (4, 12)
     '''
     ao_loc = moleintor.make_loc(mol._bas[:bas_id1], '')
-    nao_id0 = ao_loc[bas_id0]
-    nao_id1 = ao_loc[-1]
+    nao_id0 = int(ao_loc[bas_id0])
+    nao_id1 = int(ao_loc[-1])
     return nao_id0, nao_id1
 
 def ao_loc_nr(mol, cart=None):
@@ -1961,7 +1970,7 @@ def same_mol(mol1, mol2, tol=1e-5, cmp_basis=True, ignore_chiral=False):
 is_same_mol = same_mol
 
 def chiral_mol(mol1, mol2=None):
-    '''Detect whether the given molelcule is chiral molecule or two molecules
+    '''Detect whether the given molecule is chiral molecule or two molecules
     are chiral isomers.
     '''
     if mol2 is None:
@@ -2091,7 +2100,7 @@ def tostring(mol, format='raw'):
             output.append('%-4s   %s' % (symb, line))
         return '\n'.join(output)
     else:
-        raise NotImplementedError
+        raise NotImplementedError(f'format={format}')
 
 def tofile(mol, filename, format=None):
     '''Write molecular geometry to a file of the required format.
@@ -2197,7 +2206,7 @@ class MoleBase(lib.StreamObject):
             subgroup
 
         atom : list or str
-            To define molecluar structure.  The internal format is
+            To define molecular structure.  The internal format is
 
             | atom = [[atom1, (x, y, z)],
             |         [atom2, (x, y, z)],
@@ -2333,7 +2342,6 @@ class MoleBase(lib.StreamObject):
         self._env = numpy.zeros(PTR_ENV_START)
         self._ecpbas = numpy.zeros((0,8), dtype=numpy.int32)
 
-        self.stdout = sys.stdout
         self.groupname = 'C1'
         self.topgroup = 'C1'
         self.symm_orb = None
@@ -2452,12 +2460,12 @@ class MoleBase(lib.StreamObject):
     __getstate__ = dumps
     __setstate__ = loads_
 
-    def build(self, dump_input=True, parse_arg=ARGPARSE,
+    def build(self, dump_input=DUMPINPUT, parse_arg=ARGPARSE,
               verbose=None, output=None, max_memory=None,
               atom=None, basis=None, unit=None, nucmod=None, ecp=None, pseudo=None,
               charge=None, spin=0, symmetry=None, symmetry_subgroup=None,
               cart=None, magmom=None):
-        '''Setup moleclue and initialize some control parameters.  Whenever you
+        '''Setup molecule and initialize some control parameters.  Whenever you
         change the value of the attributes of :class:`Mole`, you need call
         this function to refresh the internal data of Mole.
 
@@ -2473,7 +2481,7 @@ class MoleBase(lib.StreamObject):
             max_memory : int, float
                 Allowd memory in MB.  If given, overwrite :attr:`Mole.max_memory`
             atom : list or str
-                To define molecluar structure.
+                To define molecular structure.
             basis : dict or str
                 To define basis set.
             nucmod : dict or str
@@ -2750,7 +2758,7 @@ class MoleBase(lib.StreamObject):
                           '          X                Y                Z       unit  Magmom\n')
         for ia,atom in enumerate(self._atom):
             coorda = tuple([x * param.BOHR for x in atom[1]])
-            coordb = tuple([x for x in atom[1]])
+            coordb = tuple(atom[1])
             magmom = self.magmom[ia]
             self.stdout.write('[INPUT]%3d %-4s %16.12f %16.12f %16.12f AA  '
                               '%16.12f %16.12f %16.12f Bohr  %4.1f\n'
@@ -3059,18 +3067,17 @@ class MoleBase(lib.StreamObject):
             mol._env[ptr+0] = unit * atoms_or_coords[:,0]
             mol._env[ptr+1] = unit * atoms_or_coords[:,1]
             mol._env[ptr+2] = unit * atoms_or_coords[:,2]
+            # reset nuclear energy
+            mol.enuc = None
         else:
             mol.symmetry = symmetry
             mol.build(False, False)
 
-        # reset nuclear energy
-        mol.enuc = None
-
         if mol.verbose >= logger.INFO:
             logger.info(mol, 'New geometry')
             for ia, atom in enumerate(mol._atom):
                 coorda = tuple([x * param.BOHR for x in atom[1]])
-                coordb = tuple([x for x in atom[1]])
+                coordb = tuple(atom[1])
                 coords = coorda + coordb
                 logger.info(mol, ' %3d %-4s %16.12f %16.12f %16.12f AA  '
                             '%16.12f %16.12f %16.12f Bohr\n',
@@ -3147,7 +3154,7 @@ class MoleBase(lib.StreamObject):
         '''
         if self._atm[atm_id,NUC_MOD_OF] != NUC_FRAC_CHARGE:
             # regular QM atoms
-            return self._atm[atm_id,CHARGE_OF]
+            return int(self._atm[atm_id,CHARGE_OF])
         else:
             # MM atoms with fractional charges
             return self._env[self._atm[atm_id,PTR_FRAC_CHARGE]]
@@ -3211,7 +3218,7 @@ class MoleBase(lib.StreamObject):
         >>> mol.atom_nshells(1)
         5
         '''
-        return (self._bas[:,ATOM_OF] == atm_id).sum()
+        return int((self._bas[:,ATOM_OF] == atm_id).sum())
 
     def atom_shell_ids(self, atm_id):
         r'''A list of the shell-ids of the given atom
@@ -3258,7 +3265,7 @@ class MoleBase(lib.StreamObject):
         >>> mol.bas_atom(7)
         1
         '''
-        return self._bas[bas_id,ATOM_OF].copy()
+        return int(self._bas[bas_id,ATOM_OF])
 
     def bas_angular(self, bas_id):
         r'''The angular momentum associated with the given basis
@@ -3273,7 +3280,7 @@ class MoleBase(lib.StreamObject):
         >>> mol.bas_atom(7)
         2
         '''
-        return self._bas[bas_id,ANG_OF].copy()
+        return int(self._bas[bas_id,ANG_OF])
 
     def bas_nctr(self, bas_id):
         r'''The number of contracted GTOs for the given shell
@@ -3288,7 +3295,7 @@ class MoleBase(lib.StreamObject):
         >>> mol.bas_atom(3)
         3
         '''
-        return self._bas[bas_id,NCTR_OF].copy()
+        return int(self._bas[bas_id,NCTR_OF])
 
     def bas_nprim(self, bas_id):
         r'''The number of primitive GTOs for the given shell
@@ -3303,7 +3310,7 @@ class MoleBase(lib.StreamObject):
         >>> mol.bas_atom(3)
         11
         '''
-        return self._bas[bas_id,NPRIM_OF].copy()
+        return int(self._bas[bas_id,NPRIM_OF])
 
     def bas_kappa(self, bas_id):
         r'''Kappa (if l < j, -l-1, else l) of the given shell
@@ -3318,7 +3325,7 @@ class MoleBase(lib.StreamObject):
         >>> mol.bas_kappa(3)
         0
         '''
-        return self._bas[bas_id,KAPPA_OF].copy()
+        return int(self._bas[bas_id,KAPPA_OF])
 
     def bas_exp(self, bas_id):
         r'''exponents (ndarray) of the given shell
@@ -3431,6 +3438,11 @@ class MoleBase(lib.StreamObject):
                 | 1 : hermitian
                 | 2 : anti-hermitian
 
+            shls_slice : 4-element, 6-element or 8-element tuple
+                Label the start-stop shells for each index in the integral.
+                For example, the 8-element tuple for the 2-electron integral
+                tensor (ij|kl) = intor('int2e') are specified as
+                (ish_start, ish_end, jsh_start, jsh_end, ksh_start, ksh_end, lsh_start, lsh_end)
             grids : ndarray
                 Coordinates of grids for the int1e_grids integrals
 
@@ -3748,7 +3760,7 @@ class Mole(MoleBase):
     def ao2mo(self, mo_coeffs, erifile=None, dataname='eri_mo', intor='int2e',
               **kwargs):
         '''Integral transformation for arbitrary orbitals and arbitrary
-        integrals.  See more detalied documentation in func:`ao2mo.kernel`.
+        integrals.  See more detailed documentation in func:`ao2mo.kernel`.
 
         Args:
             mo_coeffs (an np array or a list of arrays) : A matrix of orbital
@@ -3800,7 +3812,7 @@ class Mole(MoleBase):
         return ao2mo.kernel(self, mo_coeffs, erifile, dataname, intor, **kwargs)
 
     def to_cell(self, a, dimension=3):
-        '''Put a molecule in a cell with periodic boundary condictions
+        '''Put a molecule in a cell with periodic boundary conditions
 
         Args:
             a : (3,3) ndarray
@@ -4054,7 +4066,7 @@ def fakemol_for_charges(coords, expnt=1e16):
         # approximate point charge with gaussian distribution exp(-1e16*r^2)
         fakebas[:,PTR_EXP] = ptr
         fakebas[:,PTR_COEFF] = ptr+1
-        fakeenv.append([expnt, 1/(2*numpy.sqrt(numpy.pi)*gaussian_int(2,expnt))])
+        fakeenv.append([expnt, 1 / (2*numpy.sqrt(numpy.pi)*gaussian_int(2,expnt))])
         ptr += 2
     else:
         assert expnt.size == nbas
@@ -4071,6 +4083,46 @@ def fakemol_for_charges(coords, expnt=1e16):
     fakemol._built = True
     return fakemol
 
+def fakemol_for_cgtf_charge(coord, expnt=1e16, contr_coeff=1):
+    '''Constructs a "fake" Mole object that has a Gaussian charge
+    distribution at the specified coordinate (coord).  The charge
+    can be given as a linear combination of Gaussians with
+    exponents expnt and contraction coefficients contr_coeff.
+    '''
+    assert coord.shape[0] == 1
+    expnt = numpy.asarray(expnt).ravel()
+    contr_coeff = numpy.asarray(contr_coeff).ravel()
+
+    fakeatm = numpy.zeros((1,ATM_SLOTS), dtype=numpy.int32)
+    fakebas = numpy.zeros((1,BAS_SLOTS), dtype=numpy.int32)
+    fakeenv = [0] * PTR_ENV_START
+    ptr = PTR_ENV_START
+    fakeatm[:,PTR_COORD] = numpy.arange(ptr, ptr+3, 3)
+    fakeenv.append(coord.ravel())
+    ptr += 3
+    fakebas[:,ATOM_OF] = 0#numpy.arange(nbas)
+    fakebas[:,NPRIM_OF] = contr_coeff.size
+    fakebas[:,NCTR_OF] = 1
+    if expnt.size == 1:
+        expnt = expnt[0]
+        fakebas[:,PTR_EXP] = ptr
+        fakebas[:,PTR_COEFF] = ptr+1
+        fakeenv.append([expnt, 1 / (2*numpy.sqrt(numpy.pi)*gaussian_int(2,expnt))])
+        ptr += 2
+    else:
+        assert expnt.size == contr_coeff.size
+        fakebas[:,PTR_EXP] = ptr
+        fakebas[:,PTR_COEFF] = ptr + contr_coeff.size
+        coeff = contr_coeff / (2 * numpy.sqrt(numpy.pi) * gaussian_int(2, expnt))
+        fakeenv.append(numpy.vstack((expnt, coeff)).ravel())
+
+    fakemol = Mole()
+    fakemol._atm = fakeatm
+    fakemol._bas = fakebas
+    fakemol._env = numpy.hstack(fakeenv)
+    fakemol._built = True
+    return fakemol
+
 def classify_ecp_pseudo(mol, ecp, pp):
     '''
     Check whether ecp keywords are presented in pp and whether pp keywords are

pyscf/gto/moleintor.py

@@ -594,7 +594,7 @@ def getints4c(intor_name, atm, bas, env, shls_slice=None, comp=1,
     if aosym == 's8':
         assert (shls_slice is None)
         from pyscf.scf import _vhf
-        nao = ao_loc[-1]
+        nao = int(ao_loc[-1])
         nao_pair = nao*(nao+1)//2
         out = numpy.ndarray((nao_pair*(nao_pair+1)//2), buffer=out)
         if nao_pair == 0:

pyscf/gw/gw_ac.py

@@ -20,7 +20,7 @@
 Spin-restricted G0W0 approximation with analytic continuation
 This implementation has N^4 scaling, and is faster than GW-CD (N^4)
 and analytic GW (N^6) methods.
-GW-AC is recommended for valence states only, and is inaccuarate for core states.
+GW-AC is recommended for valence states only, and is inaccurate for core states.
 
 Method:
     See T. Zhu and G.K.-L. Chan, arxiv:2007.03148 (2020) for details
@@ -230,7 +230,7 @@ def _get_scaled_legendre_roots(nw):
 
 def _get_clenshaw_curtis_roots(nw):
     """
-    Clenshaw-Curtis qaudrature on [0,inf)
+    Clenshaw-Curtis quadrature on [0,inf)
     Ref: J. Chem. Phys. 132, 234114 (2010)
     Returns:
         freqs : 1D ndarray

pyscf/gw/gw_cd.py

@@ -192,7 +192,7 @@ def get_rho_response_R(gw, omega, Lpq):
 
 def get_sigmaR_diag(gw, omega, orbp, ef, Lpq):
     '''
-    Compute self-energy for poles inside coutour
+    Compute self-energy for poles inside contour
     (more and more expensive away from Fermi surface)
     '''
     mo_energy = gw._scf.mo_energy
@@ -234,7 +234,7 @@ def _get_scaled_legendre_roots(nw):
 
 def _get_clenshaw_curtis_roots(nw):
     """
-    Clenshaw-Curtis qaudrature on [0,inf)
+    Clenshaw-Curtis quadrature on [0,inf)
     Ref: J. Chem. Phys. 132, 234114 (2010)
     Returns:
         freqs : 1D ndarray