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

pyscf/pbc/scf/khf.py

@@ -35,7 +35,6 @@ from pyscf.pbc.scf import hf as pbchf
 from pyscf import lib
 from pyscf.scf import hf as mol_hf
 from pyscf.lib import logger
-from pyscf.pbc.gto import ecp
 from pyscf.pbc.scf import addons
 from pyscf.pbc.scf import chkfile  # noqa
 from pyscf.pbc import tools
@@ -79,6 +78,7 @@ def get_hcore(mf, cell=None, kpts=None):
     else:
         nuc = lib.asarray(mf.with_df.get_nuc(kpts))
     if len(cell._ecpbas) > 0:
+        from pyscf.pbc.gto import ecp
         nuc += lib.asarray(ecp.ecp_int(cell, kpts))
     t = lib.asarray(cell.pbc_intor('int1e_kin', 1, 1, kpts))
     return nuc + t
@@ -249,7 +249,7 @@ def energy_elec(mf, dm_kpts=None, h1e_kpts=None, vhf_kpts=None):
     mf.scf_summary['e1'] = e1.real
     mf.scf_summary['e2'] = e_coul.real
     logger.debug(mf, 'E1 = %s  E_coul = %s', e1, e_coul)
-    if CHECK_COULOMB_IMAG and abs(e_coul.imag > mf.cell.precision*10):
+    if CHECK_COULOMB_IMAG and abs(e_coul.imag) > mf.cell.precision*10:
         logger.warn(mf, "Coulomb energy has imaginary part %s. "
                     "Coulomb integrals (e-e, e-N) may not converge !",
                     e_coul.imag)
