pyscf 2.11.0__py3-none-macosx_11_0_arm64.whl → 2.12.1__py3-none-macosx_11_0_arm64.whl

pyscf/__init__.py

@@ -35,7 +35,7 @@ to try out the package::
 
 '''
 
-__version__ = '2.11.0'
+__version__ = '2.12.1'
 
 import os
 import sys

pyscf/adc/__init__.py

@@ -31,14 +31,14 @@ from pyscf.adc import uadc_amplitudes
 from pyscf.adc import radc_ip
 from pyscf.adc import radc_ip_cvs
 from pyscf.adc import radc_ea
+from pyscf.adc import radc_ee
 from pyscf.adc import uadc_ip
 from pyscf.adc import uadc_ip_cvs
 from pyscf.adc import uadc_ea
+from pyscf.adc import uadc_ee
 
 
 def ADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    if not (frozen is None or frozen == 0):
-        raise NotImplementedError
 
     if mf.istype('UHF'):
         return UADC(mf, frozen, mo_coeff, mo_occ)
@@ -54,8 +54,6 @@ ADC.__doc__ = uadc.UADC.__doc__
 
 
 def UADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    if not (frozen is None or frozen == 0):
-        raise NotImplementedError
 
     if not (mf.istype('UHF') or mf.istype('ROHF')):
         mf = mf.to_uhf()
@@ -65,8 +63,6 @@ def UADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
 UADC.__doc__ = uadc.UADC.__doc__
 
 def RADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    if not (frozen is None or frozen == 0):
-        raise NotImplementedError
 
     mf = mf.remove_soscf()
     if not mf.istype('RHF'):

pyscf/adc/radc.py

@@ -16,6 +16,7 @@
 #         Samragni Banerjee <samragnibanerjee4@gmail.com>
 #         James Serna <jamcar456@gmail.com>
 #         Terrence Stahl <terrencestahl1@gmail.com>
+#         Ning-Yuan Chen <cny003@outlook.com>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -29,6 +30,8 @@ from pyscf.adc import radc_ao2mo
 from pyscf.adc import radc_amplitudes
 from pyscf import __config__
 from pyscf import df
+from pyscf.mp import mp2
+from pyscf.data.nist import HARTREE2EV
 
 
 # Excited-state kernel
@@ -64,7 +67,14 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
     imds = adc.get_imds(eris)
     matvec, diag = adc.gen_matvec(imds, eris)
 
-    guess = adc.get_init_guess(nroots, diag, ascending = True)
+    if guess is None:
+        guess = adc.get_init_guess(nroots, diag, ascending = True)
+    elif isinstance(guess, str) and guess == "cis" and adc.method_type == "ee":
+        guess = adc.get_init_guess(nroots, diag, ascending = True, type = "cis", eris = eris)
+    elif hasattr(guess, '__len__'):
+        guess = adc.get_init_guess(nroots, diag, ascending = True, type = "read", ini = guess)
+    else:
+        raise NotImplementedError("Guess type not implemented")
 
     conv, adc.E, U = lib.linalg_helper.davidson_nosym1(
         lambda xs : [matvec(x) for x in xs],
@@ -73,7 +83,7 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
 
     adc.U = np.array(U).T.copy()
 
-    if adc.compute_properties and adc.method_type != "ee":
+    if adc.compute_properties:
         adc.P,adc.X = adc.get_properties(nroots)
     else:
         adc.P = None
@@ -94,9 +104,12 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
 
     for n in range(nroots):
         print_string = ('%s root %d  |  Energy (Eh) = %14.10f  |  Energy (eV) = %12.8f  ' %
-                        (adc.method, n, adc.E[n], adc.E[n]*27.2114))
+                        (adc.method, n, adc.E[n], adc.E[n]*HARTREE2EV))
         if adc.compute_properties and adc.method_type != "ee":
             print_string += ("|  Spec. factor = %10.8f  " % adc.P[n])
+
+        if adc.compute_properties and adc.method_type == "ee":
+            print_string += ("|  Osc. strength = %10.8f  " % adc.P[n])
         print_string += ("|  conv = %s" % conv[n])
         logger.info(adc, print_string)
 
@@ -108,14 +121,13 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
     return adc.E, adc.U, adc.P, adc.X
 
 
-def make_ref_rdm1(adc):
+def make_ref_rdm1(adc, with_frozen=True, ao_repr=False):
 
     if adc.method not in ("adc(2)", "adc(2)-x", "adc(3)"):
         raise NotImplementedError(adc.method)
 
     t1 = adc.t1
     t2 = adc.t2
-    t2_ce = t1[0][:]
     t1_ccee = t2[0][:]
 
     ######################
@@ -123,6 +135,11 @@ def make_ref_rdm1(adc):
     nocc = adc._nocc
     nvir = adc._nvir
 
+    if t1[0] is not None:
+        t2_ce = t1[0][:]
+    else:
+        t2_ce = np.zeros((nocc, nvir))
+
     nmo = nocc + nvir
 
     OPDM = np.zeros((nmo,nmo))
@@ -145,9 +162,13 @@ def make_ref_rdm1(adc):
 
     ####### ADC(3) SPIN ADAPTED REF OPDM WITH SQA ################
     if adc.method == "adc(3)":
-        t3_ce = adc.t1[1][:]
         t2_ccee = t2[1][:]
 
+        if t1[1] is not None:
+            t3_ce = t1[1][:]
+        else:
+            t3_ce = np.zeros((nocc, nvir))
+
         #### OCC-OCC ###
         OPDM[:nocc, :nocc] -= 2 * lib.einsum('Iiab,Jiab->IJ',
                                              t1_ccee, t2_ccee, optimize = einsum_type)
@@ -167,7 +188,7 @@ def make_ref_rdm1(adc):
         OPDM[nocc:, :nocc]  -= 1/2 * \
             lib.einsum('iIAa,ia->AI', t1_ccee, t2_ce, optimize = einsum_type)
 
-        ##### VIR=VIR ###
+        ##### VIR-VIR ###
         OPDM[nocc:, nocc:] += 2 * lib.einsum('ijAa,ijBa->AB',
                                              t1_ccee, t2_ccee, optimize = einsum_type)
         OPDM[nocc:, nocc:] -= lib.einsum('ijAa,jiBa->AB', t1_ccee, t2_ccee, optimize = einsum_type)
@@ -175,9 +196,39 @@ def make_ref_rdm1(adc):
                                              t1_ccee, t2_ccee, optimize = einsum_type)
         OPDM[nocc:, nocc:] -= lib.einsum('ijBa,jiAa->AB', t1_ccee, t2_ccee, optimize = einsum_type)
 
+    if with_frozen and adc.frozen is not None:
+        nmo = adc.mo_occ.size
+        nocc = np.count_nonzero(adc.mo_occ > 0)
+        dm = np.zeros((nmo,nmo))
+        dm[np.diag_indices(nocc)] = 1
+        moidx = np.where(adc.get_frozen_mask())[0]
+        dm[moidx[:,None],moidx] = OPDM
+        OPDM = dm
+        if ao_repr:
+            mo = adc.mo_coeff_hf
+            OPDM = lib.einsum('pi,ij,qj->pq', mo, OPDM, mo)
+
+    elif ao_repr:
+        mo = adc.mo_coeff
+        OPDM = lib.einsum('pi,ij,qj->pq', mo, OPDM, mo)
+
     return 2 * OPDM
 
 
+def get_frozen_mask(adc):
+
+    moidx = np.ones(adc.mo_occ.size, dtype=bool)
+    if adc.frozen is None:
+        pass
+    elif isinstance(adc.frozen, (int, np.integer)):
+        moidx[:adc.frozen] = False
+    elif hasattr(adc.frozen, '__len__'):
+        moidx[list(adc.frozen)] = False
+    else:
+        raise NotImplementedError
+    return moidx
+
+
 class RADC(lib.StreamObject):
     '''Ground state calculations
 
