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

pyscf/scf/rohf.py

@@ -47,6 +47,13 @@ def init_guess_by_atom(mol):
         dm = lib.tag_array(dm, mo_coeff=dm.mo_coeff, mo_occ=dm.mo_occ)
     return dm
 
+def init_guess_by_sap(mol, sap_basis, **kwargs):
+    dm = hf.init_guess_by_sap(mol, sap_basis, **kwargs)
+    dm = numpy.array((dm*.5, dm*.5))
+    if hasattr(dm, 'mo_coeff'):
+        dm = lib.tag_array(dm, mo_coeff=dm.mo_coeff, mo_occ=dm.mo_occ)
+    return dm
+
 init_guess_by_huckel = uhf.init_guess_by_huckel
 init_guess_by_mod_huckel = uhf.init_guess_by_mod_huckel
 
@@ -270,7 +277,7 @@ def energy_elec(mf, dm=None, h1e=None, vhf=None):
 get_veff = uhf.get_veff
 
 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
     '''
@@ -312,7 +319,7 @@ def analyze(mf, verbose=logger.DEBUG, with_meta_lowdin=WITH_META_LOWDIN,
         pop_and_charge = mf.mulliken_meta(mf.mol, dm, s=ovlp_ao, verbose=log)
     else:
         pop_and_charge = mf.mulliken_pop(mf.mol, dm, s=ovlp_ao, verbose=log)
-    dip = mf.dip_moment(mf.mol, dm, verbose=log)
+    dip = mf.dip_moment(mf.mol, dm, origin=origin, verbose=log)
     return pop_and_charge, dip
 
 mulliken_pop = hf.mulliken_pop
@@ -381,7 +388,7 @@ class ROHF(hf.RHF):
 
     def init_guess_by_atom(self, mol=None):
         if mol is None: mol = self.mol
-        logger.info(self, 'Initial guess from the superpostion of atomic densties.')
+        logger.info(self, 'Initial guess from the superposition of atomic densities.')
         return init_guess_by_atom(mol)
 
     def init_guess_by_huckel(self, mol=None):
@@ -404,6 +411,30 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
         mo_occ = self.get_occ(mo_energy, mo_coeff)
         return self.make_rdm1(mo_coeff, mo_occ)
 
+    def init_guess_by_sap(self, mol=None, **kwargs):
+        from pyscf.gto.basis import load
+        if mol is None: mol = self.mol
+        sap_basis = self.sap_basis
+        logger.info(self, '''Initial guess from superposition of atomic potentials (doi:10.1021/acs.jctc.8b01089)
+This is the Gaussian fit version as described in doi:10.1063/5.0004046.''')
+        if isinstance(sap_basis, str):
+            atoms = [coord[0] for coord in mol._atom]
+            sapbas = {}
+            for atom in set(atoms):
+                single_element_bs = load(sap_basis, atom)
+                if isinstance(single_element_bs, dict):
+                    sapbas[atom] = numpy.asarray(single_element_bs[atom][0][1:], dtype=float)
+                else:
+                    sapbas[atom] = numpy.asarray(single_element_bs[0][1:], dtype=float)
+            logger.note(self, f'Found SAP basis {sap_basis.split("/")[-1]}')
+        elif isinstance(sap_basis, dict):
+            sapbas = {}
+            for key in sap_basis:
+                sapbas[key] = numpy.asarray(sap_basis[key][0][1:], dtype=float)
+        else:
+            logger.error(self, 'sap_basis is of an unexpected datatype.')
+        return init_guess_by_sap(mol, sap_basis=sapbas, **kwargs)
+
     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)
@@ -480,7 +511,8 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
                   internal=getattr(__config__, 'scf_stability_internal', True),
                   external=getattr(__config__, 'scf_stability_external', False),
                   verbose=None,
-                  return_status=False):
+                  return_status=False,
+                  **kwargs):
         '''
         ROHF/ROKS stability analysis.
 
@@ -506,7 +538,7 @@ employing the updated GWH rule from doi:10.1021/ja00480a005.''')
             and the second corresponds to the external stability.
         '''
         from pyscf.scf.stability import rohf_stability
-        return rohf_stability(self, internal, external, verbose, return_status)
+        return rohf_stability(self, internal, external, verbose, return_status, **kwargs)
 
     def nuc_grad_method(self):
         from pyscf.grad import rohf

