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

pyscf/adc/uadc_ea.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>
 #
 
@@ -287,22 +290,13 @@ def get_imds(adc, eris=None):
             M_ab_a += lib.einsum('mlfd,mled,aebf->ab',t2_1_ab, t2_1_ab, eris_vvvv, optimize=True)
             del eris_vvvv
 
-            temp = np.zeros((nocc_a,nocc_a,nvir_a,nvir_a))
-            temp[:,:,ab_ind_a[0],ab_ind_a[1]] =  adc.imds.t2_1_vvvv[0]
-            temp[:,:,ab_ind_a[1],ab_ind_a[0]] = -adc.imds.t2_1_vvvv[0]
-
-            M_ab_a -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',t2_1_a, temp, optimize=True)
-            del temp
-
+            M_ab_a -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',
+                                                t2_1_a, adc.imds.t2_1_vvvv[0], optimize=True)
         else:
-
-            temp_t2a_vvvv = np.zeros((nocc_a,nocc_a,nvir_a,nvir_a))
-            temp_t2a_vvvv[:,:,ab_ind_a[0],ab_ind_a[1]] = adc.imds.t2_1_vvvv[0][:]
-            temp_t2a_vvvv[:,:,ab_ind_a[1],ab_ind_a[0]] = -adc.imds.t2_1_vvvv[0][:]
-
-            M_ab_a -= 2*0.5*0.25*lib.einsum('mlad,mlbd->ab',  temp_t2a_vvvv, t2_1_a, optimize=True)
-            M_ab_a -= 2*0.5*0.25*lib.einsum('mlaf,mlbf->ab', t2_1_a, temp_t2a_vvvv, optimize=True)
-            del temp_t2a_vvvv
+            M_ab_a -= 2*0.5*0.25*lib.einsum('mlad,mlbd->ab',
+                                            adc.imds.t2_1_vvvv[0], t2_1_a, optimize=True)
+            M_ab_a -= 2*0.5*0.25*lib.einsum('mlaf,mlbf->ab', t2_1_a,
+                                            adc.imds.t2_1_vvvv[0], optimize=True)
 
         if isinstance(eris.vvvv_p, list):
 
@@ -387,18 +381,20 @@ def get_imds(adc, eris=None):
             M_ab_b += lib.einsum('mlfd,mled,eafb->ab',t2_1_ab, t2_1_ab,   eris_vVvV, optimize=True)
 
             eris_vVvV = eris_vVvV.reshape(nvir_a*nvir_b,nvir_a*nvir_b)
-            temp = adc.imds.t2_1_vvvv[1]
-            M_ab_a -= 0.5*lib.einsum('mlaf,mlbf->ab',t2_1_ab, temp, optimize=True)
-            M_ab_b -= 0.5*lib.einsum('mlfa,mlfb->ab',t2_1_ab, temp, optimize=True)
-            del temp
+
+            M_ab_a -= 0.5*lib.einsum('mlaf,mlbf->ab',t2_1_ab, adc.imds.t2_1_vvvv[1], optimize=True)
+            M_ab_b -= 0.5*lib.einsum('mlfa,mlfb->ab',t2_1_ab, adc.imds.t2_1_vvvv[1], optimize=True)
+
         else:
-            t2_vVvV = adc.imds.t2_1_vvvv[1][:]
+            M_ab_a -= 0.5 * lib.einsum('mlad,mlbd->ab',
+                                       adc.imds.t2_1_vvvv[1], t2_1_ab, optimize=True)
+            M_ab_b -= 0.5 * lib.einsum('mlda,mldb->ab',
+                                       adc.imds.t2_1_vvvv[1], t2_1_ab, optimize=True)
+            M_ab_a -= 0.5 * lib.einsum('mlaf,mlbf->ab', t2_1_ab,
+                                       adc.imds.t2_1_vvvv[1], optimize=True)
+            M_ab_b -= 0.5 * lib.einsum('mlfa,mlfb->ab', t2_1_ab,
+                                       adc.imds.t2_1_vvvv[1], optimize=True)
 
-            M_ab_a -= 0.5 * lib.einsum('mlad,mlbd->ab', t2_vVvV, t2_1_ab, optimize=True)
-            M_ab_b -= 0.5 * lib.einsum('mlda,mldb->ab', t2_vVvV, t2_1_ab, optimize=True)
-            M_ab_a -= 0.5 * lib.einsum('mlaf,mlbf->ab',t2_1_ab, t2_vVvV, optimize=True)
-            M_ab_b -= 0.5 * lib.einsum('mlfa,mlfb->ab',t2_1_ab, t2_vVvV, optimize=True)
-            del t2_vVvV
         del t2_1_a
 
         if isinstance(eris.VVVV_p,np.ndarray):
@@ -409,22 +405,13 @@ def get_imds(adc, eris=None):
             M_ab_b += lib.einsum('mldf,mlde,aebf->ab',t2_1_ab, t2_1_ab, eris_VVVV, optimize=True)
             del eris_VVVV
 
-            temp = np.zeros((nocc_b,nocc_b,nvir_b,nvir_b))
-            temp[:,:,ab_ind_b[0],ab_ind_b[1]] =  adc.imds.t2_1_vvvv[2]
-            temp[:,:,ab_ind_b[1],ab_ind_b[0]] = -adc.imds.t2_1_vvvv[2]
-            M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',t2_1_b, temp, optimize=True)
-            del temp
+            M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',
+                                                t2_1_b, adc.imds.t2_1_vvvv[2], optimize=True)
         else:
-
-            temp_t2b_VVVV = np.zeros((nocc_b,nocc_b,nvir_b,nvir_b))
-            temp_t2b_VVVV[:,:,ab_ind_b[0],ab_ind_b[1]] = adc.imds.t2_1_vvvv[2][:]
-            temp_t2b_VVVV[:,:,ab_ind_b[1],ab_ind_b[0]] = -adc.imds.t2_1_vvvv[2][:]
-
             M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlad,mlbd->ab',
-                                                temp_t2b_VVVV, t2_1_b, optimize=True)
+                                                adc.imds.t2_1_vvvv[2], t2_1_b, optimize=True)
             M_ab_b -= 2 * 0.5 * 0.25*lib.einsum('mlaf,mlbf->ab',
-                                                t2_1_b, temp_t2b_VVVV, optimize=True)
-            del temp_t2b_VVVV
+                                                t2_1_b, adc.imds.t2_1_vvvv[2], optimize=True)
 
         if isinstance(eris.vvvv_p, list):
 
@@ -1971,6 +1958,7 @@ class UADCEA(uadc.UADC):
     }
 
     def __init__(self, adc):
+        self.mol = adc.mol
         self.verbose = adc.verbose
         self.stdout = adc.stdout
         self.max_memory = adc.max_memory
@@ -1987,6 +1975,7 @@ class UADCEA(uadc.UADC):
         self._scf = adc._scf
         self._nocc = adc._nocc
         self._nvir = adc._nvir
+        self._nmo = adc._nmo
         self.nocc_a = adc._nocc[0]
         self.nocc_b = adc._nocc[1]
         self.nvir_a = adc._nvir[0]
@@ -1996,14 +1985,14 @@ class UADCEA(uadc.UADC):
         self.mo_energy_b = adc.mo_energy_b
         self.nmo_a = adc._nmo[0]
         self.nmo_b = adc._nmo[1]
-        self.mol = adc.mol
         self.transform_integrals = adc.transform_integrals
         self.with_df = adc.with_df
+        self.compute_properties = adc.compute_properties
+        self.approx_trans_moments = adc.approx_trans_moments
+
         self.spec_factor_print_tol = adc.spec_factor_print_tol
         self.evec_print_tol = adc.evec_print_tol
 
-        self.compute_properties = adc.compute_properties
-        self.approx_trans_moments = adc.approx_trans_moments
         self.E = adc.E
         self.U = adc.U
         self.P = adc.P
@@ -2014,11 +2003,12 @@ class UADCEA(uadc.UADC):
     matvec = matvec
     get_diag = get_diag
     get_trans_moments = get_trans_moments
-    analyze_spec_factor = analyze_spec_factor
     get_properties = get_properties
+
     analyze = analyze
