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

pyscf/pbc/scf/_response_functions.py

@@ -64,34 +64,64 @@ def _gen_rhf_response(mf, mo_coeff=None, mo_occ=None,
                 if hermi == 2:
                     v1 = numpy.zeros_like(dm1)
                 else:
+                    assert kshift == 0
                     v1 = ni.nr_rks_fxc(cell, mf.grids, mf.xc, dm0, dm1, 0, hermi,
                                        rho0, vxc, fxc, kpts, max_memory=max_memory)
                 if hybrid:
-                    if hermi != 2:
+                    if omega == 0:
+                        vj, vk = _get_jk(mf, cell, dm1, hermi, kpts, kshift)
+                        vk *= hyb
+                    elif alpha == 0: # LR=0, only SR exchange
+                        vj = _get_j(mf, cell, dm1, hermi, kpts, kshift)
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=-omega)
+                        vk *= hyb
+                    elif hyb == 0: # SR=0, only LR exchange
+                        vj = _get_j(mf, cell, dm1, hermi, kpts, kshift)
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega)
+                        vk *= alpha
+                    else: # SR and LR exchange with different ratios
                         vj, vk = _get_jk(mf, cell, dm1, hermi, kpts, kshift)
-                        v1 += vj - .5 * hyb * vk
+                        vk *= hyb
+                        vk += _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega) * (alpha-hyb)
+                    if hermi != 2:
+                        v1 += vj - .5 * vk
                     else:
-                        v1 -= .5 * hyb * _get_k(mf, cell, dm1, hermi, kpts, kshift)
+                        v1 += -.5 * vk
                 elif hermi != 2:
                     v1 += _get_j(mf, cell, dm1, hermi, kpts, kshift)
                 return v1
 
         elif singlet:
+            fxc *= .5
             def vind(dm1, kshift=0):
                 if hermi == 2:
                     v1 = numpy.zeros_like(dm1)
                 else:
+                    assert kshift == 0
                     # nr_rks_fxc_st requires alpha of dm1
                     v1 = numint.nr_rks_fxc_st(ni, cell, mf.grids, mf.xc, dm0, dm1, 0,
                                               True, rho0, vxc, fxc, kpts,
                                               max_memory=max_memory)
-                    v1 *= .5
                 if hybrid:
-                    if hermi != 2:
+                    if omega == 0:
                         vj, vk = _get_jk(mf, cell, dm1, hermi, kpts, kshift)
-                        v1 += vj - .5 * hyb * vk
+                        vk *= hyb
+                    elif alpha == 0: # LR=0, only SR exchange
+                        vj = _get_j(mf, cell, dm1, hermi, kpts, kshift)
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=-omega)
+                        vk *= hyb
+                    elif hyb == 0: # SR=0, only LR exchange
+                        vj = _get_j(mf, cell, dm1, hermi, kpts, kshift)
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega)
+                        vk *= alpha
+                    else: # SR and LR exchange with different ratios
+                        vj, vk = _get_jk(mf, cell, dm1, hermi, kpts, kshift)
+                        vk *= hyb
+                        vk += _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega) * (alpha-hyb)
+                    if hermi != 2:
+                        v1 += vj - .5 * vk
                     else:
-                        v1 -= .5 * hyb * _get_k(mf, cell, dm1, hermi, kpts, kshift)
+                        v1 += -.5 * vk
                 elif hermi != 2:
                     v1 += _get_j(mf, cell, dm1, hermi, kpts, kshift)
                 return v1
@@ -100,13 +130,23 @@ def _gen_rhf_response(mf, mo_coeff=None, mo_occ=None,
                 if hermi == 2:
                     v1 = numpy.zeros_like(dm1)
                 else:
+                    assert kshift == 0
                     # nr_rks_fxc_st requires alpha of dm1
                     v1 = numint.nr_rks_fxc_st(ni, cell, mf.grids, mf.xc, dm0, dm1, 0,
                                               False, rho0, vxc, fxc, kpts,
                                               max_memory=max_memory)
                     v1 *= .5
                 if hybrid:
-                    v1 += -.5 * hyb * _get_k(mf, cell, dm1, hermi, kpts, kshift)
+                    if omega == 0:
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift) * hyb
+                    elif alpha == 0: # LR=0, only SR exchange
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=-omega) * hyb
+                    elif hyb == 0: # SR=0, only LR exchange
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega) * alpha
+                    else: # SR and LR exchange with different ratios
+                        vk = _get_k(mf, cell, dm1, hermi, kpts, kshift) * hyb
+                        vk += _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega) * (alpha-hyb)
+                    v1 += -.5 * vk
                 return v1
 
     else:  # HF
@@ -154,6 +194,7 @@ def _gen_uhf_response(mf, mo_coeff=None, mo_occ=None,
             if hermi == 2:
                 v1 = numpy.zeros_like(dm1)
             else:
+                assert kshift == 0
                 v1 = ni.nr_uks_fxc(cell, mf.grids, mf.xc, dm0, dm1, 0, hermi,
                                    rho0, vxc, fxc, kpts, max_memory=max_memory)
             if not hybrid:
@@ -161,11 +202,25 @@ def _gen_uhf_response(mf, mo_coeff=None, mo_occ=None,
                     vj = _get_j(mf, cell, dm1, hermi, kpts, kshift)
                     v1 += vj[0] + vj[1]
             else:
-                if with_j:
+                if omega == 0:
+                    vj, vk = _get_jk(mf, cell, dm1, hermi, kpts, kshift)
+                    vk *= hyb
+                elif alpha == 0: # LR=0, only SR exchange
+                    vj = _get_j(mf, cell, dm1, hermi, kpts, kshift)
+                    vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=-omega)
+                    vk *= hyb
+                elif hyb == 0: # SR=0, only LR exchange
+                    vj = _get_j(mf, cell, dm1, hermi, kpts, kshift)
+                    vk = _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega)
+                    vk *= alpha
+                else: # SR and LR exchange with different ratios
                     vj, vk = _get_jk(mf, cell, dm1, hermi, kpts, kshift)
-                    v1 += vj[0] + vj[1] - vk * hyb
+                    vk *= hyb
+                    vk += _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=omega) * (alpha-hyb)
+                if with_j:
+                    v1 += vj[0] + vj[1] - vk
                 else:
-                    v1 -= hyb * _get_k(mf, cell, dm1, hermi, kpts, kshift)
+                    v1 -= vk
             return v1
 
     elif with_j:
@@ -187,7 +242,8 @@ def _gen_ghf_response(mf, mo_coeff=None, mo_occ=None,
     '''
     raise NotImplementedError
 
-def _get_jk_kshift(mf, dm_kpts, hermi, kpts, kshift, with_j=True, with_k=True):
+def _get_jk_kshift(mf, dm_kpts, hermi, kpts, kshift, with_j=True, with_k=True,
+                   omega=None):
     from pyscf.pbc.df.df_jk import get_j_kpts_kshift, get_k_kpts_kshift
     vj = vk = None
     if with_j:
@@ -196,19 +252,23 @@ def _get_jk_kshift(mf, dm_kpts, hermi, kpts, kshift, with_j=True, with_k=True):
         vk = get_k_kpts_kshift(mf.with_df, dm_kpts, kshift, hermi=hermi, kpts=kpts,
                                exxdiv=mf.exxdiv)
     return vj, vk
-def _get_jk(mf, cell, dm1, hermi, kpts, kshift, with_j=True, with_k=True):
+def _get_jk(mf, cell, dm1, hermi, kpts, kshift, with_j=True, with_k=True, omega=None):
     from pyscf.pbc import df
     if kshift == 0:
-        return mf.get_jk(cell, dm1, hermi=hermi, kpts=kpts, with_j=with_j, with_k=with_k)
+        return mf.get_jk(cell, dm1, hermi=hermi, kpts=kpts,
+                         with_j=with_j, with_k=with_k, omega=omega)
+    elif omega is not None and omega != 0:
+        raise NotImplementedError
     elif mf.rsjk is not None or not isinstance(mf.with_df, df.df.DF):
         lib.logger.error(mf, 'Non-zero kshift is only supported by GDF/RSDF.')
         raise NotImplementedError
     else:
-        return _get_jk_kshift(mf, dm1, hermi, kpts, kshift, with_j=with_j, with_k=with_k)
-def _get_j(mf, cell, dm1, hermi, kpts, kshift):
-    return _get_jk(mf, cell, dm1, hermi, kpts, kshift, True, False)[0]
-def _get_k(mf, cell, dm1, hermi, kpts, kshift):
-    return _get_jk(mf, cell, dm1, hermi, kpts, kshift, False, True)[1]
+        return _get_jk_kshift(mf, dm1, hermi, kpts, kshift,
+                              with_j=with_j, with_k=with_k, omega=omega)
+def _get_j(mf, cell, dm1, hermi, kpts, kshift, omega=None):
+    return _get_jk(mf, cell, dm1, hermi, kpts, kshift, True, False, omega)[0]
+def _get_k(mf, cell, dm1, hermi, kpts, kshift, omega=None):
+    return _get_jk(mf, cell, dm1, hermi, kpts, kshift, False, True, omega)[1]
 
 
 khf.KRHF.gen_response = _gen_rhf_response
@@ -233,8 +293,6 @@ def _gen_rhf_response_gam(mf, mo_coeff=None, mo_occ=None,
 
         omega, alpha, hyb = ni.rsh_and_hybrid_coeff(mf.xc, spin=cell.spin)
         hybrid = ni.libxc.is_hybrid_xc(mf.xc)
-        if omega != 0:  # For range separated Coulomb
-            raise NotImplementedError
 
         if not hybrid and isinstance(mf.with_df, multigrid.MultiGridFFTDF):
             dm0 = mf.make_rdm1(mo_coeff, mo_occ)
@@ -261,16 +319,31 @@ def _gen_rhf_response_gam(mf, mo_coeff=None, mo_occ=None,
                     v1 = ni.nr_rks_fxc(cell, mf.grids, mf.xc, dm0, dm1, 0, hermi,
                                        rho0, vxc, fxc, kpt, max_memory=max_memory)
                 if hybrid:
+                    if omega == 0:
+                        vj, vk = mf.get_jk(cell, dm1, hermi, kpt=kpt)
+                        vk *= hyb
+                    elif alpha == 0: # LR=0, only SR exchange
+                        vj = mf.get_j(cell, dm1, hermi, kpt=kpt)
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=-omega)
+                        vk *= hyb
+                    elif hyb == 0: # SR=0, only LR exchange
+                        vj = mf.get_j(cell, dm1, hermi, kpt=kpt)
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega)
+                        vk *= alpha
+                    else: # SR and LR exchange with different ratios
+                        vj, vk = mf.get_jk(cell, dm1, hermi, kpt=kpt)
+                        vk *= hyb
+                        vk += mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega) * (alpha-hyb)
                     if hermi != 2:
-                        vj, vk = mf.get_jk(cell, dm1, hermi=hermi, kpt=kpt)
-                        v1 += vj - .5 * hyb * vk
+                        v1 += vj - .5 * vk
                     else:
-                        v1 -= .5 * hyb * mf.get_k(cell, dm1, hermi=hermi, kpt=kpt)
+                        v1 += -.5 * vk
                 elif hermi != 2:
                     v1 += mf.get_j(cell, dm1, hermi=hermi, kpt=kpt)
                 return v1
 
         elif singlet:
+            fxc *= .5
             def vind(dm1):
                 if hermi == 2:
                     v1 = numpy.zeros_like(dm1)
@@ -279,13 +352,26 @@ def _gen_rhf_response_gam(mf, mo_coeff=None, mo_occ=None,
                     v1 = numint.nr_rks_fxc_st(ni, cell, mf.grids, mf.xc, dm0, dm1, 0,
                                               True, rho0, vxc, fxc, kpt,
                                               max_memory=max_memory)
-                    v1 *= .5
                 if hybrid:
+                    if omega == 0:
+                        vj, vk = mf.get_jk(cell, dm1, hermi, kpt=kpt)
+                        vk *= hyb
+                    elif alpha == 0: # LR=0, only SR exchange
+                        vj = mf.get_j(cell, dm1, hermi, kpt=kpt)
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=-omega)
+                        vk *= hyb
+                    elif hyb == 0: # SR=0, only LR exchange
+                        vj = mf.get_j(cell, dm1, hermi, kpt=kpt)
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega)
+                        vk *= alpha
+                    else: # SR and LR exchange with different ratios
+                        vj, vk = mf.get_jk(cell, dm1, hermi, kpt=kpt)
+                        vk *= hyb
+                        vk += mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega) * (alpha-hyb)
                     if hermi != 2:
-                        vj, vk = mf.get_jk(cell, dm1, hermi=hermi, kpt=kpt)
-                        v1 += vj - .5 * hyb * vk
+                        v1 += vj - .5 * vk
                     else:
-                        v1 -= .5 * hyb * mf.get_k(cell, dm1, hermi=hermi, kpt=kpt)
+                        v1 += -.5 * vk
                 elif hermi != 2:
                     v1 += mf.get_j(cell, dm1, hermi=hermi, kpt=kpt)
                 return v1
@@ -300,7 +386,16 @@ def _gen_rhf_response_gam(mf, mo_coeff=None, mo_occ=None,
                                               max_memory=max_memory)
                     v1 *= .5
                 if hybrid:
-                    v1 += -.5 * hyb * mf.get_k(cell, dm1, hermi=hermi, kpt=kpt)
+                    if omega == 0:
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt) * hyb
+                    elif alpha == 0: # LR=0, only SR exchange
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=-omega) * hyb
+                    elif hyb == 0: # SR=0, only LR exchange
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega) * alpha
+                    else: # SR and LR exchange with different ratios
+                        vk = mf.get_k(cell, dm1, hermi, kpt=kpt) * hyb
+                        vk += mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega) * (alpha-hyb)
+                    v1 += -.5 * vk
                 return v1
 
     else:  # HF
@@ -329,8 +424,6 @@ def _gen_uhf_response_gam(mf, mo_coeff=None, mo_occ=None,
 
         omega, alpha, hyb = ni.rsh_and_hybrid_coeff(mf.xc, spin=cell.spin)
         hybrid = ni.libxc.is_hybrid_xc(mf.xc)
-        if omega != 0:  # For range separated Coulomb
-            raise NotImplementedError
 
         if not hybrid and isinstance(mf.with_df, multigrid.MultiGridFFTDF):
             dm0 = mf.make_rdm1(mo_coeff, mo_occ)
@@ -355,11 +448,25 @@ def _gen_uhf_response_gam(mf, mo_coeff=None, mo_occ=None,
                     vj = mf.get_j(cell, dm1, hermi=hermi, kpt=kpt)
                     v1 += vj[0] + vj[1]
             else:
+                if omega == 0:
+                    vj, vk = mf.get_jk(cell, dm1, hermi, kpt=kpt)
+                    vk *= hyb
+                elif alpha == 0: # LR=0, only SR exchange
+                    vj = mf.get_j(cell, dm1, hermi, kpt=kpt)
+                    vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=-omega)
+                    vk *= hyb
+                elif hyb == 0: # SR=0, only LR exchange
+                    vj = mf.get_j(cell, dm1, hermi, kpt=kpt)
+                    vk = mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega)
+                    vk *= alpha
+                else: # SR and LR exchange with different ratios
+                    vj, vk = mf.get_jk(cell, dm1, hermi, kpt=kpt)
+                    vk *= hyb
+                    vk += mf.get_k(cell, dm1, hermi, kpt=kpt, omega=omega) * (alpha-hyb)
                 if with_j:
-                    vj, vk = mf.get_jk(cell, dm1, hermi=hermi, kpt=kpt)
-                    v1 += vj[0] + vj[1] - vk * hyb
+                    v1 += vj[0] + vj[1] - vk
                 else:
-                    v1 -= hyb * mf.get_k(cell, dm1, hermi=hermi, kpt=kpt)
+                    v1 -= vk
             return v1
 
     elif with_j:

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
 '''
 

pyscf/pbc/scf/ghf.py

@@ -117,7 +117,7 @@ class GHF(pbchf.SCF):
     _finalize = mol_ghf.GHF._finalize
     analyze = lib.invalid_method('analyze')
     mulliken_pop = lib.invalid_method('mulliken_pop')
-    mulliken_meta = lib.invalid_method('mulliken_meta')
+    mulliken_meta = mol_ghf.GHF.mulliken_meta
     spin_square = mol_ghf.GHF.spin_square
     stability = mol_ghf.GHF.stability
 

pyscf/pbc/scf/hf.py

@@ -35,7 +35,6 @@ from pyscf.lib import logger
 from pyscf.data import nist
 from pyscf.pbc import gto
 from pyscf.pbc import tools
-from pyscf.pbc.gto import ecp
 from pyscf.pbc.gto.pseudo import get_pp
 from pyscf.pbc.scf import addons
 from pyscf.pbc import df
@@ -83,6 +82,7 @@ def get_hcore(cell, kpt=np.zeros(3)):
     else:
         hcore += get_nuc(cell, kpt)
     if len(cell._ecpbas) > 0:
+        from pyscf.pbc.gto import ecp
         hcore += ecp.ecp_int(cell, kpt)
     return hcore
 
@@ -246,7 +246,7 @@ def dip_moment(cell, dm, unit='Debye', verbose=logger.NOTE,
     # With the optimal origin of the unti cell, the net dipole in the unit
     # cell should be strictly zero. However, the integral grids are often not
     # enough to produce the zero dipole. Errors are caused by the sub-optimal
-    # origin and the numerial integration.
+    # origin and the numerical integration.
     if origin is None:
         origin = _search_dipole_gauge_origin(cell, grids, rho, log)
 
@@ -540,40 +540,16 @@ class SCF(mol_hf.SCF):
 
     @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
 
     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')
-        elif 'kpt' in self.__dict__:
+        if 'kpt' in self.__dict__:
             self.kpt = self.__dict__.pop('kpt')
 
-        # "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 == self.kpt):
-                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()
+                self.rsjk = self.rsjk.__class__(cell, self.kpt)
 
         if self.verbose >= logger.WARN:
             self.check_sanity()
@@ -638,6 +614,7 @@ class SCF(mol_hf.SCF):
         else:
             nuc = self.with_df.get_nuc(kpt)
         if len(cell._ecpbas) > 0:
+            from pyscf.pbc.gto import ecp
             nuc += ecp.ecp_int(cell, kpt)
         return nuc + cell.pbc_intor('int1e_kin', 1, 1, kpt)
 
@@ -680,7 +657,7 @@ class SCF(mol_hf.SCF):
 
             if with_k and self.exxdiv == 'ewald':
                 from pyscf.pbc.df.df_jk import _ewald_exxdiv_for_G0
-                # G=0 is not inculded in the ._eri integrals
+                # G=0 is not included in the ._eri integrals
                 _ewald_exxdiv_for_G0(self.cell, kpt, dm.reshape(-1,nao,nao),
                                      vk.reshape(-1,nao,nao))
         elif self.rsjk:
@@ -786,9 +763,21 @@ class SCF(mol_hf.SCF):
     def from_chk(self, chk=None, project=None, kpt=None):
         return self.init_guess_by_chkfile(chk, project, kpt)
 
-    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/kpt'] = self.kpt
+        elif self.chkfile:
             with lib.H5FileWrap(self.chkfile, 'a') as fh5:
                 fh5['scf/kpt'] = self.kpt
         return self

pyscf/pbc/scf/kghf.py

@@ -136,38 +136,41 @@ def get_occ(mf, mo_energy_kpts=None, mo_coeff_kpts=None):
 
     return mo_occ_kpts
 
-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, nso = dm_ao_kpts.shape[:2]
+    nao = nso // 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_aa = lib.einsum('kap,kpq,kbq->ab', c_inv, dm_ao_kpts[:,:nao,:nao], c_inv.conj())
+    dm_bb = lib.einsum('kap,kpq,kbq->ab', c_inv, dm_ao_kpts[:,nao:,nao:], c_inv.conj())
+
+    return (dm_aa, dm_bb)
+
+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 = khf.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("KGHF mulliken_meta")
-    dm_ao_gamma = dm_ao_kpts[0,:,:]
-    nso = dm_ao_gamma.shape[-1]
-    nao = nso // 2
 
-    dm_ao_gamma_aa = dm_ao_gamma[:nao,:nao]
-    dm_ao_gamma_bb = dm_ao_gamma[nao:,nao:]
-    s_gamma = s[0,:,:].real
-    s_gamma_aa = s_gamma[:nao,:nao]
-    orth_coeff = orth.orth_ao(cell, 'meta_lowdin', pre_orth_method, s=s_gamma_aa)
-    c_inv = np.dot(orth_coeff.T, s_gamma_aa)
-    dm_aa = reduce(np.dot, (c_inv, dm_ao_gamma_aa, c_inv.T.conj()))
-    dm_bb = reduce(np.dot, (c_inv, dm_ao_gamma_bb, c_inv.T.conj()))
+    if s is None:
+        s = khf.get_ovlp(None, cell=cell, kpts=kpts)
+    if s is not None:
+        if s[0].shape == dm_ao_kpts[0].shape:   # s in SO
+            nao = dm_ao_kpts[0].shape[0]//2
+            s = lib.asarray(s[:,:nao,:nao], order='C') # keep only one spin sector
+
+    dm_aa, dm_bb = _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_aa,dm_bb), np.eye(orth_coeff.shape[0]), log)
+    return mol_uhf.mulliken_pop(cell, (dm_aa,dm_bb), np.eye(dm_aa.shape[0]), log)
 
 def _cast_mol_init_guess(fn):
     def fn_init_guess(mf, cell=None, kpts=None):
@@ -259,12 +262,13 @@ class KGHF(khf.KSCF):
         raise NotImplementedError
 
     @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 s is None: s = self.get_ovlp(cell)
-        return mulliken_meta(cell, dm, s=s, verbose=verbose,
+        if kpts is None: kpts = self.kpts
+        if s is None: s = khf.get_ovlp(self, cell, kpts)
+        return mulliken_meta(cell, dm, kpts, s=s, verbose=verbose,
                              pre_orth_method=pre_orth_method)
 
     def mulliken_pop(self):
@@ -303,7 +307,7 @@ if __name__ == '__main__':
     mf = KGHF(cell, kpts=kpts)
     mf.kernel()
 
-    # x2c1e decoractor to KGHF class.
+    # x2c1e decorator to KGHF class.
     #mf = KGHF(cell, kpts=kpts).x2c1e()
     # or
     #mf = KGHF(cell, kpts=kpts).sfx2c1e()