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

pyscf/pbc/gto/cell.py

@@ -17,6 +17,7 @@
 #         Timothy Berkelbach <tim.berkelbach@gmail.com>
 #
 
+import os
 import sys
 import json
 import ctypes
@@ -66,6 +67,7 @@ def pack(cell):
     '''
     cldic = mole.pack(cell)
     cldic['a'] = cell.a
+    cldic['fractional'] = cell.fractional
     cldic['precision'] = cell.precision
     cldic['ke_cutoff'] = cell.ke_cutoff
     cldic['exp_to_discard'] = cell.exp_to_discard
@@ -87,23 +89,20 @@ def unpack(celldic):
 def dumps(cell):
     '''Serialize Cell object to a JSON formatted str.
     '''
-    exclude_keys = {'output', 'stdout', '_keys', 'symm_orb', 'irrep_id',
-                        'irrep_name', 'lattice_symmetry'}
+    exclude_keys = {'output', 'stdout', '_keys', '_ctx_lock',
+                    'symm_orb', 'irrep_id', 'irrep_name', 'lattice_symmetry'}
 
     celldic = dict(cell.__dict__)
     for k in exclude_keys:
         if k in celldic:
             del (celldic[k])
     for k in celldic:
-        if isinstance(celldic[k], np.ndarray):
+        if isinstance(celldic[k], (np.ndarray, np.generic)):
             celldic[k] = celldic[k].tolist()
     celldic['atom'] = repr(cell.atom)
     celldic['basis']= repr(cell.basis)
     celldic['pseudo'] = repr(cell.pseudo)
     celldic['ecp'] = repr(cell.ecp)
-    # Explicitly convert mesh because it is often created as numpy array
-    if isinstance(cell.mesh, np.ndarray):
-        celldic['mesh'] = cell.mesh.tolist()
 
     try:
         return json.dumps(celldic)
@@ -120,6 +119,8 @@ def dumps(cell):
                     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 cell.dumps drops attribute %s because '
                           'it is not JSON-serializable' % k)
@@ -497,7 +498,7 @@ def error_for_ke_cutoff(cell, ke_cutoff, omega=None):
 def get_bounding_sphere(cell, rcut):
     '''Finds all the lattice points within a sphere of radius rcut.
 
-    Defines a parallelipiped given by -N_x <= n_x <= N_x, with x in [1,3]
+    Defines a parallelepiped given by -N_x <= n_x <= N_x, with x in [1,3]
     See Martin p. 85
 
     Args:
