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

pyscf/pbc/dft/numint.py

@@ -276,7 +276,8 @@ def eval_rho2(cell, ao, mo_coeff, mo_occ, non0tab=None, xctype='LDA',
                     rho[4] -= rho5 * 2
                 rho[tau_idx] -= rho5 * .5
     else:
-        rho = numint.eval_rho2(cell, ao, mo_coeff, mo_occ, non0tab, xctype, verbose)
+        rho = numint.eval_rho2(cell, ao, mo_coeff, mo_occ, non0tab, xctype,
+                               with_lapl, verbose)
     return rho
 
 
@@ -477,7 +478,7 @@ def nr_uks(ni, cell, grids, xc_code, dms, spin=1, relativity=0, hermi=1,
                 vmata[i] += ni._vxc_mat(cell, ao_k1, wv[0], mask, xctype,
                                         shls_slice, ao_loc, v_hermi)
                 vmatb[i] += ni._vxc_mat(cell, ao_k1, wv[1], mask, xctype,
-                                        shls_slice, ao_loc, hermi)
+                                        shls_slice, ao_loc, v_hermi)
 
         vmat = numpy.stack([vmata, vmatb])
         # call swapaxes method to swap last two indices because vmat may be a 3D
@@ -636,11 +637,12 @@ def nr_rks_fxc(ni, cell, grids, xc_code, dm0, dms, relativity=0, hermi=0,
     elif isinstance(kpts, KPoints):
         kpts = kpts.kpts_ibz
 
+    v_hermi = 0
     if is_zero(kpts):
         if isinstance(dms, numpy.ndarray) and dms.dtype == numpy.double:
             # for real orbitals and real matrix, K_{ia,bj} = K_{ia,jb}
             # The output matrix v = K*x_{ia} is symmetric
-            hermi = 1
+            v_hermi = 1
 
     if xctype in ('LDA', 'GGA', 'MGGA'):
         make_rho, nset, nao = ni._gen_rho_evaluator(cell, dms, hermi, False)
@@ -660,10 +662,10 @@ def nr_rks_fxc(ni, cell, grids, xc_code, dm0, dms, relativity=0, hermi=0,
                     vxc1 = numpy.einsum('xg,xyg->yg', rho1, _fxc)
                 wv = weight * vxc1
                 vmat[i] += ni._vxc_mat(cell, ao_k1, wv, mask, xctype,
-                                       shls_slice, ao_loc, hermi)
+                                       shls_slice, ao_loc, v_hermi)
 
         vmat = numpy.stack(vmat)
-        if hermi == 1:
+        if v_hermi == 1:
             # call swapaxes method to swap last two indices because vmat may be a 3D
             # array (nset,nao,nao) in single k-point mode or a 4D array
             # (nset,nkpts,nao,nao) in k-points mode
@@ -759,10 +761,11 @@ def nr_uks_fxc(ni, cell, grids, xc_code, dm0, dms, relativity=0, hermi=0,
         kpts = kpts.kpts_ibz
 
     dma, dmb = _format_uks_dm(dms)
+    v_hermi = 0
     if is_zero(kpts) and dma.dtype == numpy.double:
         # for real orbitals and real matrix, K_{ia,bj} = K_{ia,jb}
         # The output matrix v = K*x_{ia} is symmetric
-        hermi = 1
+        v_hermi = 1
 
     nao = dma.shape[-1]
     make_rhoa, nset = ni._gen_rho_evaluator(cell, dma, hermi, False)[:2]
@@ -782,19 +785,19 @@ def nr_uks_fxc(ni, cell, grids, xc_code, dm0, dms, relativity=0, hermi=0,
             for i in range(nset):
                 rho1a = make_rhoa(i, ao_k1, mask, xctype)
                 rho1b = make_rhob(i, ao_k1, mask, xctype)
-                rho1 = numpy.stack([rho1a, rho1b])
                 if xctype == 'LDA':
-                    vxc1 = numpy.einsum('ag,abyg->byg', rho1, _fxc[:,0,:])
+                    wv = rho1a * _fxc[0,0] + rho1b * _fxc[1,0]
                 else:
-                    vxc1 = numpy.einsum('axg,axbyg->byg', rho1, _fxc)
-                wv = weight * vxc1
+                    wv  = numpy.einsum('xg,xbyg->byg', rho1a, _fxc[0])
+                    wv += numpy.einsum('xg,xbyg->byg', rho1b, _fxc[1])
+                wv *= weight
                 vmata[i] += ni._vxc_mat(cell, ao_k1, wv[0], mask, xctype,
-                                        shls_slice, ao_loc, hermi)
+                                        shls_slice, ao_loc, v_hermi)
                 vmatb[i] += ni._vxc_mat(cell, ao_k1, wv[1], mask, xctype,
-                                        shls_slice, ao_loc, hermi)
+                                        shls_slice, ao_loc, v_hermi)
 
         vmat = numpy.stack([vmata, vmatb])
-        if hermi == 1:
+        if v_hermi == 1:
             vmat = vmat + vmat.conj().swapaxes(-2,-1)
         if nset == 1:
             vmat = vmat.reshape((2,) + dma.shape)
@@ -852,12 +855,13 @@ def cache_xc_kernel(ni, cell, grids, xc_code, mo_coeff, mo_occ, spin=0,
     else:
         is_rhf = mo_coeff[0].ndim == 1
 
+    with_lapl = False
     nao = cell.nao_nr()
     if is_rhf:
         rho = []
         for ao_k1, ao_k2, mask, weight, coords \
                 in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):
-            rho.append(ni.eval_rho2(cell, ao_k1, mo_coeff, mo_occ, mask, xctype))
+            rho.append(ni.eval_rho2(cell, ao_k1, mo_coeff, mo_occ, mask, xctype, with_lapl))
         rho = numpy.hstack(rho)
         if spin == 1:
             rho *= .5
@@ -868,8 +872,8 @@ def cache_xc_kernel(ni, cell, grids, xc_code, mo_coeff, mo_occ, spin=0,
         rhob = []
         for ao_k1, ao_k2, mask, weight, coords \
                 in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):
-            rhoa.append(ni.eval_rho2(cell, ao_k1, mo_coeff[0], mo_occ[0], mask, xctype))
-            rhob.append(ni.eval_rho2(cell, ao_k1, mo_coeff[1], mo_occ[1], mask, xctype))
+            rhoa.append(ni.eval_rho2(cell, ao_k1, mo_coeff[0], mo_occ[0], mask, xctype, with_lapl))
+            rhob.append(ni.eval_rho2(cell, ao_k1, mo_coeff[1], mo_occ[1], mask, xctype, with_lapl))
         rho = numpy.stack([numpy.hstack(rhoa), numpy.hstack(rhob)])
     vxc, fxc = ni.eval_xc_eff(xc_code, rho, deriv=2, xctype=xctype)[1:3]
     return rho, vxc, fxc
@@ -898,12 +902,13 @@ def cache_xc_kernel1(ni, cell, grids, xc_code, dm, spin=0,
 
     # 0th order density matrix must be hermitian
     hermi = 1
+    with_lapl = False
     nao = cell.nao_nr()
     if is_rhf:
         rho = []
         for ao_k1, ao_k2, mask, weight, coords \
                 in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):
-            rho.append(ni.eval_rho1(cell, ao_k1, dm, mask, xctype, hermi))
+            rho.append(ni.eval_rho1(cell, ao_k1, dm, mask, xctype, hermi, with_lapl))
         rho = numpy.hstack(rho)
         if spin == 1:
             rho *= .5
@@ -914,8 +919,8 @@ def cache_xc_kernel1(ni, cell, grids, xc_code, dm, spin=0,
         rhob = []
         for ao_k1, ao_k2, mask, weight, coords \
                 in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):
-            rhoa.append(ni.eval_rho1(cell, ao_k1, dm[0], mask, xctype, hermi))
-            rhob.append(ni.eval_rho1(cell, ao_k1, dm[1], mask, xctype, hermi))
+            rhoa.append(ni.eval_rho1(cell, ao_k1, dm[0], mask, xctype, hermi, with_lapl))
+            rhob.append(ni.eval_rho1(cell, ao_k1, dm[1], mask, xctype, hermi, with_lapl))
         rho = numpy.stack([numpy.hstack(rhoa), numpy.hstack(rhob)])
     vxc, fxc = ni.eval_xc_eff(xc_code, rho, deriv=2, xctype=xctype)[1:3]
     return rho, vxc, fxc
@@ -985,11 +990,13 @@ class NumInt(lib.StreamObject, numint.LibXCMixin):
                       hermi, kpt, kpts_band, max_memory, verbose)
 
     def _vxc_mat(self, cell, ao, wv, mask, xctype, shls_slice, ao_loc, hermi):
+        if xctype == 'MGGA':
+            tau_idx = 4
+            wv[tau_idx] *= .5 # *.5 for 1/2 in tau
         if hermi == 1:
             # *.5 because mat + mat.T in the caller when hermi=1
             wv[0] *= .5
             if xctype == 'MGGA':
-                tau_idx = 4
                 wv[tau_idx] *= .5
         return _vxc_mat(cell, ao, wv, mask, xctype, shls_slice, ao_loc, hermi)
 
@@ -1190,11 +1197,13 @@ class KNumInt(lib.StreamObject, numint.LibXCMixin):
         nao = ao_kpts[0].shape[-1]
         dtype = numpy.result_type(wv, *ao_kpts)
         mat = numpy.empty((nkpts,nao,nao), dtype=dtype)
+        if xctype == 'MGGA':
+            tau_idx = 4
+            wv[tau_idx] *= .5 # *.5 for 1/2 in tau
         if hermi == 1:
             # *.5 because mat + mat.T in the caller when hermi=1
             wv[0] *= .5
             if xctype == 'MGGA':
-                tau_idx = 4
                 wv[tau_idx] *= .5
 
         for k in range(nkpts):

pyscf/pbc/eph/eph_fd.py

@@ -137,7 +137,7 @@ def kernel(mf, disp=1e-4, mo_rep=False):
     mo_coeff = np.asarray(mf.mo_coeff)
     RESTRICTED= (mo_coeff.ndim==3)
     cell = mf.cell
-    cells_a, cells_b = gen_cells(cell, disp/2.0) # generate a bunch of cells with disp/2 on each cartesion coord
+    cells_a, cells_b = gen_cells(cell, disp/2.0) # generate a bunch of cells with disp/2 on each cartesian coord
     mfset = run_mfs(mf, cells_a, cells_b) # run mean field calculations on all these cells
     vmat = get_vmat(mf, mfset, disp) # extracting <u|dV|v>/dR
     hmat = run_hess(mfset, disp)

pyscf/pbc/geomopt/geometric_solver.py

@@ -133,7 +133,7 @@ def kernel(method, assert_convergence=ASSERT_CONV,
     # When symmetry is enabled, the molecule may be shifted or rotated to make
     # the z-axis be the main axis. The transformation can cause inconsistency
     # between the optimization steps. The transformation is muted by setting
-    # an explict point group to the keyword mol.symmetry (see symmetry
+    # an explicit point group to the keyword mol.symmetry (see symmetry
     # detection code in Mole.build function).
 
     # geomeTRIC library on pypi requires to provide config file log.ini.

pyscf/pbc/gto/cell.py

@@ -66,6 +66,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,8 +88,8 @@ 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:
@@ -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:
@@ -1075,7 +1076,7 @@ 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',
     }
@@ -1087,6 +1088,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
@@ -1265,13 +1267,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 +1292,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 +1334,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 +1348,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 +1429,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 +1464,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 +1552,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 +1758,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)

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:

