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

pyscf/__init__.py

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

pyscf/adc/radc.py

@@ -15,7 +15,7 @@
 # Author: Abdelrahman Ahmed <>
 #         Samragni Banerjee <samragnibanerjee4@gmail.com>
 #         James Serna <jamcar456@gmail.com>
-#         Terrence Stahl <>
+#         Terrence Stahl <terrencestahl1@gmail.com>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -23,15 +23,12 @@
 Restricted algebraic diagrammatic construction
 '''
 import numpy as np
-import pyscf.ao2mo as ao2mo
 from pyscf import lib
 from pyscf.lib import logger
 from pyscf.adc import radc_ao2mo
-from pyscf.adc import dfadc
 from pyscf.adc import radc_amplitudes
 from pyscf import __config__
 from pyscf import df
-from pyscf import symm
 
 
 # Excited-state kernel
@@ -50,6 +47,20 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
     if eris is None:
         eris = adc.transform_integrals()
 
+    if adc.approx_trans_moments:
+        if adc.method in ("adc(2)", "adc(2)-x"):
+            logger.warn(
+                adc,
+                "Approximations for transition moments are requested...\n"
+                + adc.method
+                + " transition properties will neglect second-order amplitudes...")
+        else:
+            logger.warn(
+                adc,
+                "Approximations for transition moments are requested...\n"
+                + adc.method
+                + " transition properties will neglect third-order amplitudes...")
+
     imds = adc.get_imds(eris)
     matvec, diag = adc.gen_matvec(imds, eris)
 
@@ -57,24 +68,34 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
 
     conv, adc.E, U = lib.linalg_helper.davidson_nosym1(
         lambda xs : [matvec(x) for x in xs],
-        guess, diag, nroots=nroots, verbose=log, tol=adc.conv_tol,
+        guess, diag, nroots=nroots, verbose=log, tol=adc.conv_tol, max_memory=adc.max_memory,
         max_cycle=adc.max_cycle, max_space=adc.max_space, tol_residual=adc.tol_residual)
 
     adc.U = np.array(U).T.copy()
 
-    if adc.compute_properties:
+    if adc.compute_properties and adc.method_type != "ee":
         adc.P,adc.X = adc.get_properties(nroots)
+    else:
+        adc.P = None
+        adc.X = None
+
     nfalse = np.shape(conv)[0] - np.sum(conv)
 
+    spin_mult = None
+    if adc.method_type in ("ip", "ea"):
+        spin_mult = "doublet"
+    else:
+        spin_mult = "singlet"
+
     header = ("\n*************************************************************"
-              "\n            ADC calculation summary"
+              "\n        ADC calculation summary (" + spin_mult + " states only)"
               "\n*************************************************************")
     logger.info(adc, header)
 
     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:
+        if adc.compute_properties and adc.method_type != "ee":
             print_string += ("|  Spec. factor = %10.8f  " % adc.P[n])
         print_string += ("|  conv = %s" % conv[n])
         logger.info(adc, print_string)
@@ -198,7 +219,6 @@ class RADC(lib.StreamObject):
     }
 
     def __init__(self, mf, frozen=0, mo_coeff=None, mo_occ=None):
-        from pyscf import gto
 
         if 'dft' in str(mf.__module__):
             raise NotImplementedError('DFT reference for UADC')
@@ -216,8 +236,8 @@ class RADC(lib.StreamObject):
 
         self.max_space = getattr(__config__, 'adc_radc_RADC_max_space', 12)
         self.max_cycle = getattr(__config__, 'adc_radc_RADC_max_cycle', 50)
-        self.conv_tol = getattr(__config__, 'adc_radc_RADC_conv_tol', 1e-12)
-        self.tol_residual = getattr(__config__, 'adc_radc_RADC_tol_residual', 1e-6)
+        self.conv_tol = getattr(__config__, 'adc_radc_RADC_conv_tol', 1e-8)
+        self.tol_residual = getattr(__config__, 'adc_radc_RADC_tol_residual', 1e-5)
         self.scf_energy = mf.e_tot
 
         self.frozen = frozen
@@ -369,6 +389,9 @@ class RADC(lib.StreamObject):
         if (self.method_type == "ea"):
             e_exc, v_exc, spec_fac, x, adc_es = self.ea_adc(nroots=nroots, guess=guess, eris=eris)
 
+        elif (self.method_type == "ee"):
+            e_exc, v_exc, spec_fac, x, adc_es = self.ee_adc(nroots=nroots, guess=guess, eris=eris)
+
         elif(self.method_type == "ip"):
             if not isinstance(self.ncvs, type(None)) and self.ncvs > 0:
                 e_exc, v_exc, spec_fac, x, adc_es = self.ip_cvs_adc(
@@ -393,6 +416,12 @@ class RADC(lib.StreamObject):
         e_exc, v_exc, spec_fac, x = adc_es.kernel(nroots, guess, eris)
         return e_exc, v_exc, spec_fac, x, adc_es
 
+    def ee_adc(self, nroots=1, guess=None, eris=None):
+        from pyscf.adc import radc_ee
+        adc_es = radc_ee.RADCEE(self)
+        e_exc, v_exc, spec_fac, x = adc_es.kernel(nroots, guess, eris)
+        return e_exc, v_exc, spec_fac, x, adc_es
+
     def ip_adc(self, nroots=1, guess=None, eris=None):
         from pyscf.adc import radc_ip
         adc_es = radc_ip.RADCIP(self)

pyscf/adc/radc_amplitudes.py

@@ -23,14 +23,10 @@
 Restricted algebraic diagrammatic construction
 '''
 import numpy as np