@@ -278,31 +278,36 @@ def analyze(mf, verbose=None, with_meta_lowdin=WITH_META_LOWDIN,
         #return mf.mulliken_pop(mf.cell, dm, s=ovlp_ao, verbose=verbose)
 
 
-def mulliken_meta(cell, dm_ao_kpts, verbose=logger.DEBUG,
+def _make_rdm1_meta(cell, dm_ao_kpts, kpts, pre_orth_method, s):
+    from pyscf.lo import orth
+    from pyscf.pbc.tools import k2gamma
+
+    kmesh = k2gamma.kpts_to_kmesh(cell, kpts-kpts[0])
+    nkpts, nao = dm_ao_kpts.shape[:2]
+    scell, phase = k2gamma.get_phase(cell, kpts, kmesh)
+    s_sc = k2gamma.to_supercell_ao_integrals(cell, kpts, s, kmesh=kmesh, force_real=False)
+    orth_coeff = orth.orth_ao(scell, 'meta_lowdin', pre_orth_method, s=s_sc)[:,:nao] # cell 0 only
+    c_inv = np.dot(orth_coeff.T.conj(), s_sc)
+    c_inv = lib.einsum('aRp,Rk->kap', c_inv.reshape(nao,nkpts,nao), phase)
+    dm = lib.einsum('kap,kpq,kbq->ab', c_inv, dm_ao_kpts, c_inv.conj())
+
+    return dm
+
+
+def mulliken_meta(cell, dm_ao_kpts, kpts, verbose=logger.DEBUG,
                   pre_orth_method=PRE_ORTH_METHOD, s=None):
     '''A modified Mulliken population analysis, based on meta-Lowdin AOs.
-
-    Note this function only computes the Mulliken population for the gamma
-    point density matrix.
+    The results are equivalent to the corresponding supercell calculation.
     '''
-    from pyscf.lo import orth
-    if s is None:
-        s = get_ovlp(cell)
     log = logger.new_logger(cell, verbose)
-    log.note('Analyze output for *gamma point*')
-    log.info('    To include the contributions from k-points, transform to a '
-             'supercell then run the population analysis on the supercell\n'
-             '        from pyscf.pbc.tools import k2gamma\n'
-             '        k2gamma.k2gamma(mf).mulliken_meta()')
-    log.note("KRHF mulliken_meta")
-    dm_ao_gamma = dm_ao_kpts[0,:,:].real
-    s_gamma = s[0,:,:].real
-    orth_coeff = orth.orth_ao(cell, 'meta_lowdin', pre_orth_method, s=s_gamma)
-    c_inv = np.dot(orth_coeff.T, s_gamma)
-    dm = reduce(np.dot, (c_inv, dm_ao_gamma, c_inv.T.conj()))
+
+    if s is None:
+        s = get_ovlp(None, cell=cell, kpts=kpts)
+
+    dm = _make_rdm1_meta(cell, dm_ao_kpts, kpts, pre_orth_method, s)
 
     log.note(' ** Mulliken pop on meta-lowdin orthogonal AOs **')
-    return mol_hf.mulliken_pop(cell, dm, np.eye(orth_coeff.shape[0]), log)
+    return mol_hf.mulliken_pop(cell, dm, np.eye(dm.shape[0]), log)
 
 
 def canonicalize(mf, mo_coeff_kpts, mo_occ_kpts, fock=None):
@@ -469,6 +474,61 @@ class KSCF(pbchf.SCF):
     def mo_occ_kpts(self):
         return self.mo_occ
 
+    @property
+    def kpts(self):
+        if 'kpts' in self.__dict__:
+            # To handle the attribute kpt loaded from chkfile
+            self.kpts = self.__dict__.pop('kpts')
+        return self.with_df.kpts
+
+    @kpts.setter
+    def kpts(self, x):
+        self.with_df.kpts = np.reshape(x, (-1,3))
+        if self.rsjk:
+            self.rsjk.kpts = self.with_df.kpts
+
+    @property
+    def kmesh(self):
+        '''The number of k-points along each axis in the first Brillouin zone'''
+        from pyscf.pbc.tools.k2gamma import kpts_to_kmesh
+        kpts = self.kpts
+        kmesh = kpts_to_kmesh(kpts)
+        if len(kpts) != np.prod(kmesh):
+            logger.WARN(self, 'K-points specified in %s are not Monkhorst-Pack %s grids',
+                        self, kmesh)
+        return kmesh
+
+    @kmesh.setter
+    def kmesh(self, x):
+        self.kpts = self.cell.make_kpts(x)
+
+    def build(self, cell=None):
+        # To handle the attribute kpt or kpts loaded from chkfile
+        if 'kpts' in self.__dict__:
+            self.kpts = self.__dict__.pop('kpts')
+
+        # "vcut_ws" precomputing is triggered by pbc.tools.pbc.get_coulG
+        #if self.exxdiv == 'vcut_ws':
+        #    if self.exx_built is False:
+        #        self.precompute_exx()
+        #    logger.info(self, 'WS alpha = %s', self.exx_alpha)
+
+        kpts = self.kpts
+        if self.rsjk:
+            if not np.all(self.rsjk.kpts == kpts):
+                self.rsjk = self.rsjk.__class__(cell, kpts)
+
+        # for GDF and MDF
+        with_df = self.with_df
+        if len(kpts) > 1 and getattr(with_df, '_j_only', False):
+            logger.warn(self, 'df.j_only cannot be used with k-point HF')
+            with_df._j_only = False
+            with_df.reset()
+
+        if self.verbose >= logger.WARN:
+            self.check_sanity()
+        return self
+
     def dump_flags(self, verbose=None):
         mol_hf.SCF.dump_flags(self, verbose)
         logger.info(self, '\n')
@@ -611,9 +671,21 @@ class KSCF(pbchf.SCF):
     def from_chk(self, chk=None, project=None, kpts=None):
         return self.init_guess_by_chkfile(chk, project, kpts)
 
-    def dump_chk(self, envs):
-        if self.chkfile:
-            mol_hf.SCF.dump_chk(self, envs)
+    def dump_chk(self, envs_or_file):
+        '''Serialize the SCF object and save it to the specified chkfile.
+
+        Args:
+            envs_or_file:
+                If this argument is a file path, the serialized SCF object is
+                saved to the file specified by this argument.
+                If this attribute is a dict (created by locals()), the necessary
+                variables are saved to the file specified by the attribute mf.chkfile.
+        '''
+        mol_hf.SCF.dump_chk(self, envs_or_file)
+        if isinstance(envs_or_file, str):
+            with lib.H5FileWrap(envs_or_file, 'a') as fh5:
+                fh5['scf/kpts'] = self.kpts
+        elif self.chkfile:
             with lib.H5FileWrap(self.chkfile, 'a') as fh5:
                 fh5['scf/kpts'] = self.kpts
         return self
@@ -621,7 +693,7 @@ class KSCF(pbchf.SCF):
     def analyze(mf, verbose=None, with_meta_lowdin=WITH_META_LOWDIN, **kwargs):
         raise NotImplementedError
 
-    def mulliken_meta(self, cell=None, dm=None, verbose=logger.DEBUG,
+    def mulliken_meta(self, cell=None, dm=None, kpts=None, verbose=logger.DEBUG,
                       pre_orth_method=PRE_ORTH_METHOD, s=None):
         raise NotImplementedError
 
@@ -726,12 +798,13 @@ class KRHF(KSCF):
         return dm_kpts
 
     @lib.with_doc(mulliken_meta.__doc__)
-    def mulliken_meta(self, cell=None, dm=None, verbose=logger.DEBUG,
+    def mulliken_meta(self, cell=None, dm=None, kpts=None, verbose=logger.DEBUG,
                       pre_orth_method=PRE_ORTH_METHOD, s=None):
         if cell is None: cell = self.cell
         if dm is None: dm = self.make_rdm1()
+        if kpts is None: kpts = self.kpts
         if s is None: s = self.get_ovlp(cell)
-        return mulliken_meta(cell, dm, s=s, verbose=verbose,
+        return mulliken_meta(cell, dm, kpts, s=s, verbose=verbose,
                              pre_orth_method=pre_orth_method)
 
     def nuc_grad_method(self):
@@ -741,9 +814,10 @@ class KRHF(KSCF):
     def stability(self,
                   internal=getattr(__config__, 'pbc_scf_KSCF_stability_internal', True),
                   external=getattr(__config__, 'pbc_scf_KSCF_stability_external', False),
-                  verbose=None):
+                  verbose=None,
+                  return_status=False):
         from pyscf.pbc.scf.stability import rhf_stability
-        return rhf_stability(self, internal, external, verbose)
+        return rhf_stability(self, internal, external, verbose, return_status)
 
     def to_ks(self, xc='HF'):
         '''Convert to RKS object.

pyscf/pbc/scf/khf_ksymm.py

@@ -76,7 +76,7 @@ def energy_elec(mf, dm_kpts=None, h1e_kpts=None, vhf_kpts=None):
     mf.scf_summary['e1'] = e1.real
     mf.scf_summary['e2'] = e_coul.real
     logger.debug(mf, 'E1 = %s  E_coul = %s', e1, e_coul)
-    if khf.CHECK_COULOMB_IMAG and abs(e_coul.imag > mf.cell.precision*10):
+    if khf.CHECK_COULOMB_IMAG and abs(e_coul.imag) > mf.cell.precision*10:
         logger.warn(mf, "Coulomb energy has imaginary part %s. "
                     "Coulomb integrals (e-e, e-N) may not converge !",
                     e_coul.imag)
@@ -166,6 +166,20 @@ class KsymAdaptedKSCF(khf.KSCF):
         self.with_df.kpts = np.reshape(kpts_bz, (-1,3))
         self._kpts = kpts
 
+    @property
+    def kmesh(self):
+        from pyscf.pbc.tools.k2gamma import kpts_to_kmesh
+        kpts_bz = self._kpts.kpts
+        kmesh = kpts_to_kmesh(kpts_bz)
+        if len(kpts_bz) != np.prod(kmesh):
+            logger.WARN(self, 'K-points specified in %s are not Monkhorst-Pack %s grids',
+                        self, kmesh)
+        return kmesh
+
+    @kmesh.setter
+    def kmesh(self, x):
+        self.kpts = self.cell.make_kpts(x)
+
     def dump_flags(self, verbose=None):
         mol_hf.SCF.dump_flags(self, verbose)
         logger.info(self, '\n')

pyscf/pbc/scf/krohf.py

@@ -211,15 +211,12 @@ get_rho = kuhf.get_rho
 
 
 @lib.with_doc(khf.mulliken_meta.__doc__)
-def mulliken_meta(cell, dm_ao_kpts, verbose=logger.DEBUG,
+def mulliken_meta(cell, dm_ao_kpts, kpts, verbose=logger.DEBUG,
                   pre_orth_method=PRE_ORTH_METHOD, s=None):
     '''Mulliken population analysis, based on meta-Lowdin AOs.
-
-    Note this function only computes the Mulliken population for the gamma
-    point density matrix.
     '''
     dm = dm_ao_kpts[0] + dm_ao_kpts[1]
-    return khf.mulliken_meta(cell, dm, verbose, pre_orth_method, s)
+    return khf.mulliken_meta(cell, dm, kpts, verbose, pre_orth_method, s)
 
 
 def canonicalize(mf, mo_coeff_kpts, mo_occ_kpts, fock=None):
@@ -362,12 +359,13 @@ class KROHF(khf.KRHF):
         if kpts is None: kpts = self.kpts
         return init_guess_by_chkfile(self.cell, chk, project, kpts)
 
-    def mulliken_meta(self, cell=None, dm=None, verbose=logger.DEBUG,
+    def mulliken_meta(self, cell=None, dm=None, kpts=None, verbose=logger.DEBUG,
                       pre_orth_method=PRE_ORTH_METHOD, s=None):
         if cell is None: cell = self.cell
         if dm is None: dm = self.make_rdm1()
+        if kpts is None: kpts = self.kpts
         if s is None: s = self.get_ovlp(cell)
-        return mulliken_meta(cell, dm, s=s, verbose=verbose,
+        return mulliken_meta(cell, dm, kpts, s=s, verbose=verbose,
                              pre_orth_method=pre_orth_method)
 
     def stability(self,

pyscf/pbc/scf/kuhf.py

@@ -209,39 +209,59 @@ def energy_elec(mf, dm_kpts=None, h1e_kpts=None, vhf_kpts=None):
     mf.scf_summary['e1'] = e1.real
     mf.scf_summary['e2'] = e_coul.real
     logger.debug(mf, 'E1 = %s  E_coul = %s', e1, e_coul)
-    if CHECK_COULOMB_IMAG and abs(e_coul.imag > mf.cell.precision*10):
+    if CHECK_COULOMB_IMAG and abs(e_coul.imag) > mf.cell.precision*10:
         logger.warn(mf, "Coulomb energy has imaginary part %s. "
                     "Coulomb integrals (e-e, e-N) may not converge !",
                     e_coul.imag)
     return (e1+e_coul).real, e_coul.real
 
 
-def mulliken_meta(cell, dm_ao_kpts, verbose=logger.DEBUG,
+def _make_rdm1_meta(cell, dm_ao_kpts, kpts, pre_orth_method, s):
+    from pyscf.lo import orth
+    from pyscf.pbc.tools import k2gamma
+
+    kmesh = k2gamma.kpts_to_kmesh(cell, kpts-kpts[0])
+    nkpts, nao = dm_ao_kpts[0].shape[:2]
+    scell, phase = k2gamma.get_phase(cell, kpts, kmesh)
+    s_sc = k2gamma.to_supercell_ao_integrals(cell, kpts, s, kmesh=kmesh, force_real=False)
+    orth_coeff = orth.orth_ao(scell, 'meta_lowdin', pre_orth_method, s=s_sc)[:,:nao] # cell 0 only
+    c_inv = np.dot(orth_coeff.T.conj(), s_sc)
+    c_inv = lib.einsum('aRp,Rk->kap', c_inv.reshape(nao,nkpts,nao), phase)
+    dm_a = lib.einsum('kap,kpq,kbq->ab', c_inv, dm_ao_kpts[0], c_inv.conj())
+    dm_b = lib.einsum('kap,kpq,kbq->ab', c_inv, dm_ao_kpts[1], c_inv.conj())
+
+    return (dm_a, dm_b)
+
+
+def mulliken_meta(cell, dm_ao_kpts, kpts, verbose=logger.DEBUG,
                   pre_orth_method=PRE_ORTH_METHOD, s=None):
     '''A modified Mulliken population analysis, based on meta-Lowdin AOs.
-
-    Note this function only computes the Mulliken population for the gamma
-    point density matrix.
+    The results are equivalent to the corresponding supercell calculation.
     '''
-    from pyscf.lo import orth
+    log = logger.new_logger(cell, verbose)
+
     if s is None:
-        s = khf.get_ovlp(cell)
+        s = khf.get_ovlp(None, cell=cell, kpts=kpts)
+
+    dm_a, dm_b = _make_rdm1_meta(cell, dm_ao_kpts, kpts, pre_orth_method, s)
+
+    log.note(' ** Mulliken pop alpha/beta on meta-lowdin orthogonal AOs **')
+    return mol_uhf.mulliken_pop(cell, (dm_a,dm_b), np.eye(dm_a.shape[0]), log)
+
+
+def mulliken_meta_spin(cell, dm_ao_kpts, kpts, verbose=logger.DEBUG,
+                       pre_orth_method=PRE_ORTH_METHOD, s=None):
+    '''A modified Mulliken population analysis, based on meta-Lowdin AOs.
+    '''
     log = logger.new_logger(cell, verbose)
-    log.note('Analyze output for *gamma point*.')
-    log.info('    To include the contributions from k-points, transform to a '
-             'supercell then run the population analysis on the supercell\n'
-             '        from pyscf.pbc.tools import k2gamma\n'
-             '        k2gamma.k2gamma(mf).mulliken_meta()')
-    log.note("KUHF mulliken_meta")
-    dm_ao_gamma = dm_ao_kpts[:,0,:,:].real
-    s_gamma = s[0,:,:].real
-    orth_coeff = orth.orth_ao(cell, 'meta_lowdin', pre_orth_method, s=s_gamma)
-    c_inv = np.dot(orth_coeff.T, s_gamma)
-    dm_a = reduce(np.dot, (c_inv, dm_ao_gamma[0], c_inv.T.conj()))
-    dm_b = reduce(np.dot, (c_inv, dm_ao_gamma[1], c_inv.T.conj()))
+
+    if s is None:
+        s = khf.get_ovlp(None, cell=cell, kpts=kpts)
+
+    dm_a, dm_b = _make_rdm1_meta(cell, dm_ao_kpts, kpts, pre_orth_method, s)
 
     log.note(' ** Mulliken pop alpha/beta on meta-lowdin orthogonal AOs **')
-    return mol_uhf.mulliken_pop(cell, (dm_a,dm_b), np.eye(orth_coeff.shape[0]), log)
+    return mol_uhf.mulliken_spin_pop(cell, (dm_a,dm_b), np.eye(dm_a.shape[0]), log)
 
 
 def canonicalize(mf, mo_coeff_kpts, mo_occ_kpts, fock=None):
@@ -369,6 +389,7 @@ class KUHF(khf.KSCF):
     '''UHF class with k-point sampling.
     '''
     conv_tol_grad = getattr(__config__, 'pbc_scf_KSCF_conv_tol_grad', None)
+    init_guess_breaksym = getattr(__config__, 'scf_uhf_init_guess_breaksym', 1)
 
     _keys = {"init_guess_breaksym"}
 
@@ -390,7 +411,6 @@ class KUHF(khf.KSCF):
                  exxdiv=getattr(__config__, 'pbc_scf_SCF_exxdiv', 'ewald')):
         khf.KSCF.__init__(self, cell, kpts, exxdiv)
         self.nelec = None
-        self.init_guess_breaksym = None
 
     @property
     def nelec(self):
@@ -509,14 +529,25 @@ class KUHF(khf.KSCF):
         return init_guess_by_chkfile(self.cell, chk, project, kpts)
 
     @lib.with_doc(mulliken_meta.__doc__)
-    def mulliken_meta(self, cell=None, dm=None, verbose=logger.DEBUG,
+    def mulliken_meta(self, cell=None, dm=None, kpts=None, verbose=logger.DEBUG,
                       pre_orth_method=PRE_ORTH_METHOD, s=None):
         if cell is None: cell = self.cell
         if dm is None: dm = self.make_rdm1()
+        if kpts is None: kpts = self.kpts
         if s is None: s = self.get_ovlp(cell)
-        return mulliken_meta(cell, dm, s=s, verbose=verbose,
+        return mulliken_meta(cell, dm, kpts, s=s, verbose=verbose,
                              pre_orth_method=pre_orth_method)
 
+    @lib.with_doc(mulliken_meta_spin.__doc__)
+    def mulliken_meta_spin(self, cell=None, dm=None, kpts=None, verbose=logger.DEBUG,
+                           pre_orth_method=PRE_ORTH_METHOD, s=None):
+        if cell is None: cell = self.cell
+        if dm is None: dm = self.make_rdm1()
+        if kpts is None: kpts = self.kpts
+        if s is None: s = self.get_ovlp(cell)
+        return mulliken_meta_spin(cell, dm, kpts, s=s, verbose=verbose,
+                                  pre_orth_method=pre_orth_method)
+
     def mulliken_pop(self):
         raise NotImplementedError
 

pyscf/pbc/scf/kuhf_ksymm.py

@@ -102,7 +102,7 @@ def energy_elec(mf, dm_kpts=None, h1e_kpts=None, vhf_kpts=None):
     mf.scf_summary['e1'] = e1.real
     mf.scf_summary['e2'] = e_coul.real
     logger.debug(mf, 'E1 = %s  E_coul = %s', e1, e_coul)
-    if kuhf.CHECK_COULOMB_IMAG and abs(e_coul.imag > mf.cell.precision*10):
+    if kuhf.CHECK_COULOMB_IMAG and abs(e_coul.imag) > mf.cell.precision*10:
         logger.warn(mf, "Coulomb energy has imaginary part %s. "
                     "Coulomb integrals (e-e, e-N) may not converge !",
                     e_coul.imag)

pyscf/pbc/scf/rsjk.py

@@ -96,6 +96,11 @@ class RangeSeparatedJKBuilder(lib.StreamObject):
         self._last_vs = (0, 0)
         self._qindex = None
 
+    __getstate__, __setstate__ = lib.generate_pickle_methods(
+            excludes=('rs_cell', 'cell_d', 'supmol_sr', 'supmol_ft', 'supmol_d',
+                      '_sr_without_dddd', '_last_vs', '_qindex'),
+            reset_state=True)
+
     def has_long_range(self):
         '''Whether to add the long-range part computed with AFT/FFT integrals'''
         return self.omega is None or abs(self.cell.omega) < self.omega
@@ -123,8 +128,7 @@ class RangeSeparatedJKBuilder(lib.StreamObject):
         self.supmol_sr = None
         self.supmol_ft = None
         self.supmol_d = None
-        self.exclude_dd_block = True
-        self.approx_vk_lr_missing_mo = False
+        self._sr_without_dddd = None
         self._last_vs = (0, 0)
         self._qindex = None
         return self
@@ -361,7 +365,7 @@ class RangeSeparatedJKBuilder(lib.StreamObject):
 
         cache_size = _get_cache_size(cell, 'int2e_sph')
         cell0_dims = cell0_ao_loc[1:] - cell0_ao_loc[:-1]
-        cache_size += cell0_dims.max()**4 * comp * 2
+        cache_size += int(cell0_dims.max())**4 * comp * 2
 
         if hermi:
             fdot_suffix = 's2kl'
@@ -422,7 +426,7 @@ class RangeSeparatedJKBuilder(lib.StreamObject):
             subset_only = intersection(kpts, kpts_band).size == len(kpts_band)
             if not subset_only:
                 log.warn('Approximate J/K matrices at kpts_band '
-                         'with the bvk-cell dervied from kpts')
+                         'with the bvk-cell derived from kpts')
                 expLk = np.exp(1j*np.dot(supmol.bvkmesh_Ls, kpts_band.T))
         vs = lib.einsum('snpRq,Rk->snkpq', vs, expLk)
         vs = np.asarray(vs, order='C')
@@ -595,10 +599,10 @@ class RangeSeparatedJKBuilder(lib.StreamObject):
 
         if (cell.dimension == 3 or
             (cell.dimension == 2 and cell.low_dim_ft_type != 'inf_vacuum')):
-            G0_idx = 0  # due to np.fft.fftfreq convension
+            G0_idx = 0  # due to np.fft.fftfreq convention
             # G=0 associated to 2e integrals in real-space
             coulG_SR_at_G0 = np.pi/self.omega**2
-            # For cell.dimension = 2, coulG is computed with truncated coulomb
+            # For cell.dimension = 2, coulG is computed with truncated Coulomb
             # interactions. The 3d coulG_SR below is to remove the analytical
             # SR from get_jk_sr (which was computed with full Coulomb) then to
             # add truncated Coulomb for AFT part.
@@ -1084,7 +1088,7 @@ class RangeSeparatedJKBuilder(lib.StreamObject):
 
         if self._sr_without_dddd and naod > 0:
             # (DD|DD) with full coulG, rest terms with coulG_LR
-            log.debug1('ft_aopair dd-blcok for dddd-block ERI')
+            log.debug1('ft_aopair dd-block for dddd-block ERI')
             if cell.dimension < 2:
                 raise NotImplementedError
             if cell.dimension == 2 and cell.low_dim_ft_type == 'inf_vacuum':
@@ -1271,7 +1275,7 @@ def _guess_omega(cell, kpts, mesh=None):
         nk = (cell.nao/25 * nkpts)**(1./3)
         ke_cutoff = 50 / (.7+.25*nk+.05*nk**3)
         ke_cutoff = max(ke_cutoff, ke_min)
-        # avoid large omega since nuermical issues were found in Rys
+        # avoid large omega since numerical issues were found in Rys
         # polynomials when computing SR integrals with nroots > 3
         exps = [e for l, e in zip(cell._bas[:,gto.ANG_OF], cell.bas_exps()) if l != 0]
         if exps:
@@ -1299,11 +1303,11 @@ def estimate_ke_cutoff_for_omega(cell, omega, precision=None):
     return Ecut
 
 def estimate_omega_for_ke_cutoff(cell, ke_cutoff, precision=None):
-    '''The minimal omega in attenuated Coulombl given energy cutoff
+    '''The minimal omega in attenuated Coulomb given energy cutoff
     '''
     if precision is None:
         precision = cell.precision
-#    # esitimation based on \int dk 4pi/k^2 exp(-k^2/4omega) sometimes is not
+#    # estimation based on \int dk 4pi/k^2 exp(-k^2/4omega) sometimes is not
 #    # enough to converge the 2-electron integrals. A penalty term here is to
 #    # reduce the error in integrals
 #    precision *= 1e-2

pyscf/pbc/scf/scfint.py

@@ -31,7 +31,7 @@ import numpy as np
 import pyscf.pbc.scf
 from pyscf.pbc import gto as pgto
 
-print('This module is deporacted and will be removed in future release.  '
+print('This module is deprecated and will be removed in future release.  '
       'Please use cell.pbc_intor and pbc.hf.get_hcore.')
 
 def get_hcore(cell, kpt=None):

pyscf/pbc/scf/stability.py

@@ -33,13 +33,17 @@ from pyscf.lib import logger
 from pyscf.pbc.scf import newton_ah
 from pyscf.pbc.scf import _response_functions  # noqa
 
-def rhf_stability(mf, internal=True, external=False, verbose=None):
+def rhf_stability(mf, internal=True, external=False, verbose=None, return_status=False):
     mo_i = mo_e = None
+    stable_i = stable_e = None
     if internal:
-        mo_i = rhf_internal(mf, verbose=verbose)
+        mo_i, stable_i = rhf_internal(mf, verbose=verbose, return_status=True)
     if external:
-        mo_e = rhf_external(mf, verbose=verbose)
-    return mo_i, mo_e
+        mo_e, stable_e = rhf_external(mf, verbose=verbose, return_status=True)
+    if return_status:
+        return mo_i, mo_e, stable_i, stable_e
+    else:
+        return mo_i, mo_e
 
 def uhf_stability(mf, internal=True, external=False, verbose=None):
     mo_i = mo_e = None
@@ -49,7 +53,7 @@ def uhf_stability(mf, internal=True, external=False, verbose=None):
         mo_e = uhf_external(mf, verbose=verbose)
     return mo_i, mo_e
 
-def rhf_internal(mf, verbose=None):
+def rhf_internal(mf, verbose=None, return_status=False):
     log = logger.new_logger(mf, verbose)
     g, hop, hdiag = newton_ah.gen_g_hop_rhf(mf, mf.mo_coeff, mf.mo_occ)
     def precond(dx, e, x0):
@@ -59,7 +63,7 @@ def rhf_internal(mf, verbose=None):
     # The results of hop(x) corresponds to a displacement that reduces
     # gradients g.  It is the vir-occ block of the matrix vector product
     # (Hessian*x). The occ-vir block equals to x2.T.conj(). The overall
-    # Hessian for internal reotation is x2 + x2.T.conj(). This is
+    # Hessian for internal rotation is x2 + x2.T.conj(). This is
     # the reason we apply (.real * 2) below
     def hessian_x(x):
         return hop(x).real * 2
@@ -67,13 +71,17 @@ def rhf_internal(mf, verbose=None):
     x0 = numpy.zeros_like(g)
     x0[g!=0] = 1. / hdiag[g!=0]
     e, v = lib.davidson(hessian_x, x0, precond, tol=1e-4, verbose=log)
-    if e < -1e-5:
+    stable = not (e < -1e-5)
+    if stable:
+        log.log('KRHF/KRKS wavefunction is stable in the internal stability analysis')
+        mo = mf.mo_coeff
+    else:
         log.log('KRHF/KRKS wavefunction has an internal instability')
         mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
+    if return_status:
+        return mo, stable
     else:
-        log.log('KRHF/KRKS wavefunction is stable in the internal stability analysis')
-        mo = mf.mo_coeff
-    return mo
+        return mo
 
 def _rotate_mo(mo_coeff, mo_occ, dx):
     mo = []
@@ -142,7 +150,7 @@ def _gen_hop_rhf_external(mf, verbose=None):
     return hop_rhf2uhf, hdiag
 
 
-def rhf_external(mf, verbose=None):
+def rhf_external(mf, verbose=None, return_status=False):
     log = logger.new_logger(mf, verbose)
     hop2, hdiag2 = _gen_hop_rhf_external(mf)
 
@@ -153,13 +161,17 @@ def rhf_external(mf, verbose=None):
     x0 = numpy.zeros_like(hdiag2)
     x0[hdiag2>1e-5] = 1. / hdiag2[hdiag2>1e-5]
     e3, v3 = lib.davidson(hop2, x0, precond, tol=1e-4, verbose=log)
-    if e3 < -1e-5:
+    stable = not (e3 < -1e-5)
+    if stable:
+        log.log('KRHF/KRKS wavefunction is stable in the KRHF/KRKS -> KUHF/KUKS stability analysis')
+        mo = (mf.mo_coeff, mf.mo_coeff)
+    else:
         log.log('KRHF/KRKS wavefunction has an KRHF/KRKS -> KUHF/KUKS instability.')
         mo = (_rotate_mo(mf.mo_coeff, mf.mo_occ, v3), mf.mo_coeff)
+    if return_status:
+        return mo, stable
     else:
-        log.log('KRHF/KRKS wavefunction is stable in the KRHF/KRKS -> KUHF/KUKS stability analysis')
-        mo = (mf.mo_coeff, mf.mo_coeff)
-    return mo
+        return mo
 
 def uhf_internal(mf, verbose=None):
     log = logger.new_logger(mf, verbose)

pyscf/pbc/scf/uhf.py

@@ -107,6 +107,8 @@ get_rho = pbchf.get_rho
 class UHF(pbchf.SCF):
     '''UHF class for PBCs.
     '''
+    init_guess_breaksym = getattr(__config__, 'scf_uhf_init_guess_breaksym', 1)
+
     _keys = {"init_guess_breaksym"}
 
     init_guess_by_minao  = mol_uhf.UHF.init_guess_by_minao
@@ -125,6 +127,7 @@ class UHF(pbchf.SCF):
     analyze = mol_uhf.UHF.analyze
     mulliken_pop = mol_uhf.UHF.mulliken_pop
     mulliken_meta = mol_uhf.UHF.mulliken_meta
+    mulliken_meta_spin = mol_uhf.UHF.mulliken_meta_spin
     canonicalize = mol_uhf.UHF.canonicalize
     spin_square = mol_uhf.UHF.spin_square
     stability = mol_uhf.UHF.stability
@@ -134,7 +137,6 @@ class UHF(pbchf.SCF):
                  exxdiv=getattr(__config__, 'pbc_scf_SCF_exxdiv', 'ewald')):
         pbchf.SCF.__init__(self, cell, kpt, exxdiv)
         self.nelec = None
-        self.init_guess_breaksym = None
 
     @property
     def nelec(self):

pyscf/pbc/symm/symmetry.py

@@ -146,7 +146,7 @@ class Symmetry():
         nop : int
             Length of `ops`.
         Dmats : list of 2d arrays
-            Wigner D-matries
+            Wigner D-matrices
         l_max : int
             Maximum angular momentum considered in `Dmats`
     '''
@@ -193,7 +193,7 @@ class Symmetry():
                 self.ops = ops
 
         self.nop = len(self.ops)
-        self.has_inversion = any([op.rot_is_inversion for op in self.ops])
+        self.has_inversion = any(op.rot_is_inversion for op in self.ops)
 
         l_max = None
         if 'auxcell' in kwargs: