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

pyscf/adc/uadc.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Samragni Banerjee <samragnibanerjee4@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
-#
 
 '''
 Unrestricted algebraic diagrammatic construction
@@ -29,6 +31,7 @@ from pyscf.adc import radc_ao2mo
 from pyscf.adc import dfadc
 from pyscf import __config__
 from pyscf import df
+from pyscf import scf
 
 
 # Excited-state kernel
@@ -44,13 +47,17 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
         adc.check_sanity()
     adc.dump_flags()
 
+    if isinstance(adc._scf, scf.rohf.ROHF) and (adc.method_type == "ip" or adc.method_type == "ea"):
+        logger.warn(
+            adc, "EA/IP-ADC with the ROHF reference do not incorporate the occ-vir Fock matrix elements...")
+
     if eris is None:
         eris = adc.transform_integrals()
 
     imds = adc.get_imds(eris)
     matvec, diag = adc.gen_matvec(imds, eris)
 
-    guess = adc.get_init_guess(nroots, diag, ascending=True)
+    guess = adc.get_init_guess(nroots, diag, ascending = True)
 
     conv, adc.E, U = lib.linalg_helper.davidson1(
         lambda xs : [matvec(x) for x in xs],
@@ -61,7 +68,6 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
 
     if adc.compute_properties:
         adc.P,adc.X = adc.get_properties(nroots)
-
     nfalse = np.shape(conv)[0] - np.sum(conv)
 
     header = ("\n*************************************************************"
@@ -69,17 +75,17 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
               "\n*************************************************************")
     logger.info(adc, header)
 
-    if nfalse >= 1:
-        logger.warn(adc, "Davidson iterations for " + str(nfalse) + " root(s) not converged\n")
-
     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))
         if adc.compute_properties:
-            print_string += ("|  Spec factors = %10.8f  " % adc.P[n])
+            print_string += ("|  Spec. factor = %10.8f  " % adc.P[n])
         print_string += ("|  conv = %s" % conv[n])
         logger.info(adc, print_string)
 
+    if nfalse >= 1:
+        logger.warn(adc, "Davidson iterations for " + str(nfalse) + " root(s) did not converge!!!")
+
     log.timer('ADC', *cput0)
 
     return adc.E, adc.U, adc.P, adc.X
@@ -114,14 +120,13 @@ class UADC(lib.StreamObject):
     incore_complete = getattr(__config__, 'adc_uadc_UADC_incore_complete', False)
 
     _keys = {
-        'tol_residual','conv_tol', 'e_corr', 'method',
-        'method_type', 'mo_coeff', 'mol', 'mo_energy_b',
-        'scf_energy', 'e_tot', 't1', 'frozen',
-        'mo_energy_a', 'chkfile', 'max_space', 't2', 'mo_occ', 'max_cycle',
-        'incore_complete', 'mo_energy_a', 'mo_energy_b', 'with_df',
-        'compute_mpn_energy', 'compute_spec', 'compute_properties',
+        'tol_residual','conv_tol', 'e_corr', 'method', 'method_type', 'mo_coeff',
+        'mol', 'mo_energy_a', 'mo_energy_b', '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',
+        'E', 'U', 'P', 'X', 'ncvs', 'dip_mom', 'dip_mom_nuc',
+        'spin_c', 'f_ov'
     }
 
     def __init__(self, mf, frozen=None, mo_coeff=None, mo_occ=None):
@@ -144,12 +149,59 @@ class UADC(lib.StreamObject):
         self.max_space = getattr(__config__, 'adc_uadc_UADC_max_space', 12)
         self.max_cycle = getattr(__config__, 'adc_uadc_UADC_max_cycle', 50)
         self.conv_tol = getattr(__config__, 'adc_uadc_UADC_conv_tol', 1e-12)
-        self.tol_residual = getattr(__config__, 'adc_uadc_UADC_tol_res', 1e-6)
-
+        self.tol_residual = getattr(__config__, 'adc_uadc_UADC_tol_residual', 1e-6)
         self.scf_energy = mf.e_tot
+
         self.frozen = frozen
         self.incore_complete = self.incore_complete or self.mol.incore_anyway
 
+        self.f_ov = None
+
+        if isinstance(mf, scf.rohf.ROHF):
+
+            logger.info(mf, "\nROHF reference detected in ADC, semicanonicalizing the orbitals...")
+
+            mo_a = mo_coeff.copy()
+            nalpha = mf.mol.nelec[0]
+            nbeta = mf.mol.nelec[1]
+
+            h1e = mf.get_hcore()
+            dm = mf.make_rdm1()
+            vhf = mf.get_veff(mf.mol, dm)
+
+            fock_a = h1e + vhf[0]
+            fock_b = h1e + vhf[1]
+
+            if nalpha > nbeta:
+                ndocc = nbeta
+                nsocc = nalpha - nbeta
+            else:
+                ndocc = nalpha
+                nsocc = nbeta - nalpha
+
+            fock_a = np.dot(mo_a.T,np.dot(fock_a, mo_a))
+            fock_b = np.dot(mo_a.T,np.dot(fock_b, mo_a))
+
+            # Semicanonicalize Ca using fock_a, nocc_a -> Ca, mo_energy_a, U_a, f_ov_a
+            mo_a, mo_energy_a, f_ov_a, f_aa = self.semi_canonicalize_orbitals(
+                fock_a, ndocc + nsocc, mo_a)
+
+            # Semicanonicalize Cb using fock_b, nocc_b -> Cb, mo_energy_b, U_b, f_ov_b
+            mo_b, mo_energy_b, f_ov_b, f_bb = self.semi_canonicalize_orbitals(fock_b, ndocc, mo_a)
+
+            mo_coeff = [mo_a, mo_b]
+
+            f_ov = [f_ov_a, f_ov_b]
+
+            self.f_ov = f_ov
+            self.spin_c = True
+            self.mo_energy_a = mo_energy_a.copy()
+            self.mo_energy_b = mo_energy_b.copy()
+
+        else:
+            self.mo_energy_a = mf.mo_energy[0]
+            self.mo_energy_b = mf.mo_energy[1]
+
         self.mo_coeff = mo_coeff
         self.mo_occ = mo_occ
         self.e_corr = None
@@ -159,28 +211,66 @@ class UADC(lib.StreamObject):
         self._nocc = mf.nelec
         self._nmo = (mo_coeff[0].shape[1], mo_coeff[1].shape[1])
         self._nvir = (self._nmo[0] - self._nocc[0], self._nmo[1] - self._nocc[1])
-        self.mo_energy_a = mf.mo_energy[0]
-        self.mo_energy_b = mf.mo_energy[1]
         self.chkfile = mf.chkfile
         self.method = "adc(2)"
         self.method_type = "ip"
         self.with_df = None
-        self.compute_mpn_energy = True
-        self.compute_spec = True
         self.compute_properties = True
         self.approx_trans_moments = False
         self.evec_print_tol = 0.1
         self.spec_factor_print_tol = 0.1
+        self.ncvs = None
+
         self.E = None
         self.U = None
         self.P = None
         self.X = (None,)
-        self.ncvs = None
+
+        self.spin_c = False
+
+        dip_ints = -self.mol.intor('int1e_r',comp=3)
+        dip_mom_a = np.zeros((dip_ints.shape[0], self._nmo[0], self._nmo[0]))
+        dip_mom_b = np.zeros((dip_ints.shape[0], self._nmo[1], self._nmo[1]))
+
+        for i in range(dip_ints.shape[0]):
+            dip = dip_ints[i,:,:]
+            dip_mom_a[i,:,:] = np.dot(mo_coeff[0].T, np.dot(dip, mo_coeff[0]))
+            dip_mom_b[i,:,:] = np.dot(mo_coeff[1].T, np.dot(dip, mo_coeff[1]))
+
+        self.dip_mom = []
+        self.dip_mom.append(dip_mom_a)
+        self.dip_mom.append(dip_mom_b)
+
+        charges = self.mol.atom_charges()
+        coords  = self.mol.atom_coords()
+        self.dip_mom_nuc = lib.einsum('i,ix->x', charges, coords)
 
     compute_amplitudes = uadc_amplitudes.compute_amplitudes
     compute_energy = uadc_amplitudes.compute_energy
     transform_integrals = uadc_ao2mo.transform_integrals_incore
 
+    def semi_canonicalize_orbitals(self, f, nocc, C):
+
+        # Diagonalize occ-occ block
+        evals_oo, evecs_oo = np.linalg.eigh(f[:nocc, :nocc])
+
+        # Diagonalize virt-virt block
+        evals_vv, evecs_vv = np.linalg.eigh(f[nocc:, nocc:])
+
+        evals = np.hstack((evals_oo, evals_vv))
+
+        U = np.zeros_like(f)
+
+        U[:nocc, :nocc] = evecs_oo
+        U[nocc:, nocc:] = evecs_vv
+
+        C = np.dot(C, U)
+
+        transform_f = np.dot(U.T, np.dot(f, U))
+        f_ov = transform_f[:nocc, nocc:].copy()
+
+        return C, evals, f_ov, transform_f
+
     def dump_flags(self, verbose=None):
         logger.info(self, '')
         logger.info(self, '******** %s ********', self.__class__)
@@ -200,8 +290,8 @@ class UADC(lib.StreamObject):
         return self
 
     def kernel_gs(self):
-        assert (self.mo_coeff is not None)
-        assert (self.mo_occ is not None)
+        assert(self.mo_coeff is not None)
+        assert(self.mo_occ is not None)
 
         self.method = self.method.lower()
         if self.method not in ("adc(2)", "adc(2)-x", "adc(3)"):
@@ -301,8 +391,8 @@ class UADC(lib.StreamObject):
 
     def _finalize(self):
         '''Hook for dumping results and clearing up the object.'''
-        logger.note(self, 'E_corr = %.8f',
-                    self.e_corr)
+        logger.note(self, 'MP%s correlation energy of reference state (a.u.) = %.8f',
+                    self.method[4], self.e_corr)
         return self
 
     def ea_adc(self, nroots=1, guess=None, eris=None):
@@ -347,7 +437,6 @@ class UADC(lib.StreamObject):
         return self._adc_es.make_rdm1()
 
 if __name__ == '__main__':
-    from pyscf import scf
     from pyscf import gto
     from pyscf import adc
 

pyscf/adc/uadc_amplitudes.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Samragni Banerjee <samragnibanerjee4@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -29,7 +32,7 @@ from pyscf.adc import dfadc
 from pyscf.adc.radc_amplitudes import _create_t2_h5cache
 from pyscf import __config__
 from pyscf import df
-
+from pyscf import scf
 
 def compute_amplitudes_energy(myadc, eris, verbose=None):
 
@@ -126,12 +129,29 @@ def compute_amplitudes(myadc, eris):
 
     cput0 = log.timer_debug1("Completed t2_1 amplitude calculation", *cput0)
 
+    t1_1 = (None,)
+
+    if isinstance(myadc._scf, scf.rohf.ROHF):
+
+        f_ov_a, f_ov_b = myadc.f_ov
+
+        t1_1_a = f_ov_a/D1_a
+        t1_1_b = f_ov_b/D1_b
+        t1_1 = (t1_1_a, t1_1_b)
+    else:
+        f_ov_a = np.zeros((nocc_a, nvir_a))
+        f_ov_b = np.zeros((nocc_b, nvir_b))
+        t1_1_a = np.zeros((nocc_a, nvir_a))
+        t1_1_b = np.zeros((nocc_b, nvir_b))
+
+
     t1_2 = (None,)
     if myadc.approx_trans_moments is False or myadc.method == "adc(3)":
         # Compute second-order singles t1 (tij)
 
         t1_2_a = np.zeros((nocc_a,nvir_a))
         t1_2_b = np.zeros((nocc_b,nvir_b))
+
         if isinstance(eris.ovvv, type(None)):
             chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
             a = 0
@@ -152,6 +172,33 @@ def compute_amplitudes(myadc, eris):
         t1_2_a -= 0.5*lib.einsum('lcki,klac->ia',eris_ovoo,t2_1_a[:],optimize=True)
         t1_2_a += 0.5*lib.einsum('kcli,klac->ia',eris_ovoo,t2_1_a[:],optimize=True)
 
+        if isinstance(myadc._scf, scf.rohf.ROHF):
+            t1_2_a += lib.einsum('d,ld,ilad->ia',e_a[nocc_a:],t1_1_a,t2_1_a[:], optimize = True)
+            t1_2_a += lib.einsum('d,ld,ilad->ia',e_b[nocc_b:],t1_1_b,t2_1_ab[:], optimize = True)
+
+            t1_2_a -= lib.einsum('l,ld,ilad->ia',e_a[:nocc_a],t1_1_a,t2_1_a[:], optimize = True)
+            t1_2_a -= lib.einsum('l,ld,ilad->ia',e_b[:nocc_b],t1_1_b,t2_1_ab[:], optimize = True)
+
+
+            t1_2_a += 0.5*lib.einsum('a,ld,ilad->ia',e_a[nocc_a:],t1_1_a,t2_1_a[:], optimize = True)
+            t1_2_a += 0.5*lib.einsum('a,ld,ilad->ia',
+                                     e_a[nocc_a:],t1_1_b,t2_1_ab[:], optimize = True)
+
+            t1_2_a -= 0.5*lib.einsum('i,ld,ilad->ia',e_a[:nocc_a],t1_1_a,t2_1_a[:], optimize = True)
+            t1_2_a -= 0.5*lib.einsum('i,ld,ilad->ia',
+                                     e_a[:nocc_a],t1_1_b,t2_1_ab[:], optimize = True)
+
+            t1_2_a += lib.einsum('ld,ilad->ia',f_ov_a,t2_1_a[:], optimize = True)
+            t1_2_a += lib.einsum('ld,ilad->ia',f_ov_b,t2_1_ab[:], optimize = True)
+
+            t1_2_a += lib.einsum('ld,iadl->ia',t1_1_a, eris.ovvo, optimize = True)
+            t1_2_a -= lib.einsum('ld,idal->ia',t1_1_a, eris.ovvo, optimize = True)
+            t1_2_a += lib.einsum('ld,iadl->ia',t1_1_b, eris.ovVO, optimize = True)
+
+            t1_2_a += lib.einsum('ld,iadl->ia',t1_1_a,eris.ovvo, optimize = True)
+            t1_2_a -= lib.einsum('ld,liad->ia',t1_1_a,eris.oovv, optimize = True)
+            t1_2_a += lib.einsum('ld,iadl->ia',t1_1_b,eris.ovVO, optimize = True)
+
         if isinstance(eris.OVvv, type(None)):
             chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
             a = 0
@@ -184,7 +231,33 @@ def compute_amplitudes(myadc, eris):
             del eris_ovVV
 
         t1_2_a -= lib.einsum('lcki,klac->ia',eris_OVoo,t2_1_ab[:],optimize=True)
-        t1_2_b -= lib.einsum('lcki,lkca->ia',eris_ovOO,t2_1_ab[:])
+        t1_2_b -= lib.einsum('lcki,lkca->ia',eris_ovOO,t2_1_ab[:],optimize=True)
+
+        if isinstance(myadc._scf, scf.rohf.ROHF):
+            t1_2_b += lib.einsum('d,ld,ilad->ia',e_b[nocc_b:],t1_1_b,t2_1_b[:], optimize = True)
+            t1_2_b += lib.einsum('d,ld,lida->ia',e_a[nocc_a:],t1_1_a,t2_1_ab[:], optimize = True)
+
+            t1_2_b -= lib.einsum('l,ld,ilad->ia',e_b[:nocc_b],t1_1_b,t2_1_b[:], optimize = True)
+            t1_2_b -= lib.einsum('l,ld,lida->ia',e_a[:nocc_a],t1_1_a,t2_1_ab[:], optimize = True)
+
+            t1_2_b += 0.5*lib.einsum('a,ld,ilad->ia',e_b[nocc_b:],t1_1_b,t2_1_b[:], optimize = True)
+            t1_2_b += 0.5*lib.einsum('a,ld,lida->ia',
+                                     e_b[nocc_b:],t1_1_a,t2_1_ab[:], optimize = True)
+
+            t1_2_b -= 0.5*lib.einsum('i,ld,ilad->ia',e_b[:nocc_b],t1_1_b,t2_1_b[:], optimize = True)
+            t1_2_b -= 0.5*lib.einsum('i,ld,lida->ia',
+                                     e_b[:nocc_b],t1_1_a,t2_1_ab[:], optimize = True)
+
+            t1_2_b += lib.einsum('ld,ilad->ia',f_ov_b,t2_1_b[:], optimize = True)
+            t1_2_b += lib.einsum('ld,lida->ia',f_ov_a,t2_1_ab[:], optimize = True)
+
+            t1_2_b += lib.einsum('ld,iadl->ia',t1_1_b, eris.OVVO, optimize = True)
+            t1_2_b -= lib.einsum('ld,idal->ia',t1_1_b, eris.OVVO, optimize = True)
+            t1_2_b += lib.einsum('ld,ldai->ia',t1_1_a, eris.ovVO, optimize = True)
+
+            t1_2_b += lib.einsum('ld,iadl->ia',t1_1_b,eris.OVVO, optimize = True)
+            t1_2_b -= lib.einsum('ld,liad->ia',t1_1_b,eris.OOVV, optimize = True)
+            t1_2_b += lib.einsum('ld,ldai->ia',t1_1_a,eris.ovVO, optimize = True)
 
         if isinstance(eris.OVVV, type(None)):
             chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
@@ -234,19 +307,20 @@ def compute_amplitudes(myadc, eris):
             eris_vvvv = eris.vvvv_p
             temp = np.ascontiguousarray(
                 t2_1_a[:,:,ab_ind_a[0],ab_ind_a[1]]).reshape(nocc_a*nocc_a,-1)
-            t2_1_vvvv_a = np.dot(temp,eris_vvvv.T).reshape(nocc_a, nocc_a, -1)
+            temp = np.dot(temp,eris_vvvv.T).reshape(nocc_a, nocc_a, -1)
+            t2_1_vvvv_a = np.zeros((nocc_a,nocc_a,nvir_a,nvir_a))
+            t2_1_vvvv_a[:,:,ab_ind_a[0],ab_ind_a[1]] = temp
+            t2_1_vvvv_a[:,:,ab_ind_a[1],ab_ind_a[0]] = -temp
             del eris_vvvv
         elif isinstance(eris.vvvv_p, list):
-            t2_1_vvvv_a = contract_ladder_antisym(myadc,t2_1_a[:], eris.vvvv_p)
+            t2_1_vvvv_a = contract_ladder_antisym(myadc,t2_1_a[:], eris.vvvv_p, pack = False)
         else:
-            t2_1_vvvv_a = contract_ladder_antisym(myadc,t2_1_a[:], eris.Lvv)
+            t2_1_vvvv_a = contract_ladder(myadc, t2_1_a[:], (eris.Lvv, eris.Lvv))
 
         if not isinstance(eris.oooo, np.ndarray):
             t2_1_vvvv_a = h5cache_t2.create_dataset('t2_1_vvvv_a', data=t2_1_vvvv_a)
 
-        t2_2_a = np.zeros((nocc_a,nocc_a,nvir_a,nvir_a))
-        t2_2_a[:,:,ab_ind_a[0],ab_ind_a[1]] = t2_1_vvvv_a[:]
-        t2_2_a[:,:,ab_ind_a[1],ab_ind_a[0]] = -t2_1_vvvv_a[:]
+        t2_2_a = t2_1_vvvv_a[:].copy()
 
         t2_2_a += 0.5*lib.einsum('kilj,klab->ijab', eris_oooo, t2_1_a[:],optimize=True)
         t2_2_a -= 0.5*lib.einsum('kjli,klab->ijab', eris_oooo, t2_1_a[:],optimize=True)
@@ -262,23 +336,53 @@ def compute_amplitudes(myadc, eris):
         del temp
         del temp_1
 
+        if isinstance(myadc._scf, scf.rohf.ROHF):
+            t2_2_a += lib.einsum('la,ibjl->ijab',t1_1_a,eris.ovoo, optimize = True)
+            t2_2_a -= lib.einsum('la,jbil->ijab',t1_1_a,eris.ovoo, optimize = True)
+
+
+            t2_2_a -= lib.einsum('lb,iajl->ijab',t1_1_a,eris.ovoo, optimize = True)
+            t2_2_a += lib.einsum('lb,jail->ijab',t1_1_a,eris.ovoo, optimize = True)
+
+            if isinstance(eris.ovvv, type(None)):
+                chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
+                a = 0
+                for p in range(0,nocc_a,chnk_size):
+                    eris_ovvv = dfadc.get_ovvv_spin_df(
+                        myadc, eris.Lov, eris.Lvv, p, chnk_size).reshape(-1,nvir_a,nvir_a,nvir_a)
+                    k = eris_ovvv.shape[0]
+                    t2_2_a[:,a:a+k] += lib.einsum('id,jbad->ijab',t1_1_a,eris_ovvv, optimize = True)
+                    t2_2_a[:,a:a+k] -= lib.einsum('id,jabd->ijab',t1_1_a,eris_ovvv, optimize = True)
+                    t2_2_a[a:a+k] -= lib.einsum('jd,ibad->ijab',t1_1_a,eris_ovvv, optimize = True)
+                    t2_2_a[a:a+k] += lib.einsum('jd,iabd->ijab',t1_1_a,eris_ovvv, optimize = True)
+                    del eris_ovvv
+                    a += k
+            else:
+                eris_ovvv = uadc_ao2mo.unpack_eri_1(eris.ovvv, nvir_a)
+                t2_2_a += lib.einsum('id,jbad->ijab',t1_1_a,eris_ovvv, optimize = True)
+                t2_2_a -= lib.einsum('id,jabd->ijab',t1_1_a,eris_ovvv, optimize = True)
+                t2_2_a -= lib.einsum('jd,ibad->ijab',t1_1_a,eris_ovvv, optimize = True)
+                t2_2_a += lib.einsum('jd,iabd->ijab',t1_1_a,eris_ovvv, optimize = True)
+                del eris_ovvv
+
         if isinstance(eris.VVVV_p, np.ndarray):
             eris_VVVV = eris.VVVV_p
             temp = np.ascontiguousarray(
                 t2_1_b[:,:,ab_ind_b[0],ab_ind_b[1]]).reshape(nocc_b*nocc_b,-1)
-            t2_1_vvvv_b = np.dot(temp,eris_VVVV.T).reshape(nocc_b, nocc_b, -1)
+            temp = np.dot(temp,eris_VVVV.T).reshape(nocc_b, nocc_b, -1)
+            t2_1_vvvv_b = np.zeros((nocc_b,nocc_b,nvir_b,nvir_b))
+            t2_1_vvvv_b[:,:,ab_ind_b[0],ab_ind_b[1]] = temp
+            t2_1_vvvv_b[:,:,ab_ind_b[1],ab_ind_b[0]] = -temp
             del eris_VVVV
         elif isinstance(eris.VVVV_p, list) :
-            t2_1_vvvv_b = contract_ladder_antisym(myadc,t2_1_b[:],eris.VVVV_p)
+            t2_1_vvvv_b = contract_ladder_antisym(myadc,t2_1_b[:],eris.VVVV_p, pack = False)
         else:
-            t2_1_vvvv_b = contract_ladder_antisym(myadc,t2_1_b[:],eris.LVV)
+            t2_1_vvvv_b = contract_ladder(myadc, t2_1_b[:], (eris.LVV, eris.LVV))
 
         if not isinstance(eris.oooo, np.ndarray):
             t2_1_vvvv_b = h5cache_t2.create_dataset('t2_1_vvvv_b', data=t2_1_vvvv_b)
 
-        t2_2_b = np.zeros((nocc_b,nocc_b,nvir_b,nvir_b))
-        t2_2_b[:,:,ab_ind_b[0],ab_ind_b[1]] = t2_1_vvvv_b[:]
-        t2_2_b[:,:,ab_ind_b[1],ab_ind_b[0]] = -t2_1_vvvv_b[:]
+        t2_2_b = t2_1_vvvv_b[:].copy()
 
         t2_2_b += 0.5*lib.einsum('kilj,klab->ijab', eris_OOOO, t2_1_b[:],optimize=True)
         t2_2_b -= 0.5*lib.einsum('kjli,klab->ijab', eris_OOOO, t2_1_b[:],optimize=True)
@@ -290,9 +394,38 @@ def compute_amplitudes(myadc, eris):
         t2_2_b += temp - temp.transpose(1,0,2,3) - temp.transpose(0,1,3,2) + temp.transpose(1,0,3,2)
         t2_2_b += temp_1 - temp_1.transpose(1,0,2,3) - \
                                             temp_1.transpose(0,1,3,2) + temp_1.transpose(1,0,3,2)
+
         del temp
         del temp_1
 
+        if isinstance(myadc._scf, scf.rohf.ROHF):
+            t2_2_b += lib.einsum('la,ibjl->ijab',t1_1_b,eris.OVOO, optimize = True)
+            t2_2_b -= lib.einsum('la,jbil->ijab',t1_1_b,eris.OVOO, optimize = True)
+
+            t2_2_b -= lib.einsum('lb,iajl->ijab',t1_1_b,eris.OVOO, optimize = True)
+            t2_2_b += lib.einsum('lb,jail->ijab',t1_1_b,eris.OVOO, optimize = True)
+
+            if isinstance(eris.OVVV, type(None)):
+                chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
+                a = 0
+                for p in range(0,nocc_b,chnk_size):
+                    eris_OVVV = dfadc.get_ovvv_spin_df(
+                        myadc, eris.LOV, eris.LVV, p, chnk_size).reshape(-1,nvir_b,nvir_b,nvir_b)
+                    k = eris_OVVV.shape[0]
+                    t2_2_b[:,a:a+k] += lib.einsum('id,jbad->ijab',t1_1_b,eris_OVVV, optimize = True)
+                    t2_2_b[:,a:a+k] -= lib.einsum('id,jabd->ijab',t1_1_b,eris_OVVV, optimize = True)
+                    t2_2_b[a:a+k] -= lib.einsum('jd,ibad->ijab',t1_1_b,eris_OVVV, optimize = True)
+                    t2_2_b[a:a+k] += lib.einsum('jd,iabd->ijab',t1_1_b,eris_OVVV, optimize = True)
+                    del eris_OVVV
+                    a += k
+            else:
+                eris_OVVV = uadc_ao2mo.unpack_eri_1(eris.OVVV, nvir_b)
+                t2_2_b += lib.einsum('id,jbad->ijab',t1_1_b,eris_OVVV, optimize = True)
+                t2_2_b -= lib.einsum('id,jabd->ijab',t1_1_b,eris_OVVV, optimize = True)
+                t2_2_b -= lib.einsum('jd,ibad->ijab',t1_1_b,eris_OVVV, optimize = True)
+                t2_2_b += lib.einsum('jd,iabd->ijab',t1_1_b,eris_OVVV, optimize = True)
+                del eris_OVVV
+
         if isinstance(eris.vVvV_p, np.ndarray):
             temp = t2_1_ab.reshape(nocc_a*nocc_b,nvir_a*nvir_b)
             eris_vVvV = eris.vVvV_p
@@ -317,6 +450,43 @@ def compute_amplitudes(myadc, eris):
         t2_2_ab += lib.einsum('kcai,kjcb->ijab',eris_ovvo,t2_1_ab[:],optimize=True)
         t2_2_ab -= lib.einsum('kiac,kjcb->ijab',eris_oovv,t2_1_ab[:],optimize=True)
 
+        if isinstance(myadc._scf, scf.rohf.ROHF):
+            t2_2_ab -= lib.einsum('la,jbil->ijab',t1_1_a,eris.OVoo, optimize = True)
+            t2_2_ab -= lib.einsum('lb,iajl->ijab',t1_1_b,eris.ovOO, optimize = True)
+
+            if isinstance(eris.OVvv, type(None)):
+                chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
+                a = 0
+                for p in range(0,nocc_b,chnk_size):
+                    eris_OVvv = dfadc.get_ovvv_spin_df(
+                        myadc, eris.LOV, eris.Lvv, p, chnk_size).reshape(-1,nvir_b,nvir_a,nvir_a)
+                    k = eris_OVvv.shape[0]
+                    t2_2_ab[:, a:a+k] += lib.einsum('id,jbad->ijab',
+                                                    t1_1_a,eris_OVvv, optimize = True)
+                    del eris_OVvv
+                    a += k
+            else:
+                eris_OVvv = uadc_ao2mo.unpack_eri_1(eris.OVvv, nvir_a)
+                t2_2_ab += lib.einsum('id,jbad->ijab',t1_1_a,eris_OVvv, optimize = True)
+                del eris_OVvv
+
+            if isinstance(eris.ovVV, type(None)):
+                chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
+                a = 0
+                for p in range(0,nocc_a,chnk_size):
+                    eris_ovVV = dfadc.get_ovvv_spin_df(
+                        myadc, eris.Lov, eris.LVV, p, chnk_size).reshape(-1,nvir_a,nvir_b,nvir_b)
+                    k = eris_ovVV.shape[0]
+                    t2_2_ab[a:a+k] += lib.einsum('jd,iabd->ijab',t1_1_b,eris_ovVV, optimize = True)
+                    del eris_ovVV
+                    a += k
+            else:
+                eris_ovVV = uadc_ao2mo.unpack_eri_1(eris.ovVV, nvir_b)
+                t2_2_ab += lib.einsum('jd,iabd->ijab',t1_1_b,eris_ovVV, optimize = True)
+                del eris_ovVV
+
+
+
         D2_a = d_ij_a.reshape(-1,1) - d_ab_a.reshape(-1)
         D2_a = D2_a.reshape((nocc_a,nocc_a,nvir_a,nvir_a))
         t2_2_a = t2_2_a/D2_a
@@ -694,7 +864,7 @@ def compute_amplitudes(myadc, eris):
         t2_2 = (t2_2_a , t2_2_ab, t2_2_b)
         t2_1_vvvv = (t2_1_vvvv_a, t2_1_vvvv_ab, t2_1_vvvv_b)
 
-    t1 = (t1_2, t1_3)
+    t1 = (t1_2, t1_3, t1_1)
     t2 = (t2_1, t2_2)
 
     cput0 = log.timer_debug1("Completed amplitude calculation", *cput0)
@@ -738,17 +908,38 @@ def compute_energy(myadc, t1, t2, eris):
     e_mp -= 0.25 * lib.einsum('ijab,ibaj', t2_b, eris_OVVO)
     del t2_b
 
+    logger.info(myadc, "Reference correlation energy (doubles): %.8f", e_mp)
+
+    if isinstance(myadc._scf, scf.rohf.ROHF):
+        f_ov_a = myadc.f_ov[0]
+        f_ov_b = myadc.f_ov[1]
+        t1_1_a = t1[2][0].copy()
+        t1_1_b = t1[2][1].copy()
+
+        if (myadc.method == "adc(3)"):
+            t1_1_a += t1[0][0]
+            t1_1_b += t1[0][1]
+
+        singles = lib.einsum('ia,ia', f_ov_a, t1_1_a)
+        singles += lib.einsum('ia,ia', f_ov_b, t1_1_b)
+
+        e_mp += singles
+
+        logger.info(myadc, "Reference correlation energy (singles): %.8f", singles)
+
     cput0 = log.timer_debug1("Completed energy calculation", *cput0)
 
     return e_mp
 
-def contract_ladder(myadc,t_amp,vvvv_p):
+
+def contract_ladder(myadc,t_amp,vvvv_p, prefactor = 1.0, pack = False):
 
     nocc_a = t_amp.shape[0]
     nocc_b = t_amp.shape[1]
     nvir_a = t_amp.shape[2]
     nvir_b = t_amp.shape[3]
 
+    tril_idx = np.tril_indices(nvir_a, k=-1)
     t_amp_t = np.ascontiguousarray(t_amp.reshape(nocc_a*nocc_b,-1).T)
     t = np.zeros((nvir_a,nvir_b, nocc_a*nocc_b))
     chnk_size = uadc_ao2mo.calculate_chunk_size(myadc)
@@ -773,12 +964,14 @@ def contract_ladder(myadc,t_amp,vvvv_p):
     else:
         raise Exception("Unknown vvvv type")
 
-    t = np.ascontiguousarray(t.transpose(2,0,1)).reshape(nocc_a, nocc_b, nvir_a, nvir_b)
+    t = prefactor * np.ascontiguousarray(t.transpose(2,0,1)).reshape(nocc_a, nocc_b, nvir_a, nvir_b)
+    if pack:
+        t = t[:, :, tril_idx[0], tril_idx[1]]
 
     return t
 
 
-def contract_ladder_antisym(myadc,t_amp,vvvv_d):
+def contract_ladder_antisym(myadc,t_amp,vvvv_d, pack = True):
 
     nocc = t_amp.shape[0]
     nvir = t_amp.shape[2]
@@ -811,6 +1004,8 @@ def contract_ladder_antisym(myadc,t_amp,vvvv_d):
         raise Exception("Unknown vvvv type")
 
     t = np.ascontiguousarray(t.transpose(2,0,1)).reshape(nocc, nocc, nvir, nvir)
-    t = t[:, :, tril_idx[0], tril_idx[1]]
+
+    if pack:
+        t = t[:, :, tril_idx[0], tril_idx[1]]
 
     return t

pyscf/adc/uadc_ao2mo.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Samragni Banerjee <samragnibanerjee4@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -199,7 +202,7 @@ def transform_integrals_outcore(myadc):
             eris.OOvv[i] = buf[:nocc_b,nocc_a:,nocc_a:]
             eris.OVvo[i] = buf[nocc_b:,nocc_a:,:nocc_a]
             eris.OVvv[i] = lib.pack_tril(buf[nocc_b:,nocc_a:,nocc_a:])
-        del (tmpf['ba'])
+        del(tmpf['ba'])
 
     buf = None
     cput1 = logger.timer_debug1(myadc, 'transforming oopq, ovpq', *cput1)
@@ -465,17 +468,35 @@ def transform_integrals_df(myadc):
     eris.Lvv = eris.Lvv.reshape(naux,nvir_a,nvir_a)
     eris.LVV = eris.LVV.reshape(naux,nvir_b,nvir_b)
 
-    if not isinstance(myadc.ncvs, type(None)) and myadc.ncvs > 0:
-        ncvs = myadc.ncvs
-        eris.Lce = eris.Lce.reshape(naux,ncvs,nvir_a)
-        eris.Lee = eris.Lvv
-        eris.LCE = eris.LCE.reshape(naux,ncvs,nvir_b)
-        eris.LEE = eris.LVV
-
     log.timer('DF-ADC integral transformation', *cput0)
 
     return eris
 
+def unpack_eri_1(eri, norb):
+
+    n_oo = norb * (norb + 1) // 2
+    ind_oo = np.tril_indices(norb)
+
+    eri_ = None
+
+    if len(eri.shape) == 3:
+        if (eri.shape[0] == n_oo):
+            eri_ = np.zeros((norb, norb, eri.shape[1], eri.shape[2]))
+            eri_[ind_oo[0], ind_oo[1]] = eri
+            eri_[ind_oo[1], ind_oo[0]] = eri
+
+        elif (eri.shape[2] == n_oo):
+            eri_ = np.zeros((eri.shape[0], eri.shape[1], norb, norb))
+            eri_[:, :, ind_oo[0], ind_oo[1]] = eri
+            eri_[:, :, ind_oo[1], ind_oo[0]] = eri
+        else:
+            raise TypeError("ERI dimensions don't match")
+
+    else:
+        raise RuntimeError("ERI does not have a correct dimension")
+
+    return eri_
+
 def calculate_chunk_size(myadc):
 
     avail_mem = (myadc.max_memory - lib.current_memory()[0]) * 0.25