pyscf 2.8.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.8.0'
+__version__ = '2.9.0'
 
 import os
 import sys

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/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/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()

pyscf/cc/uccsd.py

@@ -236,8 +236,8 @@ def update_amps(cc, t1, t2, eris):
     u1a -= np.einsum('imea,me->ia', t2aa, Fova)
     u1a += np.einsum('iMaE,ME->ia', t2ab, Fovb)
     u1b += fovb.conj()
-    u1b += np.einsum('ie,ae->ia',t1b,Fvvb)
-    u1b -= np.einsum('ma,mi->ia',t1b,Foob)
+    u1b += np.einsum('ie,ae->ia', t1b, Fvvb)
+    u1b -= np.einsum('ma,mi->ia', t1b, Foob)
     u1b -= np.einsum('imea,me->ia', t2bb, Fovb)
     u1b += np.einsum('mIeA,me->IA', t2ab, Fova)
 
@@ -246,8 +246,8 @@ def update_amps(cc, t1, t2, eris):
     wovvo -= eris_oovv.transpose(0,2,3,1)
     wovvo += eris_ovvo.transpose(0,2,1,3)
     oovv = eris_oovv - eris_ovvo.transpose(0,3,2,1)
-    u1a-= np.einsum('nf,niaf->ia', t1a,      oovv)
-    tmp1aa = lib.einsum('ie,mjbe->mbij', t1a,      oovv)
+    u1a-= np.einsum('nf,niaf->ia', t1a, oovv)
+    tmp1aa = lib.einsum('ie,mjbe->mbij', t1a, oovv)
     u2aa += 2*lib.einsum('ma,mbij->ijab', t1a, tmp1aa)
     eris_ovvo = eris_oovv = oovv = tmp1aa = None
 
@@ -256,8 +256,8 @@ def update_amps(cc, t1, t2, eris):
     wOVVO -= eris_OOVV.transpose(0,2,3,1)
     wOVVO += eris_OVVO.transpose(0,2,1,3)
     OOVV = eris_OOVV - eris_OVVO.transpose(0,3,2,1)
-    u1b-= np.einsum('nf,niaf->ia', t1b,      OOVV)
-    tmp1bb = lib.einsum('ie,mjbe->mbij', t1b,      OOVV)
+    u1b-= np.einsum('nf,niaf->ia', t1b, OOVV)
+    tmp1bb = lib.einsum('ie,mjbe->mbij', t1b, OOVV)
     u2bb += 2*lib.einsum('ma,mbij->ijab', t1b, tmp1bb)
     eris_OVVO = eris_OOVV = OOVV = None
 
@@ -356,16 +356,16 @@ def energy(cc, t1=None, t2=None, eris=None):
     fovb = eris.fockb[:noccb,noccb:]
     e  = np.einsum('ia,ia', fova, t1a)
     e += np.einsum('ia,ia', fovb, t1b)
-    e += 0.25*np.einsum('ijab,iajb',t2aa,eris_ovov)
-    e -= 0.25*np.einsum('ijab,ibja',t2aa,eris_ovov)
-    e += 0.25*np.einsum('ijab,iajb',t2bb,eris_OVOV)
-    e -= 0.25*np.einsum('ijab,ibja',t2bb,eris_OVOV)
-    e +=      np.einsum('iJaB,iaJB',t2ab,eris_ovOV)
-    e += 0.5*np.einsum('ia,jb,iajb',t1a,t1a,eris_ovov)
-    e -= 0.5*np.einsum('ia,jb,ibja',t1a,t1a,eris_ovov)
-    e += 0.5*np.einsum('ia,jb,iajb',t1b,t1b,eris_OVOV)
-    e -= 0.5*np.einsum('ia,jb,ibja',t1b,t1b,eris_OVOV)
-    e +=     np.einsum('ia,jb,iajb',t1a,t1b,eris_ovOV)
+    e += 0.25*np.einsum('ijab,iajb',t2aa, eris_ovov)
+    e -= 0.25*np.einsum('ijab,ibja',t2aa, eris_ovov)
+    e += 0.25*np.einsum('ijab,iajb',t2bb, eris_OVOV)
+    e -= 0.25*np.einsum('ijab,ibja',t2bb, eris_OVOV)
+    e +=      np.einsum('iJaB,iaJB',t2ab, eris_ovOV)
+    e += 0.5*lib.einsum('ia,jb,iajb',t1a, t1a, eris_ovov)
+    e -= 0.5*lib.einsum('ia,jb,ibja',t1a, t1a, eris_ovov)
+    e += 0.5*lib.einsum('ia,jb,iajb',t1b, t1b, eris_OVOV)
+    e -= 0.5*lib.einsum('ia,jb,ibja',t1b, t1b, eris_OVOV)
+    e +=     lib.einsum('ia,jb,iajb',t1a, t1b, eris_ovOV)
     if abs(e.imag) > 1e-4:
         logger.warn(cc, 'Non-zero imaginary part found in UCCSD energy %s', e)
     return e.real
@@ -687,11 +687,10 @@ class UCCSD(ccsd.CCSDBase):
             return _make_eris_incore(self, mo_coeff)
 
         elif getattr(self._scf, 'with_df', None):
-            # TODO: Uncomment once there is an unrestricted DF-CCSD implementation
-            #logger.warn(self, 'UCCSD detected DF being used in the HF object. '
-            #            'MO integrals are computed based on the DF 3-index tensors.\n'
-            #            'It\'s recommended to use dfccsd.CCSD for the '
-            #            'DF-CCSD calculations')
+            logger.warn(self, 'UCCSD detected DF being used in the HF object. '
+                       'MO integrals are computed based on the DF 3-index tensors.\n'
+                       'It\'s recommended to use dfuccsd.UCCSD for the '
+                       'DF-UCCSD calculations')
             return _make_df_eris_outcore(self, mo_coeff)
         else:
             return _make_eris_outcore(self, mo_coeff)
@@ -732,6 +731,16 @@ class UCCSD(ccsd.CCSDBase):
         from pyscf.cc import eom_uccsd
         return eom_uccsd.EOMEE(self)
 
+    def density_fit(self, auxbasis=None, with_df=None):
+        from pyscf.cc import dfuccsd
+        mycc = dfuccsd.UCCSD(self._scf, self.frozen, self.mo_coeff, self.mo_occ)
+        if with_df is not None:
+            mycc.with_df = with_df
+        if mycc.with_df.auxbasis != auxbasis:
+            mycc.with_df = mycc.with_df.copy()
+            mycc.with_df.auxbasis = auxbasis
+        return mycc
+
     def nuc_grad_method(self):
         from pyscf.grad import uccsd
         return uccsd.Gradients(self)

pyscf/df/addons.py

@@ -52,8 +52,10 @@ DEFAULT_AUXBASIS = {
     'def2svp'     : ('def2-svp-jkfit'         , 'def2-svp-ri'        ),
     'def2svpd'    : ('def2-svp-jkfit'         , 'def2-svpd-ri'       ),
     'def2tzvp'    : ('def2-tzvp-jkfit'        , 'def2-tzvp-ri'       ),
+    'def2mtzvp'   : ('def2-tzvp-jkfit'        , 'def2-tzvp-ri'       ),
     'def2tzvpd'   : ('def2-tzvp-jkfit'        , 'def2-tzvpd-ri'      ),
     'def2tzvpp'   : ('def2-tzvpp-jkfit'       , 'def2-tzvpp-ri'      ),
+    'def2mtzvpp'  : ('def2-tzvpp-jkfit'       , 'def2-tzvpp-ri'      ),
     'def2tzvppd'  : ('def2-tzvpp-jkfit'       , 'def2-tzvppd-ri'     ),
     'def2qzvp'    : ('def2-qzvp-jkfit'        , 'def2-qzvp-ri'       ),
     'def2qzvpd'   : ('def2-qzvp-jkfit'        , None                 ),
@@ -174,6 +176,9 @@ def make_auxbasis(mol, mp2fit=False):
         _basis = {a: default_basis for a in uniq_atoms}
         _basis.update(mol.basis)
         del (_basis['default'])
+    elif (isinstance(mol.basis, dict) and
+            all([isinstance(basis, str) for basis in mol.basis.values()])):
+        _basis = {a: mol.basis[a] for a in uniq_atoms}
     else:
         _basis = mol._basis or {}
 
@@ -191,7 +196,7 @@ def make_auxbasis(mol, mp2fit=False):
                 if auxb is not None:
                     try:
                         # Test if basis auxb for element k is available
-                        gto.basis.load(auxb, k)
+                        gto.basis.load(auxb, elements._std_symbol_without_ghost(k))
                     except BasisNotFoundError:
                         pass
                     else:

pyscf/df/df_jk.py

@@ -258,6 +258,33 @@ def get_jk(dfobj, dm, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-13):
     vj = 0
     vk = numpy.zeros_like(dms)
 
+    if numpy.iscomplexobj(dms):
+        if with_j:
+            vj = numpy.zeros_like(dms)
+        max_memory = dfobj.max_memory - lib.current_memory()[0]
+        blksize = max(4, int(min(dfobj.blockdim, max_memory*.22e6/8/nao**2)))
+        buf = numpy.empty((blksize,nao,nao))
+        buf1 = numpy.empty((nao,blksize,nao))
+        for eri1 in dfobj.loop(blksize):
+            naux, nao_pair = eri1.shape
+            eri1 = lib.unpack_tril(eri1, out=buf)
+            if with_j:
+                tmp = numpy.einsum('pij,nji->pn', eri1, dms.real)
+                vj.real += numpy.einsum('pn,pij->nij', tmp, eri1)
+                tmp = numpy.einsum('pij,nji->pn', eri1, dms.imag)
+                vj.imag += numpy.einsum('pn,pij->nij', tmp, eri1)
+            buf2 = numpy.ndarray((nao,naux,nao), buffer=buf1)
+            for k in range(nset):
+                buf2[:] = lib.einsum('pij,jk->ipk', eri1, dms[k].real)
+                vk[k].real += lib.einsum('ipk,pkj->ij', buf2, eri1)
+                buf2[:] = lib.einsum('pij,jk->ipk', eri1, dms[k].imag)
+                vk[k].imag += lib.einsum('ipk,pkj->ij', buf2, eri1)
+            t1 = log.timer_debug1('jk', *t1)
+        if with_j: vj = vj.reshape(dm_shape)
+        if with_k: vk = vk.reshape(dm_shape)
+        logger.timer(dfobj, 'df vj and vk', *t0)
+        return vj, vk
+
     if with_j:
         idx = numpy.arange(nao)
         dmtril = lib.pack_tril(dms + dms.conj().transpose(0,2,1))
@@ -322,6 +349,7 @@ def get_jk(dfobj, dm, hermi=0, with_j=True, with_k=True, direct_scf_tol=1e-13):
         buf = numpy.empty((2,blksize,nao,nao))
         for eri1 in dfobj.loop(blksize):
             naux, nao_pair = eri1.shape
+            assert (nao_pair == nao*(nao+1)//2)
             if with_j:
                 # uses numpy.matmul
                 vj += dmtril.dot(eri1.T).dot(eri1)
@@ -388,6 +416,7 @@ def get_j(dfobj, dm, hermi=0, direct_scf_tol=1e-13):
     opt = dfobj._vjopt
     fakemol = opt.fakemol
     dm = numpy.asarray(dm, order='C')
+    assert dm.dtype == numpy.float64
     dm_shape = dm.shape
     nao = dm_shape[-1]
     dm = dm.reshape(-1,nao,nao)

pyscf/df/hessian/uhf.py

@@ -465,9 +465,9 @@ def _gen_jk(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None,
             vj1_buf[i] += np.einsum('xp,pij->xij', wj1, coef3c)
         if with_k:
             rhok0_PlJ = lib.einsum('plj,Jj->plJ', rhok0a_Pl_[p0:p1], mocca)
-            vk1a_buf += lib.einsum('xijp,plj->xil', int3c_ip1, rhok0_PlJ[p0:p1])
+            vk1a_buf += lib.einsum('xijp,plj->xil', int3c_ip1, rhok0_PlJ)
             rhok0_PlJ = lib.einsum('plj,Jj->plJ', rhok0b_Pl_[p0:p1], moccb)
-            vk1b_buf += lib.einsum('xijp,plj->xil', int3c_ip1, rhok0_PlJ[p0:p1])
+            vk1b_buf += lib.einsum('xijp,plj->xil', int3c_ip1, rhok0_PlJ)
         int3c_ip1 = None
     vj1_buf = ftmp['vj1_buf'] = vj1_buf
 

pyscf/df/incore.py

@@ -62,7 +62,7 @@ def aux_e2(mol, auxmol_or_auxbasis, intor='int3c2e', aosym='s1', comp=None, out=
                       mol.nbas, mol.nbas+auxmol.nbas)
     else:
         assert len(shls_slice) == 6
-        assert shls_slice[5] < auxmol.nbas
+        assert shls_slice[5] <= auxmol.nbas
         shls_slice = list(shls_slice)
         shls_slice[4] += mol.nbas
         shls_slice[5] += mol.nbas

pyscf/dft/libxc.py

@@ -19,7 +19,7 @@
 
 '''
 XC functional, the interface to libxc
-(http://www.tddft.org/programs/octopus/wiki/index.php/Libxc)
+(https://libxc.gitlab.io)
 '''
 
 import sys

pyscf/fci/fci_dhf_slow.py

@@ -76,7 +76,7 @@ def kernel(h1e, eri, norb, nelec, ecore=0, nroots=1, verbose=3):
 
 
 # dm_pq = <|p^+ q|>
-def make_rdm1(fcivec, norb, nelec, link_index=None):
+def make_rdm1_slow(fcivec, norb, nelec, link_index=None):
     if link_index is None:
         link_index = cistring.gen_linkstr_index(range(norb), nelec)
     rdm1 = numpy.zeros((norb, norb), dtype=fcivec.dtype)
@@ -85,6 +85,20 @@ def make_rdm1(fcivec, norb, nelec, link_index=None):
             rdm1[a, i] += sign * numpy.dot(fcivec[str1].conj(), fcivec[str0])
     return rdm1
 
+
+# dm_pq = <|p^+ q|>
+def make_rdm1(fcivec, norb, nelec, link_index=None):
+    if nelec == 0:
+        return numpy.zeros((norb, norb), dtype=fcivec.dtype)
+    nd = cistring.num_strings(norb, nelec - 1)
+    index_d = cistring.gen_des_str_index(range(norb), nelec)
+    dci = numpy.zeros((nd, norb), dtype=fcivec.dtype)
+    for str0, tab in enumerate(index_d):
+        for _, i, str1, sign in tab:
+            dci[str1, i] += sign * fcivec[str0]
+    return dci.conj().T @ dci
+
+
 # dm_pq,rs = <|p^+ q r^+ s|>
 def make_rdm12(fcivec, norb, nelec, link_index=None, reorder=True):
     if link_index is None:

pyscf/grad/sacasscf.py

@@ -444,6 +444,8 @@ class Gradients (lagrange.Gradients):
             self.e_states = np.asarray (mc.e_tot)
         if isinstance (mc, StateAverageMCSCFSolver):
             self.weights = np.asarray (mc.weights)
+        if np.amax (self.weights) - np.amin (self.weights) > 1e-8:
+            raise NotImplementedError ("Unequal weights in SA-CASSCF gradients")
         assert (len (self.weights) == self.nroots), '{} {} {}'.format (
             mc.fcisolver.__class__, self.weights, self.nroots)
         lagrange.Gradients.__init__(self, mc, self.ngorb+self.nci)