pyscf 2.4.0__py3-none-macosx_11_0_arm64.whl → 2.6.0__py3-none-macosx_11_0_arm64.whl

pyscf/__init__.py

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

pyscf/adc/__init__.py

@@ -23,7 +23,6 @@ Algebraic Diagrammatic Construction
 ===================================
 '''
 
-from pyscf import scf
 from pyscf import lib
 from pyscf.adc import uadc
 from pyscf.adc import radc
@@ -41,15 +40,15 @@ def ADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
     if not (frozen is None or frozen == 0):
         raise NotImplementedError
 
-    if isinstance(mf, scf.uhf.UHF):
+    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 = scf.addons.convert_to_uhf(mf)
+    #    mf = mf.to_uhf(mf)
     #    return UADC(mf, frozen, mo_coeff, mo_occ)
     # TODO add ROHF functionality
-    elif isinstance(mf, scf.rhf.RHF):
+    elif mf.istype('RHF'):
         return RADC(mf, frozen, mo_coeff, mo_occ)
     else :
         raise RuntimeError('ADC code only supports RHF, ROHF, and UHF references')
@@ -62,10 +61,9 @@ def UADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
     if not (frozen is None or frozen == 0):
         raise NotImplementedError
 
-    from pyscf.soscf import newton_ah
-
-    if isinstance(mf, newton_ah._CIAH_SOSCF) or not isinstance(mf, scf.uhf.UHF):
-        mf = scf.addons.convert_to_uhf(mf)
+    mf = mf.remove_soscf()
+    if not mf.istype('UHF'):
+        mf = mf.to_uhf()
 
     return uadc.UADC(mf, frozen, mo_coeff, mo_occ)
 
@@ -77,10 +75,9 @@ def RADC(mf, frozen=None, mo_coeff=None, mo_occ=None):
     if not (frozen is None or frozen == 0):
         raise NotImplementedError
 
-    from pyscf.soscf import newton_ah
-
-    if isinstance(mf, newton_ah._CIAH_SOSCF) or not isinstance(mf, scf.rhf.RHF):
-        mf = scf.addons.convert_to_rhf(mf)
+    mf = mf.remove_soscf()
+    if not mf.istype('RHF'):
+        mf = mf.to_rhf()
 
     return radc.RADC(mf, frozen, mo_coeff, mo_occ)
 

pyscf/adc/radc.py

@@ -111,7 +111,7 @@ class RADC(lib.StreamObject):
     blkmin = getattr(__config__, 'adc_radc_RADC_blkmin', 4)
     memorymin = getattr(__config__, 'adc_radc_RADC_memorymin', 2000)
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method', 'mo_coeff',
         'mol', 'mo_energy', 'incore_complete',
         'scf_energy', 'e_tot', 't1', 'frozen', 'chkfile',
@@ -119,7 +119,7 @@ class RADC(lib.StreamObject):
         'imds', 'method', 'method_type', 'with_df', 'compute_properties',
         'approx_trans_moments', 'evec_print_tol', 'spec_factor_print_tol',
         'ncvs', 'E', 'U', 'P', 'X',
-    ))
+    }
 
     def __init__(self, mf, frozen=0, mo_coeff=None, mo_occ=None):
         from pyscf import gto

pyscf/adc/radc_ea.py

@@ -966,13 +966,13 @@ class RADCEA(radc.RADC):
             Spectroscopic amplitudes for each EA transition.
     '''
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method', 'mo_coeff',
         'mo_energy', 't1', 'max_space', 't2', 'max_cycle',
         'nmo', 'transform_integrals', 'with_df', 'compute_properties',
         'approx_trans_moments', 'E', 'U', 'P', 'X',
         'evec_print_tol', 'spec_factor_print_tol',
-    ))
+    }
 
     def __init__(self, adc):
         self.mol = adc.mol

pyscf/adc/radc_ip.py

