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

pyscf/__init__.py

@@ -35,7 +35,7 @@ to try out the package::
 
 '''
 
-__version__ = '2.6.2'
+__version__ = '2.7.0'
 
 import os
 import sys
@@ -56,7 +56,7 @@ if PYSCF_EXT_PATH:
                     __path__.append(os.path.join(p, f, 'pyscf'))
                 del f
         elif os.path.exists(p):
-            # Load all moduels defined inside the file PYSCF_EXT_PATH
+            # Load all modules defined inside the file PYSCF_EXT_PATH
             with open(p, 'r') as f:
                 __path__.extend(f.read().splitlines())
             del f

pyscf/adc/__init__.py

@@ -42,12 +42,8 @@ def ADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
 
     if mf.istype('UHF'):
         return UADC(mf, frozen, mo_coeff, mo_occ)
-    #elif isinstance(mf, scf.rohf.ROHF):
-    #    lib.logger.warn(mf, 'RADC method does not support ROHF reference. ROHF object '
-    #                    'is converted to UHF object and UADC method is called.')
-    #    mf = mf.to_uhf(mf)
-    #    return UADC(mf, frozen, mo_coeff, mo_occ)
-    # TODO add ROHF functionality
+    elif mf.istype('ROHF'):
+        return UADC(mf, frozen, mo_coeff, mo_occ)
     elif mf.istype('RHF'):
         return RADC(mf, frozen, mo_coeff, mo_occ)
     else :
@@ -61,8 +57,7 @@ def UADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
     if not (frozen is None or frozen == 0):
         raise NotImplementedError
 
-    mf = mf.remove_soscf()
-    if not mf.istype('UHF'):
+    if not (mf.istype('UHF') or mf.istype('ROHF')):
         mf = mf.to_uhf()
 
     return uadc.UADC(mf, frozen, mo_coeff, mo_occ)

pyscf/adc/dfadc.py

@@ -12,6 +12,13 @@
 # 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.
+#
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
+#         Alexander Sokolov <alexander.y.sokolov@gmail.com>
+#
 
 import numpy as np
 
@@ -58,6 +65,7 @@ def get_ovvv_spin_df(myadc, Lov, Lvv, p, chnk_size):
     #vvvv = np.ascontiguousarray(vvvv.transpose(0,2,1,3)).reshape(-1, nvir, nvir * nvir)
     return ovvv
 
+
 def get_vvvv_df(myadc, Lvv, p, chnk_size):
 
     ''' Returns approximate vvvv integrals used in restricted implementation'''
@@ -75,11 +83,13 @@ def get_vvvv_df(myadc, Lvv, p, chnk_size):
     Lvv = Lvv.reshape(naux,nvir*nvir)
     vvvv = np.dot(Lvv_temp, Lvv)
     vvvv = vvvv.reshape(-1, nvir, nvir, nvir)
-    vvvv = np.ascontiguousarray(vvvv.transpose(0,2,1,3)).reshape(-1, nvir, nvir * nvir)
+    vvvv = vvvv.transpose(0,2,1,3).reshape(-1, nvir, nvir, nvir)
+    vvvv = np.ascontiguousarray(vvvv)
+
     return vvvv
 
 
-def get_vvvv_antisym_df(myadc, Lvv, p, chnk_size):
+def get_vvvv_antisym_df(myadc, Lvv, p, chnk_size, pack = True):
 
     ''' Returns approximate antisymmetrized vvvv integrals (alpha/beta spin) used in unrestricted implementation'''
 
@@ -95,9 +105,13 @@ def get_vvvv_antisym_df(myadc, Lvv, p, chnk_size):
     Lvv = Lvv.reshape(naux,nvir*nvir)
     vvvv = np.dot(Lvv_temp, Lvv)
     vvvv = vvvv.reshape(-1, nvir, nvir, nvir)
-    vvvv = vvvv.transpose(0,2,1,3).reshape(-1, nvir, nvir, nvir)
+    vvvv = vvvv.transpose(0,2,1,3)
     vvvv -= vvvv.transpose(0,1,3,2)
-    vvvv = np.ascontiguousarray(vvvv[:, :, ind_vv_g[0], ind_vv_g[1]])
+
+    if pack:
+        vvvv = np.ascontiguousarray(vvvv[:, :, ind_vv_g[0], ind_vv_g[1]])
+    else:
+        vvvv = np.ascontiguousarray(vvvv)
 
     return vvvv
 
@@ -116,7 +130,9 @@ def get_vVvV_df(myadc, Lvv, LVV, p, chnk_size):
         Lvv_temp = np.ascontiguousarray(Lvv.T.reshape(-1,naux))
 
     LVV = LVV.reshape(naux,nvir_2*nvir_2)
-    vvvv = np.dot(Lvv_temp, LVV).reshape(-1,nvir_1,nvir_2,nvir_2)
-    vvvv = np.ascontiguousarray(vvvv.transpose(0,2,1,3)).reshape(-1, nvir_2, nvir_1, nvir_2)
+    vvvv = np.dot(Lvv_temp, LVV)
+    vvvv = vvvv.reshape(-1,nvir_1,nvir_2,nvir_2)
+    vvvv = vvvv.transpose(0,2,1,3)
+    vvvv = np.ascontiguousarray(vvvv)
 
     return vvvv

pyscf/adc/radc.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>
 #
 
@@ -50,7 +53,7 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
     imds = adc.get_imds(eris)
     matvec, diag = adc.gen_matvec(imds, eris)
 
-    guess = adc.get_init_guess(nroots, diag, ascending=True)
+    guess = adc.get_init_guess(nroots, diag, ascending = True)
 
     conv, adc.E, U = lib.linalg_helper.davidson_nosym1(
         lambda xs : [matvec(x) for x in xs],
@@ -61,6 +64,7 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
 
     if adc.compute_properties:
         adc.P,adc.X = adc.get_properties(nroots)
+    nfalse = np.shape(conv)[0] - np.sum(conv)
 
     header = ("\n*************************************************************"
               "\n            ADC calculation summary"
@@ -71,15 +75,88 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
         print_string = ('%s root %d  |  Energy (Eh) = %14.10f  |  Energy (eV) = %12.8f  ' %
                         (adc.method, n, adc.E[n], adc.E[n]*27.2114))
         if adc.compute_properties:
-            print_string += ("|  Spec factors = %10.8f  " % adc.P[n])
+            print_string += ("|  Spec. factor = %10.8f  " % adc.P[n])
         print_string += ("|  conv = %s" % conv[n])
         logger.info(adc, print_string)
 
+    if nfalse >= 1:
+        logger.warn(adc, "Davidson iterations for " + str(nfalse) + " root(s) did not converge!!!")
+
     log.timer('ADC', *cput0)
 
     return adc.E, adc.U, adc.P, adc.X
 
 
+def make_ref_rdm1(adc):
+
+    if adc.method not in ("adc(2)", "adc(2)-x", "adc(3)"):
+        raise NotImplementedError(adc.method)
+
+    t1 = adc.t1
+    t2 = adc.t2
+    t2_ce = t1[0][:]
+    t1_ccee = t2[0][:]
+
+    ######################
+    einsum_type = True
+    nocc = adc._nocc
+    nvir = adc._nvir
+
+    nmo = nocc + nvir
+
+    OPDM = np.zeros((nmo,nmo))
+
+    ####### ADC(2) SPIN ADAPTED REF OPDM with SQA ################
+    ### OCC-OCC ###
+    OPDM[:nocc, :nocc] += lib.einsum('IJ->IJ', np.identity(nocc), optimize = einsum_type).copy()
+    OPDM[:nocc, :nocc] -= 2 * lib.einsum('Iiab,Jiab->IJ', t1_ccee, t1_ccee, optimize = einsum_type)
+    OPDM[:nocc, :nocc] += lib.einsum('Iiab,Jiba->IJ', t1_ccee, t1_ccee, optimize = einsum_type)
+
+    ### OCC-VIR ###
+    OPDM[:nocc, nocc:] += lib.einsum('IA->IA', t2_ce, optimize = einsum_type).copy()
+
+    ### VIR-OCC ###
+    OPDM[nocc:, :nocc] += lib.einsum('IA->AI', t2_ce, optimize = einsum_type).copy()
+
+    ### VIR-VIR ###
+    OPDM[nocc:, nocc:] += 2 * lib.einsum('ijAa,ijBa->AB', t1_ccee, t1_ccee, optimize = einsum_type)
+    OPDM[nocc:, nocc:] -= lib.einsum('ijAa,jiBa->AB', t1_ccee, t1_ccee, optimize = einsum_type)
+
+    ####### ADC(3) SPIN ADAPTED REF OPDM WITH SQA ################
+    if adc.method == "adc(3)":
+        t3_ce = adc.t1[1][:]
+        t2_ccee = t2[1][:]
+
+        #### OCC-OCC ###
+        OPDM[:nocc, :nocc] -= 2 * lib.einsum('Iiab,Jiab->IJ',
+                                             t1_ccee, t2_ccee, optimize = einsum_type)
+        OPDM[:nocc, :nocc] += lib.einsum('Iiab,Jiba->IJ', t1_ccee, t2_ccee, optimize = einsum_type)
+        OPDM[:nocc, :nocc] -= 2 * lib.einsum('Jiab,Iiab->IJ',
+                                             t1_ccee, t2_ccee, optimize = einsum_type)
+        OPDM[:nocc, :nocc] += lib.einsum('Jiab,Iiba->IJ', t1_ccee, t2_ccee, optimize = einsum_type)
+
+        ##### OCC-VIR ### ####
+        OPDM[:nocc, nocc:]  += lib.einsum('IA->IA', t3_ce, optimize = einsum_type).copy()
+        OPDM[:nocc, nocc:] +=  lib.einsum('IiAa,ia->IA', t1_ccee, t2_ce, optimize = einsum_type)
+        OPDM[:nocc, nocc:] -= 1/2 * \
+            lib.einsum('iIAa,ia->IA', t1_ccee, t2_ce, optimize = einsum_type)
+        ###### VIR-OCC ###
+        OPDM[nocc:, :nocc]  += lib.einsum('IA->AI', t3_ce, optimize = einsum_type).copy()
+        OPDM[nocc:, :nocc]  += lib.einsum('IiAa,ia->AI', t1_ccee, t2_ce, optimize = einsum_type)
+        OPDM[nocc:, :nocc]  -= 1/2 * \
+            lib.einsum('iIAa,ia->AI', t1_ccee, t2_ce, optimize = einsum_type)
+
+        ##### VIR=VIR ###
+        OPDM[nocc:, nocc:] += 2 * lib.einsum('ijAa,ijBa->AB',
+                                             t1_ccee, t2_ccee, optimize = einsum_type)
+        OPDM[nocc:, nocc:] -= lib.einsum('ijAa,jiBa->AB', t1_ccee, t2_ccee, optimize = einsum_type)
+        OPDM[nocc:, nocc:] += 2 * lib.einsum('ijBa,ijAa->AB',
+                                             t1_ccee, t2_ccee, optimize = einsum_type)
+        OPDM[nocc:, nocc:] -= lib.einsum('ijBa,jiAa->AB', t1_ccee, t2_ccee, optimize = einsum_type)
+
+    return 2 * OPDM
+
+
 class RADC(lib.StreamObject):
     '''Ground state calculations
 
