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

pyscf/scf/addons.py

@@ -44,6 +44,18 @@ def smearing(mf, sigma=None, method=SMEARING_METHOD, mu0=None, fix_spin=False):
         return mf
 
     assert not mf.istype('KSCF')
+    if mf.istype('ROHF'):
+        # Roothaan Fock matrix does not make much sense for smearing.
+        # Restore the conventional RHF treatment.
+        from pyscf import scf
+        from pyscf import dft
+        known_class = {
+            dft.rks_symm.ROKS: dft.rks_symm.RKS,
+            dft.roks.ROKS    : dft.rks.RKS     ,
+            scf.hf_symm.ROHF : scf.hf_symm.RHF ,
+            scf.rohf.ROHF    : scf.hf.RHF      ,
+        }
+        mf = _object_without_soscf(mf, known_class)
     return lib.set_class(_SmearingSCF(mf, sigma, method, mu0, fix_spin),
                          (_SmearingSCF, mf.__class__))
 
@@ -69,13 +81,13 @@ def _gaussian_smearing_occ(mu, mo_energy, sigma):
     return 0.5 * scipy.special.erfc((mo_energy - mu) / sigma)
 
 def _smearing_optimize(f_occ, mo_es, nocc, sigma):
-    def nelec_cost_fn(m, mo_es, nocc):
+    def nelec_cost_fn(m):
         mo_occ = f_occ(m, mo_es, sigma)
         return (mo_occ.sum() - nocc)**2
 
     fermi = _get_fermi(mo_es, nocc)
     res = scipy.optimize.minimize(
-        nelec_cost_fn, fermi, args=(mo_es, nocc), method='Powell',
+        nelec_cost_fn, fermi, method='Powell',
         options={'xtol': 1e-5, 'ftol': 1e-5, 'maxiter': 10000})
     mu = res.x
     mo_occs = f_occ(mu, mo_es, sigma)
@@ -83,7 +95,10 @@ def _smearing_optimize(f_occ, mo_es, nocc, sigma):
 
 def _get_fermi(mo_energy, nocc):
     mo_e_sorted = numpy.sort(mo_energy)
-    return mo_e_sorted[nocc-1]
+    if isinstance(nocc, int):
+        return mo_e_sorted[nocc-1]
+    else: # nocc = ?.5 or nocc = ?.0
+        return mo_e_sorted[numpy.ceil(nocc).astype(int) - 1]
 
 class _SmearingSCF:
 
@@ -116,6 +131,7 @@ class _SmearingSCF:
     def get_occ(self, mo_energy=None, mo_coeff=None):
         '''Label the occupancies for each orbital
         '''
+        from pyscf import scf
         from pyscf.pbc.tools import print_mo_energy_occ
         if (self.sigma == 0) or (not self.sigma) or (not self.smearing_method):
             mo_occ = super().get_occ(mo_energy, mo_coeff)
@@ -123,7 +139,10 @@ class _SmearingSCF:
 
         is_uhf = self.istype('UHF')
         is_rhf = self.istype('RHF')
-        is_rohf = self.istype('ROHF')
+        if isinstance(self, scf.rohf.ROHF):
+            # 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':
@@ -131,11 +150,8 @@ class _SmearingSCF:
         else:
             f_occ = _gaussian_smearing_occ
 
-        if self.fix_spin and (is_uhf or is_rohf): # spin separated fermi level
-            if is_rohf: # treat rohf as uhf
-                mo_es = (mo_energy, mo_energy)
-            else:
-                mo_es = mo_energy
+        if self.fix_spin and is_uhf: # spin separated fermi level
+            mo_es = mo_energy
             nocc = self.nelec
             if self.mu0 is None:
                 mu_a, occa = _smearing_optimize(f_occ, mo_es[0], nocc[0], sigma)
@@ -165,19 +181,17 @@ class _SmearingSCF:
                         sigma, mu[1], self.entropy)
             if self.verbose >= logger.DEBUG:
                 print_mo_energy_occ(self, mo_energy, mo_occs, True)
-            if is_rohf:
-                mo_occs = mo_occs[0] + mo_occs[1]
         else: # all orbitals treated with the same fermi level
-            nocc = nelectron = self.mol.nelectron
+            nelectron = self.mol.nelectron
             if is_uhf:
                 mo_es = numpy.hstack(mo_energy)
             else:
                 mo_es = mo_energy
             if is_rhf:
-                nocc = (nelectron + 1) // 2
+                nelectron = nelectron / 2
 
             if self.mu0 is None:
-                mu, mo_occs = _smearing_optimize(f_occ, mo_es, nocc, sigma)
+                mu, mo_occs = _smearing_optimize(f_occ, mo_es, nelectron, sigma)
             else:
                 # If mu0 is given, fix mu instead of electron number. XXX -Chong Sun
                 mu = self.mu0
@@ -188,7 +202,7 @@ class _SmearingSCF:
                 mo_occs *= 2
                 self.entropy *= 2
 
-            fermi = _get_fermi(mo_es, nocc)
+            fermi = _get_fermi(mo_es, nelectron)
             logger.debug(self, '    Fermi level %g  Sum mo_occ = %s  should equal nelec = %s',
                          fermi, mo_occs.sum(), nelectron)
             logger.info(self, '    sigma = %g  Optimized mu = %.12g  entropy = %.12g',

pyscf/scf/cphf.py

@@ -17,7 +17,7 @@
 #
 
 '''
-Restricted coupled pertubed Hartree-Fock solver
+Restricted coupled perturbed Hartree-Fock solver
 '''
 
 
@@ -68,15 +68,16 @@ def solve_nos1(fvind, mo_energy, mo_occ, h1,
     e_i = mo_energy[mo_occ>0]
     e_ai = 1 / (e_a[:,None] + level_shift - e_i)
     mo1base = h1 * -e_ai
+    nvir, nocc = e_ai.shape
 
     def vind_vo(mo1):
-        mo1 = mo1.reshape(h1.shape)
-        v = fvind(mo1).reshape(h1.shape)
+        mo1 = mo1.reshape(-1, nvir, nocc)
+        v = fvind(mo1).reshape(-1, nvir, nocc)
         if level_shift != 0:
             v -= mo1 * level_shift
         v *= e_ai
-        return v.ravel()
-    mo1 = lib.krylov(vind_vo, mo1base.ravel(),
+        return v.reshape(-1, nvir*nocc)
+    mo1 = lib.krylov(vind_vo, mo1base.reshape(-1, nvir*nocc),
                      tol=tol, max_cycle=max_cycle, hermi=hermi, verbose=log)
     log.timer('krylov solver in CPHF', *t0)
     return mo1.reshape(h1.shape), None
@@ -119,20 +120,20 @@ def solve_withs1(fvind, mo_energy, mo_occ, h1, s1,
     mo1base[:,occidx] = -s1[:,occidx] * .5
 
     def vind_vo(mo1):
-        mo1 = mo1.reshape(mo1base.shape)
-        v = fvind(mo1).reshape(mo1base.shape)
+        mo1 = mo1.reshape(-1, nmo, nocc)
+        v = fvind(mo1).reshape(-1, nmo, nocc)
         if level_shift != 0:
             v -= mo1 * level_shift
         v[:,viridx,:] *= e_ai
         v[:,occidx,:] = 0
-        return v.ravel()
-    mo1 = lib.krylov(vind_vo, mo1base.ravel(),
+        return v.reshape(-1, nmo*nocc)
+    mo1 = lib.krylov(vind_vo, mo1base.reshape(-1, nmo*nocc),
                      tol=tol, max_cycle=max_cycle, hermi=hermi, verbose=log)
-    mo1 = mo1.reshape(mo1base.shape)
+    mo1 = mo1.reshape(-1, nmo, nocc)
     mo1[:,occidx] = mo1base[:,occidx]
     log.timer('krylov solver in CPHF', *t0)
 
-    hs += fvind(mo1).reshape(mo1base.shape)
+    hs += fvind(mo1).reshape(-1, nmo, nocc)
     mo1[:,viridx] = hs[:,viridx] / (e_i - e_a[:,None])
 
     # mo_e1 has the same symmetry as the first order Fock matrix (hermitian or
@@ -143,44 +144,5 @@ def solve_withs1(fvind, mo_energy, mo_occ, h1, s1,
     if h1.ndim == 3:
         return mo1, mo_e1
     else:
-        return mo1.reshape(h1.shape), mo_e1.reshape(nocc,nocc)
-
-if __name__ == '__main__':
-    numpy.random.seed(1)
-    nd = 3
-    nocc = 5
-    nmo = 12
-    nvir = nmo - nocc
-    a = numpy.random.random((nocc*nvir,nocc*nvir))
-    a = a + a.T
-    def fvind(x):
-        v = numpy.dot(a,x[:,nocc:].reshape(-1,nocc*nvir).T)
-        v1 = numpy.zeros((nd,nmo,nocc))
-        v1[:,nocc:] = v.T.reshape(nd,nvir,nocc)
-        return v1
-    mo_energy = numpy.sort(numpy.random.random(nmo)) * 10
-    mo_occ = numpy.zeros(nmo)
-    mo_occ[:nocc] = 2
-    e_i = mo_energy[mo_occ>0]
-    e_a = mo_energy[mo_occ==0]
-    e_ai = 1 / lib.direct_sum('a-i->ai', e_a, e_i)
-    h1 = numpy.random.random((nd,nmo,nocc))
-    h1[:,:nocc,:nocc] = h1[:,:nocc,:nocc] + h1[:,:nocc,:nocc].transpose(0,2,1)
-    s1 = numpy.random.random((nd,nmo,nocc))
-    s1[:,:nocc,:nocc] = s1[:,:nocc,:nocc] + s1[:,:nocc,:nocc].transpose(0,2,1)
-
-    x = solve(fvind, mo_energy, mo_occ, h1, s1, max_cycle=30)[0]
-    print(numpy.linalg.norm(x)-6.272581531366389)
-    hs = h1.reshape(-1,nmo,nocc) - s1.reshape(-1,nmo,nocc)*e_i
-    print(abs(hs[:,nocc:] + fvind(x)[:,nocc:]+x[:,nocc:]/e_ai).sum())
-
-################
-    xref = solve(fvind, mo_energy, mo_occ, h1, s1*0, max_cycle=30)[0][:,mo_occ==0]
-    def fvind(x):
-        return numpy.dot(a,x.reshape(nd,nocc*nvir).T).T.reshape(nd,nvir,nocc)
-    h1 = h1[:,nocc:]
-    x0 = numpy.linalg.solve(numpy.diag(1/e_ai.ravel())+a, -h1.reshape(nd,-1).T).T.reshape(nd,nvir,nocc)
-    x1 = solve(fvind, mo_energy, mo_occ, h1, max_cycle=30)[0]
-    print(abs(x0-x1).sum())
-    print(abs(xref-x1).sum())
-    print(abs(h1 + fvind(x1)+x1/e_ai).sum())
+        assert h1.ndim == 2
+        return mo1[0], mo_e1[0]

pyscf/scf/dhf.py

@@ -62,11 +62,13 @@ def kernel(mf, conv_tol=1e-9, conv_tol_grad=None,
         dm = dm0
 
     mf._coulomb_level = 'LLLL'
+    cycles = 0
     if dm0 is None and mf._coulomb_level.upper() == 'LLLL':
         scf_conv, e_tot, mo_energy, mo_coeff, mo_occ \
                 = hf.kernel(mf, 1e-2, 1e-1,
                             dump_chk, dm0=dm, callback=callback,
                             conv_check=False)
+        cycles += mf.cycles
         dm = mf.make_rdm1(mo_coeff, mo_occ)
         mf._coulomb_level = 'SSLL'
 
@@ -77,13 +79,16 @@ def kernel(mf, conv_tol=1e-9, conv_tol_grad=None,
                     = hf.kernel(mf, 1e-3, 1e-1,
                                 dump_chk, dm0=dm, callback=callback,
                                 conv_check=False)
+            cycles += mf.cycles
             dm = mf.make_rdm1(mo_coeff, mo_occ)
         mf._coulomb_level = 'SSSS'
     else:
         mf._coulomb_level = 'SSLL'
 
-    return hf.kernel(mf, conv_tol, conv_tol_grad, dump_chk, dm0=dm,
-                     callback=callback, conv_check=conv_check)
+    out = hf.kernel(mf, conv_tol, conv_tol_grad, dump_chk, dm0=dm,
+                    callback=callback, conv_check=conv_check)
+    mf.cycles = cycles + mf.cycles
+    return out
 
 def energy_elec(mf, dm=None, h1e=None, vhf=None):
     r'''Electronic part of Dirac-Hartree-Fock energy
@@ -93,7 +98,7 @@ def energy_elec(mf, dm=None, h1e=None, vhf=None):
 
     Kwargs:
         dm : 2D ndarray
-            one-partical density matrix
+            one-particle density matrix
         h1e : 2D ndarray
             Core hamiltonian
         vhf : 2D ndarray
@@ -232,6 +237,24 @@ def init_guess_by_mod_huckel(mol):
     dm = hf.init_guess_by_mod_huckel(mol)
     return _proj_dmll(mol, dm, mol)
 
+def init_guess_by_sap(mol, mf):
+    '''Generate initial guess density matrix from a superposition of
+    atomic potentials (SAP), doi:10.1021/acs.jctc.8b01089.
+    This is the Gaussian fit implementation, see doi:10.1063/5.0004046.
+
+    Args:
+        mol : MoleBase object
+            the molecule object for which the initial guess is evaluated
+        sap_basis : dict
+            SAP basis in internal format (python dictionary)
+
+    Returns:
+        dm0 : ndarray
+            SAP initial guess density matrix
+    '''
+    dm = hf.SCF.init_guess_by_sap(mf, mol)
+    return _proj_dmll(mol, dm, mol)
+
 def init_guess_by_chkfile(mol, chkfile_name, project=None):
     '''Read SCF chkfile and make the density matrix for 4C-DHF initial guess.
 
@@ -290,7 +313,7 @@ def get_init_guess(mol, key='minao', **kwargs):
 
     Kwargs:
         key : str
-            One of 'minao', 'atom', 'huckel', 'mod_huckel', 'hcore', '1e', 'chkfile'.
+            One of 'minao', 'atom', 'huckel', 'mod_huckel', 'hcore', '1e', 'sap', 'chkfile'.
     '''
     return UHF(mol).get_init_guess(mol, key, **kwargs)
 
@@ -398,7 +421,7 @@ def dip_moment(mol, dm, unit='Debye', verbose=logger.NOTE, **kwargs):
 
     charges = mol.atom_charges()
     coords  = mol.atom_coords()
-    charge_center = numpy.einsum('i,ix->x', charges, coords)
+    charge_center = numpy.einsum('i,ix->x', charges, coords) / sum(charges)
     with mol.with_common_orig(charge_center):
         ll_dip = mol.intor_symmetric('int1e_r_spinor', comp=3)
         ss_dip = mol.intor_symmetric('int1e_sprsp_spinor', comp=3)
@@ -406,7 +429,9 @@ def dip_moment(mol, dm, unit='Debye', verbose=logger.NOTE, **kwargs):
     n2c = mol.nao_2c()
     c = lib.param.LIGHT_SPEED
     dip = numpy.einsum('xij,ji->x', ll_dip, dm[:n2c,:n2c]).real
-    dip+= numpy.einsum('xij,ji->x', ss_dip, dm[n2c:,n2c:]).real * (.5/c**2)
+    dip+= numpy.einsum('xij,ji->x', ss_dip, dm[n2c:,n2c:]).real * (.5/c)**2
+
+    dip *= -1.
 
     if unit.upper() == 'DEBYE':
         dip *= nist.AU2DEBYE
@@ -453,8 +478,7 @@ class DHF(hf.SCF):
     # corrections for small component when with_ssss is set to False
     ssss_approx = getattr(__config__, 'scf_dhf_SCF_ssss_approx', 'Visscher')
 
-    _keys = {'conv_tol', 'with_ssss', 'with_gaunt',
-                 'with_breit', 'ssss_approx'}
+    _keys = {'conv_tol', 'with_ssss', 'with_gaunt', 'with_breit', 'ssss_approx'}
 
     def __init__(self, mol):
         hf.SCF.__init__(self, mol)
@@ -510,6 +534,11 @@ class DHF(hf.SCF):
 employing the updated GWH rule from doi:10.1021/ja00480a005.''')
         return init_guess_by_mod_huckel(mol)
 
+    @lib.with_doc(hf.SCF.init_guess_by_sap.__doc__)
+    def init_guess_by_sap(self, mol=None, **kwargs):
+        if mol is None: mol = self.mol
+        return init_guess_by_sap(mol, self)
+
     def init_guess_by_chkfile(self, chkfile=None, project=None):
         if chkfile is None: chkfile = self.chkfile
         return init_guess_by_chkfile(self.mol, chkfile, project=project)
@@ -685,7 +714,7 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
         self._opt = {None: None}
         return self
 
-    def stability(self, internal=None, external=None, verbose=None, return_status=False):
+    def stability(self, internal=None, external=None, verbose=None, return_status=False, **kwargs):
         '''
         DHF/DKS stability analysis.
 
@@ -707,7 +736,7 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
             and the second corresponds to the external stability.
         '''
         from pyscf.scf.stability import dhf_stability
-        return dhf_stability(self, verbose, return_status)
+        return dhf_stability(self, verbose, return_status, **kwargs)
 
     def to_rhf(self):
         raise RuntimeError

pyscf/scf/dispersion.py

@@ -23,6 +23,7 @@ dispersion correction for HF and DFT
 import warnings
 from functools import lru_cache
 from pyscf.lib import logger
+from pyscf import scf
 
 # supported dispersion corrections
 DISP_VERSIONS = ['d3bj', 'd3zero', 'd3bjm', 'd3zerom', 'd3op', 'd4']
@@ -115,8 +116,13 @@ def check_disp(mf, disp=None):
     if disp == 0: # disp = False
         return False
 
-    # The disp method for both HF and MCSCF is set to 'hf'
-    method = getattr(mf, 'xc', 'hf')
+    # To prevent mf.do_disp() triggering the SCF.__getattr__ method, do not use
+    # method = getattr(mf, 'xc', 'hf').
+    if isinstance(mf, scf.hf.KohnShamDFT):
+        method = mf.xc
+    else:
+        # Set the disp method for both HF and MCSCF to 'hf'
+        method = 'hf'
     disp_version = parse_disp(method)[1]
 
     if disp is None: # Using the disp version decoded from the mf.xc attribute
@@ -169,9 +175,4 @@ def get_dispersion(mf, disp=None, with_3body=None, verbose=None):
         mf.scf_summary['dispersion'] = e_d4
         return e_d4
     else:
-        raise RuntimeError(f'dipersion correction: {disp_version} is not supported.')
-
-# Inject to SCF class
-from pyscf import scf
-scf.hf.SCF.do_disp = check_disp
-scf.hf.SCF.get_dispersion = get_dispersion
+        raise RuntimeError(f'dispersion correction: {disp_version} is not supported.')

pyscf/scf/ghf.py

@@ -287,7 +287,7 @@ def spin_square(mo, s=1):
     return ss, s*2+1
 
 def analyze(mf, verbose=logger.DEBUG, with_meta_lowdin=WITH_META_LOWDIN,
-            **kwargs):
+            origin=None, **kwargs):
     '''Analyze the given SCF object:  print orbital energies, occupancies;
     print orbital coefficients; Mulliken population analysis; Dipole moment
     '''
@@ -301,7 +301,7 @@ def analyze(mf, verbose=logger.DEBUG, with_meta_lowdin=WITH_META_LOWDIN,
         log.note('MO #%-3d energy= %-18.15g occ= %g', i+MO_BASE, mo_energy[i], c)
     ovlp_ao = mf.get_ovlp()
     dm = mf.make_rdm1(mo_coeff, mo_occ)
-    dip = mf.dip_moment(mf.mol, dm, verbose=log)
+    dip = mf.dip_moment(mf.mol, dm, origin=origin, verbose=log)
     if with_meta_lowdin:
         pop_and_chg = mf.mulliken_meta(mf.mol, dm, s=ovlp_ao, verbose=log)
     else:
@@ -316,7 +316,7 @@ def mulliken_pop(mol, dm, s=None, verbose=logger.DEBUG):
     dmb = dm[nao:,nao:]
     if s is not None:
         assert (s.size == nao**2 or numpy.allclose(s[:nao,:nao], s[nao:,nao:]))
-        s = s[:nao,:nao]
+        s = lib.asarray(s[:nao,:nao], order='C')
     return uhf.mulliken_pop(mol, (dma,dmb), s, verbose)
 
 def mulliken_meta(mol, dm_ao, verbose=logger.DEBUG,
@@ -328,7 +328,7 @@ def mulliken_meta(mol, dm_ao, verbose=logger.DEBUG,
     dmb = dm_ao[nao:,nao:]
     if s is not None:
         assert (s.size == nao**2 or numpy.allclose(s[:nao,:nao], s[nao:,nao:]))
-        s = s[:nao,:nao]
+        s = lib.asarray(s[:nao,:nao], order='C')
     return uhf.mulliken_meta(mol, (dma,dmb), verbose, pre_orth_method, s)
 
 def det_ovlp(mo1, mo2, occ1, occ2, ovlp):
@@ -349,11 +349,11 @@ def det_ovlp(mo1, mo2, occ1, occ2, ovlp):
     x = numpy.dot(u/s, vt)
     return numpy.prod(s), x
 
-def dip_moment(mol, dm, unit_symbol='Debye', verbose=logger.NOTE):
+def dip_moment(mol, dm, unit_symbol='Debye', origin=None, verbose=logger.NOTE):
     nao = mol.nao_nr()
     dma = dm[:nao,:nao]
     dmb = dm[nao:,nao:]
-    return hf.dip_moment(mol, dma+dmb, unit_symbol, verbose)
+    return hf.dip_moment(mol, dma+dmb, unit=unit_symbol, verbose=verbose, origin=origin)
 
 canonicalize = hf.canonicalize
 
@@ -438,6 +438,12 @@ class GHF(hf.SCF):
 employing the updated GWH rule from doi:10.1021/ja00480a005.''')
         return _from_rhf_init_dm(hf.init_guess_by_mod_huckel(mol))
 
+    @lib.with_doc(hf.SCF.init_guess_by_sap.__doc__)
+    def init_guess_by_sap(self, mol=None, **kwargs):
+        return _from_rhf_init_dm(
+            hf.SCF.init_guess_by_sap(self, mol, **kwargs)
+        )
+
     @lib.with_doc(hf.SCF.init_guess_by_chkfile.__doc__)
     def init_guess_by_chkfile(self, chkfile=None, project=None):
         if chkfile is None: chkfile = self.chkfile
@@ -504,10 +510,10 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
 
     @lib.with_doc(dip_moment.__doc__)
     def dip_moment(self, mol=None, dm=None, unit_symbol='Debye',
-                   verbose=logger.NOTE):
+                   origin=None, verbose=logger.NOTE):
         if mol is None: mol = self.mol
         if dm is None: dm = self.make_rdm1()
-        return dip_moment(mol, dm, unit_symbol, verbose=verbose)
+        return dip_moment(mol, dm, unit_symbol, origin=origin, verbose=verbose)
 
     def convert_from_(self, mf):
         '''Create GHF object based on the RHF/UHF object'''
@@ -515,9 +521,9 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
         self.__dict__.update(tgt.__dict__)
         return self
 
-    def stability(self, internal=None, external=None, verbose=None, return_status=False):
+    def stability(self, internal=None, external=None, verbose=None, return_status=False, **kwargs):
         from pyscf.scf.stability import ghf_stability
-        return ghf_stability(self, verbose, return_status)
+        return ghf_stability(self, verbose, return_status, **kwargs)
 
     def nuc_grad_method(self):
         raise NotImplementedError
@@ -525,9 +531,15 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
     def x2c1e(self):
         '''X2C with spin-orbit coupling effects.
 
-        Note the difference to PySCF-1.7. In PySCF it calls spin-free X2C1E.
-        This result (mol.GHF().x2c() ) should equal to mol.X2C() although they
-        are solved in different AO basis (spherical GTO vs spinor GTO)
+        Starting from PySCF 2.1, this function (mol.GHF().x2c()) produces an X2C
+        calculation in spherical GTO bases. The results in theory are equivalent
+        to those obtained from the mol.X2C() method, which is computed in the
+        spinor GTO bases. This function called the spin-free X2C1E method in the
+        older versions.
+
+        Please note the difference from other SCF methods, such as RHF and UHF.
+        In those methods, the .x2c() method produces a scalar relativistic
+        calculation using the X2C Hamiltonian.
         '''
         from pyscf.x2c.x2c import x2c1e_ghf
         return x2c1e_ghf(self)

pyscf/scf/ghf_symm.py

@@ -153,8 +153,8 @@ class SymAdaptedGHF(ghf.GHF):
 
         nirrep = len(symm_orb)
         symm_orb = [scipy.linalg.block_diag(c, c) for c in symm_orb]
-        s = [reduce(numpy.dot, (c.T,s,c)) for c in symm_orb]
-        h = [reduce(numpy.dot, (c.T,h,c)) for c in symm_orb]
+        h = symm.symmetrize_matrix(h, symm_orb)
+        s = symm.symmetrize_matrix(s, symm_orb)
         cs = []
         es = []
         orbsym = []