@@ -1012,6 +1013,142 @@ def rcut_by_shells(cell, precision=None, rcut=0,
         return shell_radius, pgf_radius
     return shell_radius
 
+def tostring(cell, format='poscar'):
+    '''Convert cell geometry to a string of the required format.
+
+    Supported output formats:
+        | poscar: VASP POSCAR
+        | xyz: Extended XYZ with Lattice information
+    '''
+    format = format.lower()
+    output = []
+    if format == 'poscar' or format == 'vasp' or format == 'xyz':
+        lattice_vectors = cell.lattice_vectors() * param.BOHR
+        coords = cell.atom_coords() * param.BOHR
+        if format == 'poscar' or format == 'vasp':
+            output.append('Written by PySCF, units are A')
+            output.append('1.0')
+            for lattice_vector in lattice_vectors:
+                ax, ay, az = lattice_vector
+                output.append('%14.5f %14.5f %14.5f' % (ax, ay, az))
+            unique_atoms = dict()
+            for atom in cell.elements:
+                if atom not in unique_atoms:
+                    unique_atoms[atom] = 1
+                else:
+                    unique_atoms[atom] += 1
+            output.append(' '.join(unique_atoms))
+            output.append(' '.join(str(count) for count in unique_atoms.values()))
+            output.append('Cartesian')
+            for atom_type in unique_atoms:
+                for atom, coord in zip(cell.elements, coords):
+                    if atom == atom_type:
+                        x, y, z = coord
+                        output.append('%14.5f %14.5f %14.5f' % (x, y, z))
+            return '\n'.join(output)
+        elif format == 'xyz':
+            output.append('%d' % cell.natm)
+            output.append('Lattice="'+' '.join(f'{ax:14.5f}' for ax in lattice_vectors.ravel())
+                +'" Properties=species:S:1:pos:R:3')
+            for i in range(cell.natm):
+                symb = cell.atom_pure_symbol(i)
+                x, y, z = coords[i]
+                output.append('%-4s %14.5f %14.5f %14.5f' %
+                              (symb, x, y, z))
+            return '\n'.join(output)
+    else:
+        raise NotImplementedError(f'format={format}')
+
+def tofile(cell, filename, format=None):
+    if format is None:  # Guess format based on filename
+        if filename.lower() == 'poscar':
+            format = 'poscar'
+        else:
+            format = os.path.splitext(filename)[1][1:]
+    string = tostring(cell, format)
+    with open(filename,  'w', encoding='utf-8') as f:
+        f.write(string)
+        f.write('\n')
+    return string
+
+def fromfile(filename, format=None):
+    '''Read cell geometry from a file
+    (in testing)
+
+    Supported formats:
+        | poscar: VASP POSCAR file format
+        | xyz: Extended XYZ with Lattice information
+    '''
+    if format is None:  # Guess format based on filename
+        if filename.lower() == 'poscar':
+            format = 'poscar'
+        else:
+            format = os.path.splitext(filename)[1][1:].lower()
+        if format not in ('poscar', 'vasp', 'xyz'):
+            format = 'raw'
+    with open(filename, 'r') as f:
+        return fromstring(f.read(), format)
+
+def fromstring(string, format='poscar'):
+    '''Convert the string of the specified format to internal format
+    (in testing)
+
+    Supported formats:
+        | poscar: VASP POSCAR file format
+        | xyz: Extended XYZ with Lattice information
+
+    Returns:
+        a: Lattice vectors
+        atom: Atomic elements and xyz coordinates
+    '''
+    format = format.lower()
+    if format == 'poscar' or format == 'vasp':
+        lines = string.splitlines()
+        scale = float(lines[1])
+        a = lines[2:5]
+        lattice_vectors = np.array([np.fromstring(ax, sep=' ') for ax in a])
+        lattice_vectors *= scale
+        a = []
+        for i in range(3):
+            a.append(' '.join(str(ax) for ax in lattice_vectors[i]))
+        atom_position_type = lines[7].strip()
+        unique_atoms = dict()
+        natm = 0
+        for atom, count in zip(lines[5].split(), lines[6].split()):
+            unique_atoms[atom] = int(count)
+            natm += int(count)
+        atoms = []
+        start = 8
+        for atom_type in unique_atoms:
+            end = start + unique_atoms[atom_type]
+            for line in lines[start:end]:
+                coords = np.fromstring(line, sep=' ')
+                if atom_position_type.lower() == 'cartesian':
+                    x, y, z = coords * scale
+                elif atom_position_type.lower() == 'direct':
+                    x, y, z = np.dot(coords, lattice_vectors)
+                else:
+                    raise RuntimeError('Error reading VASP geometry due to '
+                        f'atom position type "{atom_position_type}". Atom '
+                        'positions must be Direct or Cartesian.')
+                atoms.append('%s %14.5f %14.5f %14.5f'
+                    % (atom_type, x, y, z))
+            start = end
+        return '\n'.join(a), '\n'.join(atoms)
+    elif format == 'xyz':
+        lines = string.splitlines()
+        natm = int(lines[0])
+        lattice_vectors = lines[1].split('Lattice=')[1].split('"')[1].split()
+        a = []
+        for i in range(3):
+            a.append(" ".join(lattice_vectors[3*i:3*i+3]))
+        return '\n'.join(a), '\n'.join(lines[2:natm+2])
+    elif format == 'raw':
+        lines = string.splitlines()
+        return '\n'.join(lines[:3]), '\n'.join(lines[4:])
+    else:
+        raise NotImplementedError
+
 
 class Cell(mole.MoleBase):
     '''A Cell object holds the basic information of a crystal.
@@ -1075,11 +1212,14 @@ class Cell(mole.MoleBase):
 
     _keys = {
         'precision', 'exp_to_discard',
-        'a', 'ke_cutoff', 'pseudo', 'dimension', 'low_dim_ft_type',
+        'a', 'ke_cutoff', 'pseudo', 'fractional', 'dimension', 'low_dim_ft_type',
         'space_group_symmetry', 'symmorphic', 'lattice_symmetry', 'mesh', 'rcut',
         'use_loose_rcut', 'use_particle_mesh_ewald',
     }
 
+    tostring = tostring
+    tofile = tofile
+
     def __init__(self, **kwargs):
         mole.MoleBase.__init__(self)
         self.a = None # lattice vectors, (a1,a2,a3)
@@ -1087,6 +1227,7 @@ class Cell(mole.MoleBase):
         # of fourier components, with .5 * G**2 < ke_cutoff
         self.ke_cutoff = None
 
+        self.fractional = False
         self.dimension = 3
         # TODO: Simple hack for now; the implementation of ewald depends on the
         #       density-fitting class.  This determines how the ewald produces
@@ -1105,6 +1246,20 @@ class Cell(mole.MoleBase):
         for key, val in kwargs.items():
             setattr(self, key, val)
 
+    def fromstring(self, string, format='poscar'):
+        '''Update the Cell object based on the input geometry string'''
+        a, atom = fromstring(string, format)
+        self.a = a
+        self.set_geom_(atom, unit='Angstrom', inplace=True)
+        return self
+
+    def fromfile(self, filename, format=None):
+        '''Update the Cell object based on the input geometry file'''
+        a, atom = fromfile(filename, format)
+        self.a = a
+        self.set_geom_(atom, unit='Angstrom', inplace=True)
+        return self
+
     @property
     def mesh(self):
         return self._mesh
@@ -1265,13 +1420,23 @@ class Cell(mole.MoleBase):
             self._mesh_from_build = _mesh_from_build
         return self
 
+    @lib.with_doc(mole.format_atom.__doc__)
+    def format_atom(self, atoms, origin=0, axes=None,
+                    unit=getattr(__config__, 'UNIT', 'Ang')):
+        if not self.fractional:
+            return mole.format_atom(atoms, origin, axes, unit)
+        _atoms = mole.format_atom(atoms, origin, axes, unit=1.)
+        _a = self.lattice_vectors()
+        c = np.array([a[1] for a in _atoms]).dot(_a)
+        return [(a[0], r) for a, r in zip(_atoms, c.tolist())]
+
 #Note: Exculde dump_input, parse_arg, basis from kwargs to avoid parsing twice
     def build(self, dump_input=True, parse_arg=mole.ARGPARSE,
               a=None, mesh=None, ke_cutoff=None, precision=None, nimgs=None,
               h=None, dimension=None, rcut= None, low_dim_ft_type=None,
               space_group_symmetry=None, symmorphic=None,
               use_loose_rcut=None, use_particle_mesh_ewald=None,
-              *args, **kwargs):
+              fractional=None, *args, **kwargs):
         '''Setup Mole molecule and Cell and initialize some control parameters.
         Whenever you change the value of the attributes of :class:`Cell`,
         you need call this function to refresh the internal data of Cell.
@@ -1280,6 +1445,10 @@ class Cell(mole.MoleBase):
             a : (3,3) ndarray
                 The real-space cell lattice vectors. Each row represents
                 a lattice vector.
+            fractional : bool
+                Whether the atom postions are specified in fractional coordinates.
+                The default value is False, which means the coordinates are
+                interpreted as Cartesian coordinate.
             mesh : (3,) ndarray of ints
                 The number of *positive* G-vectors along each direction.
             ke_cutoff : float
@@ -1318,6 +1487,7 @@ class Cell(mole.MoleBase):
         if mesh is not None: self.mesh = mesh
         if nimgs is not None: self.nimgs = nimgs
         if dimension is not None: self.dimension = dimension
+        if fractional is not None: self.fractional = fractional
         if precision is not None: self.precision = precision
         if rcut is not None: self.rcut = rcut
         if ke_cutoff is not None: self.ke_cutoff = ke_cutoff
@@ -1331,8 +1501,11 @@ class Cell(mole.MoleBase):
         if symmorphic is not None:
             self.symmorphic = symmorphic
 
-        dump_input = dump_input and not self._built and self.verbose > logger.NOTE
-        mole.MoleBase.build(self, dump_input, parse_arg, *args, **kwargs)
+        if self.a is None:
+            raise RuntimeError('Lattice parameters not specified')
+
+        _built = self._built
+        mole.MoleBase.build(self, False, parse_arg, *args, **kwargs)
 
         exp_min = np.array([self.bas_exp(ib).min() for ib in range(self.nbas)])
         if self.exp_to_discard is None:
@@ -1409,11 +1582,6 @@ class Cell(mole.MoleBase):
                         '%d contracted functions', nprim_drop, nctr_drop)
             #logger.debug1(self, 'Old shells %s', steep_shls)
 