pyscf/scf/stability.py

@@ -33,8 +33,13 @@ from pyscf.lib import logger
 from pyscf.scf import hf, hf_symm, uhf_symm
 from pyscf.scf import _response_functions  # noqa
 from pyscf.soscf import newton_ah
+from pyscf import __config__
 
-def rhf_stability(mf, internal=True, external=False, verbose=None, return_status=False):
+STAB_NROOTS = getattr(__config__, 'stab_nroots', 3)
+STAB_TOL = getattr(__config__, 'stab_tol', 1e-4)
+
+def rhf_stability(mf, internal=True, external=False, verbose=None, return_status=False,
+                  nroots=STAB_NROOTS, tol=STAB_TOL):
     '''
     Stability analysis for RHF/RKS method.
 
@@ -49,6 +54,10 @@ def rhf_stability(mf, internal=True, external=False, verbose=None, return_status
             stability analysis.
         return_status: bool
             Whether to return `stable_i` and `stable_e`
+        nroots : int
+            Number of roots solved by Davidson solver
+        tol : float
+            Convergence threshold for Davidson solver
 
     Returns:
         If return_status is False (default), the return value includes
@@ -62,21 +71,18 @@ def rhf_stability(mf, internal=True, external=False, verbose=None, return_status
         and the second corresponds to the external stability.
     '''
     mo_i = mo_e = None
+    stable_i = stable_e = None
+    if internal:
+        mo_i, stable_i = rhf_internal(mf, verbose=verbose, return_status=True, nroots=nroots, tol=tol)
+    if external:
+        mo_e, stable_e = rhf_external(mf, verbose=verbose, return_status=True, nroots=nroots, tol=tol)
     if return_status:
-        stable_i = stable_e = None
-        if internal:
-            mo_i, stable_i = rhf_internal(mf, verbose=verbose, return_status=True)
-        if external:
-            mo_e, stable_e = rhf_external(mf, verbose=verbose, return_status=True)
         return mo_i, mo_e, stable_i, stable_e
     else:
-        if internal:
-            mo_i = rhf_internal(mf, verbose=verbose)
-        if external:
-            mo_e = rhf_external(mf, verbose=verbose)
         return mo_i, mo_e
 
-def uhf_stability(mf, internal=True, external=False, verbose=None, return_status=False):
+def uhf_stability(mf, internal=True, external=False, verbose=None, return_status=False,
+                  nroots=STAB_NROOTS, tol=STAB_TOL):
     '''
     Stability analysis for UHF/UKS method.
 
@@ -91,6 +97,10 @@ def uhf_stability(mf, internal=True, external=False, verbose=None, return_status
             stability analysis.
         return_status: bool
             Whether to return `stable_i` and `stable_e`
+        nroots : int
+            Number of roots solved by Davidson solver
+        tol : float
+            Convergence threshold for Davidson solver
 
     Returns:
         If return_status is False (default), the return value includes
@@ -104,21 +114,18 @@ def uhf_stability(mf, internal=True, external=False, verbose=None, return_status
         and the second corresponds to the external stability.
     '''
     mo_i = mo_e = None
+    stable_i = stable_e = None
+    if internal:
+        mo_i, stable_i = uhf_internal(mf, verbose=verbose, return_status=True, nroots=nroots, tol=tol)
+    if external:
+        mo_e, stable_e = uhf_external(mf, verbose=verbose, return_status=True, nroots=nroots, tol=tol)
     if return_status:
-        stable_i = stable_e = None
-        if internal:
-            mo_i, stable_i = uhf_internal(mf, verbose=verbose, return_status=True)
-        if external:
-            mo_e, stable_e = uhf_external(mf, verbose=verbose, return_status=True)
         return mo_i, mo_e, stable_i, stable_e
     else:
-        if internal:
-            mo_i = uhf_internal(mf, verbose=verbose)
-        if external:
-            mo_e = uhf_external(mf, verbose=verbose)
         return mo_i, mo_e
 