@@ -112,13 +189,12 @@ class RADC(lib.StreamObject):
     memorymin = getattr(__config__, 'adc_radc_RADC_memorymin', 2000)
 
     _keys = {
-        'tol_residual','conv_tol', 'e_corr', 'method', 'mo_coeff',
+        'tol_residual','conv_tol', 'e_corr', 'method', 'method_type', 'mo_coeff',
         'mol', 'mo_energy', 'incore_complete',
-        'scf_energy', 'e_tot', 't1', 'frozen', 'chkfile',
-        'max_space', 't2', 'mo_occ', 'max_cycle',
-        'imds', 'method', 'method_type', 'with_df', 'compute_properties',
+        'scf_energy', 'e_tot', 't1', 't2', 'frozen', 'chkfile',
+        'max_space', 'mo_occ', 'max_cycle', 'imds', 'with_df', 'compute_properties',
         'approx_trans_moments', 'evec_print_tol', 'spec_factor_print_tol',
-        'ncvs', 'E', 'U', 'P', 'X',
+        'E', 'U', 'P', 'X', 'ncvs', 'dip_mom', 'dip_mom_nuc'
     }
 
     def __init__(self, mf, frozen=0, mo_coeff=None, mo_occ=None):
@@ -141,7 +217,7 @@ 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_res', 1e-6)
+        self.tol_residual = getattr(__config__, 'adc_radc_RADC_tol_residual', 1e-6)
         self.scf_energy = mf.e_tot
 
         self.frozen = frozen
@@ -172,9 +248,23 @@ class RADC(lib.StreamObject):
         self.P = None
         self.X = None
 
+        dip_ints = -self.mol.intor('int1e_r',comp=3)
+        dip_mom = np.zeros((dip_ints.shape[0], self._nmo, self._nmo))
+
+        for i in range(dip_ints.shape[0]):
+            dip = dip_ints[i,:,:]
+            dip_mom[i,:,:] = np.dot(mo_coeff.T, np.dot(dip, mo_coeff))
+
+        self.dip_mom = dip_mom
+
+        charges = self.mol.atom_charges()
+        coords  = self.mol.atom_coords()
+        self.dip_mom_nuc = lib.einsum('i,ix->x', charges, coords)
+
     compute_amplitudes = radc_amplitudes.compute_amplitudes
     compute_energy = radc_amplitudes.compute_energy
     transform_integrals = radc_ao2mo.transform_integrals_incore
+    make_ref_rdm1 = make_ref_rdm1
 
     def dump_flags(self, verbose=None):
         logger.info(self, '')
@@ -194,8 +284,8 @@ class RADC(lib.StreamObject):
         return self
 
     def kernel_gs(self):
-        assert (self.mo_coeff is not None)
-        assert (self.mo_occ is not None)
+        assert(self.mo_coeff is not None)
+        assert(self.mo_occ is not None)
 
         self.method = self.method.lower()
         if self.method not in ("adc(2)", "adc(2)-x", "adc(3)"):