@@ -211,14 +262,14 @@ class RADC(lib.StreamObject):
 
     _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method', 'method_type', 'mo_coeff',
-        'mol', 'mo_energy', 'incore_complete',
+        'mo_coeff_hf', 'mol', 'mo_energy', 'incore_complete',
         'scf_energy', 'e_tot', 't1', 't2', 'frozen', 'chkfile',
         'max_space', 'mo_occ', 'max_cycle', 'imds', 'with_df', 'compute_properties',
         'approx_trans_moments', 'evec_print_tol', 'spec_factor_print_tol',
-        'E', 'U', 'P', 'X', 'ncvs', 'dip_mom', 'dip_mom_nuc'
+        'E', 'U', 'P', 'X', 'ncvs', 'dip_mom', 'dip_mom_nuc', 'if_heri_eris'
     }
 
-    def __init__(self, mf, frozen=0, mo_coeff=None, mo_occ=None):
+    def __init__(self, mf, frozen=None, mo_coeff=None, mo_occ=None):
 
         if 'dft' in str(mf.__module__):
             raise NotImplementedError('DFT reference for UADC')
@@ -243,16 +294,45 @@ class RADC(lib.StreamObject):
         self.frozen = frozen
         self.incore_complete = self.incore_complete or self.mol.incore_anyway
 