-    compute_dyson_mo = compute_dyson_mo
+    analyze_spec_factor = analyze_spec_factor
     analyze_eigenvector = analyze_eigenvector
+    compute_dyson_mo = compute_dyson_mo
 
     def get_init_guess(self, nroots=1, diag=None, ascending=True):
         if diag is None :

pyscf/adc/uadc_ip.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>
 #
 
@@ -1849,6 +1852,7 @@ class UADCIP(uadc.UADC):
     }
 
     def __init__(self, adc):
+        self.mol = adc.mol
         self.verbose = adc.verbose
         self.stdout = adc.stdout
         self.max_memory = adc.max_memory
@@ -1865,6 +1869,7 @@ class UADCIP(uadc.UADC):
         self._scf = adc._scf
         self._nocc = adc._nocc
         self._nvir = adc._nvir
+        self._nmo = adc._nmo
         self.nocc_a = adc._nocc[0]
         self.nocc_b = adc._nocc[1]
         self.nvir_a = adc._nvir[0]
@@ -1874,14 +1879,14 @@ class UADCIP(uadc.UADC):
         self.mo_energy_b = adc.mo_energy_b
         self.nmo_a = adc._nmo[0]
         self.nmo_b = adc._nmo[1]
-        self.mol = adc.mol
         self.transform_integrals = adc.transform_integrals
         self.with_df = adc.with_df
+        self.compute_properties = adc.compute_properties
+        self.approx_trans_moments = adc.approx_trans_moments
+
         self.spec_factor_print_tol = adc.spec_factor_print_tol
         self.evec_print_tol = adc.evec_print_tol
 
-        self.compute_properties = adc.compute_properties
-        self.approx_trans_moments = adc.approx_trans_moments
         self.E = adc.E
         self.U = adc.U
         self.P = adc.P

pyscf/adc/uadc_ip_cvs.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Abdelrahman Ahmed <abdelrahman.maa.ahmed@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 

pyscf/agf2/__init__.py

@@ -17,8 +17,8 @@
 #
 
 '''
-Auxiliary second-order Green's function perturbation therory
-============================================================
+Auxiliary second-order Green's function perturbation theory
+===========================================================
 
 The AGF2 method permits the computation of quasiparticle excitations and 
 ground-state properties at the AGF2(None,0) level. 

pyscf/agf2/aux_space.py

@@ -446,7 +446,7 @@ def combine(*auxspcs):
     '''
 
     nphys = [auxspc.nphys for auxspc in auxspcs]
-    if not all([x == nphys[0] for x in nphys]):
+    if not all(x == nphys[0] for x in nphys):
         raise ValueError('Size of physical space must be the same to '
                          'combine AuxiliarySpace objects.')
     nphys = nphys[0]

pyscf/agf2/chkfile.py

@@ -111,7 +111,7 @@ def load_agf2(chkfile):
 def dump_agf2(agf2, chkfile=None, key='agf2',
               gf=None, se=None, frozen=None, nmom=None,
               mo_energy=None, mo_coeff=None, mo_occ=None):
-    ''' Save the AGF2 calculatuion to a chkfile.
+    ''' Save the AGF2 calculation to a chkfile.
     '''
 
     if mpi_helper.rank != 0:

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

@@ -487,15 +487,17 @@ def _load_from_h5g(h5group, row0, row1, out=None):
         col1 = 0
         for key in range(nkeys):
             col0, col1 = col1, col1 + h5group[str(key)].shape[1]
-            h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,col0:col1],
-                                          source_sel=numpy.s_[row0:row1])
+            if col1 > col0:
+                h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,col0:col1],
+                                            source_sel=numpy.s_[row0:row1])
     else:  # multiple components
         out = numpy.ndarray((dat.shape[0], row1-row0, ncol), dat.dtype, buffer=out)
         col1 = 0
         for key in range(nkeys):
             col0, col1 = col1, col1 + h5group[str(key)].shape[2]
-            h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,:,col0:col1],
-                                          source_sel=numpy.s_[:,row0:row1])
+            if col1 > col0:
+                h5group[str(key)].read_direct(out, dest_sel=numpy.s_[:,:,col0:col1],
+                                            source_sel=numpy.s_[:,row0:row1])
     return out
 
 def _transpose_to_h5g(h5group, key, dat, blksize, chunks=None):
@@ -708,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]
 
@@ -771,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

@@ -23,7 +23,7 @@ Simple usage::
     >>> mf = scf.RHF(mol).run()
     >>> cc.CCSD(mf).run()
 
-:func:`cc.CCSD` returns an instance of CCSD class.  Followings are parameters
+:func:`cc.CCSD` returns an instance of CCSD class.  Following are parameters
 to control CCSD calculation.
 
     verbose : int
@@ -54,8 +54,8 @@ to control CCSD calculation.
 
 Saved results
 
-    converged : bool
-        CCSD converged or not
+    iterinfo : common.IterationInfo
+        Information about iteration (see pyscf.common.Iteration in detail)
     e_tot : float
         Total CCSD energy (HF + correlation)
     t1, t2 :
@@ -216,3 +216,21 @@ def FNOCCSD(mf, thresh=1e-6, pct_occ=None, nvir_act=None, frozen=None):
         return self
     mycc._finalize = _finalize.__get__(mycc, mycc.__class__)
     return mycc
+
+def BCCD(mf, frozen=None, u=None, conv_tol_normu=1e-5, max_cycle=20, diis=True,
+         canonicalization=True):
+    from pyscf.cc.bccd import bccd_kernel_
+    from pyscf.lib import StreamObject
+    mycc = CCSD(mf, frozen=frozen)
+
+    class BCCD(mycc.__class__):
+        def kernel(self):
+            obj = self.view(mycc.__class__)
+            obj.conv_tol = 1e-3
+            obj.kernel()
+            bccd_kernel_(obj, u, conv_tol_normu, max_cycle, diis,
+                         canonicalization, self.verbose)
+            self.__dict__.update(obj.__dict__)
+            return self.e_tot
+
+    return mycc.view(BCCD)

pyscf/cc/bccd.py

@@ -313,49 +313,3 @@ def bccd_kernel_(mycc, u=None, conv_tol_normu=1e-5, max_cycle=20, diis=True,
         mycc.t2 = t2
 
     return mycc
-
-if __name__ == "__main__":
-    import pyscf
-    from pyscf import cc
-
-    np.set_printoptions(3, linewidth=1000, suppress=True)
-    mol = pyscf.M(
-        atom = 'H 0 0 0; F 0 0 1.1',
-        basis = 'ccpvdz',
-        verbose = 4,
-        spin = 0,
-    )
-
-    myhf = mol.HF()
-    myhf.kernel()
-    E_ref = myhf.e_tot
-    rdm1_mf = myhf.make_rdm1()
-
-    mycc = cc.CCSD(myhf, frozen=None)
-    #mycc.frozen = [0]
-    mycc.kernel()
-    mycc.conv_tol = 1e-3
-
-    mycc = bccd_kernel_(mycc, diis=True, verbose=4)
-    e_r = mycc.e_tot
-    e_ccsd_t = mycc.ccsd_t()
-    # PSI4 reference
-    assert abs(e_ccsd_t - -0.002625521337000) < 1e-5
-
-    print (la.norm(mycc.t1))
-    assert la.norm(mycc.t1) < 1e-5
-
-    myhf = mol.UHF()
-    myhf.kernel()
-    myucc = cc.CCSD(myhf, frozen=None)
-    myucc.frozen = [0]
-    myucc.kernel()
-
-    mybcc = bccd_kernel_(myucc)
-    e_u = mybcc.e_tot
-
-    mygcc = cc.addons.convert_to_gccsd(mycc)
-    mybcc = bccd_kernel_(mygcc)
-    e_g = mybcc.e_tot
-    print (abs(e_g - e_r))
-    assert abs(e_g - e_r) < 1e-6

pyscf/cc/ccsd.py

@@ -65,7 +65,8 @@ def kernel(mycc, eris=None, t1=None, t2=None, max_cycle=50, tol=1e-8,
     else:
         adiis = None
 
-    conv = False
+    converged = False
+    mycc.cycles = 0
     for istep in range(max_cycle):
         t1new, t2new = mycc.update_amps(t1, t2, eris)
         if callback is not None:
@@ -75,22 +76,29 @@ 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)
         eold, eccsd = eccsd, mycc.energy(t1, t2, eris)
+        mycc.cycles = istep + 1
         log.info('cycle = %d  E_corr(%s) = %.15g  dE = %.9g  norm(t1,t2) = %.6g',
                  istep+1, name, eccsd, eccsd - eold, normt)
         cput1 = log.timer(f'{name} iter', *cput1)
         if abs(eccsd-eold) < tol and normt < tolnormt:
-            conv = True
+            converged = True
             break
     log.timer(name, *cput0)
-    return conv, eccsd, t1, t2
+    return converged, eccsd, t1, t2
 
 
 def update_amps(mycc, t1, t2, eris):
@@ -582,7 +590,7 @@ def _contract_s4vvvv_t2(mycc, mol, vvvv, t2, out=None, verbose=None):
         tril2sq = lib.square_mat_in_trilu_indices(nvira)
         loadbuf = numpy.empty((blksize,blksize,nvirb,nvirb))
 
-        slices = [(i0, i1) for i0, i1 in lib.prange(0, nvira, blksize)]
+        slices = list(lib.prange(0, nvira, blksize))
         for istep, wwbuf in enumerate(fmap(load, lib.prange(0, nvira, blksize))):
             i0, i1 = slices[istep]
             off0 = i0*(i0+1)//2
@@ -609,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)
@@ -870,7 +880,7 @@ class CCSDBase(lib.StreamObject):
         incore_complete : bool
             Avoid all I/O (also for DIIS). Default is False.
         level_shift : float
-            A shift on virtual orbital energies to stablize the CCSD iteration
+            A shift on virtual orbital energies to stabilize the CCSD iteration
         frozen : int or list
             If integer is given, the inner-most orbitals are frozen from CC
             amplitudes.  Given the orbital indices (0-based) in a list, both
@@ -891,10 +901,10 @@ class CCSDBase(lib.StreamObject):
             callback function can access all local variables in the current
             environment.
 
-    Saved results
+    Saved results:
 
         converged : bool
-            CCSD converged or not
+            Whether the CCSD iteration converged
         e_corr : float
             CCSD correlation correction
         e_tot : float
@@ -903,6 +913,8 @@ class CCSDBase(lib.StreamObject):
             T amplitudes t1[i,a], t2[i,j,a,b]  (i,j in occ, a,b in virt)
         l1, l2 :
             Lambda amplitudes l1[i,a], l2[i,j,a,b]  (i,j in occ, a,b in virt)
+        cycles : int
+            The number of iteration cycles performed
     '''
 
     max_cycle = getattr(__config__, 'cc_ccsd_CCSD_max_cycle', 50)
@@ -929,8 +941,8 @@ class CCSDBase(lib.StreamObject):
         'diis_start_cycle', 'diis_start_energy_diff', 'direct',
         'async_io', 'incore_complete', 'cc2', 'callback',
         'mol', 'verbose', 'stdout', 'frozen', 'level_shift',
-        'mo_coeff', 'mo_occ', 'converged', 'converged_lambda', 'emp2', 'e_hf',
-        'e_corr', 't1', 't2', 'l1', 'l2', 'chkfile',
+        'mo_coeff', 'mo_occ', 'cycles', 'converged_lambda', 'emp2', 'e_hf',
+        'converged', 'e_corr', 't1', 't2', 'l1', 'l2', 'chkfile',
     }
 
     def __init__(self, mf, frozen=None, mo_coeff=None, mo_occ=None):
@@ -959,6 +971,7 @@ class CCSDBase(lib.StreamObject):
         self.mo_coeff = mo_coeff
         self.mo_occ = mo_occ
         self.converged = False
+        self.cycles = None
         self.converged_lambda = False
         self.emp2 = None
         self.e_hf = None
@@ -971,6 +984,9 @@ class CCSDBase(lib.StreamObject):
         self._nmo = None
         self.chkfile = mf.chkfile
 
+    __getstate__, __setstate__ = lib.generate_pickle_methods(
+            excludes=('chkfile', 'callback'))
+
     @property
     def ecc(self):
         return self.e_corr

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