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

pyscf/dft/numint.py

@@ -2633,7 +2633,7 @@ def get_rho(ni, mol, dm, grids, max_memory=2000):
 class LibXCMixin:
     libxc = libxc
 
-    omega = None  # RSH paramter
+    omega = None  # RSH parameter
 
 ####################
 # Overwrite following functions to use custom XC functional
@@ -2654,6 +2654,10 @@ class LibXCMixin:
         return self.libxc.eval_xc(xc_code, rho, spin, relativity, deriv,
                                   omega, verbose)
 
+    def eval_xc1(self, xc_code, rho, spin=0, deriv=1, omega=None):
+        if omega is None: omega = self.omega
+        return self.libxc.eval_xc1(xc_code, rho, spin, deriv, omega)
+
     def eval_xc_eff(self, xc_code, rho, deriv=1, omega=None, xctype=None,
                     verbose=None):
         r'''Returns the derivative tensor against the density parameters
@@ -2693,12 +2697,12 @@ class LibXCMixin:
         else:
             spin = 0
 
-        out = self.libxc.eval_xc1(xc_code, rho, spin, deriv, omega)
+        out = self.eval_xc1(xc_code, rho, spin, deriv, omega)
         evfk = [out[0]]
         for order in range(1, deriv+1):
             evfk.append(xc_deriv.transform_xc(rho, out, xctype, spin, order))
         if deriv < 3:
-            # The return has at least [e, v, f, k] terms
+            # Returns at least [e, v, f, k] terms
             evfk.extend([None] * (3 - deriv))
         return evfk
 

pyscf/dft/radi.py

@@ -21,10 +21,20 @@
 import numpy
 from pyscf.data import radii
 from pyscf.data.elements import charge as elements_proton
+from pyscf import __config__
 
 BRAGG_RADII = radii.BRAGG
 COVALENT_RADII = radii.COVALENT
 
+# The effective atomic radius in Treutler's original paper (JCP 102, 346) was
+# omitted in PySCF versions 2.6 and earlier. This can cause discrepancies in the
+# numerical grids when compared to other software (See issue #2178 for details).
+# Note that using the atom-specific radius may slightly alter the results of
+# numerical integration, potentially leading to differences of ~ 1e-6 per atom
+# in total energy.
+# Disable this flag to make DFT grids consistent with old PySCF versions.
+ATOM_SPECIFIC_TREUTLER_GRIDS = getattr(__config__, 'ATOM_SPECIFIC_TREUTLER_GRIDS', True)
+
 # P.M.W. Gill, B.G. Johnson, J.A. Pople, Chem. Phys. Letters 209 (1993) 506-512
 SG1RADII = numpy.array((
     0,
@@ -95,15 +105,41 @@ def gauss_chebyshev(n, *args, **kwargs):
     dr = fac * numpy.sin(x1)**4 * ln2/(1+xi)
     return r, dr
 
-
-def treutler_ahlrichs(n, *args, **kwargs):
+# Individually optimized Treutler/Ahlrichs radius parameter.
+# H - Kr are taken from the original paper JCP 102, 346 (1995)
+# Other elements are copied from Psi4 source code
+_treutler_ahlrichs_xi = [1.0, # Ghost
+    0.8,                               0.9,           # 1s
+    1.8, 1.4, 1.3, 1.1, 0.9, 0.9, 0.9, 0.9,           # 2s2p
+    1.4, 1.3, 1.3, 1.2, 1.1, 1.0, 1.0, 1.0,           # 3s3p
+    1.5, 1.4,                                         # 4s
+    1.3, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.1, 1.1, 1.1, # 3d
+              1.1, 1.0, 0.9, 0.9, 0.9, 0.9,           # 4p
+    2.000, 1.700,                                                         # 5s
+    1.500, 1.500, 1.350, 1.350, 1.250, 1.200, 1.250, 1.300, 1.500, 1.500, # 4d
+                  1.300, 1.200, 1.200, 1.150, 1.150, 1.150,               # 5p
+    2.500, 2.200,                                                         # 6s
+           2.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,               # La, Ce-Eu
+           1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,        # Gd, Tb-Lu
+           1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, # 5d
+                  1.500, 1.500, 1.500, 1.500, 1.500, 1.500,               # 6p
+    2.500, 2.100,                                                         # 7s
+           3.685, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,
+           1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500, 1.500,
+] # noqa: E124
+
+def treutler_ahlrichs(n, chg, *args, **kwargs):
     '''
     Treutler-Ahlrichs [JCP 102, 346 (1995); DOI:10.1063/1.469408] (M4) radial grids
     '''
+    if ATOM_SPECIFIC_TREUTLER_GRIDS:
+        xi = _treutler_ahlrichs_xi[chg]
+    else:
+        xi = 1.
     r = numpy.empty(n)
     dr = numpy.empty(n)
     step = numpy.pi / (n+1)
-    ln2 = 1 / numpy.log(2)
+    ln2 = xi / numpy.log(2)
     for i in range(n):
         x = numpy.cos((i+1)*step)
         r [i] = -ln2*(1+x)**.6 * numpy.log((1-x)/2)
@@ -113,8 +149,6 @@ def treutler_ahlrichs(n, *args, **kwargs):
 treutler = treutler_ahlrichs
 
 
-
-
 def becke_atomic_radii_adjust(mol, atomic_radii):
     '''Becke atomic radii adjust function'''
 # Becke atomic size adjustment.  J. Chem. Phys. 88, 2547

pyscf/dft/rks.py

@@ -228,7 +228,7 @@ def energy_elec(ks, dm=None, h1e=None, vhf=None):
         ks : an instance of DFT class
 
         dm : 2D ndarray
-            one-partical density matrix
+            one-particle density matrix
         h1e : 2D ndarray
             Core hamiltonian
 

pyscf/dft/xc_deriv.py

@@ -455,7 +455,7 @@ def _stack_fggg(fggg, axis=0, rho=None):
 @lru_cache(100)
 def _product_uniq_indices(nvars, order):
     '''
-    Indexing the symmetry unique elements in cartensian product
+    Indexing the symmetry unique elements in cartesian product
     '''
     # n = 0
     # for i range(nvars):

pyscf/dft/xcfun.py

@@ -36,10 +36,61 @@ _itrf = lib.load_library('libxcfun_itrf')
 _itrf.xcfun_splash.restype = ctypes.c_char_p
 _itrf.xcfun_version.restype = ctypes.c_char_p
 _itrf.XCFUN_eval_xc.restype = ctypes.c_int
+_itrf.xcfun_enumerate_parameters.restype = ctypes.c_char_p
+_itrf.XCFUN_xc_type.restype = ctypes.c_int
+_itrf.xcfun_describe_short.restype = ctypes.c_char_p
+_itrf.xcfun_describe_short.argtype = [ctypes.c_char_p]
+_itrf.xcfun_describe_long.restype = ctypes.c_char_p
+_itrf.xcfun_describe_long.argtype = [ctypes.c_char_p]
 
 __version__ = _itrf.xcfun_version().decode("UTF-8")
 __reference__ = _itrf.xcfun_splash().decode("UTF-8")
 
+def print_XC_CODES():
+    '''
+    Dump the built-in xcfun XC_CODES in a readable format.
+    '''
+    lda_ids = []
+    gga_ids = []
+    mgga_ids = []
+    xc_codes = {}
+
+    print('XC = XC_CODES = {')
+    for i in range(78):
+        name = _itrf.xcfun_enumerate_parameters(ctypes.c_int(i))
+        sdescr = _itrf.xcfun_describe_short(name)
+        #ldescr = _itrf.xcfun_describe_long(ctypes.c_int(i))
+        if sdescr is not None:
+            name = name.decode('UTF-8')
+            key = f"'{name}'"
+            sdescr = sdescr.decode('UTF-8')
+            print(f'{key:<16s}: {i:2d},  #{sdescr}')
+            xc_codes[name] = i
+
+        fntype = _itrf.XCFUN_xc_type(ctypes.c_int(i))
+        if fntype == 0:
+            lda_ids.append(i)
+        elif fntype == 1:
+            gga_ids.append(i)
+        elif fntype == 2:
+            mgga_ids.append(i)
+
+    alias = {
+        'SLATER': 'SLATERX',
+        'LDA'   : 'SLATERX',
+        'VWN'   : 'VWN5C',
+        'VWN5'  : 'VWN5C',
+        'B88'   : 'BECKEX',
+        'LYP'   : 'LYPC',
+    }
+    for k, v in alias.items():
+        key = f"'{k}'"
+        print(f'{key:<16s}: {xc_codes[v]:2d},  # {v}')
+    print('}')
+    print('LDA_IDS = %s' % lda_ids)
+    print('GGA_IDS = %s' % gga_ids)
+    print('MGGA_IDS = %s' % mgga_ids)
+
 XC = XC_CODES = {
 'SLATERX'       :  0,  #Slater LDA exchange
 'PW86X'         :  1,  #PW86 exchange
@@ -449,7 +500,7 @@ def parse_xc(description):
                 fac, key = token.split('*')
                 if fac[0].isalpha():
                     fac, key = key, fac
-                fac = sign * float(fac.replace('_', '-'))
+                fac = sign * float(fac.replace('E_', 'E-'))
             else:
                 fac, key = sign, token
 
@@ -833,7 +884,7 @@ XC_D0000003 = 119
 
 def eval_xc(xc_code, rho, spin=0, relativity=0, deriv=1, omega=None, verbose=None):
     r'''Interface to call xcfun library to evaluate XC functional, potential
-    and functional derivatives. Return deriviates following libxc convention.
+    and functional derivatives. Return derivatives following libxc convention.
 
     See also :func:`pyscf.dft.libxc.eval_xc`
     '''

pyscf/eph/eph_fd.py

@@ -101,7 +101,7 @@ def kernel(mf, disp=1e-4, mo_rep=False, cutoff_frequency=CUTOFF_FREQUENCY, keep_
     omega, vec = get_mode(mf, cutoff_frequency, keep_imag_frequency)
     mass = mol.atom_mass_list() * MP_ME
     vec = rhf_eph._freq_mass_weighted_vec(vec, omega, mass)
-    mols_a, mols_b = gen_moles(mol, disp/2.0) # generate a bunch of molecules with disp/2 on each cartesion coord
+    mols_a, mols_b = gen_moles(mol, disp/2.0) # generate a bunch of molecules with disp/2 on each cartesian coord
     mfset = run_mfs(mf, mols_a, mols_b) # run mean field calculations on all these molecules
     vmat = get_vmat(mf, mfset, disp) # extracting <p|dV|q>/dR
     if mo_rep:

pyscf/eph/rhf.py

@@ -23,7 +23,7 @@ Analytical electron-phonon matrix for restricted hartree fock
 import numpy as np
 import scipy.linalg
 from pyscf.hessian import rhf
-from pyscf.lib import logger, chkfile
+from pyscf.lib import logger
 from pyscf.scf._response_functions import _gen_rhf_response
 from pyscf import __config__
 from pyscf.data.nist import HARTREE2WAVENUMBER, MP_ME
@@ -37,16 +37,16 @@ def kernel(ephobj, mo_energy=None, mo_coeff=None, mo_occ=None, mo_rep=False):
     if mo_coeff is None: mo_coeff = ephobj.base.mo_coeff
     if mo_occ is None: mo_occ = ephobj.base.mo_occ
 
-    # chkfile is used to pass first orbitals from hessian methods to eph methods
-    # TODO: Remove the dependence to chfile and return first orbitals from a function
-    assert ephobj.chkfile is not None, 'chkfile is required to save first order orbitals'
+    h1ao = ephobj.make_h1(mo_coeff, mo_occ)
+    mo1, mo_e1 = ephobj.solve_mo1(mo_energy, mo_coeff, mo_occ, h1ao)
 
-    de = ephobj.hess_elec(mo_energy, mo_coeff, mo_occ)
+    de = ephobj.hess_elec(mo_energy, mo_coeff, mo_occ,
+                          mo1=mo1, mo_e1=mo_e1, h1ao=h1ao)
     ephobj.de = de + ephobj.hess_nuc(ephobj.mol)
 
     omega, vec = ephobj.get_mode(ephobj.mol, ephobj.de)
     ephobj.omega, ephobj.vec = omega, vec
-    ephobj.eph = ephobj.get_eph(ephobj.chkfile, omega, vec, mo_rep)
+    ephobj.eph = ephobj.get_eph(mo1, omega, vec, mo_rep)
     return ephobj.eph, ephobj.omega
 
 def solve_hmat(mol, hmat, cutoff_frequency=CUTOFF_FREQUENCY,
@@ -143,10 +143,6 @@ def _freq_mass_weighted_vec(vec, omega, mass):
     return vec
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = chkfile.load(mo1, 'scf_mo1')
-        mo1 = {int(k): mo1[k] for k in mo1}
-
     mol = ephobj.mol
     mf = ephobj.base
     vnuc_deriv = ephobj.vnuc_generator(mol)
@@ -209,29 +205,3 @@ class EPH(rhf.Hessian):
     get_eph = get_eph
     vnuc_generator = vnuc_generator
     kernel = kernel
-
-if __name__ == '__main__':
-    from pyscf import gto, scf
-
-    mol = gto.M()
-    mol.atom = [['O', [0.000000000000,  -0.000000000775,   0.923671924285]],
-                ['H', [-0.000000000000,  -1.432564848017,   2.125164039823]],
-                ['H', [0.000000000000,   1.432564848792,   2.125164035930]]]
-    mol.unit = 'Bohr'
-    mol.basis = 'sto3g'
-    mol.verbose=4
-    mol.build() # this is a pre-computed relaxed geometry
-
-    mf = scf.RHF(mol)
-    mf.conv_tol = 1e-16
-    mf.conv_tol_grad = 1e-10
-    mf.kernel()
-
-    myeph = EPH(mf)
-
-    grad = mf.nuc_grad_method().kernel()
-    print("Force on the atoms/au:")
-    print(grad)
-
-    eph, omega = myeph.kernel(mo_rep=True)
-    print(np.amax(eph))

pyscf/eph/rks.py

@@ -100,10 +100,6 @@ def _get_vxc_deriv1(hessobj, mo_coeff, mo_occ, max_memory):
     return vmat
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1 = {int(k): mo1[k] for k in mo1}
-
     mol = ephobj.mol
     mf = ephobj.base
     ni = mf._numint

pyscf/eph/uhf.py

@@ -54,18 +54,12 @@ def uhf_deriv_generator(mf, mo_coeff, mo_occ):
     return fx
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1a = mo1['0']
-        mo1b = mo1['1']
-        mo1a = {int(k): mo1a[k] for k in mo1a}
-        mo1b = {int(k): mo1b[k] for k in mo1b}
-
     mol = ephobj.mol
     mf = ephobj.base
     vnuc_deriv = ephobj.vnuc_generator(mol)
     aoslices = mol.aoslice_by_atom()
 
+    mo1a, mo1b = mo1
     mo_coeff, mo_occ = mf.mo_coeff, mf.mo_occ
     vind = uhf_deriv_generator(mf, mf.mo_coeff, mf.mo_occ)
     nao, nmo = mo_coeff[0].shape

pyscf/eph/uks.py

@@ -124,13 +124,6 @@ def _get_vxc_deriv1(hessobj, mo_coeff, mo_occ, max_memory):
     return vmata, vmatb
 
 def get_eph(ephobj, mo1, omega, vec, mo_rep):
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1a = mo1['0']
-        mo1b = mo1['1']
-        mo1a = {int(k): mo1a[k] for k in mo1a}
-        mo1b = {int(k): mo1b[k] for k in mo1b}
-
     mol = ephobj.mol
     mf = ephobj.base
     ni = mf._numint
@@ -141,6 +134,7 @@ def get_eph(ephobj, mo1, omega, vec, mo_rep):
     vnuc_deriv = ephobj.vnuc_generator(mol)
     aoslices = mol.aoslice_by_atom()
 
+    mo1a, mo1b = mo1
     mo_coeff, mo_occ = mf.mo_coeff, mf.mo_occ
     vind = uhf_deriv_generator(mf, mf.mo_coeff, mf.mo_occ)
     mem_now = lib.current_memory()[0]

pyscf/fci/addons.py

@@ -224,7 +224,7 @@ def cylindrical_init_guess(mol, norb, nelec, orbsym, wfnsym=0, singlet=True,
                     ci_1[addr_x_a,addr_y_b] = numpy.sqrt(.5)
                     ci_1[addr_y_a,addr_x_b] =-numpy.sqrt(.5)
             else:
-                # TODO: Other direct-product to direct-sum transofromation
+                # TODO: Other direct-product to direct-sum transformation
                 # which involves CG coefficients.
                 ci_1[addra,addrb] = 1
             ci0.append(ci_1.ravel())
@@ -316,7 +316,7 @@ def guess_wfnsym(ci, norb, nelec, orbsym):
     else:
         wfnsym = [_guess_wfnsym(c, strsa, strsb, orbsym) for c in ci]
         if any(wfnsym[0] != x for x in wfnsym):
-            warnings.warn('Different wfnsym %s found in different CI vecotrs' % wfnsym)
+            warnings.warn('Different wfnsym %s found in different CI vectors' % wfnsym)
         wfnsym = wfnsym[0]
     return wfnsym
 
@@ -703,6 +703,121 @@ def transform_ci(ci, nelec, u):
     ci = lib.dot(ci, trans_ci_b)
     return ci
 
+def civec_spinless_repr_generator(ci0_r, norb, nelec_r):
+    '''Put CI vectors in the spinless representation; i.e., map
+        norb -> 2 * norb
+        (neleca, nelecb) -> (neleca+nelecb, 0)
+    This permits linear combinations of CI vectors with different
+    M == neleca-nelecb at the price of higher memory cost. This function
+    does NOT change the datatype.
+
+    Args:
+        ci0_r: sequence or generator of ndarray of length nprods
+            CAS-CI vectors in the spin-pure representation
+        norb: integer
+            Number of orbitals
+        nelec_r: sequence of tuple of length (2)
+            (neleca, nelecb) for each element of ci0_r
+
+    Returns:
+        ci1_r_gen: callable that returns a generator of length nprods
+            generates spinless CAS-CI vectors
+        ss2spinless: callable
+            Put a CAS-CI vector in the spinless representation
+            Args:
+                ci0: ndarray
+                    CAS-CI vector
+                ne: tuple of length 2
+                    neleca, nelecb of target Hilbert space
+            Returns:
+                ci1: ndarray
+                    spinless CAS-CI vector
+        spinless2ss: callable
+            Perform the reverse operation on a spinless CAS-CI vector
+            Args:
+                ci2: ndarray
+                    spinless CAS-CI vector
+                ne: tuple of length 2
+                    neleca, nelecb target Hilbert space
+            Returns:
+                ci3: ndarray
+                    CAS-CI vector of ci2 in the (neleca, nelecb) Hilbert space
+    '''
+    nelec_r_tot = [sum (n) for n in nelec_r]
+    if len(set(nelec_r_tot)) > 1:
+        raise NotImplementedError("Different particle-number subspaces")
+    nelec = nelec_r_tot[0]
+    addrs = {}
+    ndet_sp = {}
+    for ne in set(nelec_r):
+        neleca, nelecb = _unpack_nelec(ne)
+        ndeta = cistring.num_strings(norb, neleca)
+        ndetb = cistring.num_strings(norb, nelecb)
+        strsa = cistring.addrs2str(norb, neleca, list(range(ndeta)))
+        strsb = cistring.addrs2str(norb, nelecb, list(range(ndetb)))
+        strs = numpy.add.outer(strsa, numpy.left_shift(strsb, norb)).ravel()
+        addrs[ne] = cistring.strs2addr(2*norb, nelec, strs)
+        ndet_sp[ne] = (ndeta,ndetb)
+    strs = strsa = strsb = None
+    ndet = cistring.num_strings(2*norb, nelec)
+    def ss2spinless(ci0, ne, buf=None):
+        if buf is None:
+            ci1 = numpy.empty(ndet, dtype=ci0.dtype)
+        else:
+            ci1 = numpy.asarray(buf).flat[:ndet]
+        ci1[:] = 0.0
+        ci1[addrs[ne]] = ci0[:,:].ravel ()
+        neleca, nelecb = _unpack_nelec (ne)
+        if abs(neleca*nelecb)%2: ci1[:] *= -1
+        # Sign comes from changing representation:
+        # ... a2' a1' a0' ... b2' b1' b0' |vac>
+        # ->
+        # ... b2' b1' b0' .. a2' a1' a0' |vac>
+        # i.e., strictly decreasing from left to right
+        # (the ordinality of spin-down is conventionally greater than spin-up)
+        return ci1[:,None]
+    def spinless2ss(ci2, ne):
+        ''' Generate the spin-separated CI vector in a particular M
+        Hilbert space from a spinless CI vector '''
+        ci3 = ci2[addrs[ne]].reshape(ndet_sp[ne])
+        neleca, nelecb = _unpack_nelec (ne)
+        if abs(neleca*nelecb)%2: ci3[:] *= -1
+        return ci3
+    def ci1_r_gen(buf=None):
+        if callable(ci0_r):
+            ci0_r_gen = ci0_r()
+        else:
+            ci0_r_gen = (c for c in ci0_r)
+        for ci0, ne in zip(ci0_r_gen, nelec_r):
+            # Doing this in two lines saves memory: ci0 is overwritten
+            ci0 = ss2spinless(ci0, ne)
+            yield ci0
+    return ci1_r_gen, ss2spinless, spinless2ss
+
+def civec_spinless_repr(ci0_r, norb, nelec_r):
+    '''Put CI vectors in the spinless representation; i.e., map
+        norb -> 2 * norb
+        (neleca, nelecb) -> (neleca+nelecb, 0)
+    This permits linear combinations of CI vectors with different
+    M == neleca-nelecb at the price of higher memory cost. This function
+    does NOT change the datatype.
+
+    Args:
+        ci0_r: sequence or generator of ndarray of length nprods
+            CAS-CI vectors in the spin-pure representation
+        norb: integer
+            Number of orbitals
+        nelec_r: sequence of tuple of length (2)
+            (neleca, nelecb) for each element of ci0_r
+
+    Returns:
+        ci1_r: ndarray of shape (nprods, ndet_spinless)
+            spinless CAS-CI vectors
+    '''
+    ci1_r_gen, *_ = civec_spinless_repr_generator(ci0_r, norb, nelec_r)
+    ci1_r = numpy.stack([x.copy() for x in ci1_r_gen()], axis=0)
+    return ci1_r
+
 
 def _unpack_nelec(nelec, spin=None):
     if spin is None:

pyscf/fci/cistring.py

@@ -200,7 +200,7 @@ def gen_linkstr_index(orb_list, nocc, strs=None, tril=False):
     For given string str0, index[str0] is (nocc+nocc*nvir) x 4 array.
     The first nocc rows [i(:occ),i(:occ),str0,sign] are occupied-occupied
     excitations, which do not change the string. The next nocc*nvir rows
-    [a(:vir),i(:occ),str1,sign] are occupied-virtual exciations, starting from
+    [a(:vir),i(:occ),str1,sign] are occupied-virtual excitations, starting from
     str0, annihilating i, creating a, to get str1.
     '''
     if strs is None:

pyscf/fci/direct_nosym.py

@@ -125,7 +125,7 @@ def contract_2e(eri, fcivec, norb, nelec, link_index=None):
     outI += contract_2e(eriI, ciR, norb, nelec, link_index=link_index)
     out = outR.astype(numpy.complex128)
     out.imag = outI
-    return outR
+    return out
 
 def absorb_h1e(h1e, eri, norb, nelec, fac=1):
     '''Modify 2e Hamiltonian to include 1e Hamiltonian contribution.
@@ -204,11 +204,11 @@ class FCISolver(direct_spin1.FCISolver):
             return scipy.linalg.eigh(op)
 
         # TODO: check the hermitian of Hamiltonian then determine whether to
-        # call the non-hermitian diagonlization solver davidson_nosym1
+        # call the non-hermitian diagonalization solver davidson_nosym1
 
         warnings.warn('direct_nosym.kernel is not able to diagonalize '
                       'non-Hermitian Hamiltonian. If h1e and h2e is not '
-                      'hermtian, calling symmetric diagonlization in eig '
+                      'hermtian, calling symmetric diagonalization in eig '
                       'can lead to wrong results.')
 
         self.converged, e, ci = \

pyscf/fci/direct_spin0_symm.py

@@ -74,15 +74,20 @@ def get_init_guess(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
     strsa = cistring.gen_strings4orblist(range(norb), neleca)
     na = len(strsa)
     airreps = direct_spin1_symm._gen_strs_irrep(strsa, orbsym)
-    hdiag = hdiag.reshape(na,na)
 
     sym_allowed = (airreps[:,None] ^ airreps) == wfnsym
     idx = numpy.arange(na)
     sym_allowed[idx[:,None] < idx] = False
     idx_a, idx_b = numpy.where(sym_allowed)
 
+    hdiag = hdiag.reshape(na,na)[idx_a,idx_b]
+    if hdiag.size <= nroots:
+        hdiag_indices = numpy.arange(hdiag.size)
+    else:
+        hdiag_indices = numpy.argpartition(hdiag, nroots-1)[:nroots]
+
     ci0 = []
-    for k in numpy.argpartition(hdiag[idx_a,idx_b], nroots-1)[:nroots]:
+    for k in hdiag_indices:
         addra, addrb = idx_a[k], idx_b[k]
         x = numpy.zeros((na, na))
         if addra == addrb:
@@ -92,61 +97,35 @@ def get_init_guess(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
         ci0.append(x.ravel().view(direct_spin1.FCIvector))
 
     if len(ci0) == 0:
-        raise RuntimeError(f'Initial guess for symmetry {wfnsym} not found')
+        raise lib.exceptions.WfnSymmetryError(
+            f'Initial guess for symmetry {wfnsym} not found')
     return ci0
 
 def get_init_guess_cyl_sym(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
     neleca, nelecb = direct_spin1._unpack_nelec(nelec)
-    strsa = cistring.gen_strings4orblist(range(norb), neleca)
-    airreps_d2h = direct_spin1_symm._gen_strs_irrep(strsa, orbsym)
-    a_ls = direct_spin1_symm._strs_angular_momentum(strsa, orbsym)
-
-    wfnsym_in_d2h = wfnsym % 10
-    wfn_momentum = symm.basis.linearmole_irrep2momentum(wfnsym)
-    na = len(strsa)
-    hdiag = hdiag.reshape(na,na)
-    degen = orbsym.degen_mapping
+    na = cistring.num_strings(norb, neleca)
+    ci0_guess = direct_spin1_symm.get_init_guess_cyl_sym(
+            norb, nelec, nroots, hdiag, orbsym, wfnsym)
     ci0 = []
-    iroot = 0
-    wfn_ungerade = wfnsym_in_d2h >= 4
-    a_ungerade = airreps_d2h >= 4
-    sym_allowed = a_ungerade[:,None] == a_ungerade ^ wfn_ungerade
-    # total angular momentum == wfn_momentum
-    sym_allowed &= a_ls[:,None] == wfn_momentum - a_ls
-    idx = numpy.arange(na)
-    sym_allowed[idx[:,None] < idx] = False
-
-    idx_a, idx_b = numpy.where(sym_allowed)
-    for k in hdiag[idx_a,idx_b].argsort():
-        addra, addrb = idx_a[k], idx_b[k]
-        ca = direct_spin1_symm._cyl_sym_csf2civec(strsa, addra, orbsym, degen)
-        cb = direct_spin1_symm._cyl_sym_csf2civec(strsa, addrb, orbsym, degen)
-        if wfn_momentum > 0 or wfnsym in (0, 5):
-            x = ca.real[:,None] * cb.real
-            x-= ca.imag[:,None] * cb.imag
-        else:
-            x = ca.imag[:,None] * cb.real
-            x+= ca.real[:,None] * cb.imag
-        if addra == addrb:
-            norm = numpy.linalg.norm(x)
-        else:
-            x = x + x.T
-            norm = numpy.linalg.norm(x)
-            if norm < 1e-3:
-                continue
+    for x in ci0_guess:
+        x = x.reshape(na, na)
+        x = x + x.T
+        norm = numpy.linalg.norm(x)
+        if norm < 1e-3:
+            continue
         x *= 1./norm
         ci0.append(x.ravel().view(direct_spin1.FCIvector))
-        iroot += 1
-        if iroot >= nroots:
-            break
 
     if len(ci0) == 0:
-        raise RuntimeError(f'Initial guess for symmetry {wfnsym} not found')
+        raise lib.exceptions.WfnSymmetryError(
+            f'Initial guess for symmetry {wfnsym} not found')
     return ci0
 
 
 class FCISolver(direct_spin0.FCISolver):
 
+    _keys = {'wfnsym', 'sym_allowed_idx'}
+
     davidson_only = getattr(__config__, 'fci_direct_spin1_symm_FCI_davidson_only', True)
     pspace_size = getattr(__config__, 'fci_direct_spin1_symm_FCI_pspace_size', 400)