-def rohf_stability(mf, internal=True, external=False, verbose=None, return_status=False):
+def rohf_stability(mf, internal=True, external=False, verbose=None, return_status=False,
+                   nroots=STAB_NROOTS, tol=STAB_TOL):
     '''
     Stability analysis for ROHF/ROKS method.
 
@@ -132,6 +139,10 @@ def rohf_stability(mf, internal=True, external=False, verbose=None, return_statu
             External stability. It is not available in current version.
         return_status: bool
             Whether to return `stable_i` and `stable_e`
+        nroots : int
+            Number of roots solved by Davidson solver
+        tol : float
+            Convergence threshold for Davidson solver
 
     Returns:
         If return_status is False (default), the return value includes
@@ -145,21 +156,25 @@ def rohf_stability(mf, internal=True, external=False, verbose=None, return_statu
         and the second corresponds to the external stability.
     '''
     mo_i = mo_e = None
+    stable_i = stable_e = None
+    if internal:
+        mo_i, stable_i = rohf_internal(mf, verbose=verbose, return_status=True, nroots=nroots, tol=tol)
+    if external:
+        mo_e, stable_e = rohf_external(mf, verbose=verbose, return_status=True, nroots=nroots, tol=tol)
     if return_status:
-        stable_i = stable_e = None
-        if internal:
-            mo_i, stable_i = rohf_internal(mf, verbose=verbose, return_status=True)
-        if external:
-            mo_e, stable_e = rohf_external(mf, verbose=verbose, return_status=True)
         return mo_i, mo_e, stable_i, stable_e
     else:
-        if internal:
-            mo_i = rohf_internal(mf, verbose=verbose)
-        if external:
-            mo_e = rohf_external(mf, verbose=verbose)
         return mo_i, mo_e
 
-def ghf_stability(mf, verbose=None, return_status=False):
+def dump_status(log, stable, method_class, stab_type):
+    if not stable:
+        log.note(method_class + f' wavefunction has an {stab_type} instability')
+    else:
+        log.note(method_class + f' wavefunction is stable in the {stab_type} '
+                 'stability analysis')
+
+def ghf_stability(mf, verbose=None, return_status=False,
+                  nroots=STAB_NROOTS, tol=STAB_TOL):
     '''
     Stability analysis for GHF/GKS method.
 
@@ -169,6 +184,10 @@ def ghf_stability(mf, verbose=None, return_status=False):
     Kwargs:
         return_status: bool
             Whether to return `stable_i` and `stable_e`
+        nroots : int
+            Number of roots solved by Davidson solver
+        tol : float
+            Convergence threshold for Davidson solver
 
     Returns:
         If return_status is False (default), the return value includes
@@ -193,21 +212,23 @@ def ghf_stability(mf, verbose=None, return_status=False):
     x0[g!=0] = 1. / hdiag[g!=0]
     if not with_symmetry:  # allow to break point group symmetry
         x0[numpy.argmin(hdiag)] = 1
-    e, v = lib.davidson(hessian_x, x0, precond, tol=1e-4, verbose=log)
-    if e < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has an internal instability')
-        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
-        stable = False
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the internal '
-                 'stability analysis')
+    e, v = lib.davidson(hessian_x, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('ghf_stability: lowest eigs of H = %s', e)
+    if nroots != 1:
+        e, v = e[0], v[0]
+    stable = not (e < -1e-5)
+    dump_status(log, stable, f'{mf.__class__}', 'internal')
+    if stable:
         mo = mf.mo_coeff
+    else:
+        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
     if return_status:
         return mo, stable
     else:
         return mo
 
-def dhf_stability(mf, verbose=None, return_status=False):
+def dhf_stability(mf, verbose=None, return_status=False,
+                  nroots=STAB_NROOTS, tol=STAB_TOL):
     '''
     Stability analysis for DHF/DKS method.
 
@@ -217,6 +238,10 @@ def dhf_stability(mf, verbose=None, return_status=False):
     Kwargs:
         return_status: bool
             Whether to return `stable_i` and `stable_e`
+        nroots : int
+            Number of roots solved by Davidson solver
+        tol : float
+            Convergence threshold for Davidson solver
 
     Returns:
         If return_status is False (default), the return value includes
@@ -239,26 +264,27 @@ def dhf_stability(mf, verbose=None, return_status=False):
     x0 = numpy.zeros_like(g)
     x0[g!=0] = 1. / hdiag[g!=0]
     x0[numpy.argmin(hdiag)] = 1