-        self.mo_coeff = mo_coeff
         self.mo_occ = mo_occ
         self.e_corr = None
         self.t1 = None
         self.t2 = None
         self.imds = lambda:None
         self._nocc = mf.mol.nelectron//2
-        self._nmo = mo_coeff.shape[1]
-        self._nvir = self._nmo - self._nocc
+        self.mo_coeff = mo_coeff
+        self.mo_coeff_hf = mo_coeff
         self.mo_energy = mf.mo_energy
+        self.if_heri_eris = False
+        self._nmo = None
+        mask = self.get_frozen_mask()
+        if frozen is None:
+            self._nmo = mo_coeff.shape[1]
+        elif isinstance(frozen, (int, np.integer)):
+            self._nmo = mo_coeff.shape[1]-frozen
+        elif hasattr(frozen, '__len__'):
+            self._nmo = mo_coeff.shape[1]-len(frozen)
+        else:
+            raise NotImplementedError
+        if frozen is not None:
+            maskocc = mf.mo_occ>1e-6
+            occ = maskocc & mask
+            self._nocc = int(occ.sum())
+            self.mo_coeff = mo_coeff[:,mask]
+            if self._nocc == 0:
+                raise ValueError("No occupied orbitals found")
+            if mo_coeff is self._scf.mo_coeff and self._scf.converged:
+                self.mo_energy = self.mo_energy[mask]
+            else:
+                dm = self._scf.make_rdm1(mo_coeff, self.mo_occ)
+                vhf = self._scf.get_veff(self.mol, dm)
+                fockao = self._scf.get_fock(vhf=vhf, dm=dm)
+                fock = self.mo_coeff.conj().T.dot(fockao).dot(self.mo_coeff)
+                self.mo_energy = fock.diagonal().real
+                self.scf_energy = self._scf.energy_tot(dm=dm, vhf=vhf)
+        self._nvir = self._nmo - self._nocc
+        if self._nvir == 0:
+            raise ValueError("No virtual orbitals found")
         self.chkfile = mf.chkfile
         self.method = "adc(2)"
         self.method_type = "ip"
@@ -273,7 +353,7 @@ class RADC(lib.StreamObject):
 
         for i in range(dip_ints.shape[0]):
             dip = dip_ints[i,:,:]
-            dip_mom[i,:,:] = np.dot(mo_coeff.T, np.dot(dip, mo_coeff))
+            dip_mom[i,:,:] = np.dot(self.mo_coeff.T, np.dot(dip, self.mo_coeff))
 
         self.dip_mom = dip_mom
 
@@ -285,6 +365,7 @@ class RADC(lib.StreamObject):
     compute_energy = radc_amplitudes.compute_energy
     transform_integrals = radc_ao2mo.transform_integrals_incore
     make_ref_rdm1 = make_ref_rdm1
+    get_frozen_mask = get_frozen_mask
 
     def dump_flags(self, verbose=None):
         logger.info(self, '')
@@ -321,6 +402,17 @@ class RADC(lib.StreamObject):
         nao_pair = nao * (nao+1) // 2
         mem_incore = (max(nao_pair**2, nmo**4) + nmo_pair**2) * 8/1e6
         mem_now = lib.current_memory()[0]
+        nocc_fr = self._scf.mol.nelectron//2 - self._nocc
+        nvir_fr = self._scf.mo_coeff.shape[1] - self._nmo - nocc_fr
+
+        logger.info(self, '******** ADC Orbital Information ********')
+        logger.info(self, 'Number of Frozen Occupied Orbitals: %d', nocc_fr)
+        logger.info(self, 'Number of Frozen Virtual Orbitals: %d', nvir_fr)
+        logger.info(self, 'Number of Active Occupied Orbitals: %d', self._nocc)
+        logger.info(self, 'Number of Active Virtual Orbitals: %d', self._nvir)
+        if hasattr(self.frozen, '__len__'):
+            logger.info(self, 'Frozen Orbital List: %s', self.frozen)
+        logger.info(self, '*****************************************')
 
         if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None):
             if getattr(self, 'with_df', None):
@@ -363,23 +455,35 @@ class RADC(lib.StreamObject):
         nao_pair = nao * (nao+1) // 2
         mem_incore = (max(nao_pair**2, nmo**4) + nmo_pair**2) * 8/1e6
         mem_now = lib.current_memory()[0]
-
-        if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None):
-            if getattr(self, 'with_df', None):
-                self.with_df = self.with_df
-            else:
-                self.with_df = self._scf.with_df
-
-            def df_transform():
-                return radc_ao2mo.transform_integrals_df(self)
-            self.transform_integrals = df_transform
-        elif (self._scf._eri is None or
-              (mem_incore+mem_now >= self.max_memory and not self.incore_complete)):
-            def outcore_transform():
-                return radc_ao2mo.transform_integrals_outcore(self)
-            self.transform_integrals = outcore_transform
-
-        eris = self.transform_integrals()
+        nocc_fr = self._scf.mol.nelectron//2 - self._nocc
+        nvir_fr = self._scf.mo_coeff.shape[1] - self._nmo - nocc_fr
+
+        logger.info(self, '******** ADC Orbital Information ********')
+        logger.info(self, 'Number of Frozen Occupied Orbitals: %d', nocc_fr)
+        logger.info(self, 'Number of Frozen Virtual Orbitals: %d', nvir_fr)
+        logger.info(self, 'Number of Active Occupied Orbitals: %d', self._nocc)
+        logger.info(self, 'Number of Active Virtual Orbitals: %d', self._nvir)
+        if hasattr(self.frozen, '__len__'):
+            logger.info(self, 'Frozen Orbital List: %s', self.frozen)
+        logger.info(self, '*****************************************')
+
+        if eris is None:
+            if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None):
+                if getattr(self, 'with_df', None):
+                    self.with_df = self.with_df
+                else:
+                    self.with_df = self._scf.with_df
+
+                def df_transform():
+                    return radc_ao2mo.transform_integrals_df(self)
+                self.transform_integrals = df_transform
+            elif (self._scf._eri is None or
+                    (mem_incore+mem_now >= self.max_memory and not self.incore_complete)):
+                def outcore_transform():
+                    return radc_ao2mo.transform_integrals_outcore(self)
+                self.transform_integrals = outcore_transform
+
+            eris = self.transform_integrals()
 
         self.e_corr, self.t1, self.t2 = radc_amplitudes.compute_amplitudes_energy(
             self, eris=eris, verbose=self.verbose)
@@ -402,7 +506,10 @@ class RADC(lib.StreamObject):
         else:
             raise NotImplementedError(self.method_type)
         self._adc_es = adc_es
-        return e_exc, v_exc, spec_fac, x
+        if self.if_heri_eris:
+            return e_exc, v_exc, spec_fac, x, eris
+        else:
+            return e_exc, v_exc, spec_fac, x
 
     def _finalize(self):
         '''Hook for dumping results and clearing up the object.'''
@@ -454,8 +561,32 @@ class RADC(lib.StreamObject):
     def compute_dyson_mo(self):
         return self._adc_es.compute_dyson_mo()
 