@@ -921,14 +921,14 @@ class RADCIP(radc.RADC):
             Spectroscopic amplitudes for each IP transition.
     '''
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method', 'mo_coeff',
         'mo_energy_b', 't1', 'mo_energy_a',
         'max_space', 't2', 'max_cycle',
         'nmo', 'transform_integrals', 'with_df', 'compute_properties',
         'approx_trans_moments', 'E', 'U', 'P', 'X',
         'evec_print_tol', 'spec_factor_print_tol',
-    ))
+    }
 
     def __init__(self, adc):
         self.mol = adc.mol

pyscf/adc/radc_ip_cvs.py

@@ -938,14 +938,14 @@ class RADCIPCVS(radc.RADC):
             Spectroscopic amplitudes for each IP transition.
     '''
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method', 'mo_coeff',
         'mo_energy_b', 't1', 'mo_energy_a',
         'max_space', 't2', 'max_cycle',
         'nmo', 'transform_integrals', 'with_df', 'compute_properties',
         'approx_trans_moments', 'E', 'U', 'P', 'X',
         'evec_print_tol', 'spec_factor_print_tol', 'ncvs',
-    ))
+    }
 
     def __init__(self, adc):
         self.mol = adc.mol

pyscf/adc/uadc.py

@@ -113,7 +113,7 @@ class UADC(lib.StreamObject):
     '''
     incore_complete = getattr(__config__, 'adc_uadc_UADC_incore_complete', False)
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method',
         'method_type', 'mo_coeff', 'mol', 'mo_energy_b',
         'scf_energy', 'e_tot', 't1', 'frozen',
@@ -122,7 +122,7 @@ class UADC(lib.StreamObject):
         'compute_mpn_energy', 'compute_spec', 'compute_properties',
         'approx_trans_moments', 'evec_print_tol', 'spec_factor_print_tol',
         'E', 'U', 'P', 'X', 'ncvs',
-    ))
+    }
 
     def __init__(self, mf, frozen=None, mo_coeff=None, mo_occ=None):
         from pyscf import gto

pyscf/adc/uadc_ea.py

@@ -1960,7 +1960,7 @@ class UADCEA(uadc.UADC):
             Spectroscopic amplitudes for each EA transition.
     '''
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method',
         'method_type', 'mo_coeff', 'mo_energy_b', 'max_memory',
         't1', 'mo_energy_a', 'max_space', 't2', 'max_cycle',
@@ -1968,7 +1968,7 @@ class UADCEA(uadc.UADC):
         'mo_energy_b', 'nmo_a', 'nmo_b', 'mol', 'transform_integrals',
         'with_df', 'spec_factor_print_tol', 'evec_print_tol',
         'compute_properties', 'approx_trans_moments', 'E', 'U', 'P', 'X',
-    ))
+    }
 
     def __init__(self, adc):
         self.verbose = adc.verbose

pyscf/adc/uadc_ip.py

@@ -1838,7 +1838,7 @@ class UADCIP(uadc.UADC):
             Spectroscopic amplitudes for each IP transition.
     '''
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method',
         'method_type', 'mo_coeff', 'mo_energy_b', 'max_memory',
         't1', 'mo_energy_a', 'max_space', 't2', 'max_cycle',
@@ -1846,7 +1846,7 @@ class UADCIP(uadc.UADC):
         'mo_energy_b', 'nmo_a', 'nmo_b', 'mol', 'transform_integrals',
         'with_df', 'spec_factor_print_tol', 'evec_print_tol',
         'compute_properties', 'approx_trans_moments', 'E', 'U', 'P', 'X',
-    ))
+    }
 
     def __init__(self, adc):
         self.verbose = adc.verbose

pyscf/adc/uadc_ip_cvs.py

@@ -2035,7 +2035,7 @@ class UADCIPCVS(uadc.UADC):
             Spectroscopic amplitudes for each IP transition.
     '''
 