-        # The rest initialization requires lattice parameters.  If .a is not
-        # set, pass the rest initialization.
-        if self.a is None:
-            return self
-
         if self.rcut is None or self._rcut_from_build:
             self._rcut = estimate_rcut(self, self.precision)
             self._rcut_from_build = True
@@ -1449,7 +1617,8 @@ class Cell(mole.MoleBase):
             _check_mesh_symm = not self._mesh_from_build
             self.build_lattice_symmetry(check_mesh_symmetry=_check_mesh_symm)
 
-        if dump_input:
+        if dump_input and not _built and self.verbose > logger.NOTE:
+            self.dump_input()
             logger.info(self, 'lattice vectors  a1 [%.9f, %.9f, %.9f]', *_a[0])
             logger.info(self, '                 a2 [%.9f, %.9f, %.9f]', *_a[1])
             logger.info(self, '                 a3 [%.9f, %.9f, %.9f]', *_a[2])
@@ -1536,7 +1705,7 @@ class Cell(mole.MoleBase):
         rcut_guess = estimate_rcut(self, self.precision)
         if self.rcut > rcut_guess*1.5:
             msg = ('.nimgs is a deprecated attribute.  It is replaced by .rcut '
-                   'attribute for lattic sum cutoff radius.  The given nimgs '
+                   'attribute for lattice sum cutoff radius.  The given nimgs '
                    '%s is far over the estimated cutoff radius %s. ' %
                    (x, rcut_guess))
             warnings.warn(msg)