pyscf/pbc/scf/addons.py

@@ -91,13 +91,17 @@ class _SmearingKSCF(mol_addons._SmearingSCF):
 
         This is a k-point version of scf.hf.SCF.get_occ
         '''
+        from pyscf.pbc import scf
         if (self.sigma == 0) or (not self.sigma) or (not self.smearing_method):
             mo_occ_kpts = super().get_occ(mo_energy_kpts, mo_coeff_kpts)
             return mo_occ_kpts
 
         is_uhf = self.istype('KUHF')
         is_rhf = self.istype('KRHF')
-        is_rohf = self.istype('KROHF')
+        if isinstance(self, scf.krohf.KROHF):
+            # ROHF leads to two Fock matrices. It's not clear how to define the
+            # Roothaan effective Fock matrix from the two.
+            raise NotImplementedError('Smearing-ROHF')
 
         sigma = self.sigma
         if self.smearing_method.lower() == 'fermi':
@@ -112,9 +116,7 @@ class _SmearingKSCF(mol_addons._SmearingSCF):
         else:
             nkpts = len(kpts)
 
-        if self.fix_spin and (is_uhf or is_rohf): # spin separated fermi level
-            if is_rohf: # treat rohf as uhf
-                mo_energy_kpts = (mo_energy_kpts, mo_energy_kpts)
+        if self.fix_spin and is_uhf: # spin separated fermi level
             mo_es = [numpy.hstack(mo_energy_kpts[0]),
                      numpy.hstack(mo_energy_kpts[1])]
             nocc = self.nelec
@@ -150,8 +152,6 @@ class _SmearingKSCF(mol_addons._SmearingSCF):
             mo_occ_kpts =(_partition_occ(mo_occs[0], mo_energy_kpts[0]),
                           _partition_occ(mo_occs[1], mo_energy_kpts[1]))
             tools.print_mo_energy_occ_kpts(self, mo_energy_kpts, mo_occ_kpts, True)
-            if is_rohf:
-                mo_occ_kpts = numpy.array(mo_occ_kpts, dtype=numpy.float64).sum(axis=0)
         else:
             nocc = nelectron = self.mol.tot_electrons(nkpts)
             if is_uhf:
@@ -488,15 +488,19 @@ def convert_to_kscf(mf, out=None):
         }
         mf = mol_addons._object_without_soscf(mf, known_cls, False)
         if mf.mo_energy is not None:
-            if mf.istype('UHF'):
-                mf.mo_occ = mf.mo_occ[:,numpy.newaxis]
-                mf.mo_coeff = mf.mo_coeff[:,numpy.newaxis]
-                mf.mo_energy = mf.mo_energy[:,numpy.newaxis]
+            if isinstance(mf, scf.kuhf.KUHF):
+                mf.mo_occ = mf.mo_occ[:, numpy.newaxis]
+                mf.mo_coeff = mf.mo_coeff[:, numpy.newaxis]
+                mf.mo_energy = mf.mo_energy[:, numpy.newaxis]
             else:
                 mf.mo_occ = mf.mo_occ[numpy.newaxis]
                 mf.mo_coeff = mf.mo_coeff[numpy.newaxis]
                 mf.mo_energy = mf.mo_energy[numpy.newaxis]
 
+        if hasattr(mf, '_numint'):
+            kpts = getattr(mf.kpts, 'kpts', mf.kpts)
+            mf._numint = dft.numint.KNumInt(kpts)
+
     if out is None:
         return mf
 
@@ -522,7 +526,7 @@ def mo_energy_with_exxdiv_none(mf, mo_coeff=None):
         fockao = mf.get_fock(vhf=vhf, dm=dm)
 
     def _get_moe1(C, fao):
-        return lib.einsum('pi,pq,qi->i', C.conj(), fao, C)
+        return lib.einsum('pi,pq,qi->i', C.conj(), fao, C).real
     def _get_moek(kC, kfao):
         return [_get_moe1(C, fao) for C,fao in zip(kC, kfao)]
 

pyscf/pbc/scf/cphf.py

@@ -17,7 +17,7 @@
 #
 
 '''
-Restricted coupled pertubed Hartree-Fock solver
+Restricted coupled perturbed Hartree-Fock solver
 Modified from pyscf.scf.cphf
 '''