-    def make_rdm1(self):
-        return self._adc_es.make_rdm1()
+    def make_rdm1(self, with_frozen=True, ao_repr=False):
+        list_rdm1 = self._adc_es._make_rdm1()
+
+        if with_frozen and self.frozen is not None:
+            nmo = self.mo_occ.size
+            nocc = np.count_nonzero(self.mo_occ > 0)
+            moidx = np.where(self.get_frozen_mask())[0]
+            for i in range(self._adc_es.U.shape[1]):
+                rdm1 = list_rdm1[i]
+                dm = np.zeros((nmo,nmo))
+                dm[np.diag_indices(nocc)] = 2
+                dm[moidx[:,None],moidx] = rdm1
+                rdm1 = dm
+                if ao_repr:
+                    mo = self.mo_coeff_hf
+                    rdm1 = lib.einsum('pi,ij,qj->pq', mo, rdm1, mo)
+                list_rdm1[i] = rdm1
+
+        elif ao_repr:
+            mo = self.mo_coeff
+            for i in range(self._adc_es.U.shape[1]):
+                rdm1 = list_rdm1[i]
+                rdm1 = lib.einsum('pi,ij,qj->pq', mo, rdm1, mo)
+                list_rdm1[i] = rdm1
+
+        return list_rdm1
 
 
 if __name__ == '__main__':

pyscf/adc/radc_amplitudes.py

@@ -117,7 +117,9 @@ def compute_amplitudes(myadc, eris):
     t1_3 = None
     t2_1_vvvv = None
 
-    if (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False) or (myadc.method == "adc(3)"):
+    if ((myadc.method == "adc(2)" and myadc.method_type == "ee" and myadc.approx_trans_moments is False)
+        or (myadc.method =="adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(3)")):
 
         # Compute second-order doubles t2 (tijab)
 

pyscf/adc/radc_ao2mo.py

@@ -44,11 +44,12 @@ def transform_integrals_incore(myadc):
     eris.ovvv = ao2mo.general(myadc._scf._eri, (occ, vir, vir, vir), compact=True).reshape(nocc, nvir, -1).copy()  # noqa: E501
     eris.vvvv = None
 