-import pyscf.ao2mo as ao2mo
 from pyscf import lib
 from pyscf.lib import logger
 from pyscf.adc import radc_ao2mo
 from pyscf.adc import dfadc
-from pyscf import __config__
-from pyscf import df
-from pyscf import symm
 import h5py
 import tempfile
 
@@ -91,18 +87,15 @@ def compute_amplitudes(myadc, eris):
 
         if isinstance(eris.ovvv, type(None)):
             chnk_size = radc_ao2mo.calculate_chunk_size(myadc)
-            a = 0
-            for p in range(0,nocc,chnk_size):
+            for a,b in lib.prange(0,nocc,chnk_size):
                 eris_ovvv = dfadc.get_ovvv_df(
-                    myadc, eris.Lov, eris.Lvv, p, chnk_size).reshape(-1,nvir,nvir,nvir)
-                k = eris_ovvv.shape[0]
-                t1_2 += 1.5*lib.einsum('kdac,ikcd->ia',eris_ovvv,t2_1[:,a:a+k],optimize=True)
-                t1_2 -= 0.5*lib.einsum('kdac,kicd->ia',eris_ovvv,t2_1[a:a+k,:],optimize=True)
-                t1_2 -= 0.5*lib.einsum('kcad,ikcd->ia',eris_ovvv,t2_1[:,a:a+k],optimize=True)
-                t1_2 += 0.5*lib.einsum('kcad,kicd->ia',eris_ovvv,t2_1[a:a+k,:],optimize=True)
+                    myadc, eris.Lov, eris.Lvv, a, chnk_size).reshape(-1,nvir,nvir,nvir)
+                t1_2 += 1.5*lib.einsum('kdac,ikcd->ia',eris_ovvv,t2_1[:,a:b],optimize=True)
+                t1_2 -= 0.5*lib.einsum('kdac,kicd->ia',eris_ovvv,t2_1[a:b,:],optimize=True)
+                t1_2 -= 0.5*lib.einsum('kcad,ikcd->ia',eris_ovvv,t2_1[:,a:b],optimize=True)
+                t1_2 += 0.5*lib.einsum('kcad,kicd->ia',eris_ovvv,t2_1[a:b,:],optimize=True)
 
                 del eris_ovvv
-                a += k
         else :
             eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)
             t1_2 += 1.5*lib.einsum('kdac,ikcd->ia',eris_ovvv,t2_1,optimize=True)
@@ -135,6 +128,7 @@ def compute_amplitudes(myadc, eris):
             eris_vvvv = eris.vvvv
             temp = t2_1.reshape(nocc*nocc,nvir*nvir)
             t2_1_vvvv = np.dot(temp,eris_vvvv.T).reshape(nocc,nocc,nvir,nvir)
+            del temp
         elif isinstance(eris.vvvv, list):
             t2_1_vvvv = contract_ladder(myadc,t2_1[:],eris.vvvv)
         else:
@@ -201,146 +195,143 @@ def compute_amplitudes(myadc, eris):
 
         if isinstance(eris.ovvv, type(None)):
             chnk_size = radc_ao2mo.calculate_chunk_size(myadc)
-            a = 0
-            for p in range(0,nocc,chnk_size):
+            for a,b in lib.prange(0,nocc,chnk_size):
                 eris_ovvv = dfadc.get_ovvv_df(
-                    myadc, eris.Lov, eris.Lvv, p, chnk_size).reshape(-1,nvir,nvir,nvir)
-                k = eris_ovvv.shape[0]
+                    myadc, eris.Lov, eris.Lvv, a, chnk_size).reshape(-1,nvir,nvir,nvir)
 
-                t1_3 += 0.5*lib.einsum('ilde,lead->ia', t2_2[:,a:a+k],eris_ovvv,optimize=True)
-                t1_3 -= 0.5*lib.einsum('lide,lead->ia', t2_2[a:a+k],eris_ovvv,optimize=True)
+                t1_3 += 0.5*lib.einsum('ilde,lead->ia', t2_2[:,a:b],eris_ovvv,optimize=True)
+                t1_3 -= 0.5*lib.einsum('lide,lead->ia', t2_2[a:b],eris_ovvv,optimize=True)
 
-                t1_3 -= 0.5*lib.einsum('ilde,ldae->ia', t2_2[:,a:a+k],eris_ovvv,optimize=True)
-                t1_3 += 0.5*lib.einsum('lide,ldae->ia', t2_2[a:a+k],eris_ovvv,optimize=True)
+                t1_3 -= 0.5*lib.einsum('ilde,ldae->ia', t2_2[:,a:b],eris_ovvv,optimize=True)
+                t1_3 += 0.5*lib.einsum('lide,ldae->ia', t2_2[a:b],eris_ovvv,optimize=True)
 
                 t1_3 -= lib.einsum('ildf,mefa,lmde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[:,a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[:,a:b] ,optimize=True)
                 t1_3 += lib.einsum('ildf,mefa,mlde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[a:b] ,optimize=True)
                 t1_3 += lib.einsum('lidf,mefa,lmde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[:,a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[:,a:b] ,optimize=True)
                 t1_3 -= lib.einsum('lidf,mefa,mlde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[a:b] ,optimize=True)
 
                 t1_3 += lib.einsum('ildf,mafe,lmde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[:,a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[:,a:b] ,optimize=True)
                 t1_3 -= lib.einsum('ildf,mafe,mlde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[a:b] ,optimize=True)
                 t1_3 -= lib.einsum('lidf,mafe,lmde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[:,a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[:,a:b] ,optimize=True)
                 t1_3 += lib.einsum('lidf,mafe,mlde->ia',
-                                   t2_1[:], eris_ovvv,  t2_1[a:a+k] ,optimize=True)
+                                   t2_1[:], eris_ovvv,  t2_1[a:b] ,optimize=True)
 
                 t1_3 += lib.einsum('ilfd,mefa,mled->ia',
-                                   t2_1[:],eris_ovvv, t2_1[a:a+k],optimize=True)
+                                   t2_1[:],eris_ovvv, t2_1[a:b],optimize=True)
                 t1_3 -= lib.einsum('ilfd,mafe,mled->ia',
-                                   t2_1[:],eris_ovvv, t2_1[a:a+k],optimize=True)
+                                   t2_1[:],eris_ovvv, t2_1[a:b],optimize=True)
 
                 t1_3 += 0.5*lib.einsum('ilaf,mefd,lmde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
                 t1_3 -= 0.5*lib.einsum('ilaf,mefd,mlde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
                 t1_3 -= 0.5*lib.einsum('liaf,mefd,lmde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
                 t1_3 += 0.5*lib.einsum('liaf,mefd,mlde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
 
                 t1_3 -= 0.5*lib.einsum('ilaf,mdfe,lmde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
                 t1_3 += 0.5*lib.einsum('ilaf,mdfe,mlde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
                 t1_3 += 0.5*lib.einsum('liaf,mdfe,lmde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
                 t1_3 -= 0.5*lib.einsum('liaf,mdfe,mlde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
 
-                t1_3[a:a+k] += 0.5*lib.einsum('lmdf,iaef,lmde->ia',
+                t1_3[a:b] += 0.5*lib.einsum('lmdf,iaef,lmde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.5*lib.einsum('lmdf,iaef,mlde->ia',
+                t1_3[a:b] -= 0.5*lib.einsum('lmdf,iaef,mlde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.5*lib.einsum('mldf,iaef,lmde->ia',
+                t1_3[a:b] -= 0.5*lib.einsum('mldf,iaef,lmde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] += 0.5*lib.einsum('mldf,iaef,mlde->ia',
+                t1_3[a:b] += 0.5*lib.einsum('mldf,iaef,mlde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
 
-                t1_3[a:a+k] -= 0.5*lib.einsum('lmdf,ifea,lmde->ia',
+                t1_3[a:b] -= 0.5*lib.einsum('lmdf,ifea,lmde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] += 0.5*lib.einsum('lmdf,ifea,mlde->ia',
+                t1_3[a:b] += 0.5*lib.einsum('lmdf,ifea,mlde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] += 0.5*lib.einsum('mldf,ifea,lmde->ia',
+                t1_3[a:b] += 0.5*lib.einsum('mldf,ifea,lmde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.5*lib.einsum('mldf,ifea,mlde->ia',
+                t1_3[a:b] -= 0.5*lib.einsum('mldf,ifea,mlde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
 
-                t1_3[a:a+k] += lib.einsum('mlfd,iaef,mled->ia',t2_1[:],
+                t1_3[a:b] += lib.einsum('mlfd,iaef,mled->ia',t2_1[:],
                                           eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= lib.einsum('mlfd,ifea,mled->ia',t2_1[:],
+                t1_3[a:b] -= lib.einsum('mlfd,ifea,mled->ia',t2_1[:],
                                           eris_ovvv,t2_1[:],optimize=True)
 
-                t1_3[a:a+k] -= 0.25*lib.einsum('lmef,iedf,lmad->ia',
+                t1_3[a:b] -= 0.25*lib.einsum('lmef,iedf,lmad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] += 0.25*lib.einsum('lmef,iedf,mlad->ia',
+                t1_3[a:b] += 0.25*lib.einsum('lmef,iedf,mlad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] += 0.25*lib.einsum('mlef,iedf,lmad->ia',
+                t1_3[a:b] += 0.25*lib.einsum('mlef,iedf,lmad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.25*lib.einsum('mlef,iedf,mlad->ia',
+                t1_3[a:b] -= 0.25*lib.einsum('mlef,iedf,mlad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
 
-                t1_3[a:a+k] += 0.25*lib.einsum('lmef,ifde,lmad->ia',
+                t1_3[a:b] += 0.25*lib.einsum('lmef,ifde,lmad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.25*lib.einsum('lmef,ifde,mlad->ia',
+                t1_3[a:b] -= 0.25*lib.einsum('lmef,ifde,mlad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.25*lib.einsum('mlef,ifde,lmad->ia',
+                t1_3[a:b] -= 0.25*lib.einsum('mlef,ifde,lmad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] += 0.25*lib.einsum('mlef,ifde,mlad->ia',
+                t1_3[a:b] += 0.25*lib.einsum('mlef,ifde,mlad->ia',
                                                t2_1[:],eris_ovvv,t2_1[:],optimize=True)
 
                 t1_3 += 0.5*lib.einsum('ilaf,mefd,lmde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
                 t1_3 -= 0.5*lib.einsum('ilaf,mefd,mlde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
 
                 t1_3 -= 0.5*lib.einsum('ilaf,mdfe,lmde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
                 t1_3 += 0.5*lib.einsum('ilaf,mdfe,mlde->ia',
-                                       t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
+                                       t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
 
-                t1_3 -= lib.einsum('ildf,mafe,mlde->ia',t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
-                t1_3 += lib.einsum('ilaf,mefd,mled->ia',t2_1[:],eris_ovvv,t2_1[a:a+k],optimize=True)
+                t1_3 -= lib.einsum('ildf,mafe,mlde->ia',t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
+                t1_3 += lib.einsum('ilaf,mefd,mled->ia',t2_1[:],eris_ovvv,t2_1[a:b],optimize=True)
 
-                t1_3[a:a+k] += 0.5*lib.einsum('lmdf,iaef,lmde->ia',
+                t1_3[a:b] += 0.5*lib.einsum('lmdf,iaef,lmde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.5*lib.einsum('lmdf,iaef,mlde->ia',
+                t1_3[a:b] -= 0.5*lib.einsum('lmdf,iaef,mlde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= 0.5*lib.einsum('mldf,iaef,lmde->ia',
+                t1_3[a:b] -= 0.5*lib.einsum('mldf,iaef,lmde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] += 0.5*lib.einsum('mldf,iaef,mlde->ia',
+                t1_3[a:b] += 0.5*lib.einsum('mldf,iaef,mlde->ia',
                                               t2_1[:],eris_ovvv,t2_1[:],optimize=True)
 
-                t1_3[a:a+k] += lib.einsum('lmdf,iaef,lmde->ia',t2_1[:],
+                t1_3[a:b] += lib.einsum('lmdf,iaef,lmde->ia',t2_1[:],
                                           eris_ovvv,t2_1[:],optimize=True)
-                t1_3[a:a+k] -= lib.einsum('lmef,iedf,lmad->ia',t2_1[:],
+                t1_3[a:b] -= lib.einsum('lmef,iedf,lmad->ia',t2_1[:],
                                           eris_ovvv,t2_1[:],optimize=True)
 
-                t1_3 += lib.einsum('ilde,lead->ia',t2_2[:,a:a+k],eris_ovvv,optimize=True)
+                t1_3 += lib.einsum('ilde,lead->ia',t2_2[:,a:b],eris_ovvv,optimize=True)
 
                 t1_3 -= lib.einsum('ildf,mefa,lmde->ia',
-                                   t2_1[:],eris_ovvv, t2_1[:,a:a+k],optimize=True)
+                                   t2_1[:],eris_ovvv, t2_1[:,a:b],optimize=True)
                 t1_3 += lib.einsum('lidf,mefa,lmde->ia',
-                                   t2_1[:],eris_ovvv, t2_1[:,a:a+k],optimize=True)
+                                   t2_1[:],eris_ovvv, t2_1[:,a:b],optimize=True)
 
                 t1_3 += lib.einsum('ilfd,mefa,lmde->ia',
-                                   t2_1[:],eris_ovvv,t2_1[:,a:a+k] ,optimize=True)
+                                   t2_1[:],eris_ovvv,t2_1[:,a:b] ,optimize=True)
                 t1_3 -= lib.einsum('ilfd,mefa,mlde->ia',
-                                   t2_1[:],eris_ovvv,t2_1[a:a+k] ,optimize=True)
+                                   t2_1[:],eris_ovvv,t2_1[a:b] ,optimize=True)
 
                 t1_3 += lib.einsum('ilaf,mefd,lmde->ia',
-                                   t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                   t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
                 t1_3 -= lib.einsum('liaf,mefd,lmde->ia',
-                                   t2_1[:],eris_ovvv,t2_1[:,a:a+k],optimize=True)
+                                   t2_1[:],eris_ovvv,t2_1[:,a:b],optimize=True)
 
                 del eris_ovvv
-                a += k
 
         else :
             eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)
@@ -553,13 +544,11 @@ def contract_ladder(myadc,t_amp,vvvv):
             t[a:a+k] = np.dot(dataset,t_amp).reshape(-1,nvir,nocc*nocc)
             a += k
     elif getattr(myadc, 'with_df', None):
-        for p in range(0,nvir,chnk_size):
-            vvvv_p = dfadc.get_vvvv_df(myadc, vvvv, p, chnk_size)
-            k = vvvv_p.shape[0]
+        for a,b in lib.prange(0,nvir,chnk_size):
+            vvvv_p = dfadc.get_vvvv_df(myadc, vvvv, a, chnk_size)
             vvvv_p = vvvv_p.reshape(-1,nvir*nvir)
-            t[a:a+k] = np.dot(vvvv_p,t_amp).reshape(-1,nvir,nocc*nocc)
+            t[a:b] = np.dot(vvvv_p,t_amp).reshape(-1,nvir,nocc*nocc)
             del vvvv_p
-            a += k
     else:
         raise Exception("Unknown vvvv type")
 

pyscf/adc/radc_ao2mo.py

@@ -22,8 +22,6 @@ import numpy as np
 import pyscf.ao2mo as ao2mo
 from pyscf import lib
 from pyscf.lib import logger
-import h5py
-import tempfile
 
 ### Incore integral transformation for integrals in Chemists' notation###
 def transform_integrals_incore(myadc):
@@ -44,8 +42,11 @@ def transform_integrals_incore(myadc):
     eris.oovv = ao2mo.general(myadc._scf._eri, (occ, occ, vir, vir), compact=False).reshape(nocc, nocc, nvir, nvir).copy()  # noqa: E501
     eris.ovvo = ao2mo.general(myadc._scf._eri, (occ, vir, vir, occ), compact=False).reshape(nocc, nvir, nvir, nocc).copy()  # noqa: E501
     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(3)"):
+    if ((myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.method_type == "ee")
+        or (myadc.method == "adc(3)")):
         eris.vvvv = ao2mo.general(myadc._scf._eri, (vir, vir, vir, vir),
                                   compact=False).reshape(nvir, nvir, nvir, nvir)
         eris.vvvv = np.ascontiguousarray(eris.vvvv.transpose(0,2,1,3))
@@ -85,6 +86,8 @@ def transform_integrals_outcore(myadc):
         'ovvo', (nocc,nvir,nvir,nocc), 'f8', chunks=(nocc,1,nvir,nocc))
     eris.ovvv = eris.feri1.create_dataset('ovvv', (nocc,nvir,nvpair), 'f8')
 
+    eris.vvvv = None
+
     def save_occ_frac(p0, p1, eri):
         eri = eri.reshape(p1-p0,nocc,nmo,nmo)
         eris.oooo[p0:p1] = eri[:,:,:nocc,:nocc]
@@ -117,6 +120,7 @@ def transform_integrals_outcore(myadc):
     fload = ao2mo.outcore._load_from_h5g
     buf = np.empty((blksize*nocc,nao_pair))
     buf_prefetch = np.empty_like(buf)
+
     def load(buf_prefetch, p0, rowmax):
         if p0 < rowmax:
             p1 = min(rowmax, p0+blksize)
@@ -151,7 +155,10 @@ 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(3)"):
+    if ((myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.method_type == "ee")
+        or (myadc.method == "adc(3)")):
+
         eris.vvvv = []
 
         cput3 = logger.process_clock(), logger.perf_counter()