-    _keys = set((
+    _keys = {
         'tol_residual','conv_tol', 'e_corr', 'method',
         'method_type', 'mo_coeff', 'mo_energy_b', 'max_memory',
         't1', 'mo_energy_a', 'max_space', 't2', 'max_cycle',
@@ -2043,7 +2043,7 @@ class UADCIPCVS(uadc.UADC):
         'mo_energy_b', 'nmo_a', 'nmo_b', 'mol', 'transform_integrals',
         'with_df', 'spec_factor_print_tol', 'evec_print_tol', 'ncvs',
         'compute_properties', 'approx_trans_moments', 'E', 'U', 'P', 'X',
-    ))
+    }
 
     def __init__(self, adc):
         self.verbose = adc.verbose

pyscf/agf2/__init__.py

@@ -102,7 +102,7 @@ def AGF2(mf, nmom=(None,0), frozen=None, mo_energy=None, mo_coeff=None, mo_occ=N
     elif isinstance(mf, scf.rohf.ROHF):
         lib.logger.warn(mf, 'RAGF2 method does not support ROHF reference. '
                             'Converting to UHF and using UAGF2.')
-        mf = scf.addons.convert_to_uhf(mf)
+        mf = mf.to_uhf()
         return UAGF2(mf, nmom, frozen, mo_energy, mo_coeff, mo_occ)
 
     elif isinstance(mf, scf.rhf.RHF):

pyscf/agf2/chempot.py

@@ -154,8 +154,8 @@ def minimize_chempot(se, fock, nelec, occupancy=2, x0=0.0, tol=1e-6, maxiter=200
     buf = np.zeros((se.nphys+se.naux, se.nphys+se.naux), dtype=dtype)
     fargs = (se, fock, nelec, occupancy, buf)
 
-    options = dict(maxiter=maxiter, ftol=tol, xtol=tol, gtol=tol)
-    kwargs = dict(x0=x0, method='TNC', jac=jac, options=options)
+    options = {'maxiter': maxiter, 'ftol': tol, 'xtol': tol, 'gtol': tol}
+    kwargs = {'x0': x0, 'method': 'TNC', 'jac': jac, 'options': options}
     fun = _objective if not jac else _gradient
 
     opt = optimize.minimize(fun, args=fargs, **kwargs)

pyscf/agf2/dfragf2.py

@@ -67,7 +67,7 @@ def build_se_part(agf2, eri, gf_occ, gf_vir, os_factor=1.0, ss_factor=1.0):
     nocc, nvir = gf_occ.naux, gf_vir.naux
     naux = agf2.with_df.get_naoaux()
     tol = agf2.weight_tol
-    facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+    facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
 
     ei, ci = gf_occ.energy, gf_occ.coupling
     ea, ca = gf_vir.energy, gf_vir.coupling
@@ -258,7 +258,7 @@ class DFRAGF2(ragf2.RAGF2):
             Auxiliaries of the Green's function
     '''
 
-    _keys = set(['_with_df', 'allow_lowmem_build'])
+    _keys = {'_with_df', 'allow_lowmem_build'}
 
     def __init__(self, mf, frozen=None, mo_energy=None, mo_coeff=None, mo_occ=None):
         ragf2.RAGF2.__init__(self, mf, frozen=frozen, mo_energy=mo_energy,
@@ -335,7 +335,7 @@ def _make_mo_eris_incore(agf2, mo_coeff=None):
     qxy = np.zeros((naux, npair))
     mo = np.asarray(eris.mo_coeff, order='F')
     sij = (0, nmo, 0, nmo)
-    sym = dict(aosym='s2', mosym='s2')
+    sym = {'aosym': 's2', 'mosym': 's2'}
 
     for p0, p1 in with_df.prange():
         eri0 = with_df._cderi[p0:p1]
@@ -370,7 +370,7 @@ def _make_qmo_eris_incore(agf2, eri, coeffs):
 
     xisym, nxi, cxi, sxi = ao2mo.incore._conc_mos(cx, ci, compact=False)
     jasym, nja, cja, sja = ao2mo.incore._conc_mos(cj, ca, compact=False)
-    sym = dict(aosym='s2', mosym='s1')
+    sym = {'aosym': 's2', 'mosym': 's1'}
 
     qxi = np.zeros((naux, nxi))
     qja = np.zeros((naux, nja))

pyscf/agf2/dfuagf2.py

@@ -70,7 +70,7 @@ def build_se_part(agf2, eri, gf_occ, gf_vir, os_factor=1.0, ss_factor=1.0):
     noccb, nvirb = gf_occ[1].naux, gf_vir[1].naux
     naux = agf2.with_df.get_naoaux()
     tol = agf2.weight_tol
-    facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+    facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
 
     ci_a, ei_a = gf_occ[0].coupling, gf_occ[0].energy
     ci_b, ei_b = gf_occ[1].coupling, gf_occ[1].energy
@@ -209,7 +209,7 @@ class DFUAGF2(uagf2.UAGF2):
             Auxiliaries of the Green's function for each spin
     '''
 
-    _keys = set(['_with_df', 'allow_lowmem_build'])
+    _keys = {'_with_df', 'allow_lowmem_build'}
 
     def __init__(self, mf, frozen=None, mo_energy=None, mo_coeff=None, mo_occ=None):
         uagf2.UAGF2.__init__(self, mf, frozen=frozen, mo_energy=mo_energy,
@@ -277,7 +277,7 @@ def _make_mo_eris_incore(agf2, mo_coeff=None):
     mob = np.asarray(mob, order='F')
     sija = (0, nmoa, 0, nmoa)
     sijb = (0, nmob, 0, nmob)
-    sym = dict(aosym='s2', mosym='s2')
+    sym = {'aosym': 's2', 'mosym': 's2'}
 
     for p0, p1 in with_df.prange():
         eri0 = with_df._cderi[p0:p1]
@@ -324,7 +324,7 @@ def _make_qmo_eris_incore(agf2, eri, coeffs_a, coeffs_b):
     jasym_a, nja_a, cja_a, sja_a = ao2mo.incore._conc_mos(cja, caa, compact=False)
     xisym_b, nxi_b, cxi_b, sxi_b = ao2mo.incore._conc_mos(cxb, cib, compact=False)
     jasym_b, nja_b, cja_b, sja_b = ao2mo.incore._conc_mos(cjb, cab, compact=False)
-    sym = dict(aosym='s2', mosym='s1')
+    sym = {'aosym': 's2', 'mosym': 's1'}
 
     qxi_a = np.zeros((naux, nxi_a))
     qxi_b = np.zeros((naux, nxi_b))

pyscf/agf2/ragf2.py

@@ -150,7 +150,7 @@ def build_se_part(agf2, eri, gf_occ, gf_vir, os_factor=1.0, ss_factor=1.0):
 
     nmo = eri.nmo
     tol = agf2.weight_tol
-    facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+    facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
 
     ci, ei = gf_occ.coupling, gf_occ.energy
     ca, ea = gf_vir.coupling, gf_vir.energy
@@ -304,7 +304,7 @@ def fock_loop(agf2, eri, gf, se):
     nqmo = nmo + naux
     buf = np.zeros((nqmo, nqmo))
     converged = False
-    opts = dict(tol=agf2.conv_tol_nelec, maxiter=agf2.max_cycle_inner)
+    opts = {'tol': agf2.conv_tol_nelec, 'maxiter': agf2.max_cycle_inner}
     rdm1_prev = 0
 
     for niter1 in range(1, agf2.max_cycle_outer+1):
@@ -507,7 +507,7 @@ class RAGF2(lib.StreamObject):
     async_io = getattr(__config__, 'agf2_async_io', True)
     incore_complete = getattr(__config__, 'agf2_incore_complete', False)
 
-    _keys = set((
+    _keys = {
         'async_io', 'mol', 'incore_complete',
         'conv_tol', 'conv_tol_rdm1', 'conv_tol_nelec', 'max_cycle',
         'max_cycle_outer', 'max_cycle_inner', 'weight_tol', 'fock_diis_space',
@@ -515,7 +515,7 @@ class RAGF2(lib.StreamObject):
         'os_factor', 'ss_factor', 'damping',
         'mo_energy', 'mo_coeff', 'mo_occ', 'se', 'gf', 'e_1b', 'e_2b', 'e_init',
         'frozen', 'converged', 'chkfile',
-    ))
+    }
 
     def __init__(self, mf, frozen=None, mo_energy=None, mo_coeff=None, mo_occ=None):
 
@@ -697,7 +697,7 @@ class RAGF2(lib.StreamObject):
         if os_factor is None: os_factor = self.os_factor
         if ss_factor is None: ss_factor = self.ss_factor
 
-        facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+        facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
         gf_occ = gf.get_occupied()
         gf_vir = gf.get_virtual()
 

pyscf/agf2/ragf2_slow.py

@@ -177,7 +177,7 @@ class RAGF2(ragf2.RAGF2):
             Auxiliaries of the Green's function
     '''
 
-    _keys = set(['nmom'])
+    _keys = {'nmom'}
 
     def __init__(self, mf, nmom=(None,0), frozen=None, mo_energy=None, mo_coeff=None, mo_occ=None):
 
@@ -222,7 +222,7 @@ class RAGF2(ragf2.RAGF2):
         if os_factor is None: os_factor = self.os_factor
         if ss_factor is None: ss_factor = self.ss_factor
 
-        facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+        facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
         gf_occ = gf.get_occupied()
         gf_vir = gf.get_virtual()
 

pyscf/agf2/uagf2.py

@@ -73,7 +73,7 @@ def build_se_part(agf2, eri, gf_occ, gf_vir, os_factor=1.0, ss_factor=1.0):
     noa, nob = gf_occ[0].naux, gf_occ[1].naux
     nva, nvb = gf_vir[0].naux, gf_vir[1].naux
     tol = agf2.weight_tol
-    facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+    facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
 
     ci_a, ei_a = gf_occ[0].coupling, gf_occ[0].energy
     ci_b, ei_b = gf_occ[1].coupling, gf_occ[1].energy
@@ -206,7 +206,7 @@ def fock_loop(agf2, eri, gf, se):
     rdm1a_prev = 0
     rdm1b_prev = 0
     converged = False
-    opts = dict(tol=agf2.conv_tol_nelec, maxiter=agf2.max_cycle_inner)
+    opts = {'tol': agf2.conv_tol_nelec, 'maxiter': agf2.max_cycle_inner}
 
     for niter1 in range(1, agf2.max_cycle_outer+1):
         sea, opt = minimize_chempot(sea, focka, nalph, x0=sea.chempot,
@@ -557,7 +557,7 @@ class UAGF2(ragf2.RAGF2):
         if os_factor is None: os_factor = self.os_factor
         if ss_factor is None: ss_factor = self.ss_factor
 
-        facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+        facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
         gf_occ = (gf[0].get_occupied(), gf[1].get_occupied())
         gf_vir = (gf[0].get_virtual(), gf[1].get_virtual())
 

pyscf/agf2/uagf2_slow.py

@@ -205,7 +205,7 @@ class UAGF2(uagf2.UAGF2):
             Auxiliaries of the Green's function for each spin
     '''
 
-    _keys = set(['nmom'])
+    _keys = {'nmom'}
 
     def __init__(self, mf, nmom=(None,0), frozen=None, mo_energy=None, mo_coeff=None, mo_occ=None):
 
@@ -250,7 +250,7 @@ class UAGF2(uagf2.UAGF2):
         if os_factor is None: os_factor = self.os_factor
         if ss_factor is None: ss_factor = self.ss_factor
 
-        facs = dict(os_factor=os_factor, ss_factor=ss_factor)
+        facs = {'os_factor': os_factor, 'ss_factor': ss_factor}
         gf_occ = (gf[0].get_occupied(), gf[1].get_occupied())
         gf_vir = (gf[0].get_virtual(), gf[1].get_virtual())
 

pyscf/ao2mo/outcore.py

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

pyscf/cc/__init__.py

@@ -75,13 +75,12 @@ from pyscf.cc import eom_rccsd
 from pyscf.cc import eom_uccsd
 from pyscf.cc import eom_gccsd
 from pyscf.cc import qcisd
-from pyscf.cc import momgfccsd
 from pyscf import scf
 
 def CCSD(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    if isinstance(mf, scf.uhf.UHF):
+    if mf.istype('UHF'):
         return UCCSD(mf, frozen, mo_coeff, mo_occ)
-    elif isinstance(mf, scf.ghf.GHF):
+    elif mf.istype('GHF'):
         return GCCSD(mf, frozen, mo_coeff, mo_occ)
     else:
         return RCCSD(mf, frozen, mo_coeff, mo_occ)
@@ -93,21 +92,22 @@ scf.hf.SCF.CCSD = CCSD
 def RCCSD(mf, frozen=None, mo_coeff=None, mo_occ=None):
     import numpy
     from pyscf import lib
-    from pyscf.soscf import newton_ah
+    from pyscf.df.df_jk import _DFHF
     from pyscf.cc import dfccsd
 
-    if isinstance(mf, scf.uhf.UHF):
+    if mf.istype('UHF'):
         raise RuntimeError('RCCSD cannot be used with UHF method.')
-    elif isinstance(mf, scf.rohf.ROHF):
+    elif mf.istype('ROHF'):
         lib.logger.warn(mf, 'RCCSD method does not support ROHF method. ROHF object '
                         'is converted to UHF object and UCCSD method is called.')
-        mf = scf.addons.convert_to_uhf(mf)
+        mf = mf.to_uhf()
         return UCCSD(mf, frozen, mo_coeff, mo_occ)
 
-    if isinstance(mf, newton_ah._CIAH_SOSCF) or not isinstance(mf, scf.hf.RHF):
-        mf = scf.addons.convert_to_rhf(mf)
+    mf = mf.remove_soscf()
+    if not mf.istype('RHF'):
+        mf = mf.to_rhf()
 
-    if getattr(mf, 'with_df', None):
+    if isinstance(mf, _DFHF) and mf.with_df:
         return dfccsd.RCCSD(mf, frozen, mo_coeff, mo_occ)
 
     elif numpy.iscomplexobj(mo_coeff) or numpy.iscomplexobj(mf.mo_coeff):
@@ -119,12 +119,13 @@ RCCSD.__doc__ = ccsd.CCSD.__doc__
 
 
 def UCCSD(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    from pyscf.soscf import newton_ah
+    from pyscf.df.df_jk import _DFHF
 
-    if isinstance(mf, newton_ah._CIAH_SOSCF) or not isinstance(mf, scf.uhf.UHF):
-        mf = scf.addons.convert_to_uhf(mf)
+    mf = mf.remove_soscf()
+    if not mf.istype('UHF'):
+        mf = mf.to_uhf()
 
-    if getattr(mf, 'with_df', None):
+    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)
@@ -134,12 +135,13 @@ UCCSD.__doc__ = uccsd.UCCSD.__doc__
 
 
 def GCCSD(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    from pyscf.soscf import newton_ah
+    from pyscf.df.df_jk import _DFHF
 
-    if isinstance(mf, newton_ah._CIAH_SOSCF) or not isinstance(mf, scf.ghf.GHF):
-        mf = scf.addons.convert_to_ghf(mf)
+    mf = mf.remove_soscf()
+    if not mf.istype('GHF'):
+        mf = mf.to_ghf()
 
-    if getattr(mf, 'with_df', None):
+    if isinstance(mf, _DFHF) and mf.with_df:
         raise NotImplementedError('DF-GCCSD')
     else:
         return gccsd.GCCSD(mf, frozen, mo_coeff, mo_occ)
@@ -147,9 +149,9 @@ GCCSD.__doc__ = gccsd.GCCSD.__doc__
 
 
 def QCISD(mf, frozen=None, mo_coeff=None, mo_occ=None):
-    if isinstance(mf, scf.uhf.UHF):
+    if mf.istype('UHF'):
         raise NotImplementedError
-    elif isinstance(mf, scf.ghf.GHF):
+    elif mf.istype('GHF'):
         raise NotImplementedError
     else:
         return RQCISD(mf, frozen, mo_coeff, mo_occ)
@@ -160,18 +162,17 @@ scf.hf.SCF.QCISD = QCISD
 def RQCISD(mf, frozen=None, mo_coeff=None, mo_occ=None):
     import numpy
     from pyscf import lib
-    from pyscf.soscf import newton_ah
 
-    if isinstance(mf, scf.uhf.UHF):
+    if mf.istype('UHF'):
         raise RuntimeError('RQCISD cannot be used with UHF method.')
-    elif isinstance(mf, scf.rohf.ROHF):
+    elif mf.istype('ROHF'):
         lib.logger.warn(mf, 'RQCISD method does not support ROHF method. ROHF object '
                         'is converted to UHF object and UQCISD method is called.')
-        mf = scf.addons.convert_to_uhf(mf)
         raise NotImplementedError
 
-    if isinstance(mf, newton_ah._CIAH_SOSCF) or not isinstance(mf, scf.hf.RHF):
-        mf = scf.addons.convert_to_rhf(mf)
+    mf = mf.remove_soscf()
+    if not mf.istype('RHF'):
+        mf = mf.to_rhf()
 
     elif numpy.iscomplexobj(mo_coeff) or numpy.iscomplexobj(mf.mo_coeff):
         raise NotImplementedError
@@ -193,15 +194,9 @@ def FNOCCSD(mf, thresh=1e-6, pct_occ=None, nvir_act=None, frozen=None):
             Number of virtual NOs to keep. Default is None. If present, overrides `thresh` and `pct_occ`.
     """
     import numpy
-    if frozen is None:
-        frozenocc = 0
-    else:
-        assert(isinstance(frozen, (int,numpy.int64)))
-        frozenocc = frozen
     from pyscf import mp
-    pt = mp.MP2(mf).set(verbose=0).run()
+    pt = mp.MP2(mf, frozen=frozen).set(verbose=0).run()
     frozen, no_coeff = pt.make_fno(thresh=thresh, pct_occ=pct_occ, nvir_act=nvir_act)
-    frozen = numpy.hstack([numpy.arange(frozenocc),frozen])
     if len(frozen) == 0: frozen = None
     pt_no = mp.MP2(mf, frozen=frozen, mo_coeff=no_coeff).set(verbose=0).run()
     mycc = CCSD(mf, frozen=frozen, mo_coeff=no_coeff)
@@ -221,5 +216,3 @@ 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
-
-MomGFCCSD = momgfccsd.MomGFCCSD

pyscf/cc/addons.py

@@ -122,14 +122,13 @@ def spin2spatial(tx, orbspin):
         return t2aa,t2ab,t2bb
 
 def convert_to_uccsd(mycc):
-    from pyscf import scf
     from pyscf.cc import uccsd, gccsd
     if isinstance(mycc, uccsd.UCCSD):
         return mycc
     elif isinstance(mycc, gccsd.GCCSD):
         raise NotImplementedError
 
-    mf = scf.addons.convert_to_uhf(mycc._scf)
+    mf = mycc._scf.to_uhf()
     ucc = uccsd.UCCSD(mf)
     assert (mycc._nocc is None)
     assert (mycc._nmo is None)
@@ -143,12 +142,11 @@ def convert_to_uccsd(mycc):
     return ucc
 
 def convert_to_gccsd(mycc):
-    from pyscf import scf
     from pyscf.cc import gccsd
     if isinstance(mycc, gccsd.GCCSD):
         return mycc
 
-    mf = scf.addons.convert_to_ghf(mycc._scf)
+    mf = mycc._scf.to_ghf()
     gcc = gccsd.GCCSD(mf)
     assert (mycc._nocc is None)
     assert (mycc._nmo is None)