-    if ((myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
-        or (myadc.method == "adc(2)-x" and myadc.method_type == "ee")
+    if ((myadc.method == "adc(2)" and myadc.method_type == "ee" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is True and myadc.method_type in ("ea","ee"))
         or (myadc.method == "adc(3)")):
         eris.vvvv = ao2mo.general(myadc._scf._eri, (vir, vir, vir, vir),
-                                  compact=False).reshape(nvir, nvir, nvir, nvir)
+                                compact=False).reshape(nvir, nvir, nvir, nvir)
         eris.vvvv = np.ascontiguousarray(eris.vvvv.transpose(0,2,1,3))
         eris.vvvv = eris.vvvv.reshape(nvir*nvir, nvir*nvir)
 
@@ -155,8 +156,9 @@ def transform_integrals_outcore(myadc):
 
     ############### forming eris_vvvv ########################################
 
-    if ((myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
-        or (myadc.method == "adc(2)-x" and myadc.method_type == "ee")
+    if ((myadc.method == "adc(2)" and myadc.method_type == "ee" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is True and myadc.method_type in ("ea","ee"))
         or (myadc.method == "adc(3)")):
 
         eris.vvvv = []
@@ -177,7 +179,7 @@ def transform_integrals_outcore(myadc):
 
             with lib.H5TmpFile() as tmpf:
                 ao2mo.outcore.general(mol, (orb_slice, vir, vir, vir), tmpf,
-                                      max_memory=avail_mem, ioblk_size=100, compact=False)
+                                    max_memory=avail_mem, ioblk_size=100, compact=False)
                 vvvv = tmpf['eri_mo'][:]
             vvvv = vvvv.reshape(orb_slice.shape[1], vir.shape[1], vir.shape[1], vir.shape[1])
             vvvv = np.ascontiguousarray(vvvv.transpose(0,2,1,3)).reshape(-1, nvir, nvir * nvir)

pyscf/adc/radc_ea.py

@@ -16,6 +16,7 @@
 #         Samragni Banerjee <samragnibanerjee4@gmail.com>
 #         James Serna <jamcar456@gmail.com>
 #         Terrence Stahl <>
+#         Ning-Yuan Chen <cny003@outlook.com>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 
 '''
@@ -28,6 +29,7 @@ from pyscf.adc import radc
 from pyscf.adc import radc_ao2mo
 from pyscf.adc import dfadc
 from pyscf import symm
+from pyscf.data.nist import HARTREE2EV
 
 
 def get_imds(adc, eris=None):
@@ -785,7 +787,7 @@ def analyze_eigenvector(adc):
             iter_num += 1
 
         logger.info(adc, '%s | root %d | Energy (eV) = %12.8f | norm(1p)  = %6.4f | norm(1h2p) = %6.4f ',
-                    adc.method, I, adc.E[I]*27.2114, U1dotU1, U2dotU2)
+                    adc.method, I, adc.E[I]*HARTREE2EV, U1dotU1, U2dotU2)
 
         if singles_val:
             logger.info(adc, "\n1p block: ")
@@ -835,7 +837,7 @@ def analyze_spec_factor(adc):
             continue
 
         logger.info(adc, '%s | root %d | Energy (eV) = %12.8f \n',
-                adc.method, i, adc.E[i]*27.2114)
+                adc.method, i, adc.E[i]*HARTREE2EV)
         logger.info(adc, "     HF MO     Spec. Contribution     Orbital symmetry")
         logger.info(adc, "-----------------------------------------------------------")
 
@@ -923,7 +925,6 @@ def make_rdm1_eigenvectors(adc, L, R):
     R = np.array(R).ravel()
 
     t1_ccee = adc.t2[0][:]
-    t2_ce = adc.t1[0][:]
 
     nocc = adc._nocc
     nvir = adc._nvir
@@ -931,13 +932,19 @@ def make_rdm1_eigenvectors(adc, L, R):
     n_singles = nvir
     n_doubles = nvir * nvir * nocc
 
+    if adc.t1[0] is not None:
+        t2_ce = adc.t1[0]
+    else:
+        t2_ce = np.zeros((nocc, nvir))
+
+    occ_list = range(nocc)
+
     s1 = 0
     f1 = n_singles
     s2 = f1
     f2 = s2 + n_doubles
 
     rdm1  = np.zeros((nmo,nmo))
-    kd_oc = np.identity(nocc)
 
     L1 = L[s1:f1]
     L2 = L[s2:f2]
@@ -952,13 +959,13 @@ def make_rdm1_eigenvectors(adc, L, R):
 
 ############# block- ij
     ### 000 ###
-    rdm1[:nocc, :nocc] += 2 * einsum('a,a,IJ->IJ', L1, R1, kd_oc, optimize = einsum_type)
+    rdm1[occ_list, occ_list] += 2 * einsum('a,a->', L1, R1, optimize = einsum_type)
 
     ### 101 ###
     rdm1[:nocc, :nocc] -= 2 * einsum('Jab,Iab->IJ', L2, R2, optimize = einsum_type)
     rdm1[:nocc, :nocc] += 1 * einsum('Jab,Iba->IJ', L2, R2, optimize = einsum_type)
-    rdm1[:nocc, :nocc] += 4 * einsum('iab,iab,IJ->IJ', L2, R2, kd_oc, optimize = einsum_type)
-    rdm1[:nocc, :nocc] -= 2 * einsum('iab,iba,IJ->IJ', L2, R2, kd_oc, optimize = einsum_type)
+    rdm1[occ_list, occ_list] += 4 * einsum('iab,iab->', L2, R2, optimize = einsum_type)
+    rdm1[occ_list, occ_list] -= 2 * einsum('iab,iba->', L2, R2, optimize = einsum_type)
 
     ### 020 ###
     rdm1[:nocc, :nocc] -= 2 * einsum('a,a,Iibc,Jibc->IJ', L1, R1,
@@ -1038,11 +1045,15 @@ def make_rdm1_eigenvectors(adc, L, R):
 
     ####### ADC(3) SPIN ADAPTED EXCITED STATE OPDM WITH SQA ################
     if adc.method == "adc(3)":
-        ### Redudant Variables used for names from SQA
+        ### Redundant Variables used for names from SQA
         einsum_type = True
-        t3_ce = adc.t1[1][:]
         t2_ccee = adc.t2[1][:]
 
+        if adc.t1[1] is not None:
+            t3_ce = adc.t1[1]
+        else:
+            t3_ce = np.zeros((nocc, nvir))
+
 ############# block- ij
         # 120 #
         rdm1[:nocc, :nocc] -= 2 * einsum('Jab,a,Ib->IJ', L2, R1, t2_ce, optimize = einsum_type)
@@ -1468,10 +1479,11 @@ class RADCEA(radc.RADC):
 
     _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method', 'mo_coeff',
-        'mo_energy', 't1', 'max_space', 't2', 'max_cycle',
+        'mo_coeff_hf', 'mo_energy', 't1', 'max_space', 't2', 'max_cycle',
         'nmo', 'transform_integrals', 'with_df', 'compute_properties',
         'approx_trans_moments', 'E', 'U', 'P', 'X',
         'evec_print_tol', 'spec_factor_print_tol',
+        '_make_rdm1', 'frozen', 'mo_occ'
     }
 
     def __init__(self, adc):
@@ -1494,12 +1506,15 @@ class RADCEA(radc.RADC):
         self._nvir = adc._nvir
         self._nmo = adc._nmo
         self.mo_coeff = adc.mo_coeff
+        self.mo_coeff_hf = adc.mo_coeff_hf
         self.mo_energy = adc.mo_energy
         self.nmo = adc._nmo
         self.transform_integrals = adc.transform_integrals
         self.with_df = adc.with_df
         self.compute_properties = adc.compute_properties
         self.approx_trans_moments = adc.approx_trans_moments
+        self.frozen = adc.frozen
+        self.mo_occ = adc.mo_occ
 
         self.evec_print_tol = adc.evec_print_tol
         self.spec_factor_print_tol = adc.spec_factor_print_tol
@@ -1509,6 +1524,8 @@ class RADCEA(radc.RADC):
         self.P = adc.P
         self.X = adc.X
 
+        self._adc_es = self
+
     kernel = radc.kernel
     get_imds = get_imds
     matvec = matvec
@@ -1521,21 +1538,36 @@ class RADCEA(radc.RADC):
     analyze_spec_factor = analyze_spec_factor
     analyze_eigenvector = analyze_eigenvector
     compute_dyson_mo = compute_dyson_mo
-    make_rdm1 = make_rdm1
-
-    def get_init_guess(self, nroots=1, diag=None, ascending=True):
-        if diag is None :
-            diag = self.get_diag()
-        idx = None
-        if ascending:
-            idx = np.argsort(diag)
+    _make_rdm1 = make_rdm1
+
+    def get_init_guess(self, nroots=1, diag=None, ascending=True, type=None, ini=None):
+        if (type=="read"):
+            logger.info(self, "obtain initial guess from input variable")
+            ncore = self._nocc
+            nextern = self._nvir
+            n_singles = nextern
+            n_doubles = ncore * nextern * nextern
+            dim = n_singles + n_doubles
+            if isinstance(ini, list):
+                g = np.array(ini)
+            else:
+                g = ini
+            if g.shape[0] != dim or g.shape[1] != nroots:
+                raise ValueError(f"Shape of guess should be ({dim},{nroots})")
+
         else:
-            idx = np.argsort(diag)[::-1]
-        guess = np.zeros((diag.shape[0], nroots))
-        min_shape = min(diag.shape[0], nroots)
-        guess[:min_shape,:min_shape] = np.identity(min_shape)
-        g = np.zeros((diag.shape[0], nroots))
-        g[idx] = guess.copy()
+            if diag is None :
+                diag = self.get_diag()
+            idx = None
+            if ascending:
+                idx = np.argsort(diag)
+            else:
+                idx = np.argsort(diag)[::-1]
+            guess = np.zeros((diag.shape[0], nroots))
+            min_shape = min(diag.shape[0], nroots)
+            guess[:min_shape,:min_shape] = np.identity(min_shape)
+            g = np.zeros((diag.shape[0], nroots))
+            g[idx] = guess.copy()
         guess = []
         for p in range(g.shape[1]):
             guess.append(g[:,p])