@@ -1742,12 +1911,14 @@ class Cell(mole.MoleBase):
         '''Return a Mole object using the same atoms and basis functions as
         the Cell object.
         '''
-        #FIXME: should cell be converted to mole object?  If cell is converted
-        # and a mole object is returned, many attributes (e.g. the GTH basis,
-        # gth-PP) will not be recognized by mole.build function.
         mol = self.view(mole.Mole)
-        delattr(mol, 'a')
-        delattr(mol, '_mesh')
+        del mol.a
+        mol.__dict__.pop('fractional', None)
+        mol.__dict__.pop('ke_cutoff', None)
+        mol.__dict__.pop('_mesh', None)
+        mol.__dict__.pop('_rcut', None)
+        mol.__dict__.pop('dimension', None)
+        mol.__dict__.pop('low_dim_ft_type', None)
         mol.enuc = None #reset nuclear energy
         if mol.symmetry:
             mol._build_symmetry()

pyscf/pbc/gto/ecp.py

@@ -21,29 +21,29 @@ Short range part of ECP under PBC
 '''
 
 from functools import reduce
-import numpy
+import numpy as np
 from pyscf import lib
-from pyscf.pbc import gto
-from pyscf.gto import PTR_EXP, AS_ECPBAS_OFFSET, AS_NECPBAS
+from pyscf import gto
+from pyscf.pbc.gto.cell import _split_basis
+from pyscf.pbc.df import incore
 
 
 def ecp_int(cell, kpts=None):
-    from pyscf.pbc.df import incore
     lib.logger.debug(cell, 'PBC-ECP integrals')
     if kpts is None:
-        kpts_lst = numpy.zeros((1,3))
+        kpts_lst = np.zeros((1,3))
     else:
-        kpts_lst = numpy.reshape(kpts, (-1,3))
+        kpts_lst = np.reshape(kpts, (-1,3))
 
-    cell, contr_coeff = gto.cell._split_basis(cell)
+    cell, contr_coeff = _split_basis(cell)
     lib.logger.debug1(cell, 'nao %d -> nao %d', *(contr_coeff.shape))
 
     ecpcell = cell.copy(deep=False)
     # append a fake s function to mimic the auxiliary index in pbc.incore.
-    exp_ptr = cell._ecpbas[-1,PTR_EXP]
-    ecpcell._bas = numpy.array([[0, 0, 1, 1, 0, exp_ptr, 0, 0]], dtype=numpy.int32)
+    exp_ptr = cell._ecpbas[-1,gto.PTR_EXP]
+    ecpcell._bas = np.array([[0, 0, 1, 1, 0, exp_ptr, 0, 0]], dtype=np.int32)
     # _env[AS_ECPBAS_OFFSET] is to be determined in pbc.incore
-    cell._env[AS_NECPBAS] = len(cell._ecpbas)
+    cell._env[gto.AS_NECPBAS] = len(cell._ecpbas)
     # shls_slice of auxiliary index (0,1) corresponds to the fake s function
     shls_slice = (0, cell.nbas, 0, cell.nbas, 0, 1)
 
@@ -57,7 +57,7 @@ def ecp_int(cell, kpts=None):
         v = lib.unpack_tril(buf[k], lib.HERMITIAN)
         if abs(kpt).max() < 1e-9:  # gamma_point:
             v = v.real
-        mat.append(reduce(numpy.dot, (contr_coeff.T, v, contr_coeff)))
-    if kpts is None or numpy.shape(kpts) == (3,):
+        mat.append(reduce(np.dot, (contr_coeff.T, v, contr_coeff)))
+    if kpts is None or np.shape(kpts) == (3,):
         mat = mat[0]
     return mat

pyscf/pbc/gto/eval_gto.py

@@ -167,8 +167,8 @@ def eval_gto(cell, eval_name, coords, comp=None, kpts=None, kpt=None,
 pbc_eval_gto = eval_gto
 
 def _estimate_rcut(cell):
-    '''Cutoff raidus, above which each shell decays to a value less than the
-    required precsion'''
+    '''Cutoff radius, above which each shell decays to a value less than the
+    required precision'''
     vol = cell.vol
     weight_penalty = vol # ~ V[r] * (vol/ngrids) * ngrids
     precision = cell.precision / max(weight_penalty, 1)
@@ -248,6 +248,6 @@ def get_lattice_Ls(cell, nimgs=None, rcut=None, dimension=None, discard=True):
     grids2atm[~edge_filter2[:,:,1],1] -= edge_ub[1]
     grids2atm[~edge_filter2[:,:,2],2] -= edge_ub[2]
     grids2atm[edge_filter1 & edge_filter2] = 0.
-    Ls_mask = (np.linalg.norm(grids2atm, axis=2) < rcut).any(axis=0)
+    Ls_mask = (np.linalg.norm(grids2atm[:,:,:dimension], axis=2) < rcut).any(axis=0)
     Ls = Ls[Ls_mask]
     return np.asarray(Ls, order='C')

pyscf/pbc/gto/neighborlist.py

@@ -24,6 +24,7 @@ from pyscf.lib import logger
 libpbc = lib.load_library('libpbc')
 
 class _CNeighborPair(ctypes.Structure):
+    __slots__ = []
     _fields_ = [("nimgs", ctypes.c_int),
                 ("Ls_list", ctypes.POINTER(ctypes.c_int)),
                 ("q_cond", ctypes.POINTER(ctypes.c_double)),
@@ -31,6 +32,7 @@ class _CNeighborPair(ctypes.Structure):
 
 
 class _CNeighborList(ctypes.Structure):
+    __slots__ = []
     _fields_ = [("nish", ctypes.c_int),
                 ("njsh", ctypes.c_int),
                 ("nimgs", ctypes.c_int),
@@ -38,6 +40,7 @@ class _CNeighborList(ctypes.Structure):
 
 
 class _CNeighborListOpt(ctypes.Structure):
+    __slots__ = []
     _fields_ = [("nl", ctypes.POINTER(_CNeighborList)),
                 ('fprescreen', ctypes.c_void_p)]
 
@@ -54,7 +57,7 @@ def build_neighbor_list_for_shlpairs(cell, cell1=None, Ls=None,
         cell1 : :class:`pbc.gto.cell.Cell`, optional
             The :class:`Cell` instance for the ket basis functions.
             If not given, both bra and ket basis functions come from cell.
-        Ls : (*,3) array, optional
+        Ls : ``(*,3)`` array, optional
             The cartesian coordinates of the periodic images.
             Default is calculated by :func:`cell.get_lattice_Ls`.
         ish_rcut : (nish,) array, optional

pyscf/pbc/gto/pseudo/pp.py

@@ -227,7 +227,7 @@ def cart2polar(rvec):
 
 
 def get_pp(cell, kpt=np.zeros(3)):
-    '''Get the periodic pseudotential nuc-el AO matrix
+    '''Get the periodic pseudopotential nuc-el AO matrix
     '''
     from pyscf.pbc import tools
     coords = cell.get_uniform_grids()