@@ -236,8 +326,8 @@ class RADC(lib.StreamObject):
         return self.e_corr, self.t1, self.t2
 
     def kernel(self, nroots=1, guess=None, eris=None):
-        assert (self.mo_coeff is not None)
-        assert (self.mo_occ is not None)
+        assert(self.mo_coeff is not None)
+        assert(self.mo_occ is not None)
 
         self.method = self.method.lower()
         if self.method not in ("adc(2)", "adc(2)-x", "adc(3)"):
@@ -293,8 +383,8 @@ class RADC(lib.StreamObject):
 
     def _finalize(self):
         '''Hook for dumping results and clearing up the object.'''
-        logger.note(self, 'E_corr = %.8f',
-                    self.e_corr)
+        logger.note(self, 'MP%s correlation energy of reference state (a.u.) = %.8f',
+                    self.method[4], self.e_corr)
         return self
 
     def ea_adc(self, nroots=1, guess=None, eris=None):
@@ -338,6 +428,7 @@ class RADC(lib.StreamObject):
     def make_rdm1(self):
         return self._adc_es.make_rdm1()
 
+
 if __name__ == '__main__':
     from pyscf import scf
     from pyscf import gto

pyscf/adc/radc_amplitudes.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Samragni Banerjee <samragnibanerjee4@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -526,7 +529,10 @@ def compute_energy(myadc, t2, eris):
     e_mp = 2 * lib.einsum('ijab,iabj', t2_new, eris_ovvo,optimize=True)
     e_mp -= lib.einsum('ijab,ibaj', t2_new, eris_ovvo,optimize=True)
 
+    logger.info(myadc, "Reference correlation energy (doubles): %.8f", e_mp)
+
     del t2_new
+
     return e_mp
 
 

pyscf/adc/radc_ao2mo.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# Author: Samragni Banerjee <samragnibanerjee4@gmail.com>
+# Author: Abdelrahman Ahmed <>
+#         Samragni Banerjee <samragnibanerjee4@gmail.com>
+#         James Serna <jamcar456@gmail.com>
+#         Terrence Stahl <>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
-#
 
 import numpy as np
 import pyscf.ao2mo as ao2mo