pyscf 2.11.0__tar.gz → 2.12.1__tar.gz

{pyscf-2.11.0 → pyscf-2.12.1}/CHANGELOG

@@ -1,3 +1,55 @@
+PySCF 2.12.1 (2026-01-27)
+-------------------------
+* Fixes
+  - NumPy 2.4.0 compatibility issue caused by mixing of scalar and 1D array
+* Improvements
+  - Optimization function for improved convergence and stability in smearing.
+
+PySCF 2.12.0 (2026-01-20)
+-------------------------
+* Added
+  - Velocity gauge integrals and oscillator strengths for TDSCF using GTH basis sets
+  - High Performance CCSDT and CCSDTQ Implementation (T1-dressed formalism)
+  - GHF stability_slow
+  - Density fitting implementation for the NEVPT2
+* Improved
+  - Adjust UHF and ROHF analyze() to be compatible with msym
+  - Evaluate pseudo potential nonlocal term gradient on real space, the same as corresponding Fock evaluation
+  - Improve GPU4PySCF interface
+  - In pseudopotential nonlocal term gradient, if large imaginary is found, print warning instead of raise error
+  - Improve PBC DFT instantiation
+  - support complex vector for fci.direct_spin1 solver
+  - Reduced memory usage for pbc RSGDF
+  - Configurable einsum backend, supporting pytblis, tlibs-einsum and tensordot
+* Fixes
+  - KRHF gradients when exxdiv='ewald'
+  - segfault for qcint backend
+  - fix a bug in x2c, where imag part has been deprecated.
+* New Features and Improvements in the Molecular ADC Module
+  - Expanded 1-RDM Functionality:
+    * Introduced 1-RDM calculation functions for CVS-IP-RADC, CVS-IP-UADC, EE-RADC, and EA-UADC methods.
+    * Enhanced reference 1-RDM calculation function in UADC.
+    * Updated 1-RDM functions in IP-UADC and EE-UADC to include contributions up to ADC(3).
+  - Expanded oscillator strengths Functionality:
+    * Enabled oscillator strengths calculation for EE-RADC.
+    * Introduced get_properties function for EE-RADC.
+    * Updated get_trans_moments function EE-UADC to include contributions from 3rd order singlet excited amplitudes
+  - Advanced Orbital Control:
+    * Implemented frozen orbital functionality across all ADC cases, offering greater computational efficiency and control.
+  - Improved Initial Guess Strategies for ADC:
+    * Added CIS initial guess options for EE-UADC and EE-RADC.
+    * Introduced user-defined initial guess capabilities for all ADC methods, providing increased flexibility.
+  - Enhanced Analysis and Output:
+    * Integrated `analyze_eigenvector` function into EE-UADC, EE-RADC, CVS-IP-RADC, and CVS-IP-UADC for detailed analysis.
+    * Added `analyze_spec_factor` for EE-RADC.
+    * Updated `analyze` function for  CVS-IP-RADC, CVS-IP-UADC, EE-RADC, and EA-UADC methods.
+    * Improved logging in `kernel` and `kernel_gs` functions (UADC and RADC) to report the number of frozen and active orbitals.
+  - Bug Fixes
+    * Resolved a bug in 1-RDM functions that occurred when `approx_trans_moments` was set to `True`.
+    * Fixed merge conflicts.
+  - General Improvements
+    * Replaced long floating-point numbers with fractional representations for improved precision and readability.
+
 PySCF 2.11.0 (2025-10-15)
 -------------------------
 * Added