pyscf/pbc/gw/krgw_ac.py

@@ -20,7 +20,7 @@
 PBC spin-restricted G0W0-AC QP eigenvalues with k-point sampling
 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
@@ -277,7 +277,7 @@ def get_sigma_diag(gw, orbs, kptlist, freqs, wts, iw_cutoff=None, max_memory=800
                     for LpqR, LpqI, sign \
                             in mydf.sr_loop([kpti, kptj], max_memory=0.1*gw._scf.max_memory, compact=False):
                         Lpq.append(LpqR+LpqI*1.0j)
-                    # support uneqaul naux on different k points
+                    # support unequal naux on different k points
                     Lpq = np.vstack(Lpq).reshape(-1,nmo**2)
                     tao = []
                     ao_loc = None
@@ -389,7 +389,7 @@ def get_rho_response_wing(gw, omega, mo_energy, Lpq, qij):
 def get_qij(gw, q, mo_coeff, uniform_grids=False):
     '''
     Compute qij = 1/Omega * |< psi_{ik} | e^{iqr} | psi_{ak-q} >|^2 at q: (nkpts, nocc, nvir)
-    through kp perturbtation theory
+    through kp perturbation theory
     Ref: Phys. Rev. B 83, 245122 (2011)
     '''
     nocc = gw.nocc
@@ -442,7 +442,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/pbc/gw/krgw_cd.py

@@ -237,7 +237,7 @@ def get_WmnI_diag(gw, orbs, kptlist, freqs, max_memory=8000):
                     for LpqR, LpqI, sign \
                             in mydf.sr_loop([kpti, kptj], max_memory=0.1*gw._scf.max_memory, compact=False):
                         Lpq.append(LpqR+LpqI*1.0j)
-                    # support uneqaul naux on different k points
+                    # support unequal naux on different k points
                     Lpq = np.vstack(Lpq).reshape(-1,nmo**2)
                     tao = []
                     ao_loc = None
@@ -338,7 +338,7 @@ def get_rho_response_R(gw, omega, mo_energy, Lpq, kL, kidx):
 
 def get_sigmaR_diag(gw, omega, kn, orbp, ef, freqs, qij, q_abs):
     '''
-    Compute self-energy for poles inside coutour
+    Compute self-energy for poles inside contour
     (more and more expensive away from Fermi surface)
     '''
     mo_energy = np.array(gw._scf.mo_energy)
@@ -394,7 +394,7 @@ def get_sigmaR_diag(gw, omega, kn, orbp, ef, freqs, qij, q_abs):
                         for LpqR, LpqI, sign \
                                 in mydf.sr_loop([kpti, kptj], max_memory=0.1*gw._scf.max_memory, compact=False):
                             Lpq.append(LpqR+LpqI*1.0j)
-                        # support uneqaul naux on different k points
+                        # support unequal naux on different k points
                         Lpq = np.vstack(Lpq).reshape(-1,nmo**2)
                         tao = []
                         ao_loc = None
@@ -577,7 +577,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/pbc/gw/kugw_ac.py

@@ -18,7 +18,7 @@
 
 '''
 PBC spin-unrestricted G0W0-AC QP eigenvalues with k-point sampling
-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
@@ -448,7 +448,7 @@ def get_rho_response_wing(gw, omega, mo_energy, Lpq, qij):
 def get_qij(gw, q, mo_coeff, uniform_grids=False):
     '''
     Compute qij = 1/Omega * |< psi_{ik} | e^{iqr} | psi_{ak-q} >|^2 at q: (nkpts, nocc, nvir)
-    through kp perturbtation theory
+    through kp perturbation theory
     Ref: Phys. Rev. B 83, 245122 (2011)
     '''
     nocca, noccb = gw.nocc
@@ -507,7 +507,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/pbc/lib/kpts_helper.py

@@ -30,7 +30,7 @@ KPT_DIFF_TOL = getattr(__config__, 'pbc_lib_kpts_helper_kpt_diff_tol', 1e-6)
 
 def is_zero(kpt):
     return abs(np.asarray(kpt)).sum() < KPT_DIFF_TOL
-gamma_point = is_zero
+is_gamma_point = gamma_point = is_zero
 
 def round_to_fbz(kpts, wrap_around=False, tol=KPT_DIFF_TOL):
     '''
@@ -91,6 +91,7 @@ def unique(kpts):
             kpts.round(digits), return_index=True, return_inverse=True, axis=0)[1:3]
         idx = uniq_index.argsort()
         rank = idx.argsort()
