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

pyscf/tdscf/uhf.py

@@ -23,9 +23,9 @@ from pyscf import scf
 from pyscf import symm
 from pyscf import ao2mo
 from pyscf.lib import logger
-from pyscf.tdscf import rhf
 from pyscf.scf import uhf_symm
-from pyscf.scf import _response_functions
+from pyscf.tdscf import rhf
+from pyscf.tdscf._lr_eig import eigh as lr_eigh, eig as lr_eig
 from pyscf.data import nist
 from pyscf import __config__
 
@@ -63,13 +63,9 @@ def gen_tda_operation(mf, fock_ao=None, wfnsym=None):
     if wfnsym is not None and mol.symmetry:
         if isinstance(wfnsym, str):
             wfnsym = symm.irrep_name2id(mol.groupname, wfnsym)
-        orbsyma, orbsymb = uhf_symm.get_orbsym(mol, mo_coeff)
         wfnsym = wfnsym % 10  # convert to D2h subgroup
-        orbsyma_in_d2h = numpy.asarray(orbsyma) % 10
-        orbsymb_in_d2h = numpy.asarray(orbsymb) % 10
-        sym_forbida = (orbsyma_in_d2h[occidxa,None] ^ orbsyma_in_d2h[viridxa]) != wfnsym
-        sym_forbidb = (orbsymb_in_d2h[occidxb,None] ^ orbsymb_in_d2h[viridxb]) != wfnsym
-        sym_forbid = numpy.hstack((sym_forbida.ravel(), sym_forbidb.ravel()))
+        x_sym_a, x_sym_b = _get_x_sym_table(mf)
+        sym_forbid = numpy.append(x_sym_a.ravel(), x_sym_b.ravel()) != wfnsym
 
     e_ia_a = mo_energy[0][viridxa] - mo_energy[0][occidxa,None]
     e_ia_b = mo_energy[1][viridxb] - mo_energy[1][occidxb,None]
@@ -83,13 +79,14 @@ def gen_tda_operation(mf, fock_ao=None, wfnsym=None):
     vresp = mf.gen_response(hermi=0, max_memory=max_memory)
 
     def vind(zs):
+        nz = len(zs)
         zs = numpy.asarray(zs)
         if wfnsym is not None and mol.symmetry:
             zs = numpy.copy(zs)
             zs[:,sym_forbid] = 0
 
-        za = zs[:,:nocca*nvira].reshape(-1,nocca,nvira)
-        zb = zs[:,nocca*nvira:].reshape(-1,noccb,nvirb)
+        za = zs[:,:nocca*nvira].reshape(nz,nocca,nvira)
+        zb = zs[:,nocca*nvira:].reshape(nz,noccb,nvirb)
         dmova = lib.einsum('xov,qv,po->xpq', za, orbva.conj(), orboa)
         dmovb = lib.einsum('xov,qv,po->xpq', zb, orbvb.conj(), orbob)
 
@@ -100,7 +97,6 @@ def gen_tda_operation(mf, fock_ao=None, wfnsym=None):
         v1a += numpy.einsum('xia,ia->xia', za, e_ia_a)
         v1b += numpy.einsum('xia,ia->xia', zb, e_ia_b)
 
-        nz = zs.shape[0]
         hx = numpy.hstack((v1a.reshape(nz,-1), v1b.reshape(nz,-1)))
         if wfnsym is not None and mol.symmetry:
             hx[:,sym_forbid] = 0
@@ -109,6 +105,17 @@ def gen_tda_operation(mf, fock_ao=None, wfnsym=None):
     return vind, hdiag
 gen_tda_hop = gen_tda_operation
 
+def _get_x_sym_table(mf):
+    '''Irrep (up to D2h symmetry) of each coefficient in X amplitude'''
+    mol = mf.mol
+    mo_occa, mo_occb = mf.mo_occ
+    orbsyma, orbsymb = uhf_symm.get_orbsym(mol, mf.mo_coeff)
+    orbsyma = orbsyma % 10
+    orbsymb = orbsymb % 10
+    x_sym_a = orbsyma[mo_occa>0,None] ^ orbsyma[mo_occa==0]
+    x_sym_b = orbsymb[mo_occb>0,None] ^ orbsymb[mo_occb==0]
+    return x_sym_a, x_sym_b
+
 def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
     r'''A and B matrices for TDDFT response function.
 
@@ -183,11 +190,24 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
         ni.libxc.test_deriv_order(mf.xc, 2, raise_error=True)
         if mf.do_nlc():
             logger.warn(mf, 'NLC functional found in DFT object.  Its second '
-                        'deriviative is not available. Its contribution is '
+                        'derivative is not available. Its contribution is '
                         'not included in the response function.')
         omega, alpha, hyb = ni.rsh_and_hybrid_coeff(mf.xc, mol.spin)
 
         add_hf_(a, b, hyb)
+        if omega != 0:  # For RSH
+            with mol.with_range_coulomb(omega):
+                eri_aa = ao2mo.general(mol, [orbo_a,mo_a,mo_a,mo_a], compact=False)
+                eri_bb = ao2mo.general(mol, [orbo_b,mo_b,mo_b,mo_b], compact=False)
+                eri_aa = eri_aa.reshape(nocc_a,nmo_a,nmo_a,nmo_a)
+                eri_bb = eri_bb.reshape(nocc_b,nmo_b,nmo_b,nmo_b)
+                a_aa, a_ab, a_bb = a
+                b_aa, b_ab, b_bb = b
+                k_fac = alpha - hyb
+                a_aa -= numpy.einsum('ijba->iajb', eri_aa[:nocc_a,:nocc_a,nocc_a:,nocc_a:]) * k_fac
+                b_aa -= numpy.einsum('jaib->iajb', eri_aa[:nocc_a,nocc_a:,:nocc_a,nocc_a:]) * k_fac
+                a_bb -= numpy.einsum('ijba->iajb', eri_bb[:nocc_b,:nocc_b,nocc_b:,nocc_b:]) * k_fac
+                b_bb -= numpy.einsum('jaib->iajb', eri_bb[:nocc_b,nocc_b:,:nocc_b,nocc_b:]) * k_fac
 
         xctype = ni._xc_type(mf.xc)
         dm0 = mf.make_rdm1(mo_coeff, mo_occ)
@@ -508,8 +528,8 @@ def analyze(tdobj, verbose=None):
             log.note('Excited State %3d: %12.5f eV %9.2f nm  f=%.4f',
                      i+1, e_ev[i], wave_length[i], f_oscillator[i])
         else:
-            wfnsyma = rhf.analyze_wfnsym(tdobj, x_syma, x[0])
-            wfnsymb = rhf.analyze_wfnsym(tdobj, x_symb, x[1])
+            wfnsyma = rhf._analyze_wfnsym(tdobj, x_syma, x[0])
+            wfnsymb = rhf._analyze_wfnsym(tdobj, x_symb, x[1])
             if wfnsyma == wfnsymb:
                 wfnsym = wfnsyma
             else:
@@ -606,7 +626,7 @@ class TDA(TDBase):
             mf = self._scf
         return gen_tda_hop(mf, wfnsym=self.wfnsym)
 
-    def init_guess(self, mf, nstates=None, wfnsym=None):
+    def init_guess(self, mf, nstates=None, wfnsym=None, return_symmetry=False):
         if nstates is None: nstates = self.nstates
         if wfnsym is None: wfnsym = self.wfnsym
 
@@ -617,30 +637,42 @@ class TDA(TDBase):
         occidxb = numpy.where(mo_occ[1]>0)[0]
         viridxa = numpy.where(mo_occ[0]==0)[0]
         viridxb = numpy.where(mo_occ[1]==0)[0]
-        e_ia_a = (mo_energy[0][viridxa,None] - mo_energy[0][occidxa]).T
-        e_ia_b = (mo_energy[1][viridxb,None] - mo_energy[1][occidxb]).T
-
-        if wfnsym is not None and mol.symmetry:
-            if isinstance(wfnsym, str):
-                wfnsym = symm.irrep_name2id(mol.groupname, wfnsym)
-            orbsyma, orbsymb = uhf_symm.get_orbsym(mol, mf.mo_coeff)
-            wfnsym = wfnsym % 10  # convert to D2h subgroup
-            orbsyma_in_d2h = numpy.asarray(orbsyma) % 10
-            orbsymb_in_d2h = numpy.asarray(orbsymb) % 10
-            e_ia_a[(orbsyma_in_d2h[occidxa,None] ^ orbsyma_in_d2h[viridxa]) != wfnsym] = 1e99
-            e_ia_b[(orbsymb_in_d2h[occidxb,None] ^ orbsymb_in_d2h[viridxb]) != wfnsym] = 1e99
-
-        e_ia = numpy.hstack((e_ia_a.ravel(), e_ia_b.ravel()))
-        nov = e_ia.size
+        e_ia_a = mo_energy[0][viridxa] - mo_energy[0][occidxa,None]
+        e_ia_b = mo_energy[1][viridxb] - mo_energy[1][occidxb,None]
+        nov = e_ia_a.size + e_ia_b.size
         nstates = min(nstates, nov)
-        e_threshold = numpy.sort(e_ia)[nstates-1]
+
+        if (wfnsym is not None or return_symmetry) and mf.mol.symmetry:
+            x_sym_a, x_sym_b = _get_x_sym_table(mf)
+            if wfnsym is not None:
+                if isinstance(wfnsym, str):
+                    wfnsym = symm.irrep_name2id(mol.groupname, wfnsym)
+                wfnsym = wfnsym % 10  # convert to D2h subgroup
+                e_ia_a[x_sym_a != wfnsym] = 1e99
+                e_ia_b[x_sym_b != wfnsym] = 1e99
+                nov_allowed = (numpy.count_nonzero(x_sym_a == wfnsym) +
+                               numpy.count_nonzero(x_sym_b == wfnsym))
+                nstates = min(nstates, nov_allowed)
+
+        e_ia = numpy.append(e_ia_a.ravel(), e_ia_b.ravel())
+        # Find the nstates-th lowest energy gap
+        e_threshold = numpy.partition(e_ia, nstates-1)[nstates-1]
         e_threshold += self.deg_eia_thresh
 
         idx = numpy.where(e_ia <= e_threshold)[0]
         x0 = numpy.zeros((idx.size, nov))
         for i, j in enumerate(idx):
             x0[i, j] = 1  # Koopmans' excitations
-        return x0
+
+        if return_symmetry:
+            if mf.mol.symmetry:
+                x_sym = numpy.append(x_sym_a.ravel(), x_sym_b.ravel())
+                x0sym = x_sym[idx]
+            else:
+                x0sym = None
+            return x0, x0sym
+        else:
+            return x0
 
     def kernel(self, x0=None, nstates=None):
         '''TDA diagonalization solver
@@ -653,6 +685,7 @@ class TDA(TDBase):
         else:
             self.nstates = nstates
         log = logger.Logger(self.stdout, self.verbose)
+        mol = self.mol
 
         vind, hdiag = self.gen_vind(self._scf)
         precond = self.get_precond(hdiag)
@@ -661,16 +694,19 @@ class TDA(TDBase):
             idx = numpy.where(w > self.positive_eig_threshold)[0]
             return w[idx], v[:,idx], idx
 
+        x0sym = None
         if x0 is None:
-            x0 = self.init_guess(self._scf, self.nstates)
-
-        self.converged, self.e, x1 = \
-                lib.davidson1(vind, x0, precond,
-                              tol=self.conv_tol,
-                              nroots=nstates, lindep=self.lindep,
-                              max_cycle=self.max_cycle,
-                              max_space=self.max_space, pick=pickeig,
-                              verbose=log)
+            x0, x0sym = self.init_guess(
+                self._scf, self.nstates, return_symmetry=True)
+        elif mol.symmetry:
+            x_sym_a, x_sym_b = _get_x_sym_table(self._scf)
+            x_sym = numpy.append(x_sym_a.ravel(), x_sym_b.ravel())
+            x0sym = [rhf._guess_wfnsym_id(self, x_sym, x) for x in x0]
+
+        self.converged, self.e, x1 = lr_eigh(
+            vind, x0, precond, tol_residual=self.conv_tol, lindep=self.lindep,
+            nroots=nstates, x0sym=x0sym, pick=pickeig, max_cycle=self.max_cycle,
+            max_memory=self.max_memory, verbose=log)
 
         nmo = self._scf.mo_occ[0].size
         nocca = (self._scf.mo_occ[0]>0).sum()
@@ -698,12 +734,11 @@ CIS = TDA
 def gen_tdhf_operation(mf, fock_ao=None, singlet=True, wfnsym=None):
     '''Generate function to compute
 
-    [ A  B][X]
-    [-B -A][Y]
+    [ A   B ][X]
+    [-B* -A*][Y]
     '''
     mol = mf.mol
     mo_coeff = mf.mo_coeff
-    assert (mo_coeff[0].dtype == numpy.double)
     mo_energy = mf.mo_energy
     mo_occ = mf.mo_occ
     nao, nmo = mo_coeff[0].shape
@@ -723,13 +758,9 @@ def gen_tdhf_operation(mf, fock_ao=None, singlet=True, wfnsym=None):
     if wfnsym is not None and mol.symmetry:
         if isinstance(wfnsym, str):
             wfnsym = symm.irrep_name2id(mol.groupname, wfnsym)
-        orbsyma, orbsymb = uhf_symm.get_orbsym(mol, mo_coeff)
         wfnsym = wfnsym % 10  # convert to D2h subgroup
-        orbsyma_in_d2h = numpy.asarray(orbsyma) % 10
-        orbsymb_in_d2h = numpy.asarray(orbsymb) % 10
-        sym_forbida = (orbsyma_in_d2h[occidxa,None] ^ orbsyma_in_d2h[viridxa]) != wfnsym
-        sym_forbidb = (orbsymb_in_d2h[occidxb,None] ^ orbsymb_in_d2h[viridxb]) != wfnsym
-        sym_forbid = numpy.hstack((sym_forbida.ravel(), sym_forbidb.ravel()))
+        x_sym_a, x_sym_b = _get_x_sym_table(mf)
+        sym_forbid = numpy.append(x_sym_a.ravel(), x_sym_b.ravel()) != wfnsym
 
     e_ia_a = mo_energy[0][viridxa] - mo_energy[0][occidxa,None]
     e_ia_b = mo_energy[1][viridxb] - mo_energy[1][occidxb,None]
@@ -755,17 +786,14 @@ def gen_tdhf_operation(mf, fock_ao=None, singlet=True, wfnsym=None):
         xb = xs[:,nocca*nvira:].reshape(nz,noccb,nvirb)
         ya = ys[:,:nocca*nvira].reshape(nz,nocca,nvira)
         yb = ys[:,nocca*nvira:].reshape(nz,noccb,nvirb)
-        # dms = AX + BY
         dmsa  = lib.einsum('xov,qv,po->xpq', xa, orbva.conj(), orboa)
         dmsb  = lib.einsum('xov,qv,po->xpq', xb, orbvb.conj(), orbob)
         dmsa += lib.einsum('xov,pv,qo->xpq', ya, orbva, orboa.conj())
         dmsb += lib.einsum('xov,pv,qo->xpq', yb, orbvb, orbob.conj())
-
         v1ao = vresp(numpy.asarray((dmsa,dmsb)))
-
         v1aov = lib.einsum('xpq,po,qv->xov', v1ao[0], orboa.conj(), orbva)
-        v1avo = lib.einsum('xpq,qo,pv->xov', v1ao[0], orboa, orbva.conj())
         v1bov = lib.einsum('xpq,po,qv->xov', v1ao[1], orbob.conj(), orbvb)
+        v1avo = lib.einsum('xpq,qo,pv->xov', v1ao[0], orboa, orbva.conj())
         v1bvo = lib.einsum('xpq,qo,pv->xov', v1ao[1], orbob, orbvb.conj())
 
         v1ov = xs * e_ia  # AX
@@ -783,7 +811,7 @@ def gen_tdhf_operation(mf, fock_ao=None, singlet=True, wfnsym=None):
     return vind, hdiag
 
 
-class TDHF(TDA):
+class TDHF(TDBase):
 
     singlet = None
 
@@ -793,10 +821,17 @@ class TDHF(TDA):
             mf = self._scf
         return gen_tdhf_operation(mf, singlet=self.singlet, wfnsym=self.wfnsym)
 
-    def init_guess(self, mf, nstates=None, wfnsym=None):
-        x0 = TDA.init_guess(self, mf, nstates, wfnsym)
-        y0 = numpy.zeros_like(x0)
-        return numpy.asarray(numpy.block([[x0, y0], [y0, x0.conj()]]))
+    def init_guess(self, mf, nstates=None, wfnsym=None, return_symmetry=False):
+        if return_symmetry:
+            x0, x0sym = TDA.init_guess(self, mf, nstates, wfnsym, return_symmetry)
+            y0 = numpy.zeros_like(x0)
+            return numpy.hstack([x0, y0]), x0sym
+        else:
+            x0 = TDA.init_guess(self, mf, nstates, wfnsym, return_symmetry)
+            y0 = numpy.zeros_like(x0)
+            return numpy.hstack([x0, y0])
+
+    get_precond = rhf.TDHF.get_precond
 
     def kernel(self, x0=None, nstates=None):
         '''TDHF diagonalization with non-Hermitian eigenvalue solver
@@ -808,29 +843,41 @@ class TDHF(TDA):
             nstates = self.nstates
         else:
             self.nstates = nstates
+        mol = self.mol
 
         log = logger.Logger(self.stdout, self.verbose)
 
         vind, hdiag = self.gen_vind(self._scf)
         precond = self.get_precond(hdiag)
 
+        # handle single kpt PBC SCF
+        if getattr(self._scf, 'kpt', None) is not None:
+            from pyscf.pbc.lib.kpts_helper import gamma_point
+            real_system = (gamma_point(self._scf.kpt) and
+                           self._scf.mo_coeff[0].dtype == numpy.double)
+        else:
+            real_system = True
+
         # We only need positive eigenvalues
         def pickeig(w, v, nroots, envs):
             realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD) &
                                   (w.real > self.positive_eig_threshold))[0]
-            return lib.linalg_helper._eigs_cmplx2real(w, v, realidx,
-                                                      real_eigenvectors=True)
+            return lib.linalg_helper._eigs_cmplx2real(w, v, realidx, real_system)
 
+        x0sym = None
         if x0 is None:
-            x0 = self.init_guess(self._scf, self.nstates)
-
-        self.converged, w, x1 = \
-                lib.davidson_nosym1(vind, x0, precond,
-                                    tol=self.conv_tol,
-                                    nroots=nstates, lindep=self.lindep,
-                                    max_cycle=self.max_cycle,
-                                    max_space=self.max_space, pick=pickeig,
-                                    verbose=log)
+            x0, x0sym = self.init_guess(
+                self._scf, self.nstates, return_symmetry=True)
+        elif mol.symmetry:
+            x_sym_a, x_sym_b = _get_x_sym_table(self._scf)
+            x_sym = y_sym = numpy.append(x_sym_a.ravel(), x_sym_b.ravel())
+            x_sym = numpy.append(x_sym, y_sym)
+            x0sym = [rhf._guess_wfnsym_id(self, x_sym, x) for x in x0]
+
+        self.converged, w, x1 = lr_eig(
+            vind, x0, precond, tol_residual=self.conv_tol, lindep=self.lindep,
+            nroots=nstates, x0sym=x0sym, pick=pickeig, max_cycle=self.max_cycle,
+            max_memory=self.max_memory, verbose=log)
 
         nmo = self._scf.mo_occ[0].size
         nocca = (self._scf.mo_occ[0]>0).sum()

pyscf/tdscf/uks.py

@@ -21,9 +21,8 @@ import numpy
 from pyscf import symm
 from pyscf import lib
 from pyscf.lib import logger
-from pyscf.tdscf import uhf
-from pyscf.scf import uhf_symm
-from pyscf.data import nist
+from pyscf.tdscf import uhf, rhf
+from pyscf.tdscf._lr_eig import eigh as lr_eigh
 from pyscf.dft.rks import KohnShamDFT
 from pyscf import __config__
 
@@ -74,13 +73,9 @@ class CasidaTDDFT(TDDFT, TDA):
         if wfnsym is not None and mol.symmetry:
             if isinstance(wfnsym, str):
                 wfnsym = symm.irrep_name2id(mol.groupname, wfnsym)
-            orbsyma, orbsymb = uhf_symm.get_orbsym(mol, mo_coeff)
             wfnsym = wfnsym % 10  # convert to D2h subgroup
-            orbsyma_in_d2h = numpy.asarray(orbsyma) % 10
-            orbsymb_in_d2h = numpy.asarray(orbsymb) % 10
-            sym_forbida = (orbsyma_in_d2h[occidxa,None] ^ orbsyma_in_d2h[viridxa]) != wfnsym
-            sym_forbidb = (orbsymb_in_d2h[occidxb,None] ^ orbsymb_in_d2h[viridxb]) != wfnsym
-            sym_forbid = numpy.hstack((sym_forbida.ravel(), sym_forbidb.ravel()))
+            x_sym_a, x_sym_b = uhf._get_x_sym_table(mf)
+            sym_forbid = numpy.append(x_sym_a.ravel(), x_sym_b.ravel()) != wfnsym
 
         e_ia_a = (mo_energy[0][viridxa,None] - mo_energy[0][occidxa]).T
         e_ia_b = (mo_energy[1][viridxb,None] - mo_energy[1][occidxb]).T
@@ -123,6 +118,7 @@ class CasidaTDDFT(TDDFT, TDA):
         '''TDDFT diagonalization solver
         '''
         cpu0 = (logger.process_clock(), logger.perf_counter())
+        mol = self.mol
         mf = self._scf
         if mf._numint.libxc.is_hybrid_xc(mf.xc):
             raise RuntimeError('%s cannot be used with hybrid functional'
@@ -142,16 +138,19 @@ class CasidaTDDFT(TDDFT, TDA):
             idx = numpy.where(w > self.positive_eig_threshold)[0]
             return w[idx], v[:,idx], idx
 
+        x0sym = None
         if x0 is None:
-            x0 = self.init_guess(self._scf, self.nstates)
-
-        self.converged, w2, x1 = \
-                lib.davidson1(vind, x0, precond,
-                              tol=self.conv_tol,
-                              nroots=nstates, lindep=self.lindep,
-                              max_cycle=self.max_cycle,
-                              max_space=self.max_space, pick=pickeig,
-                              verbose=log)
+            x0, x0sym = self.init_guess(
+                self._scf, self.nstates, return_symmetry=True)
+        elif mol.symmetry:
+            x_sym_a, x_sym_b = uhf._get_x_sym_table(self._scf)
+            x_sym = numpy.append(x_sym_a.ravel(), x_sym_b.ravel())
+            x0sym = [rhf._guess_wfnsym_id(self, x_sym, x) for x in x0]
+
+        self.converged, w2, x1 = lr_eigh(
+            vind, x0, precond, tol_residual=self.conv_tol, lindep=self.lindep,
+            nroots=nstates, x0sym=x0sym, pick=pickeig, max_cycle=self.max_cycle,
+            max_memory=self.max_memory, verbose=log)
 
         mo_energy = self._scf.mo_energy
         mo_occ = self._scf.mo_occ

pyscf/tools/fcidump.py

@@ -372,6 +372,9 @@ def to_scf(filename, molpro_orbsym=MOLPRO_ORBSYM, mf=None, **kwargs):
     mf.get_hcore = lambda *args: h1
     mf.get_ovlp = lambda *args: numpy.eye(norb)
     mf._eri = ctx['H2']
+    intor_symmetric = mf.mol.intor_symmetric
+    mf.mol.intor_symmetric = lambda intor, **kwargs: numpy.eye(norb) \
+        if intor == 'int1e_ovlp' else intor_symmetric(intor, **kwargs)
 
     return mf
 

pyscf/x2c/sfx2c1e.py

@@ -117,7 +117,7 @@ class SFX2C1E_SCF(x2c._X2C_SCF):
         log = logger.new_logger(mol, verbose)
 
         if not (isinstance(dm, numpy.ndarray) and dm.ndim == 2):
-            # UHF denisty matrices
+            # UHF density matrices
             dm = dm[0] + dm[1]
 
         if isinstance(self, ghf.GHF):

pyscf/x2c/tdscf.py

@@ -290,9 +290,9 @@ class TDA(TDBase, ghf.TDA):
             mf = self._scf
         return gen_tda_hop(mf)
 
-    def init_guess(self, mf, nstates=None, wfnsym=None):
+    def init_guess(self, mf, nstates=None, wfnsym=None, return_symmetry=False):
         assert self.wfnsym is None
-        return ghf.TDA.init_guess(self, mf, nstates, None)
+        return ghf.TDA.init_guess(self, mf, nstates, None, return_symmetry)
 
     kernel = ghf.TDA.kernel
 
@@ -313,9 +313,9 @@ class TDHF(TDBase, ghf.TDHF):
             mf = self._scf
         return gen_tdhf_operation(mf)
 
-    def init_guess(self, mf, nstates=None, wfnsym=None):
+    def init_guess(self, mf, nstates=None, wfnsym=None, return_symmetry=False):
         assert self.wfnsym is None
-        return ghf.TDHF.init_guess(self, mf, nstates, None)
+        return ghf.TDHF.init_guess(self, mf, nstates, None, return_symmetry)
 
     kernel = ghf.TDHF.kernel
 

pyscf/x2c/x2c.py

@@ -577,7 +577,7 @@ class SCF(hf.SCF):
         log = logger.new_logger(mol, verbose)
 
         if not (isinstance(dm, numpy.ndarray) and dm.ndim == 2):
-            # UHF denisty matrices
+            # UHF density matrices
             dm = dm[0] + dm[1]
 
         with mol.with_common_orig((0,0,0)):
@@ -774,17 +774,22 @@ class X2C1E_GSCF(_X2C_SCF):
         charges = mol.atom_charges()
         coords  = mol.atom_coords()
         nucl_dip = numpy.einsum('i,ix->x', charges, coords)
-        with mol.with_common_orig(nucl_dip):
-            r = mol.intor_symmetric('int1e_r')
-            ao_dip = numpy.array([_block_diag(x) for x in r])
+        with mol.with_common_orig((0,0,0)):
             if picture_change:
                 xmol = self.with_x2c.get_xmol()[0]
                 nao = xmol.nao
-                prp = xmol.intor_symmetric('int1e_sprsp').reshape(3,4,nao,nao)[:,0]
-                prp = numpy.array([_block_diag(x) for x in prp])
-                ao_dip = self.with_x2c.picture_change((ao_dip, prp))
+                r = xmol.intor_symmetric('int1e_r')
+                r = numpy.array([_block_diag(x) for x in r])
+                c1 = 0.5/lib.param.LIGHT_SPEED
+                prp = xmol.intor_symmetric('int1e_sprsp').reshape(3,4,nao,nao)
+                prp = numpy.array([_sigma_dot(x*c1**2) for x in prp])
+                ao_dip = self.with_x2c.picture_change((r, prp))
+            else:
+                r = mol.intor_symmetric('int1e_r')
+                ao_dip = numpy.array([_block_diag(x) for x in r])
 
-        mol_dip = -numpy.einsum('xij,ji->x', ao_dip, dm).real
+        el_dip = numpy.einsum('xij,ji->x', ao_dip, dm).real
+        mol_dip = nucl_dip - el_dip
 
         if unit.upper() == 'DEBYE':
             mol_dip *= nist.AU2DEBYE
@@ -810,8 +815,7 @@ class X2C1E_GSCF(_X2C_SCF):
 
 def _uncontract_mol(mol, xuncontract=None, exp_drop=0.2):
     '''mol._basis + uncontracted steep functions'''
-    pmol, contr_coeff = mol.decontract_basis(atoms=xuncontract)
-    contr_coeff = scipy.linalg.block_diag(*contr_coeff)
+    pmol, contr_coeff = mol.decontract_basis(atoms=xuncontract, aggregate=True)
     return pmol, contr_coeff
 
 
@@ -953,7 +957,7 @@ def _x2c1e_get_hcore(t, v, w, s, c):
 
     w, u = numpy.linalg.eigh(reduce(numpy.dot, (cl.T.conj(), s, cl)))
     idx = w > 1e-14
-    # Adopt (2) here becuase X is not appeared in Eq (2).
+    # Adopt (2) here because X is not appeared in Eq (2).
     # R[A] = u w^{1/2} u^+,  so R[A]^{-1} A^+ S in Eq (2) is
     r = reduce(numpy.dot, (u[:,idx]/numpy.sqrt(w[idx]), u[:,idx].T.conj(),
                            cl.T.conj(), s))

{pyscf-2.6.2.dist-info → pyscf-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyscf
-Version: 2.6.2
+Version: 2.7.0
 Summary: PySCF: Python-based Simulations of Chemistry Framework
 Author-email: Qiming Sun <osirpt.sun@gmail.com>
 Maintainer-email: Qiming Sun <osirpt.sun@gmail.com>
@@ -28,44 +28,44 @@ Classifier: Operating System :: MacOS
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: numpy !=1.16,!=1.17,>=1.13
-Requires-Dist: scipy !=1.5.0,!=1.5.1
-Requires-Dist: h5py >=2.7
+Requires-Dist: numpy!=1.16,!=1.17,>=1.13
+Requires-Dist: scipy>=1.6.0
+Requires-Dist: h5py>=2.7
 Requires-Dist: setuptools
 Provides-Extra: all
-Requires-Dist: pyscf[bse,cppe,dispersion,doci,forge,geomopt,properties,pyqmc,semiempirical] ; extra == 'all'
+Requires-Dist: pyscf[bse,cppe,dispersion,doci,forge,geomopt,properties,pyqmc,semiempirical]; extra == "all"
 Provides-Extra: bse
-Requires-Dist: basis-set-exchange ; extra == 'bse'
+Requires-Dist: basis-set-exchange; extra == "bse"
 Provides-Extra: cornell_shci
-Requires-Dist: pyscf-cornell-shci ; extra == 'cornell_shci'
+Requires-Dist: pyscf-cornell-shci; extra == "cornell-shci"
 Provides-Extra: cppe
-Requires-Dist: cppe ; extra == 'cppe'
+Requires-Dist: cppe; extra == "cppe"
 Provides-Extra: dispersion
-Requires-Dist: pyscf-dispersion ; extra == 'dispersion'
+Requires-Dist: pyscf-dispersion; extra == "dispersion"
 Provides-Extra: doci
-Requires-Dist: pyscf-doci ; extra == 'doci'
+Requires-Dist: pyscf-doci; extra == "doci"
 Provides-Extra: fciqmcscf
-Requires-Dist: pyscf-fciqmc ; extra == 'fciqmcscf'
+Requires-Dist: pyscf-fciqmc; extra == "fciqmcscf"
 Provides-Extra: forge
-Requires-Dist: pyscf-forge ; extra == 'forge'
+Requires-Dist: pyscf-forge; extra == "forge"
 Provides-Extra: geomopt
-Requires-Dist: pyberny >=0.6.2 ; extra == 'geomopt'
-Requires-Dist: geometric >=0.9.7.2 ; extra == 'geomopt'
-Requires-Dist: pyscf-qsdopt ; extra == 'geomopt'
+Requires-Dist: pyberny>=0.6.2; extra == "geomopt"
+Requires-Dist: geometric>=0.9.7.2; extra == "geomopt"
+Requires-Dist: pyscf-qsdopt; extra == "geomopt"
 Provides-Extra: icmpspt
-Requires-Dist: pyscf-icmpspt ; extra == 'icmpspt'
+Requires-Dist: pyscf-icmpspt; extra == "icmpspt"
 Provides-Extra: nao
-Requires-Dist: pyscf-nao ; extra == 'nao'
+Requires-Dist: pyscf-nao; extra == "nao"
 Provides-Extra: properties
-Requires-Dist: pyscf-properties ; extra == 'properties'
+Requires-Dist: pyscf-properties; extra == "properties"
 Provides-Extra: pyqmc
-Requires-Dist: pyqmc ; extra == 'pyqmc'
+Requires-Dist: pyqmc; extra == "pyqmc"
 Provides-Extra: semiempirical
-Requires-Dist: pyscf-semiempirical ; extra == 'semiempirical'
+Requires-Dist: pyscf-semiempirical; extra == "semiempirical"
 Provides-Extra: shciscf
-Requires-Dist: pyscf-shciscf ; extra == 'shciscf'
+Requires-Dist: pyscf-shciscf; extra == "shciscf"
 Provides-Extra: tblis
-Requires-Dist: pyscf-tblis ; extra == 'tblis'
+Requires-Dist: pyscf-tblis; extra == "tblis"
 
 <div align="left">
   <img src="https://github.com/pyscf/pyscf-doc/blob/master/logo/pyscf-logo.png" height="80px"/>
@@ -76,9 +76,9 @@ Python-based Simulations of Chemistry Framework
 [![Build Status](https://github.com/pyscf/pyscf/workflows/CI/badge.svg)](https://github.com/pyscf/pyscf/actions?query=workflow%3ACI)
 [![codecov](https://codecov.io/gh/pyscf/pyscf/branch/master/graph/badge.svg)](https://codecov.io/gh/pyscf/pyscf)
 
-2024-06-19
+2024-09-23
 
-* [Stable release 2.6.2](https://github.com/pyscf/pyscf/releases/tag/v2.6.2)
+* [Stable release 2.7.0](https://github.com/pyscf/pyscf/releases/tag/v2.7.0)
 * [Changelog](../master/CHANGELOG)
 * [Documentation](http://www.pyscf.org)
 * [Installation](#installation)

{pyscf-2.6.2.dist-info → pyscf-2.7.0.dist-info}/NOTICE

@@ -1,4 +1,4 @@
-Copyright 2014-2021 The PySCF Developers.
+Copyright 2014-2024 The PySCF Developers.
 PySCF (www.pyscf.org) was developed by:
 
 Qiming Sun
@@ -110,6 +110,8 @@ Christopher Hillenbrand
 scohenjanes5
 Michal Krompiec
 Victor Yu
+James Serna (The Ohio State University)
+Brian Zhao
 
 
 ---