{pyscf-2.11.0 → pyscf-2.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscf
-Version: 2.11.0
+Version: 2.12.1
 Summary: PySCF: Python-based Simulations of Chemistry Framework
 Author-email: Qiming Sun <osirpt.sun@gmail.com>
 Maintainer-email: Qiming Sun <osirpt.sun@gmail.com>
@@ -79,14 +79,14 @@ Python-based Simulations of Chemistry Framework
 [![Build Status](https://github.com/pyscf/pyscf/workflows/CI/badge.svg)](https://github.com/pyscf/pyscf/actions?query=workflow%3ACI)
 [![codecov](https://codecov.io/gh/pyscf/pyscf/branch/master/graph/badge.svg)](https://codecov.io/gh/pyscf/pyscf)
 
-2025-10-15
+2026-01-27
 
-* [Stable release 2.11.0](https://github.com/pyscf/pyscf/releases/tag/v2.11.0)
+* [Stable release 2.12.1](https://github.com/pyscf/pyscf/releases/tag/v2.12.1)
 * [Changelog](../master/CHANGELOG)
 * [Documentation](http://www.pyscf.org)
 * [Installation](#installation)
 * [Features](../master/FEATURES)
-* [News](https://pyscf.org/news.html): **2nd PySCF Developers Meeting!**
+* [News](https://pyscf.org/news.html): **3rd PySCF Developers Meeting!**
 
 
 # Installation
@@ -110,7 +110,7 @@ Python-based Simulations of Chemistry Framework
         pip install pyscf[dispersion]
 
 * More details of custom installation can be found in
-  [installation manual](http://pyscf.org/install.html#compiling-from-source-code)
+  [installation manual](http://pyscf.org/user/install.html#build-from-source)
 
 
 # Citing PySCF

{pyscf-2.11.0 → pyscf-2.12.1}/README.md

@@ -7,14 +7,14 @@ Python-based Simulations of Chemistry Framework
 [![Build Status](https://github.com/pyscf/pyscf/workflows/CI/badge.svg)](https://github.com/pyscf/pyscf/actions?query=workflow%3ACI)
 [![codecov](https://codecov.io/gh/pyscf/pyscf/branch/master/graph/badge.svg)](https://codecov.io/gh/pyscf/pyscf)
 
-2025-10-15
+2026-01-27
 
-* [Stable release 2.11.0](https://github.com/pyscf/pyscf/releases/tag/v2.11.0)
+* [Stable release 2.12.1](https://github.com/pyscf/pyscf/releases/tag/v2.12.1)
 * [Changelog](../master/CHANGELOG)
 * [Documentation](http://www.pyscf.org)
 * [Installation](#installation)
 * [Features](../master/FEATURES)
-* [News](https://pyscf.org/news.html): **2nd PySCF Developers Meeting!**
+* [News](https://pyscf.org/news.html): **3rd PySCF Developers Meeting!**
 
 
 # Installation
@@ -38,7 +38,7 @@ Python-based Simulations of Chemistry Framework
         pip install pyscf[dispersion]
 
 * More details of custom installation can be found in
-  [installation manual](http://pyscf.org/install.html#compiling-from-source-code)
+  [installation manual](http://pyscf.org/user/install.html#build-from-source)
 
 
 # Citing PySCF

{pyscf-2.11.0 → pyscf-2.12.1}/pyscf/__init__.py

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

{pyscf-2.11.0 → pyscf-2.12.1}/pyscf/adc/__init__.py

@@ -31,14 +31,14 @@ from pyscf.adc import uadc_amplitudes
 from pyscf.adc import radc_ip
 from pyscf.adc import radc_ip_cvs
 from pyscf.adc import radc_ea
+from pyscf.adc import radc_ee
 from pyscf.adc import uadc_ip
 from pyscf.adc import uadc_ip_cvs
 from pyscf.adc import uadc_ea
+from pyscf.adc import uadc_ee
 
 
 def ADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    if not (frozen is None or frozen == 0):
-        raise NotImplementedError
 
     if mf.istype('UHF'):
         return UADC(mf, frozen, mo_coeff, mo_occ)
@@ -54,8 +54,6 @@ ADC.__doc__ = uadc.UADC.__doc__
 
 
 def UADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    if not (frozen is None or frozen == 0):
-        raise NotImplementedError
 
     if not (mf.istype('UHF') or mf.istype('ROHF')):
         mf = mf.to_uhf()
@@ -65,8 +63,6 @@ def UADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
 UADC.__doc__ = uadc.UADC.__doc__
 
 def RADC(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('RHF'):

{pyscf-2.11.0 → pyscf-2.12.1}/pyscf/adc/radc.py

@@ -16,6 +16,7 @@
 #         Samragni Banerjee <samragnibanerjee4@gmail.com>
 #         James Serna <jamcar456@gmail.com>
 #         Terrence Stahl <terrencestahl1@gmail.com>
+#         Ning-Yuan Chen <cny003@outlook.com>
 #         Alexander Sokolov <alexander.y.sokolov@gmail.com>
 #
 
@@ -29,6 +30,8 @@ from pyscf.adc import radc_ao2mo
 from pyscf.adc import radc_amplitudes
 from pyscf import __config__
 from pyscf import df
+from pyscf.mp import mp2
+from pyscf.data.nist import HARTREE2EV
 
 
 # Excited-state kernel
@@ -64,7 +67,14 @@ 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)
+    if guess is None:
+        guess = adc.get_init_guess(nroots, diag, ascending = True)
+    elif isinstance(guess, str) and guess == "cis" and adc.method_type == "ee":
+        guess = adc.get_init_guess(nroots, diag, ascending = True, type = "cis", eris = eris)
+    elif hasattr(guess, '__len__'):
+        guess = adc.get_init_guess(nroots, diag, ascending = True, type = "read", ini = guess)
+    else:
+        raise NotImplementedError("Guess type not implemented")
 
     conv, adc.E, U = lib.linalg_helper.davidson_nosym1(
         lambda xs : [matvec(x) for x in xs],
@@ -73,7 +83,7 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
 
     adc.U = np.array(U).T.copy()
 
-    if adc.compute_properties and adc.method_type != "ee":
+    if adc.compute_properties:
         adc.P,adc.X = adc.get_properties(nroots)
     else:
         adc.P = None
@@ -94,9 +104,12 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
 
     for n in range(nroots):
         print_string = ('%s root %d  |  Energy (Eh) = %14.10f  |  Energy (eV) = %12.8f  ' %
-                        (adc.method, n, adc.E[n], adc.E[n]*27.2114))
+                        (adc.method, n, adc.E[n], adc.E[n]*HARTREE2EV))
         if adc.compute_properties and adc.method_type != "ee":
             print_string += ("|  Spec. factor = %10.8f  " % adc.P[n])
+
+        if adc.compute_properties and adc.method_type == "ee":
+            print_string += ("|  Osc. strength = %10.8f  " % adc.P[n])
         print_string += ("|  conv = %s" % conv[n])
         logger.info(adc, print_string)
 
@@ -108,14 +121,13 @@ def kernel(adc, nroots=1, guess=None, eris=None, verbose=None):
     return adc.E, adc.U, adc.P, adc.X
 
 
-def make_ref_rdm1(adc):
+def make_ref_rdm1(adc, with_frozen=True, ao_repr=False):
 
     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][:]
 
     ######################
@@ -123,6 +135,11 @@ def make_ref_rdm1(adc):
     nocc = adc._nocc
     nvir = adc._nvir
 
+    if t1[0] is not None:
+        t2_ce = t1[0][:]
+    else:
+        t2_ce = np.zeros((nocc, nvir))
+
     nmo = nocc + nvir
 
     OPDM = np.zeros((nmo,nmo))
@@ -145,9 +162,13 @@ def make_ref_rdm1(adc):
 
     ####### ADC(3) SPIN ADAPTED REF OPDM WITH SQA ################
     if adc.method == "adc(3)":
-        t3_ce = adc.t1[1][:]
         t2_ccee = t2[1][:]
 
+        if t1[1] is not None:
+            t3_ce = t1[1][:]
+        else:
+            t3_ce = np.zeros((nocc, nvir))
+
         #### OCC-OCC ###
         OPDM[:nocc, :nocc] -= 2 * lib.einsum('Iiab,Jiab->IJ',
                                              t1_ccee, t2_ccee, optimize = einsum_type)
@@ -167,7 +188,7 @@ def make_ref_rdm1(adc):
         OPDM[nocc:, :nocc]  -= 1/2 * \
             lib.einsum('iIAa,ia->AI', t1_ccee, t2_ce, optimize = einsum_type)
 
-        ##### VIR=VIR ###
+        ##### 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)
@@ -175,9 +196,39 @@ def make_ref_rdm1(adc):
                                              t1_ccee, t2_ccee, optimize = einsum_type)
         OPDM[nocc:, nocc:] -= lib.einsum('ijBa,jiAa->AB', t1_ccee, t2_ccee, optimize = einsum_type)
 
+    if with_frozen and adc.frozen is not None:
+        nmo = adc.mo_occ.size
+        nocc = np.count_nonzero(adc.mo_occ > 0)
+        dm = np.zeros((nmo,nmo))
+        dm[np.diag_indices(nocc)] = 1
+        moidx = np.where(adc.get_frozen_mask())[0]
+        dm[moidx[:,None],moidx] = OPDM
+        OPDM = dm
+        if ao_repr:
+            mo = adc.mo_coeff_hf
+            OPDM = lib.einsum('pi,ij,qj->pq', mo, OPDM, mo)
+
+    elif ao_repr:
+        mo = adc.mo_coeff
+        OPDM = lib.einsum('pi,ij,qj->pq', mo, OPDM, mo)
+
     return 2 * OPDM
 
 
+def get_frozen_mask(adc):
+
+    moidx = np.ones(adc.mo_occ.size, dtype=bool)
+    if adc.frozen is None:
+        pass
+    elif isinstance(adc.frozen, (int, np.integer)):
+        moidx[:adc.frozen] = False
+    elif hasattr(adc.frozen, '__len__'):
+        moidx[list(adc.frozen)] = False
+    else:
+        raise NotImplementedError
+    return moidx
+
+
 class RADC(lib.StreamObject):
     '''Ground state calculations
 
@@ -211,14 +262,14 @@ class RADC(lib.StreamObject):
 
     _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method', 'method_type', 'mo_coeff',
-        'mol', 'mo_energy', 'incore_complete',
+        'mo_coeff_hf', 'mol', 'mo_energy', 'incore_complete',
         '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',
-        'E', 'U', 'P', 'X', 'ncvs', 'dip_mom', 'dip_mom_nuc'
+        'E', 'U', 'P', 'X', 'ncvs', 'dip_mom', 'dip_mom_nuc', 'if_heri_eris'
     }
 
-    def __init__(self, mf, frozen=0, mo_coeff=None, mo_occ=None):
+    def __init__(self, mf, frozen=None, mo_coeff=None, mo_occ=None):
 
         if 'dft' in str(mf.__module__):
             raise NotImplementedError('DFT reference for UADC')
@@ -243,16 +294,45 @@ class RADC(lib.StreamObject):
         self.frozen = frozen
         self.incore_complete = self.incore_complete or self.mol.incore_anyway
 
-        self.mo_coeff = mo_coeff
         self.mo_occ = mo_occ
         self.e_corr = None
         self.t1 = None
         self.t2 = None
         self.imds = lambda:None
         self._nocc = mf.mol.nelectron//2
-        self._nmo = mo_coeff.shape[1]
-        self._nvir = self._nmo - self._nocc
+        self.mo_coeff = mo_coeff
+        self.mo_coeff_hf = mo_coeff
         self.mo_energy = mf.mo_energy
+        self.if_heri_eris = False
+        self._nmo = None
+        mask = self.get_frozen_mask()
+        if frozen is None:
+            self._nmo = mo_coeff.shape[1]
+        elif isinstance(frozen, (int, np.integer)):
+            self._nmo = mo_coeff.shape[1]-frozen
+        elif hasattr(frozen, '__len__'):
+            self._nmo = mo_coeff.shape[1]-len(frozen)
+        else:
+            raise NotImplementedError
+        if frozen is not None:
+            maskocc = mf.mo_occ>1e-6
+            occ = maskocc & mask
+            self._nocc = int(occ.sum())
+            self.mo_coeff = mo_coeff[:,mask]
+            if self._nocc == 0:
+                raise ValueError("No occupied orbitals found")
+            if mo_coeff is self._scf.mo_coeff and self._scf.converged:
+                self.mo_energy = self.mo_energy[mask]
+            else:
+                dm = self._scf.make_rdm1(mo_coeff, self.mo_occ)
+                vhf = self._scf.get_veff(self.mol, dm)
+                fockao = self._scf.get_fock(vhf=vhf, dm=dm)
+                fock = self.mo_coeff.conj().T.dot(fockao).dot(self.mo_coeff)
+                self.mo_energy = fock.diagonal().real
+                self.scf_energy = self._scf.energy_tot(dm=dm, vhf=vhf)
+        self._nvir = self._nmo - self._nocc
+        if self._nvir == 0:
+            raise ValueError("No virtual orbitals found")
         self.chkfile = mf.chkfile
         self.method = "adc(2)"
         self.method_type = "ip"
@@ -273,7 +353,7 @@ class RADC(lib.StreamObject):
 
         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))
+            dip_mom[i,:,:] = np.dot(self.mo_coeff.T, np.dot(dip, self.mo_coeff))
 
         self.dip_mom = dip_mom
 
@@ -285,6 +365,7 @@ class RADC(lib.StreamObject):
     compute_energy = radc_amplitudes.compute_energy
     transform_integrals = radc_ao2mo.transform_integrals_incore
     make_ref_rdm1 = make_ref_rdm1
+    get_frozen_mask = get_frozen_mask
 
     def dump_flags(self, verbose=None):
         logger.info(self, '')
@@ -321,6 +402,17 @@ class RADC(lib.StreamObject):
         nao_pair = nao * (nao+1) // 2
         mem_incore = (max(nao_pair**2, nmo**4) + nmo_pair**2) * 8/1e6
         mem_now = lib.current_memory()[0]
+        nocc_fr = self._scf.mol.nelectron//2 - self._nocc
+        nvir_fr = self._scf.mo_coeff.shape[1] - self._nmo - nocc_fr
+
+        logger.info(self, '******** ADC Orbital Information ********')
+        logger.info(self, 'Number of Frozen Occupied Orbitals: %d', nocc_fr)
+        logger.info(self, 'Number of Frozen Virtual Orbitals: %d', nvir_fr)
+        logger.info(self, 'Number of Active Occupied Orbitals: %d', self._nocc)
+        logger.info(self, 'Number of Active Virtual Orbitals: %d', self._nvir)
+        if hasattr(self.frozen, '__len__'):
+            logger.info(self, 'Frozen Orbital List: %s', self.frozen)
+        logger.info(self, '*****************************************')
 
         if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None):
             if getattr(self, 'with_df', None):
@@ -363,23 +455,35 @@ class RADC(lib.StreamObject):
         nao_pair = nao * (nao+1) // 2
         mem_incore = (max(nao_pair**2, nmo**4) + nmo_pair**2) * 8/1e6
         mem_now = lib.current_memory()[0]
-
-        if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None):
-            if getattr(self, 'with_df', None):
-                self.with_df = self.with_df
-            else:
-                self.with_df = self._scf.with_df
-
-            def df_transform():
-                return radc_ao2mo.transform_integrals_df(self)
-            self.transform_integrals = df_transform
-        elif (self._scf._eri is None or
-              (mem_incore+mem_now >= self.max_memory and not self.incore_complete)):
-            def outcore_transform():
-                return radc_ao2mo.transform_integrals_outcore(self)
-            self.transform_integrals = outcore_transform
-
-        eris = self.transform_integrals()
+        nocc_fr = self._scf.mol.nelectron//2 - self._nocc
+        nvir_fr = self._scf.mo_coeff.shape[1] - self._nmo - nocc_fr
+
+        logger.info(self, '******** ADC Orbital Information ********')
+        logger.info(self, 'Number of Frozen Occupied Orbitals: %d', nocc_fr)
+        logger.info(self, 'Number of Frozen Virtual Orbitals: %d', nvir_fr)
+        logger.info(self, 'Number of Active Occupied Orbitals: %d', self._nocc)
+        logger.info(self, 'Number of Active Virtual Orbitals: %d', self._nvir)
+        if hasattr(self.frozen, '__len__'):
+            logger.info(self, 'Frozen Orbital List: %s', self.frozen)
+        logger.info(self, '*****************************************')
+
+        if eris is None:
+            if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None):
+                if getattr(self, 'with_df', None):
+                    self.with_df = self.with_df
+                else:
+                    self.with_df = self._scf.with_df
+
+                def df_transform():
+                    return radc_ao2mo.transform_integrals_df(self)
+                self.transform_integrals = df_transform
+            elif (self._scf._eri is None or
+                    (mem_incore+mem_now >= self.max_memory and not self.incore_complete)):
+                def outcore_transform():
+                    return radc_ao2mo.transform_integrals_outcore(self)
+                self.transform_integrals = outcore_transform
+
+            eris = self.transform_integrals()
 
         self.e_corr, self.t1, self.t2 = radc_amplitudes.compute_amplitudes_energy(
             self, eris=eris, verbose=self.verbose)
@@ -402,7 +506,10 @@ class RADC(lib.StreamObject):
         else:
             raise NotImplementedError(self.method_type)
         self._adc_es = adc_es
-        return e_exc, v_exc, spec_fac, x
+        if self.if_heri_eris:
+            return e_exc, v_exc, spec_fac, x, eris
+        else:
+            return e_exc, v_exc, spec_fac, x
 
     def _finalize(self):
         '''Hook for dumping results and clearing up the object.'''
@@ -454,8 +561,32 @@ class RADC(lib.StreamObject):
     def compute_dyson_mo(self):
         return self._adc_es.compute_dyson_mo()
 
-    def make_rdm1(self):
-        return self._adc_es.make_rdm1()
+    def make_rdm1(self, with_frozen=True, ao_repr=False):
+        list_rdm1 = self._adc_es._make_rdm1()
+
+        if with_frozen and self.frozen is not None:
+            nmo = self.mo_occ.size
+            nocc = np.count_nonzero(self.mo_occ > 0)
+            moidx = np.where(self.get_frozen_mask())[0]
+            for i in range(self._adc_es.U.shape[1]):
+                rdm1 = list_rdm1[i]
+                dm = np.zeros((nmo,nmo))
+                dm[np.diag_indices(nocc)] = 2
+                dm[moidx[:,None],moidx] = rdm1
+                rdm1 = dm
+                if ao_repr:
+                    mo = self.mo_coeff_hf
+                    rdm1 = lib.einsum('pi,ij,qj->pq', mo, rdm1, mo)
+                list_rdm1[i] = rdm1
+
+        elif ao_repr:
+            mo = self.mo_coeff
+            for i in range(self._adc_es.U.shape[1]):
+                rdm1 = list_rdm1[i]
+                rdm1 = lib.einsum('pi,ij,qj->pq', mo, rdm1, mo)
+                list_rdm1[i] = rdm1
+
+        return list_rdm1
 
 
 if __name__ == '__main__':

{pyscf-2.11.0 → pyscf-2.12.1}/pyscf/adc/radc_amplitudes.py

@@ -117,7 +117,9 @@ def compute_amplitudes(myadc, eris):
     t1_3 = None
     t2_1_vvvv = None
 
-    if (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False) or (myadc.method == "adc(3)"):
+    if ((myadc.method == "adc(2)" and myadc.method_type == "ee" and myadc.approx_trans_moments is False)
+        or (myadc.method =="adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(3)")):
 
         # Compute second-order doubles t2 (tijab)
 

{pyscf-2.11.0 → pyscf-2.12.1}/pyscf/adc/radc_ao2mo.py

@@ -44,11 +44,12 @@ def transform_integrals_incore(myadc):
     eris.ovvv = ao2mo.general(myadc._scf._eri, (occ, vir, vir, vir), compact=True).reshape(nocc, nvir, -1).copy()  # noqa: E501
     eris.vvvv = None
 
-    if ((myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
-        or (myadc.method == "adc(2)-x" and myadc.method_type == "ee")
+    if ((myadc.method == "adc(2)" and myadc.method_type == "ee" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is True and myadc.method_type in ("ea","ee"))
         or (myadc.method == "adc(3)")):
         eris.vvvv = ao2mo.general(myadc._scf._eri, (vir, vir, vir, vir),
-                                  compact=False).reshape(nvir, nvir, nvir, nvir)
+                                compact=False).reshape(nvir, nvir, nvir, nvir)
         eris.vvvv = np.ascontiguousarray(eris.vvvv.transpose(0,2,1,3))
         eris.vvvv = eris.vvvv.reshape(nvir*nvir, nvir*nvir)
 
@@ -155,8 +156,9 @@ def transform_integrals_outcore(myadc):
 
     ############### forming eris_vvvv ########################################
 
-    if ((myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
-        or (myadc.method == "adc(2)-x" and myadc.method_type == "ee")
+    if ((myadc.method == "adc(2)" and myadc.method_type == "ee" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is False)
+        or (myadc.method == "adc(2)-x" and myadc.approx_trans_moments is True and myadc.method_type in ("ea","ee"))
         or (myadc.method == "adc(3)")):
 
         eris.vvvv = []
@@ -177,7 +179,7 @@ def transform_integrals_outcore(myadc):
 
             with lib.H5TmpFile() as tmpf:
                 ao2mo.outcore.general(mol, (orb_slice, vir, vir, vir), tmpf,
-                                      max_memory=avail_mem, ioblk_size=100, compact=False)
+                                    max_memory=avail_mem, ioblk_size=100, compact=False)
                 vvvv = tmpf['eri_mo'][:]
             vvvv = vvvv.reshape(orb_slice.shape[1], vir.shape[1], vir.shape[1], vir.shape[1])
             vvvv = np.ascontiguousarray(vvvv.transpose(0,2,1,3)).reshape(-1, nvir, nvir * nvir)