+        uniq_inverse = uniq_inverse.ravel()
         return kpts[uniq_index[idx]], uniq_index[idx], rank[uniq_inverse]
     except TypeError:
         # Old numpy does not support unique of 2D array
@@ -261,7 +262,7 @@ def get_kconserv(cell, kpts):
     r'''Get the momentum conservation array for a set of k-points.
 
     Given k-point indices (k, l, m) the array kconserv[k,l,m] returns
-    the index n that satifies momentum conservation,
+    the index n that satisfies momentum conservation,
 
         (k(k) - k(l) + k(m) - k(n)) \dot a = 2n\pi
 
@@ -287,7 +288,7 @@ def get_kconserv_ria(cell, kpts):
     for a set of k-points with appropriate k-shift.
 
     Given k-point indices m the array kconserv[kshift,m] returns the index n that
-    satifies a shifted momentum conservation,
+    satisfies a shifted momentum conservation,
 
         (k(m) - k(n) - k(kshift)) \dot a = 2n\pi
 

pyscf/pbc/lib/linalg_helper.py

@@ -649,7 +649,7 @@ class DavidsonZL:
                 if tmp <= self.crit_e: nconv1+=1
             if VERBOSE: print(' No. of converged eigval:',nconv1)
             if nconv1 == neig:
-                if VERBOSE: print(' Cong: all eignvalues converged ! ')
+                if VERBOSE: print(' Cong: all eigenvalues converged ! ')
             eigs = teig.copy()
 
             # Full Residuals: Res[i]=Res'[i]-w[i]*X[i]

pyscf/pbc/mp/kmp2.py

@@ -380,7 +380,7 @@ def _frozen_sanity_check(frozen, mo_occ, kpt_idx):
 
     Args:
         frozen (array_like of int): The orbital indices that will be frozen.
-        mo_occ (:obj:`ndarray` of int): The occupuation number for each orbital
+        mo_occ (:obj:`ndarray` of int): The occupation number for each orbital
             resulting from a mean-field-like calculation.
         kpt_idx (int): The k-point that `mo_occ` and `frozen` belong to.
 

pyscf/pbc/mpitools/mpi.py

@@ -67,7 +67,7 @@ INQUIRY = 50050
 TASK = 50051
 def work_share_partition(tasks, interval=.02, loadmin=1):
     loadmin = max(loadmin, len(tasks)//50//pool.size)
-    rest_tasks = [x for x in tasks[loadmin*pool.size:]]
+    rest_tasks = list(tasks[loadmin*pool.size:])
     tasks = tasks[loadmin*rank:loadmin*rank+loadmin]
     def distribute_task():
         while True: