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

pyscf/__init__.py

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

pyscf/ao2mo/__init__.py

@@ -31,6 +31,7 @@ Simple usage::
 import tempfile
 import numpy
 import h5py
+from pyscf import gto
 from pyscf.ao2mo import incore
 from pyscf.ao2mo import outcore
 from pyscf.ao2mo import r_outcore
@@ -143,7 +144,7 @@ def full(eri_or_mol, mo_coeff, erifile=None, dataname='eri_mo', intor='int2e',
     '''
     if isinstance(eri_or_mol, numpy.ndarray):
         return incore.full(eri_or_mol, mo_coeff, *args, **kwargs)
-    else:
+    elif isinstance(eri_or_mol, gto.MoleBase):
         if '_spinor' in intor:
             mod = r_outcore
         else:
@@ -157,6 +158,11 @@ def full(eri_or_mol, mo_coeff, erifile=None, dataname='eri_mo', intor='int2e',
                             *args, **kwargs)
         else:
             return mod.full_iofree(eri_or_mol, mo_coeff, intor, *args, **kwargs)
+    else:
+        raise RuntimeError('ERI is not available. If this is generated by mf._eri, '
+                           'the integral tensor is too big to store in memory. '
+                           'You should either increase mol.max_memory, or set '
+                           'mol.incore_anyway. See issue #2473.')
 
 def general(eri_or_mol, mo_coeffs, erifile=None, dataname='eri_mo', intor='int2e',
             *args, **kwargs):
@@ -293,7 +299,7 @@ def general(eri_or_mol, mo_coeffs, erifile=None, dataname='eri_mo', intor='int2e
     '''
     if isinstance(eri_or_mol, numpy.ndarray):
         return incore.general(eri_or_mol, mo_coeffs, *args, **kwargs)
-    else:
+    elif isinstance(eri_or_mol, gto.MoleBase):
         if '_spinor' in intor:
             mod = r_outcore
         else:
@@ -307,6 +313,11 @@ def general(eri_or_mol, mo_coeffs, erifile=None, dataname='eri_mo', intor='int2e
                                *args, **kwargs)
         else:
             return mod.general_iofree(eri_or_mol, mo_coeffs, intor, *args, **kwargs)
+    else:
+        raise RuntimeError('ERI is not available. If this is generated by mf._eri, '
+                           'the integral tensor is too big to store in memory. '
+                           'You should either increase mol.max_memory, or set '
+                           'mol.incore_anyway. See issue #2473.')
 
 def kernel(eri_or_mol, mo_coeffs, erifile=None, dataname='eri_mo', intor='int2e',
            *args, **kwargs):

pyscf/ao2mo/_ao2mo.py

@@ -73,7 +73,7 @@ def nr_e1fill(intor, sh_range, atm, bas, env,
     natm = ctypes.c_int(c_atm.shape[0])
     nbas = ctypes.c_int(c_bas.shape[0])
     ao_loc = make_loc(bas, intor)
-    nao = ao_loc[-1]
+    nao = int(ao_loc[-1])
 
     klsh0, klsh1, nkl = sh_range
 
@@ -137,6 +137,9 @@ def nr_e1(eri, mo_coeff, orbs_slice, aosym='s1', mosym='s1', out=None):
     if out.size == 0:
         return out
 
+    if eri.dtype != numpy.double:
+        raise TypeError('_ao2mo.nr_e1 is for double precision only')
+
     fdrv = getattr(libao2mo, 'AO2MOnr_e2_drv')
     pao_loc = ctypes.POINTER(ctypes.c_void_p)()
     c_nbas = ctypes.c_int(0)
@@ -184,6 +187,9 @@ def nr_e2(eri, mo_coeff, orbs_slice, aosym='s1', mosym='s1', out=None,
     if out.size == 0:
         return out
 
+    if eri.dtype != numpy.double:
+        raise TypeError('_ao2mo.nr_e2 is for double precision only')
+
     if ao_loc is None:
         pao_loc = ctypes.POINTER(ctypes.c_void_p)()
         c_nbas = ctypes.c_int(0)
@@ -283,6 +289,9 @@ def r_e2(eri, mo_coeff, orbs_slice, tao, ao_loc, aosym='s1', out=None):
     if out.size == 0:
         return out
 
+    if eri.dtype != numpy.complex128:
+        raise TypeError('_ao2mo.r_e2 is for complex double precision only')
+
     tao = numpy.asarray(tao, dtype=numpy.int32)
     if ao_loc is None:
         c_ao_loc = ctypes.POINTER(ctypes.c_void_p)()

pyscf/ao2mo/incore.py

@@ -202,6 +202,9 @@ def half_e1(eri_ao, mo_coeffs, compact=True):
     if nij_pair == 0:
         return eri1
 
+    if eri_ao.dtype != numpy.double:
+        raise TypeError('ao2mo.incore.half_e1 is for double precision only')
+
     if eri_ao.size == nao_pair**2: # 4-fold symmetry
         # half_e1 first transforms the indices which are contiguous in memory
         # transpose the 4-fold integrals to make ij the contiguous indices

pyscf/ao2mo/nrr_outcore.py

@@ -380,9 +380,9 @@ def _count_naopair(mol, nao):
     ao_loc = mol.ao_loc_2c()
     nao_pair = 0
     for i in range(mol.nbas):
-        di = ao_loc[i+1] - ao_loc[i]
+        di = int(ao_loc[i+1] - ao_loc[i])
         for j in range(i+1):
-            dj = ao_loc[j+1] - ao_loc[j]
+            dj = int(ao_loc[j+1] - ao_loc[j])
             nao_pair += di * dj
     return nao_pair
 

pyscf/ao2mo/outcore.py

@@ -710,8 +710,8 @@ def guess_shell_ranges(mol, aosym, max_iobuf, max_aobuf=None, ao_loc=None,
                        compress_diag=True):
     if ao_loc is None: ao_loc = mol.ao_loc_nr()
     max_iobuf = max(1, max_iobuf)
-
-    dims = ao_loc[1:] - ao_loc[:-1]
+    ao_loc_long = ao_loc.astype(numpy.int64)
+    dims = ao_loc_long[1:] - ao_loc_long[:-1]
     dijs = (dims.reshape(-1,1) * dims)
     nbas = dijs.shape[0]
 
@@ -773,7 +773,7 @@ def balance_partition(ao_loc, blksize, start_id=0, stop_id=None):
     displs = [i+start_id for i in displs]
     tasks = []
     for i0, i1 in zip(displs[:-1],displs[1:]):
-        tasks.append((i0, i1, ao_loc[i1]-ao_loc[i0]))
+        tasks.append((i0, i1, int(ao_loc[i1]-ao_loc[i0])))
     return tasks
 
 del (MAX_MEMORY)

pyscf/ao2mo/r_outcore.py

@@ -302,9 +302,9 @@ def _count_naopair(mol, nao):
     ao_loc = mol.ao_loc_2c()
     nao_pair = 0
     for i in range(mol.nbas):
-        di = ao_loc[i+1] - ao_loc[i]
+        di = int(ao_loc[i+1] - ao_loc[i])
         for j in range(i+1):
-            dj = ao_loc[j+1] - ao_loc[j]
+            dj = int(ao_loc[j+1] - ao_loc[j])
             nao_pair += di * dj
     return nao_pair
 

pyscf/cc/__init__.py

@@ -120,15 +120,14 @@ RCCSD.__doc__ = ccsd.CCSD.__doc__
 
 def UCCSD(mf, frozen=None, mo_coeff=None, mo_occ=None):
     from pyscf.df.df_jk import _DFHF
+    from pyscf.cc import dfuccsd
 
     mf = mf.remove_soscf()
     if not mf.istype('UHF'):
         mf = mf.to_uhf()
 
     if isinstance(mf, _DFHF) and mf.with_df:
-        # TODO: DF-UCCSD with memory-efficient particle-particle ladder,
-        # similar to dfccsd.RCCSD
-        return uccsd.UCCSD(mf, frozen, mo_coeff, mo_occ)
+        return dfuccsd.UCCSD(mf, frozen, mo_coeff, mo_occ)
     else:
         return uccsd.UCCSD(mf, frozen, mo_coeff, mo_occ)
 UCCSD.__doc__ = uccsd.UCCSD.__doc__

pyscf/cc/ccsd.py

@@ -76,10 +76,16 @@ def kernel(mycc, eris=None, t1=None, t2=None, max_cycle=50, tol=1e-8,
         normt = numpy.linalg.norm(tmpvec)
         tmpvec = None
         if mycc.iterative_damping < 1.0:
-            alpha = mycc.iterative_damping
-            t1new = (1-alpha) * t1 + alpha * t1new
-            t2new *= alpha
-            t2new += (1-alpha) * t2
+            alpha = numpy.asarray(mycc.iterative_damping)
+            if isinstance(t1, tuple): # e.g. UCCSD
+                t1new = tuple((1-alpha) * numpy.asarray(t1_part) + alpha * numpy.asarray(t1new_part)
+                    for t1_part, t1new_part in zip(t1, t1new))
+                t2new = tuple((1-alpha) * numpy.asarray(t2_part) + alpha * numpy.asarray(t2new_part)
+                    for t2_part, t2new_part in zip(t2, t2new))
+            else:
+                t1new = (1-alpha) * numpy.asarray(t1) + alpha * numpy.asarray(t1new)
+                t2new *= alpha
+                t2new += (1-alpha) * numpy.asarray(t2)
         t1, t2 = t1new, t2new
         t1new = t2new = None
         t1, t2 = mycc.run_diis(t1, t2, istep, normt, eccsd-eold, adiis)
@@ -611,6 +617,8 @@ def _contract_s1vvvv_t2(mycc, mol, vvvv, t2, out=None, verbose=None):
     # vvvv == None means AO-direct CCSD. It should redirect to
     # _contract_s4vvvv_t2(mycc, mol, vvvv, t2, out, verbose)
     assert (vvvv is not None)
+    if t2.size == 0:
+        return numpy.zeros_like(t2)
 
     time0 = logger.process_clock(), logger.perf_counter()
     log = logger.new_logger(mycc, verbose)
@@ -934,7 +942,7 @@ class CCSDBase(lib.StreamObject):
         'async_io', 'incore_complete', 'cc2', 'callback',
         'mol', 'verbose', 'stdout', 'frozen', 'level_shift',
         'mo_coeff', 'mo_occ', 'cycles', 'converged_lambda', 'emp2', 'e_hf',
-        'e_corr', 't1', 't2', 'l1', 'l2', 'chkfile',
+        'converged', 'e_corr', 't1', 't2', 'l1', 'l2', 'chkfile',
     }
 
     def __init__(self, mf, frozen=None, mo_coeff=None, mo_occ=None):

pyscf/cc/ccsd_rdm.py

@@ -377,8 +377,13 @@ def _make_rdm2(mycc, d1, d2, with_dm1=True, with_frozen=True, ao_repr=False):
 
 
 def _rdm2_mo2ao(dm2, mo):
+    '''
+    Back transform the two-particle density matrices to AO representation, where
+    the dm2 is defined in accordance with the chemist's ERI notation:
+    E = einsum('pqrs,pqrs', eri, rdm2)
+    '''
     mo_C = mo.conj()
-    return lib.einsum('ijkl,pi,qj,rk,sl->pqrs', dm2, mo, mo_C, mo, mo_C)
+    return lib.einsum('ijkl,pi,qj,rk,sl->pqrs', dm2, mo_C, mo, mo_C, mo)
 
 
 if __name__ == '__main__':

pyscf/cc/dfccsd.py

@@ -51,7 +51,7 @@ class RCCSD(ccsd.CCSD):
     to_gpu = lib.to_gpu
 
 
-def _contract_vvvv_t2(mycc, mol, vvL, t2, out=None, verbose=None):
+def _contract_vvvv_t2(mycc, mol, vvL, VVL, t2, out=None, verbose=None):
     '''Ht2 = numpy.einsum('ijcd,acdb->ijab', t2, vvvv)
 
     Args:
@@ -103,7 +103,7 @@ def _contract_vvvv_t2(mycc, mol, vvL, t2, out=None, verbose=None):
             ijL = vvL0[tril2sq[i0:i1,j0:j1] - off0].reshape(-1,naux)
             eri = numpy.ndarray(((i1-i0)*(j1-j0),nvir_pair), buffer=eribuf)
             for p0, p1 in lib.prange(0, nvir_pair, vvblk):
-                vvL1 = _cp(vvL[p0:p1])
+                vvL1 = _cp(VVL[p0:p1])
                 eri[:,p0:p1] = lib.ddot(ijL, vvL1.T)
                 vvL1 = None
 
@@ -120,7 +120,7 @@ def _contract_vvvv_t2(mycc, mol, vvL, t2, out=None, verbose=None):
 class _ChemistsERIs(ccsd._ChemistsERIs):
     def _contract_vvvv_t2(self, mycc, t2, direct=False, out=None, verbose=None):
         assert (not direct)
-        return _contract_vvvv_t2(mycc, self.mol, self.vvL, t2, out, verbose)
+        return _contract_vvvv_t2(mycc, self.mol, self.vvL, self.vvL, t2, out, verbose)
 
 def _make_df_eris(cc, mo_coeff=None):
     assert cc._scf.istype('RHF')

pyscf/cc/dfuccsd.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python
+# Copyright 2014-2025 The PySCF Developers. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import numpy as np
+from pyscf import lib
+from pyscf.lib import logger
+from pyscf import df
+from pyscf.cc import uccsd
+from pyscf.cc import ccsd
+from pyscf.cc import dfccsd
+from pyscf import __config__
+
+MEMORYMIN = getattr(__config__, 'cc_ccsd_memorymin', 2000)
+
+class UCCSD(uccsd.UCCSD):
+    _keys = {'with_df'}
+
+    def __init__(self, mf, frozen=None, mo_coeff=None, mo_occ=None):
+        uccsd.UCCSD.__init__(self, mf, frozen, mo_coeff, mo_occ)
+        if getattr(mf, 'with_df', None):
+            self.with_df = mf.with_df
+        else:
+            self.with_df = df.DF(mf.mol)
+            self.with_df.auxbasis = df.make_auxbasis(mf.mol, mp2fit=True)
+
+    def reset(self, mol=None):
+        self.with_df.reset(mol)
+        return uccsd.UCCSD.reset(self, mol)
+
+    def ao2mo(self, mo_coeff=None):
+        return _make_df_eris(self, mo_coeff)
+
+    def _add_vvvv(self, t1, t2, eris, out=None, with_ovvv=False, t2sym=None):
+        assert (not self.direct)
+        return uccsd.UCCSD._add_vvvv(self, t1, t2, eris, out, with_ovvv, t2sym)
+
+    def _add_vvVV(self, t1, t2, eris, out=None):
+        assert (not self.direct)
+        return uccsd.UCCSD._add_vvVV(self, t1, t2, eris, out)
+
+    to_gpu = lib.to_gpu
+
+class _ChemistsERIs(uccsd._ChemistsERIs):
+    def _contract_vvvv_t2(self, mycc, t2, direct=False, out=None, verbose=None):
+        assert (not direct)
+        return dfccsd._contract_vvvv_t2(mycc, self.mol, self.vvL, self.vvL, t2, out, verbose)
+    def _contract_VVVV_t2(self, mycc, t2, direct=False, out=None, verbose=None):
+        assert (not direct)
+        return dfccsd._contract_vvvv_t2(mycc, self.mol, self.VVL, self.VVL, t2, out, verbose)
+    def _contract_vvVV_t2(self, mycc, t2, direct=False, out=None, verbose=None):
+        assert (not direct)
+        return dfccsd._contract_vvvv_t2(mycc, self.mol, self.vvL, self.VVL, t2, out, verbose)
+
+def _cp(a):
+    return np.asarray(a, order='C')
+
+def _make_df_eris(mycc, mo_coeff=None):
+    assert mycc._scf.istype('UHF')
+    cput0 = (logger.process_clock(), logger.perf_counter())
+    log = logger.Logger(mycc.stdout, mycc.verbose)
+    eris = _ChemistsERIs()
+    eris._common_init_(mycc, mo_coeff)
+
+    moa, mob = eris.mo_coeff
+    nocca, noccb = eris.nocc
+    nao = moa.shape[0]
+    nmoa = moa.shape[1]
+    nmob = mob.shape[1]
+    nvira = nmoa - nocca
+    nvirb = nmob - noccb
+    nvira_pair = nvira * (nvira + 1) // 2
+    nvirb_pair = nvirb * (nvirb + 1) // 2
+    with_df = mycc.with_df
+    naux = eris.naux = with_df.get_naoaux()
+
+    # --- Three-center integrals
+    # (L|aa)
+    Loo = np.empty((naux, nocca, nocca))
+    Lov = np.empty((naux, nocca, nvira))
+    Lvo = np.empty((naux, nvira, nocca))
+    # (L|bb)
+    LOO = np.empty((naux, noccb, noccb))
+    LOV = np.empty((naux, noccb, nvirb))
+    LVO = np.empty((naux, nvirb, noccb))
+
+    # --- Four-center integrals
+    eris.feri = lib.H5TmpFile()
+    # (aa|aa)
+    eris.oooo = eris.feri.create_dataset('oooo', (nocca,nocca,nocca,nocca), 'f8')
+    eris.oovv = eris.feri.create_dataset('oovv', (nocca,nocca,nvira,nvira), 'f8', chunks=(nocca,nocca,1,nvira))
+    eris.ovoo = eris.feri.create_dataset('ovoo', (nocca,nvira,nocca,nocca), 'f8', chunks=(nocca,1,nocca,nocca))
+    eris.ovvo = eris.feri.create_dataset('ovvo', (nocca,nvira,nvira,nocca), 'f8', chunks=(nocca,1,nvira,nocca))
+    eris.ovov = eris.feri.create_dataset('ovov', (nocca,nvira,nocca,nvira), 'f8', chunks=(nocca,1,nocca,nvira))
+    # (bb|bb)
+    eris.OOOO = eris.feri.create_dataset('OOOO', (noccb,noccb,noccb,noccb), 'f8')
+    eris.OOVV = eris.feri.create_dataset('OOVV', (noccb,noccb,nvirb,nvirb), 'f8', chunks=(noccb,noccb,1,nvirb))
+    eris.OVOO = eris.feri.create_dataset('OVOO', (noccb,nvirb,noccb,noccb), 'f8', chunks=(noccb,1,noccb,noccb))
+    eris.OVVO = eris.feri.create_dataset('OVVO', (noccb,nvirb,nvirb,noccb), 'f8', chunks=(noccb,1,nvirb,noccb))
+    eris.OVOV = eris.feri.create_dataset('OVOV', (noccb,nvirb,noccb,nvirb), 'f8', chunks=(noccb,1,noccb,nvirb))
+    # (aa|bb)
+    eris.ooOO = eris.feri.create_dataset('ooOO', (nocca,nocca,noccb,noccb), 'f8')
+    eris.ooVV = eris.feri.create_dataset('ooVV', (nocca,nocca,nvirb,nvirb), 'f8', chunks=(nocca,nocca,1,nvirb))
+    eris.ovOO = eris.feri.create_dataset('ovOO', (nocca,nvira,noccb,noccb), 'f8', chunks=(nocca,1,noccb,noccb))
+    eris.ovVO = eris.feri.create_dataset('ovVO', (nocca,nvira,nvirb,noccb), 'f8', chunks=(nocca,1,nvirb,noccb))
+    eris.ovOV = eris.feri.create_dataset('ovOV', (nocca,nvira,noccb,nvirb), 'f8', chunks=(nocca,1,noccb,nvirb))
+    # (bb|aa)
+    eris.OOvv = eris.feri.create_dataset('OOvv', (noccb,noccb,nvira,nvira), 'f8', chunks=(noccb,noccb,1,nvira))
+    eris.OVoo = eris.feri.create_dataset('OVoo', (noccb,nvirb,nocca,nocca), 'f8', chunks=(noccb,1,nocca,nocca))
+    eris.OVvo = eris.feri.create_dataset('OVvo', (noccb,nvirb,nvira,nocca), 'f8', chunks=(noccb,1,nvira,nocca))
+
+    # nrow ~ 4e9/8/blockdim to ensure hdf5 chunk < 4GB
+    chunks = (min(nvira_pair, int(4e8 / with_df.blockdim)), min(naux, with_df.blockdim))
+    eris.vvL = eris.feri.create_dataset('vvL', (nvira_pair,naux), 'f8', chunks=chunks)
+    chunks = (min(nvirb_pair, int(4e8 / with_df.blockdim)), min(naux, with_df.blockdim))
+    eris.VVL = eris.feri.create_dataset('VVL', (nvirb_pair,naux), 'f8', chunks=chunks)
+
+    # Transform three-center integrals to MO basis
+    p1 = 0
+    for eri1 in with_df.loop():
+        eri1 = lib.unpack_tril(eri1).reshape(-1, nao, nao)
+        # (L|aa)
+        Lpq = lib.einsum('Lab,ap,bq->Lpq', eri1, moa, moa)
+        p0, p1 = p1, p1 + Lpq.shape[0]
+        blk = np.s_[p0:p1]
+        Loo[blk] = Lpq[:, :nocca, :nocca]
+        Lov[blk] = Lpq[:, :nocca, nocca:]
+        Lvo[blk] = Lpq[:, nocca:, :nocca]
+        eris.vvL[:, p0:p1] = lib.pack_tril(Lpq[:, nocca:, nocca:]).T
+        # (L|bb)
+        Lpq = None
+        Lpq = lib.einsum('Lab,ap,bq->Lpq', eri1, mob, mob)
+        LOO[blk] = Lpq[:, :noccb, :noccb]
+        LOV[blk] = Lpq[:, :noccb, noccb:]
+        LVO[blk] = Lpq[:, noccb:, :noccb]
+        eris.VVL[:, p0:p1] = lib.pack_tril(Lpq[:, noccb:, noccb:]).T
+        Lpq = None
+
+    Loo = Loo.reshape(naux, nocca * nocca)
+    Lov = Lov.reshape(naux, nocca * nvira)
+    Lvo = Lvo.reshape(naux, nocca * nvira)
+    LOO = LOO.reshape(naux, noccb * noccb)
+    LOV = LOV.reshape(naux, noccb * nvirb)
+    LVO = LVO.reshape(naux, noccb * nvirb)
+
+    eris.oooo[:] = lib.ddot(Loo.T, Loo).reshape(nocca,nocca,nocca,nocca)
+    eris.ovoo[:] = lib.ddot(Lov.T, Loo).reshape(nocca,nvira,nocca,nocca)
+    eris.ovvo[:] = lib.ddot(Lov.T, Lvo).reshape(nocca,nvira,nvira,nocca)
+    eris.ovov[:] = lib.ddot(Lov.T, Lov).reshape(nocca,nvira,nocca,nvira)
+
+    eris.OVoo[:] = lib.ddot(LOV.T, Loo).reshape(noccb,nvirb,nocca,nocca)
+    eris.OVvo[:] = lib.ddot(LOV.T, Lvo).reshape(noccb,nvirb,nvira,nocca)
+
+    Lvo = None
+
+    eris.OOOO[:] = lib.ddot(LOO.T, LOO).reshape(noccb,noccb,noccb,noccb)
+    eris.OVOO[:] = lib.ddot(LOV.T, LOO).reshape(noccb,nvirb,noccb,noccb)
+    eris.OVVO[:] = lib.ddot(LOV.T, LVO).reshape(noccb,nvirb,nvirb,noccb)
+    eris.OVOV[:] = lib.ddot(LOV.T, LOV).reshape(noccb,nvirb,noccb,nvirb)
+
+    eris.ooOO[:] = lib.ddot(Loo.T, LOO).reshape(nocca,nocca,noccb,noccb)
+    eris.ovOO[:] = lib.ddot(Lov.T, LOO).reshape(nocca,nvira,noccb,noccb)
+    eris.ovVO[:] = lib.ddot(Lov.T, LVO).reshape(nocca,nvira,nvirb,noccb)
+    eris.ovOV[:] = lib.ddot(Lov.T, LOV).reshape(nocca,nvira,noccb,nvirb)
+
+    LVO = None
+
+    mem_now = lib.current_memory()[0]
+    max_memory = max(0, mycc.max_memory - mem_now)
+
+    # eris.oovv
+    blksize = max(ccsd.BLKMIN, int((max_memory*.9e6/8-nocca**2*nvira_pair)/(nocca**2+naux)))
+    oovv_tril = np.empty((nocca * nocca, nvira_pair))
+    for p0, p1 in lib.prange(0, nvira_pair, blksize):
+        oovv_tril[:, p0:p1] = lib.ddot(Loo.T, _cp(eris.vvL[p0:p1]).T)
+    eris.oovv[:] = lib.unpack_tril(oovv_tril).reshape(nocca, nocca, nvira, nvira)
+    oovv_tril = None
+
+    # eris.ooVV
+    blksize = max(ccsd.BLKMIN, int((max_memory*.9e6/8-nocca**2*nvirb_pair)/(nocca**2+naux)))
+    oovv_tril = np.empty((nocca * nocca, nvirb_pair))
+    for p0, p1 in lib.prange(0, nvirb_pair, blksize):
+        oovv_tril[:, p0:p1] = lib.ddot(Loo.T, _cp(eris.VVL[p0:p1]).T)
+    eris.ooVV[:] = lib.unpack_tril(oovv_tril).reshape(nocca, nocca, nvirb, nvirb)
+    oovv_tril = Loo = None
+
+    mem_now = lib.current_memory()[0]
+    max_memory = max(0, mycc.max_memory - mem_now)
+
+    # eris.OOvv
+    blksize = max(ccsd.BLKMIN, int((max_memory*.9e6/8-noccb**2*nvira_pair)/(noccb**2+naux)))
+    oovv_tril = np.empty((noccb * noccb, nvira_pair))
+    for p0, p1 in lib.prange(0, nvira_pair, blksize):
+        oovv_tril[:, p0:p1] = lib.ddot(LOO.T, _cp(eris.vvL[p0:p1]).T)
+    eris.OOvv[:] = lib.unpack_tril(oovv_tril).reshape(noccb, noccb, nvira, nvira)
+    oovv_tril = None
+
+    # eris.OOVV
+    blksize = max(ccsd.BLKMIN, int((max_memory*.9e6/8-noccb**2*nvirb_pair)/(noccb**2+naux)))
+    oovv_tril = np.empty((noccb * noccb, nvirb_pair))
+    for p0, p1 in lib.prange(0, nvirb_pair, blksize):
+        oovv_tril[:, p0:p1] = lib.ddot(LOO.T, _cp(eris.VVL[p0:p1]).T)
+    eris.OOVV[:] = lib.unpack_tril(oovv_tril).reshape(noccb, noccb, nvirb, nvirb)
+    oovv_tril = LOO = None
+
+    mem_now = lib.current_memory()[0]
+    max_memory = max(0, mycc.max_memory - mem_now)
+
+    Lov = Lov.reshape(naux, nocca, nvira)
+    LOV = LOV.reshape(naux, noccb, nvirb)
+
+    # eris.ovvv
+    vblk = max(nocca, int((max_memory*.15e6/8)/(nocca*nvira_pair)))
+    vvblk = int(min(nvira_pair, 4e8/nocca, max(4, (max_memory*.8e6/8)/(vblk*nocca+naux))))
+    eris.ovvv = eris.feri.create_dataset('ovvv', (nocca, nvira, nvira_pair), 'f8', chunks=(nocca, 1, vvblk))
+    for q0, q1 in lib.prange(0, nvira_pair, vvblk):
+        vvL = _cp(eris.vvL[q0:q1])
+        for p0, p1 in lib.prange(0, nvira, vblk):
+            tmpLov = Lov[:, :, p0:p1].reshape(naux, -1)
+            eris.ovvv[:, p0:p1, q0:q1] = lib.ddot(tmpLov.T, vvL.T).reshape(nocca, p1 - p0, q1 - q0)
+        vvL = None
+
+    # eris.ovVV
+    vblk = max(nocca, int((max_memory*.15e6/8)/(nocca*nvirb_pair)))
+    vvblk = int(min(nvirb_pair, 4e8/nocca, max(4, (max_memory*.8e6/8)/(vblk*nocca+naux))))
+    eris.ovVV = eris.feri.create_dataset('ovVV', (nocca, nvira, nvirb_pair), 'f8', chunks=(nocca, 1, vvblk))
+    for q0, q1 in lib.prange(0, nvirb_pair, vvblk):
+        vvL = _cp(eris.VVL[q0:q1])
+        for p0, p1 in lib.prange(0, nvira, vblk):
+            tmpLov = Lov[:, :, p0:p1].reshape(naux, -1)
+            eris.ovVV[:, p0:p1, q0:q1] = lib.ddot(tmpLov.T, vvL.T).reshape(nocca, p1 - p0, q1 - q0)
+        vvL = None
+    Lov = None
+
+    mem_now = lib.current_memory()[0]
+    max_memory = max(0, mycc.max_memory - mem_now)
+
+    # eris.OVvv
+    vblk = max(noccb, int((max_memory*.15e6/8)/(noccb*nvira_pair)))
+    vvblk = int(min(nvira_pair, 4e8/noccb, max(4, (max_memory*.8e6/8)/(vblk*noccb+naux))))
+    eris.OVvv = eris.feri.create_dataset('OVvv', (noccb, nvirb, nvira_pair), 'f8', chunks=(noccb, 1, vvblk))
+    for q0, q1 in lib.prange(0, nvira_pair, vvblk):
+        vvL = _cp(eris.vvL[q0:q1])
+        for p0, p1 in lib.prange(0, nvirb, vblk):
+            tmpLov = LOV[:, :, p0:p1].reshape(naux, -1)
+            eris.OVvv[:, p0:p1, q0:q1] = lib.ddot(tmpLov.T, vvL.T).reshape(noccb, p1 - p0, q1 - q0)
+        vvL = None
+
+    # eris.OVVV
+    vblk = max(noccb, int((max_memory*.15e6/8)/(noccb*nvirb_pair)))
+    vvblk = int(min(nvirb_pair, 4e8/noccb, max(4, (max_memory*.8e6/8)/(vblk*noccb+naux))))
+    eris.OVVV = eris.feri.create_dataset('OVVV', (noccb, nvirb, nvirb_pair), 'f8', chunks=(noccb, 1, vvblk))
+    for q0, q1 in lib.prange(0, nvirb_pair, vvblk):
+        vvL = _cp(eris.VVL[q0:q1])
+        for p0, p1 in lib.prange(0, nvirb, vblk):
+            tmpLov = LOV[:, :, p0:p1].reshape(naux, -1)
+            eris.OVVV[:, p0:p1, q0:q1] = lib.ddot(tmpLov.T, vvL.T).reshape(noccb, p1 - p0, q1 - q0)
+        vvL = None
+    LOV = None
+
+    log.timer('DF-UCCSD integral transformation', *cput0)
+    return eris
+
+if __name__ == '__main__':
+    from pyscf import gto
+    from pyscf import scf
+
+    mol = gto.Mole()
+    mol.atom = [
+        [8 , (0. , 0.     , 0.)],
+        [1 , (0. , -0.757 , 0.587)],
+        [1 , (0. , 0.757  , 0.587)]]
+
+    mol.basis = 'cc-pvdz'
+    mol.build()
+    mf = scf.UHF(mol).density_fit('weigend').run()
+    mycc = UCCSD(mf).run()
+    print(mycc.e_corr - -0.2133709727796199)
+
+    print("IP energies... (right eigenvector)")
+    e,v = mycc.ipccsd(nroots=8)
+    print(e)
+    print(e[0] - 0.4336428577342009)
+    print(e[2] - 0.5188000951518845)
+    print(e[4] - 0.6785158684375829)
+
+    print("EA energies... (right eigenvector)")
+    e,v = mycc.eaccsd(nroots=8)
+    print(e)
+    print(e[0] - 0.1673013569134136)
+    print(e[2] - 0.2399984284491973)
+    print(e[4] - 0.5096018470162480)
+
+    e, v = mycc.eeccsd(nroots=4)
+    print(e[0] - 0.2757563806054133)
+    print(e[1] - 0.2757563806171079)
+    print(e[2] - 0.2757563806183815)
+    print(e[3] - 0.3006896721085447)

pyscf/cc/gccsd.py

@@ -128,8 +128,8 @@ class GCCSD(ccsd.CCSDBase):
         eijab = lib.direct_sum('ia,jb->ijab', eia, eia)
         t1 = eris.fock[:nocc,nocc:] / eia
         eris_oovv = np.array(eris.oovv)
-        t2 = eris_oovv / eijab
-        self.emp2 = 0.25*einsum('ijab,ijab', t2, eris_oovv.conj()).real
+        t2 = eris_oovv.conj() / eijab
+        self.emp2 = 0.25*einsum('ijab,ijab', t2, eris_oovv).real
         logger.info(self, 'Init t2, MP2 energy = %.15g', self.emp2)
         return self.emp2, t1, t2
 

pyscf/cc/rccsd.py

@@ -247,7 +247,11 @@ def _make_eris_incore(mycc, mo_coeff=None, ao2mofn=None):
         eri1 = ao2mofn(eris.mo_coeff).reshape([nmo]*4)
     else:
         eri1 = ao2mo.incore.full(mycc._scf._eri, eris.mo_coeff)
-        eri1 = ao2mo.restore(1, eri1, nmo)
+        if mycc._scf._eri.size == nmo**4:
+            # The N^4-sized full integral tensor.
+            eri1 = eri1.reshape([nmo]*4)
+        else:
+            eri1 = ao2mo.restore(1, eri1, nmo)
     eris.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy()
     eris.ovoo = eri1[:nocc,nocc:,:nocc,:nocc].copy()
     eris.ovov = eri1[:nocc,nocc:,:nocc,nocc:].copy()