-    e, v = lib.davidson(hessian_x, x0, precond, tol=1e-4, verbose=log)
-    if e < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has an internal instability')
-        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
-        stable = False
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the internal '
-                 'stability analysis')
+    e, v = lib.davidson(hessian_x, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('dhf_stability: lowest eigs of H = %s', e)
+    if nroots != 1:
+        e, v = e[0], v[0]
+    stable = not (e < -1e-5)
+    dump_status(log, stable, f'{mf.__class__}', 'internal')
+    if stable:
         mo = mf.mo_coeff
+    else:
+        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
     if return_status:
         return mo, stable
     else:
         return mo
 
-def rhf_internal(mf, with_symmetry=True, verbose=None, return_status=False):
+def rhf_internal(mf, with_symmetry=True, verbose=None, return_status=False,
+                 nroots=STAB_NROOTS, tol=STAB_TOL):
     log = logger.new_logger(mf, verbose)
     g, hop, hdiag = newton_ah.gen_g_hop_rhf(mf, mf.mo_coeff, mf.mo_occ,
                                             with_symmetry=with_symmetry)
     hdiag *= 2
-    stable = True
     def precond(dx, e, x0):
         hdiagd = hdiag - e
         hdiagd[abs(hdiagd)<1e-8] = 1e-8
@@ -266,7 +292,7 @@ def rhf_internal(mf, with_symmetry=True, verbose=None, return_status=False):
     # 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
@@ -275,15 +301,16 @@ def rhf_internal(mf, with_symmetry=True, verbose=None, return_status=False):
     x0[g!=0] = 1. / hdiag[g!=0]
     if not with_symmetry:  # allow to break point group symmetry
         x0[numpy.argmin(hdiag)] = 1
-    e, v = lib.davidson(hessian_x, x0, precond, tol=1e-4, verbose=log)
-    if e < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has an internal instability')
-        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
-        stable = False
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the internal '
-                 'stability analysis')
+    e, v = lib.davidson(hessian_x, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('rhf_internal: lowest eigs of H = %s', e)
+    if nroots != 1:
+        e, v = e[0], v[0]
+    stable = not (e < -1e-5)
+    dump_status(log, stable, f'{mf.__class__}', 'internal')
+    if stable:
         mo = mf.mo_coeff
+    else:
+        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
     if return_status:
         return mo, stable
     else:
@@ -360,10 +387,10 @@ def _gen_hop_rhf_external(mf, with_symmetry=True, verbose=None):
     return hop_real2complex, hdiag, hop_rhf2uhf, hdiag
 
 
-def rhf_external(mf, with_symmetry=True, verbose=None, return_status=False):
+def rhf_external(mf, with_symmetry=True, verbose=None, return_status=False,
+                 nroots=STAB_NROOTS, tol=STAB_TOL):
     log = logger.new_logger(mf, verbose)
     hop1, hdiag1, hop2, hdiag2 = _gen_hop_rhf_external(mf, with_symmetry)
-    stable = True
 
     def precond(dx, e, x0):
         hdiagd = hdiag1 - e
@@ -373,12 +400,12 @@ def rhf_external(mf, with_symmetry=True, verbose=None, return_status=False):
     x0[hdiag1>1e-5] = 1. / hdiag1[hdiag1>1e-5]
     if not with_symmetry:  # allow to break point group symmetry
         x0[numpy.argmin(hdiag1)] = 1
-    e1, v1 = lib.davidson(hop1, x0, precond, tol=1e-4, verbose=log)
-    if e1 < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has a real -> complex instability')
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the real -> complex '
-                 'stability analysis')
+    e1, v1 = lib.davidson(hop1, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('rhf_real2complex: lowest eigs of H = %s', e1)
+    if nroots != 1:
+        e1, v1 = e1[0], v1[0]
+    stable1 = not (e1 < -1e-5)
+    dump_status(log, stable1, f'{mf.__class__}', 'real -> complex')
 
     def precond(dx, e, x0):
         hdiagd = hdiag2 - e
@@ -386,26 +413,27 @@ def rhf_external(mf, with_symmetry=True, verbose=None, return_status=False):
         return dx/hdiagd
     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:
-        log.note(f'{mf.__class__} wavefunction has a RHF/RKS -> UHF/UKS instability.')
-        mo = (_rotate_mo(mf.mo_coeff, mf.mo_occ, v3), mf.mo_coeff)
-        stable = False
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the RHF/RKS -> '
-                 'UHF/UKS stability analysis')
+    e3, v3 = lib.davidson(hop2, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('rhf_external: lowest eigs of H = %s', e3)
+    if nroots != 1:
+        e3, v3 = e3[0], v3[0]
+    stable = not (e3 < -1e-5)
+    dump_status(log, stable, f'{mf.__class__}', 'RHF/RKS -> UHF/UKS')
+    if stable:
         mo = (mf.mo_coeff, mf.mo_coeff)
+    else:
+        mo = (_rotate_mo(mf.mo_coeff, mf.mo_occ, v3), mf.mo_coeff)
     if return_status:
         return mo, stable
     else:
         return mo
 
-def rohf_internal(mf, with_symmetry=True, verbose=None, return_status=False):
+def rohf_internal(mf, with_symmetry=True, verbose=None, return_status=False,
+                  nroots=STAB_NROOTS, tol=STAB_TOL):
     log = logger.new_logger(mf, verbose)
     g, hop, hdiag = newton_ah.gen_g_hop_rohf(mf, mf.mo_coeff, mf.mo_occ,
                                              with_symmetry=with_symmetry)
     hdiag *= 2
-    stable = True
     def precond(dx, e, x0):
         hdiagd = hdiag - e
         hdiagd[abs(hdiagd)<1e-8] = 1e-8
@@ -417,29 +445,31 @@ def rohf_internal(mf, with_symmetry=True, verbose=None, return_status=False):
     x0[g!=0] = 1. / hdiag[g!=0]
     if not with_symmetry:  # allow to break point group symmetry
         x0[numpy.argmin(hdiag)] = 1
-    e, v = lib.davidson(hessian_x, x0, precond, tol=1e-4, verbose=log)
-    if e < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has an internal instability.')
-        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
-        stable = False
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the internal '
-                 'stability analysis')
+    e, v = lib.davidson(hessian_x, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('rohf_internal: lowest eigs of H = %s', e)
+    if nroots != 1:
+        e, v = e[0], v[0]
+    stable = not (e < -1e-5)
+    dump_status(log, stable, f'{mf.__class__}', 'internal')
+    if stable:
         mo = mf.mo_coeff
+    else:
+        mo = _rotate_mo(mf.mo_coeff, mf.mo_occ, v)
     if return_status:
         return mo, stable
     else:
         return mo
 
-def rohf_external(mf, with_symmetry=True, verbose=None, return_status=False):
+def rohf_external(mf, with_symmetry=True, verbose=None, return_status=False,
+                  nroots=STAB_NROOTS, tol=STAB_TOL):
     raise NotImplementedError
 
-def uhf_internal(mf, with_symmetry=True, verbose=None, return_status=False):
+def uhf_internal(mf, with_symmetry=True, verbose=None, return_status=False,
+                 nroots=STAB_NROOTS, tol=STAB_TOL):
     log = logger.new_logger(mf, verbose)
     g, hop, hdiag = newton_ah.gen_g_hop_uhf(mf, mf.mo_coeff, mf.mo_occ,
                                             with_symmetry=with_symmetry)
     hdiag *= 2
-    stable = True
     def precond(dx, e, x0):
         hdiagd = hdiag - e
         hdiagd[abs(hdiagd)<1e-8] = 1e-8
@@ -451,18 +481,19 @@ def uhf_internal(mf, with_symmetry=True, verbose=None, return_status=False):
     x0[g!=0] = 1. / hdiag[g!=0]
     if not with_symmetry:  # allow to break point group symmetry
         x0[numpy.argmin(hdiag)] = 1
-    e, v = lib.davidson(hessian_x, x0, precond, tol=1e-4, verbose=log)
-    if e < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has an internal instability.')
+    e, v = lib.davidson(hessian_x, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('uhf_internal: lowest eigs of H = %s', e)
+    if nroots != 1:
+        e, v = e[0], v[0]
+    stable = not (e < -1e-5)
+    dump_status(log, stable, f'{mf.__class__}', 'internal')
+    if stable:
+        mo = mf.mo_coeff
+    else:
         nocca = numpy.count_nonzero(mf.mo_occ[0]> 0)
         nvira = numpy.count_nonzero(mf.mo_occ[0]==0)
         mo = (_rotate_mo(mf.mo_coeff[0], mf.mo_occ[0], v[:nocca*nvira]),
               _rotate_mo(mf.mo_coeff[1], mf.mo_occ[1], v[nocca*nvira:]))
-        stable = False
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the internal '
-                 'stability analysis')
-        mo = mf.mo_coeff
     if return_status:
         return mo, stable
     else:
@@ -569,10 +600,10 @@ def _gen_hop_uhf_external(mf, with_symmetry=True, verbose=None):
     return hop_real2complex, hdiag1, hop_uhf2ghf, hdiag2
 
 
-def uhf_external(mf, with_symmetry=True, verbose=None, return_status=False):
+def uhf_external(mf, with_symmetry=True, verbose=None, return_status=False,
+                 nroots=STAB_NROOTS, tol=STAB_TOL):
     log = logger.new_logger(mf, verbose)
     hop1, hdiag1, hop2, hdiag2 = _gen_hop_uhf_external(mf, with_symmetry)
-    stable = True
 
     def precond(dx, e, x0):
         hdiagd = hdiag1 - e
@@ -582,12 +613,12 @@ def uhf_external(mf, with_symmetry=True, verbose=None, return_status=False):
     x0[hdiag1>1e-5] = 1. / hdiag1[hdiag1>1e-5]
     if not with_symmetry:  # allow to break point group symmetry
         x0[numpy.argmin(hdiag1)] = 1
-    e1, v = lib.davidson(hop1, x0, precond, tol=1e-4, verbose=log)
-    if e1 < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has a real -> complex instability')
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the real -> complex '
-                 'stability analysis')
+    e1, v = lib.davidson(hop1, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('uhf_real2complex: lowest eigs of H = %s', e1)
+    if nroots != 1:
+        e1, v = e1[0], v[0]
+    stable1 = not (e1 < -1e-5)
+    dump_status(log, stable1, f'{mf.__class__}', 'real -> complex')
 
     def precond(dx, e, x0):
         hdiagd = hdiag2 - e
@@ -597,11 +628,14 @@ def uhf_external(mf, with_symmetry=True, verbose=None, return_status=False):
     x0[hdiag2>1e-5] = 1. / hdiag2[hdiag2>1e-5]
     if not with_symmetry:  # allow to break point group symmetry
         x0[numpy.argmin(hdiag2)] = 1
-    e3, v = lib.davidson(hop2, x0, precond, tol=1e-4, verbose=log)
-    log.debug('uhf_external: lowest eigs of H = %s', e3)
+    e3, v = lib.davidson(hop2, x0, precond, tol=tol, verbose=log, nroots=nroots)
+    log.info('uhf_external: lowest eigs of H = %s', e3)
+    if nroots != 1:
+        e3, v = e3[0], v[0]
+    stable = not (e3 < -1e-5)
+    dump_status(log, stable, f'{mf.__class__}', 'UHF/UKS -> GHF/GKS')
     mo = scipy.linalg.block_diag(*mf.mo_coeff)
-    if e3 < -1e-5:
-        log.note(f'{mf.__class__} wavefunction has an UHF/UKS -> GHF/GKS instability.')
+    if not stable:
         occidxa = numpy.where(mf.mo_occ[0]> 0)[0]
         viridxa = numpy.where(mf.mo_occ[0]==0)[0]
         occidxb = numpy.where(mf.mo_occ[1]> 0)[0]
@@ -618,10 +652,6 @@ def uhf_external(mf, with_symmetry=True, verbose=None, return_status=False):
         mo = numpy.dot(mo, u)
         mo = numpy.hstack([mo[:,:nocca], mo[:,nmo:nmo+noccb],
                            mo[:,nocca:nmo], mo[:,nmo+noccb:]])
-        stable = False
-    else:
-        log.note(f'{mf.__class__} wavefunction is stable in the UHF/UKS -> '
-                 'GHF/GKS stability analysis')
     if return_status:
         return mo, stable
     else:

pyscf/scf/ucphf.py

@@ -17,7 +17,7 @@
 #
 
 '''
-Unrestricted coupled pertubed Hartree-Fock solver
+Unrestricted coupled perturbed Hartree-Fock solver
 '''
 
 
@@ -67,25 +67,26 @@ def solve_nos1(fvind, mo_energy, mo_occ, h1,
     mo1base = numpy.hstack((h1[0].reshape(-1,nvira*nocca),
                             h1[1].reshape(-1,nvirb*noccb)))
     mo1base *= -e_ai
+    nov = e_ai.size
 
     def vind_vo(mo1):
-        mo1 = mo1.reshape(mo1base.shape)
-        v = fvind(mo1).reshape(mo1base.shape)
+        nd = mo1.shape[0]
+        v = fvind(mo1).reshape(nd, nov)
         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, nov)
+    mo1 = lib.krylov(vind_vo, mo1base.reshape(-1, nov),
                      tol=tol, max_cycle=max_cycle, hermi=hermi, verbose=log)
     log.timer('krylov solver in CPHF', *t0)
 
+    mo1 = mo1.reshape(mo1base.shape)
+    mo1_a = mo1[:,:nvira*nocca].reshape(-1,nvira,nocca)
+    mo1_b = mo1[:,nvira*nocca:].reshape(-1,nvirb,noccb)
     if isinstance(h1[0], numpy.ndarray) and h1[0].ndim == 2:
-        mo1 = (mo1[:nocca*nvira].reshape(nvira,nocca),
-               mo1[nocca*nvira:].reshape(nvirb,noccb))
+        mo1 = (mo1_a[0], mo1_b[0])
     else:
-        mo1 = mo1.reshape(mo1base.shape)
-        mo1_a = mo1[:,:nvira*nocca].reshape(-1,nvira,nocca)
-        mo1_b = mo1[:,nvira*nocca:].reshape(-1,nvirb,noccb)
+        assert h1[0].ndim == 3
         mo1 = (mo1_a, mo1_b)
     return mo1, None
 
@@ -128,20 +129,22 @@ def solve_withs1(fvind, mo_energy, mo_occ, h1, s1,
     mo1base_a[:,occidxa] = -s1_a[:,occidxa] * .5
     mo1base_b[:,occidxb] = -s1_b[:,occidxb] * .5
     mo1base = numpy.hstack((mo1base_a.reshape(nset,-1), mo1base_b.reshape(nset,-1)))
+    nov = nocca * nmoa + noccb * nmob
 
     def vind_vo(mo1):
-        mo1 = mo1.reshape(mo1base.shape)
-        v = fvind(mo1).reshape(mo1base.shape)
+        nd = mo1.shape[0]
+        mo1 = mo1.reshape(nd, nov)
+        v = fvind(mo1).reshape(nd, nov)
         if level_shift != 0:
             v -= mo1 * level_shift
-        v1a = v[:,:nmoa*nocca].reshape(nset,nmoa,nocca)
-        v1b = v[:,nmoa*nocca:].reshape(nset,nmob,noccb)
+        v1a = v[:,:nmoa*nocca].reshape(nd,nmoa,nocca)
+        v1b = v[:,nmoa*nocca:].reshape(nd,nmob,noccb)
         v1a[:,viridxa] *= eai_a
         v1b[:,viridxb] *= eai_b
         v1a[:,occidxa] = 0
         v1b[:,occidxb] = 0
-        return v.ravel()
-    mo1 = lib.krylov(vind_vo, mo1base.ravel(),
+        return v.reshape(nd, nov)
+    mo1 = lib.krylov(vind_vo, mo1base.reshape(-1, nov),
                      tol=tol, max_cycle=max_cycle, hermi=hermi, verbose=log)
     mo1 = mo1.reshape(mo1base.shape)
     mo1_a = mo1[:,:nmoa*nocca].reshape(nset,nmoa,nocca)
@@ -164,4 +167,6 @@ def solve_withs1(fvind, mo_energy, mo_occ, h1, s1,
     if isinstance(h1[0], numpy.ndarray) and h1[0].ndim == 2:
         mo1_a, mo1_b = mo1_a[0], mo1_b[0]
         mo_e1_a, mo_e1_b = mo_e1_a[0], mo_e1_b[0]
+    else:
+        assert h1[0].ndim == 3
     return (mo1_a, mo1_b), (mo_e1_a, mo_e1_b)