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

pyscf/pbc/scf/uhf.py

@@ -104,10 +104,10 @@ def dip_moment(cell, dm, unit='Debye', verbose=logger.NOTE,
 
 get_rho = pbchf.get_rho
 
-class UHF(pbchf.SCF, mol_uhf.UHF):
+class UHF(pbchf.SCF):
     '''UHF class for PBCs.
     '''
-    _keys = set(["init_guess_breaksym"])
+    _keys = {"init_guess_breaksym"}
 
     init_guess_by_minao  = mol_uhf.UHF.init_guess_by_minao
     init_guess_by_atom   = mol_uhf.UHF.init_guess_by_atom
@@ -128,6 +128,7 @@ class UHF(pbchf.SCF, mol_uhf.UHF):
     canonicalize = mol_uhf.UHF.canonicalize
     spin_square = mol_uhf.UHF.spin_square
     stability = mol_uhf.UHF.stability
+    to_gpu = lib.to_gpu
 
     def __init__(self, cell, kpt=np.zeros(3),
                  exxdiv=getattr(__config__, 'pbc_scf_SCF_exxdiv', 'ewald')):
@@ -221,10 +222,13 @@ class UHF(pbchf.SCF, mol_uhf.UHF):
             rho = self.get_rho(dm)
         return dip_moment(cell, dm, unit, verbose, rho=rho, kpt=self.kpt, **kwargs)
 
-    def get_init_guess(self, cell=None, key='minao'):
-        if cell is None: cell = self.cell
+    def get_init_guess(self, cell=None, key='minao', s1e=None):
+        if cell is None:
+            cell = self.cell
+        if s1e is None:
+            s1e = self.get_ovlp(cell)
         dm = mol_uhf.UHF.get_init_guess(self, cell, key)
-        ne = np.einsum('xij,ji->x', dm, self.get_ovlp(cell)).real
+        ne = np.einsum('xij,ji->x', dm, s1e).real
         nelec = self.nelec
         if np.any(abs(ne - nelec) > 0.01):
             logger.debug(self, 'Big error detected in the electron number '

pyscf/pbc/symm/geom.py

@@ -77,7 +77,7 @@ def search_space_group_ops(cell, rotations=None, tol=SYMPREC):
     '''
     if rotations is None: rotations = search_point_group_ops(cell, tol=tol)
     a = cell.lattice_vectors()
-    coords = cell.get_scaled_positions()
+    coords = cell.get_scaled_atom_coords()
     atmgrp = mole.atom_types(cell._atom, magmom=cell.magmom)
     atmgrp_spin_inv = {} #spin up and down inverted
     has_spin = False

pyscf/pbc/symm/pyscf_spglib.py

@@ -29,7 +29,7 @@ def cell_to_spgcell(cell):
     Convert PySCF Cell object to spglib cell object
     '''
     a = cell.lattice_vectors()
-    atm_pos = cell.get_scaled_positions()
+    atm_pos = cell.get_scaled_atom_coords()
     atm_num = []
     from pyscf.data import elements
     for symbol in cell.elements:

pyscf/pbc/symm/symmetry.py

@@ -219,7 +219,7 @@ class Symmetry():
 
 def _get_phase(cell, op, kpt_scaled, ignore_phase=False, tol=SYMPREC):
     kpt_scaled = op.a2b(cell).dot_rot(kpt_scaled)
-    coords_scaled = cell.get_scaled_positions().reshape(-1,3)
+    coords_scaled = cell.get_scaled_atom_coords().reshape(-1,3)
     natm = coords_scaled.shape[0]
     phase = np.ones((natm,), dtype=np.complex128)
     atm_map = np.arange(natm)

pyscf/pbc/tdscf/__init__.py

@@ -31,22 +31,20 @@ except (ImportError, IOError):
     pass
 
 def TDHF(mf):
-    import numpy
     if isinstance(mf, scf.khf.KSCF):
         return KTDHF(mf)
     if isinstance(mf, scf.hf.KohnShamDFT):
         raise RuntimeError('TDHF does not support DFT object %s' % mf)
-    #TODO: mf = mf.remove_soscf()
+    mf = mf.remove_soscf()
     if isinstance(mf, scf.rohf.ROHF):
         # Is it correct to call TDUHF for ROHF?
         mf = mf.to_uhf()
     return mf.TDHF()
 
 def TDA(mf):
-    import numpy
     if isinstance(mf, scf.khf.KSCF):
         return KTDA(mf)
-    #TODO: mf = mf.remove_soscf()
+    mf = mf.remove_soscf()
     if isinstance(mf, scf.rohf.ROHF):
         if isinstance(mf, scf.hf.KohnShamDFT):
             mf = mf.to_uks()
@@ -55,11 +53,10 @@ def TDA(mf):
     return mf.TDA()
 
 def TDDFT(mf):
-    import numpy
     if isinstance(mf, scf.khf.KSCF):
         return KTDDFT(mf)
     if isinstance(mf, scf.hf.KohnShamDFT):
-        #TODO: mf = mf.remove_soscf()
+        mf = mf.remove_soscf()
         if isinstance(mf, scf.rohf.ROHF):
             mf = mf.to_uks()
         return mf.TDDFT()
@@ -69,13 +66,13 @@ def TDDFT(mf):
 def KTDHF(mf):
     if isinstance(mf, scf.hf.KohnShamDFT):
         raise RuntimeError('TDHF does not support DFT object %s' % mf)
-    #TODO: mf = mf.remove_soscf()
+    mf = mf.remove_soscf()
     if isinstance(mf, scf.rohf.ROHF):
         mf = mf.to_uhf()
     return mf.TDHF()
 
 def KTDA(mf):
-    #TODO: mf = mf.remove_soscf()
+    mf = mf.remove_soscf()
     if isinstance(mf, scf.rohf.ROHF):
         if isinstance(mf, scf.hf.KohnShamDFT):
             mf = mf.to_uks()
@@ -85,7 +82,7 @@ def KTDA(mf):
 
 def KTDDFT(mf):
     if isinstance(mf, scf.hf.KohnShamDFT):
-        #TODO: mf = mf.remove_soscf()
+        mf = mf.remove_soscf()
         if isinstance(mf, scf.rohf.ROHF):
             mf = mf.to_uks()
         return mf.TDDFT()

pyscf/pbc/tdscf/krhf.py

@@ -38,7 +38,7 @@ from pyscf import __config__
 REAL_EIG_THRESHOLD = getattr(__config__, 'pbc_tdscf_rhf_TDDFT_pick_eig_threshold', 1e-3)
 
 class KTDBase(TDBase):
-    _keys = set(['kconserv', 'kshift_lst'])
+    _keys = {'kconserv', 'kshift_lst'}
 
     def __init__(self, mf, kshift_lst=None):
         assert isinstance(mf, scf.khf.KSCF)

pyscf/pbc/tdscf/krhf_slow_supercell.py

@@ -88,7 +88,7 @@ class PhysERI(PeriodicMFMixin, TDERIMatrixBlocks):
             The diagonal block.
         """
         # Everything is already implemented in molecular code
-        return super(PhysERI, self).tdhf_diag(k1, k2)
+        return super().tdhf_diag(k1, k2)
 
     def tdhf_diag(self, pairs=None):
         """
@@ -127,7 +127,7 @@ class PhysERI(PeriodicMFMixin, TDERIMatrixBlocks):
             The corresponding block of ERI (phys notation).
         """
         # Everything is already implemented in molecular code
-        return super(PhysERI, self).eri_mknj(item, k)
+        return super().eri_mknj(item, k)
 
     def eri_mknj(self, item, pairs_row=None, pairs_column=None):
         """
@@ -214,7 +214,7 @@ class PhysERI8(PhysERI4):
             frozen (int, Iterable): the number of frozen valence orbitals or the list of frozen orbitals for all
             k-points or multiple lists of frozen orbitals for each k-point;
         """
-        super(PhysERI8, self).__init__(model, frozen=frozen)
+        super().__init__(model, frozen=frozen)
 
 
 def vector_to_amplitudes(vectors, nocc, nmo):

pyscf/pbc/tdscf/rhf.py

@@ -26,7 +26,7 @@ from pyscf.pbc import scf
 from pyscf import __config__
 
 class TDBase(rhf.TDBase):
-    _keys = set(['cell'])
+    _keys = {'cell'}
 
     def __init__(self, mf):
         rhf.TDBase.__init__(self, mf)

pyscf/pbc/tools/k2gamma.py

@@ -205,40 +205,52 @@ def k2gamma(kmf, kmesh=None):
          C_{\nu ' n'} = C_{\vecR\mu, \veck m} = \frac{1}{\sqrt{N_{\UC}}}
          \e^{\ii \veck\cdot\vecR} C^{\veck}_{\mu  m}
     '''
-    from pyscf.pbc import scf
+    from pyscf.pbc import scf, dft
+    if isinstance(kmf.kpts, KPoints):
+        kmf = kmf.to_khf()
+
     def transform(mo_energy, mo_coeff, mo_occ):
-        if isinstance(kmf.kpts, KPoints):
-            kpts = kmf.kpts.kpts
-        else:
-            kpts = kmf.kpts
+        assert not isinstance(kmf.kpts, KPoints)
+        kpts = kmf.kpts
         scell, E_g, C_gamma = mo_k2gamma(kmf.cell, mo_energy, mo_coeff,
                                          kpts, kmesh)[:3]
         E_sort_idx = np.argsort(np.hstack(mo_energy), kind='stable')
         mo_occ = np.hstack(mo_occ)[E_sort_idx]
         return scell, E_g, C_gamma, mo_occ
 
-    if isinstance(kmf.kpts, KPoints):
-        mo_coeff = kmf.kpts.transform_mo_coeff(kmf.mo_coeff)
-        mo_energy = kmf.kpts.transform_mo_energy(kmf.mo_energy)
-        mo_occ = kmf.kpts.transform_mo_occ(kmf.mo_occ)
-    else:
-        mo_coeff = kmf.mo_coeff
-        mo_energy = kmf.mo_energy
-        mo_occ = kmf.mo_occ
+    mo_coeff = kmf.mo_coeff
+    mo_energy = kmf.mo_energy
+    mo_occ = kmf.mo_occ
 
     if isinstance(kmf, scf.khf.KRHF):
         scell, E_g, C_gamma, mo_occ = transform(mo_energy, mo_coeff, mo_occ)
-        mf = scf.RHF(scell)
     elif isinstance(kmf, scf.kuhf.KUHF):
         scell, Ea, Ca, occ_a = transform(mo_energy[0], mo_coeff[0], mo_occ[0])
         scell, Eb, Cb, occ_b = transform(mo_energy[1], mo_coeff[1], mo_occ[1])
-        mf = scf.UHF(scell)
         E_g = [Ea, Eb]
         C_gamma = [Ca, Cb]
         mo_occ = [occ_a, occ_b]
     else:
         raise NotImplementedError('SCF object %s not supported' % kmf)
 
+    known_cls = {
+        dft.kuks.KUKS  : dft.uks.UKS  ,
+        dft.kroks.KROKS: dft.roks.ROKS,
+        dft.krks.KRKS  : dft.rks.RKS  ,
+        dft.kgks.KGKS  : dft.gks.GKS  ,
+        scf.kuhf.KUHF  : scf.uhf.UHF  ,
+        scf.krohf.KROHF: scf.rohf.ROHF,
+        scf.khf.KRHF   : scf.hf.RHF   ,
+        scf.kghf.KGHF  : scf.ghf.GHF  ,
+    }
+    if kmf.__class__ in known_cls:
+        mf = known_cls[kmf.__class__](scell)
+        mf.exxdiv = kmf.exxdiv
+        if isinstance(mf, dft.KohnShamDFT):
+            mf.xc = kmf.xc
+    else:
+        raise RuntimeError(f'k2gamma for SCF object {kmf} not supported.')
+
     mf.mo_coeff = C_gamma
     mf.mo_energy = E_g
     mf.mo_occ = mo_occ

pyscf/pbc/tools/pbc.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 import warnings
+import ctypes
 import numpy as np
 import scipy.linalg
 from pyscf import lib
@@ -57,6 +58,44 @@ def _ifftn_blas(g, mesh):
     return out.reshape(-1, *mesh)
 
 if FFT_ENGINE == 'FFTW':
+    try:
+        libfft = lib.load_library('libfft')
+    except OSError:
+        raise RuntimeError("Failed to load libfft")
+
+    def _copy_d2z(a):
+        fn = libfft._copy_d2z
+        out = np.empty(a.shape, dtype=np.complex128)
+        fn(out.ctypes.data_as(ctypes.c_void_p),
+           a.ctypes.data_as(ctypes.c_void_p),
+           ctypes.c_size_t(a.size))
+        return out
+
+    def _complex_fftn_fftw(f, mesh, func):
+        if f.dtype == np.double and f.flags.c_contiguous:
+            # np.asarray or np.astype is too slow
+            f = _copy_d2z(f)
+        else:
+            f = np.asarray(f, order='C', dtype=np.complex128)
+        mesh = np.asarray(mesh, order='C', dtype=np.int32)
+        rank = len(mesh)
+        out = np.empty_like(f)
+        fn = getattr(libfft, func)
+        for i, fi in enumerate(f):
+            fn(fi.ctypes.data_as(ctypes.c_void_p),
+               out[i].ctypes.data_as(ctypes.c_void_p),
+               mesh.ctypes.data_as(ctypes.c_void_p),
+               ctypes.c_int(rank))
+        return out
+
+    def _fftn_wrapper(a):
+        mesh = a.shape[1:]
+        return _complex_fftn_fftw(a, mesh, 'fft')
+    def _ifftn_wrapper(a):
+        mesh = a.shape[1:]
+        return _complex_fftn_fftw(a, mesh, 'ifft')
+
+elif FFT_ENGINE == 'PYFFTW':
     # pyfftw is slower than np.fft in most cases
     try:
         import pyfftw
@@ -235,8 +274,9 @@ def get_coulG(cell, k=np.zeros(3), exx=False, mf=None, mesh=None, Gv=None,
     else:
         kG = Gv
 
-    equal2boundary = np.zeros(Gv.shape[0], dtype=bool)
+    equal2boundary = None
     if wrap_around and abs(k).sum() > 1e-9:
+        equal2boundary = np.zeros(Gv.shape[0], dtype=bool)
         # Here we 'wrap around' the high frequency k+G vectors into their lower
         # frequency counterparts.  Important if you want the gamma point and k-point
         # answers to agree
@@ -357,7 +397,8 @@ def get_coulG(cell, k=np.zeros(3), exx=False, mf=None, mesh=None, Gv=None,
         if cell.dimension > 0 and exxdiv == 'ewald' and len(G0_idx) > 0:
             coulG[G0_idx] += Nk*cell.vol*madelung(cell, kpts)
 
-    coulG[equal2boundary] = 0
+    if equal2boundary is not None:
+        coulG[equal2boundary] = 0
 
     # Scale the coulG kernel for attenuated Coulomb integrals.
     # * omega is used by RangeSeparatedJKBuilder which requires ewald probe charge
@@ -507,7 +548,7 @@ def get_lattice_Ls(cell, nimgs=None, rcut=None, dimension=None, discard=True):
 
     a = cell.lattice_vectors()
 
-    scaled_atom_coords = np.linalg.solve(a.T, cell.atom_coords().T).T
+    scaled_atom_coords = cell.get_scaled_atom_coords()
     atom_boundary_max = scaled_atom_coords[:,:dimension].max(axis=0)
     atom_boundary_min = scaled_atom_coords[:,:dimension].min(axis=0)
     if (np.any(atom_boundary_max > 1) or np.any(atom_boundary_min < -1)):
@@ -542,11 +583,12 @@ def get_lattice_Ls(cell, nimgs=None, rcut=None, dimension=None, discard=True):
                              np.arange(-bounds[2], bounds[2]+1)))
     Ls = np.dot(Ts[:,:dimension], a[:dimension])
 
-    ovlp_penalty += 1e-200  # avoid /0
-    Ts_scaled = (Ts[:,:dimension] + 1e-200) / ovlp_penalty
-    ovlp_penalty_fac = 1. / abs(Ts_scaled).min(axis=1)
-    Ls_mask = np.linalg.norm(Ls, axis=1) * (1-ovlp_penalty_fac) < rcut
-    Ls = Ls[Ls_mask]
+    if discard:
+        ovlp_penalty += 1e-200  # avoid /0
+        Ts_scaled = (Ts[:,:dimension] + 1e-200) / ovlp_penalty
+        ovlp_penalty_fac = 1. / abs(Ts_scaled).min(axis=1)
+        Ls_mask = np.linalg.norm(Ls, axis=1) * (1-ovlp_penalty_fac) < rcut
+        Ls = Ls[Ls_mask]
     return np.asarray(Ls, order='C')
 
 
@@ -590,8 +632,10 @@ def super_cell(cell, ncopy, wrap_around=False):
     supcell.a = np.einsum('i,ij->ij', ncopy, a)
     mesh = np.asarray(ncopy) * np.asarray(cell.mesh)
     supcell.mesh = (mesh // 2) * 2 + 1
-    supcell.magmom = np.repeat(np.asarray(cell.magmom).reshape(1,-1),
-                               np.prod(ncopy), axis=0).ravel()
+    if isinstance(cell.magmom, np.ndarray):
+        supcell.magmom = cell.magmom.tolist() * np.prod(ncopy)
+    else:
+        supcell.magmom = cell.magmom * np.prod(ncopy)
     return _build_supcell_(supcell, cell, Ls)
 
 
@@ -632,6 +676,7 @@ def _build_supcell_(supcell, cell, Ls):
     x, y, z = coords.T
     supcell.atom = supcell._atom = list(zip(symbs, zip(x, y, z)))
     supcell.unit = 'B'
+    supcell.enuc = None # reset nuclear energy
 
     # Do not call supcell.build() to initialize supcell since it may normalize
     # the basis contraction coefficients

pyscf/pbc/x2c/sfx2c1e.py

@@ -82,7 +82,7 @@ class SFX2C1E_SCF(x2c._X2C_SCF):
 
     __name_mixin__ = 'sfX2C1e'
 
-    _keys = set(['with_x2c'])
+    _keys = {'with_x2c'}
 
     def __init__(self, mf):
         self.__dict__.update(mf.__dict__)

pyscf/pbc/x2c/x2c1e.py

@@ -84,7 +84,7 @@ class X2C1E_GSCF(x2c._X2C_SCF):
 
     __name_mixin__ = 'X2C1e'
 
-    _keys = set(['with_x2c'])
+    _keys = {'with_x2c'}
 
     def __init__(self, mf):
         self.__dict__.update(mf.__dict__)

pyscf/post_scf.py

@@ -3,3 +3,6 @@ try:
     from . import doci
 except ImportError:
     pass
+
+# Note the agf2 module implicitly import mpi4py. This module should not be
+# automatically imported until the dependency to mpi4py is completely removed.

pyscf/qmmm/itrf.py

@@ -116,7 +116,7 @@ class QMMM:
 _QMMM = QMMM
 
 class QMMMSCF(QMMM):
-    _keys = set(['mm_mol'])
+    _keys = {'mm_mol'}
 
     def __init__(self, method, mm_mol=None):
         self.__dict__.update(method.__dict__)
@@ -188,6 +188,11 @@ class QMMMSCF(QMMM):
             nuc += q2*(charges/r).sum()
         return nuc
 
+    def to_gpu(self):
+        obj = self.undo_qmmm().to_gpu()
+        obj = qmmm_for_scf(obj, self.mm_mol)
+        return lib.to_gpu(self, obj)
+
     def nuc_grad_method(self):
         scf_grad = super().nuc_grad_method()
         return qmmm_grad_for_scf(scf_grad)
@@ -207,6 +212,8 @@ class QMMMPostSCF(QMMM):
         obj._scf = self._scf.undo_qmmm()
         return obj
 
+    to_gpu = QMMMSCF.to_gpu
+
 
 def add_mm_charges_grad(scf_grad, atoms_or_coords, charges, radii=None, unit=None):
     '''Apply the MM charges in the QM gradients' method.  It affects both the
@@ -396,6 +403,11 @@ class QMMMGrad:
             g_mm += q1 * numpy.einsum('i,ix,i->ix', charges, r1-coords, 1/r**3)
         return g_mm
 
+    def to_gpu(self):
+        obj = self.undo_qmmm().to_gpu()
+        obj = qmmm_grad_for_scf(obj)
+        return lib.to_gpu(self, obj)
+
 _QMMMGrad = QMMMGrad
 
 # Inject QMMM interface wrapper to other modules

pyscf/scf/__init__.py

@@ -92,7 +92,7 @@ Saved results
         SCF converged or not
     e_tot : float
         Total HF energy (electronic energy plus nuclear repulsion)
-    mo_energy : 
+    mo_energy :
         Orbital energies
     mo_occ
         Orbital occupancy
@@ -115,6 +115,7 @@ from pyscf.scf import dhf
 from pyscf.scf import chkfile
 from pyscf.scf import addons
 from pyscf.scf import diis
+from pyscf.scf import dispersion
 from pyscf.scf.diis import DIIS, CDIIS, EDIIS, ADIIS
 from pyscf.scf.uhf import spin_square
 from pyscf.scf.hf import get_init_guess
@@ -199,6 +200,7 @@ def X2C(mol, *args):
         return x2c.RHF(mol, *args)
     else:
         return x2c.UHF(mol, *args)
+X2C_HF = X2C
 gto.Mole.X2C = gto.Mole.X2C_HF = property(X2C)
 
 def sfx2c1e(mf):

pyscf/scf/_response_functions.py

@@ -36,7 +36,7 @@ def _gen_rhf_response(mf, mo_coeff=None, mo_occ=None,
             orbital hessian or CPHF will be generated. If singlet is boolean,
             it is used in TDDFT response kernel.
     '''
-    assert (not isinstance(mf, (uhf.UHF, rohf.ROHF)))
+    assert isinstance(mf, hf.RHF) and not isinstance(mf, (uhf.UHF, rohf.ROHF))
 
     if mo_coeff is None: mo_coeff = mf.mo_coeff
     if mo_occ is None: mo_occ = mf.mo_occ
@@ -45,7 +45,7 @@ def _gen_rhf_response(mf, mo_coeff=None, mo_occ=None,
         from pyscf.dft import numint
         ni = mf._numint
         ni.libxc.test_deriv_order(mf.xc, 2, raise_error=True)
-        if mf.nlc or ni.libxc.is_nlc(mf.xc):
+        if mf.do_nlc():
             logger.warn(mf, 'NLC functional found in DFT object.  Its second '
                         'deriviative is not available. Its contribution is '
                         'not included in the response function.')
@@ -148,13 +148,14 @@ def _gen_uhf_response(mf, mo_coeff=None, mo_occ=None,
     '''Generate a function to compute the product of UHF response function and
     UHF density matrices.
     '''
+    assert isinstance(mf, (uhf.UHF, rohf.ROHF))
     if mo_coeff is None: mo_coeff = mf.mo_coeff
     if mo_occ is None: mo_occ = mf.mo_occ
     mol = mf.mol
     if isinstance(mf, hf.KohnShamDFT):
         ni = mf._numint
         ni.libxc.test_deriv_order(mf.xc, 2, raise_error=True)
-        if mf.nlc or ni.libxc.is_nlc(mf.xc):
+        if mf.do_nlc():
             logger.warn(mf, 'NLC functional found in DFT object.  Its second '
                         'deriviative is not available. Its contribution is '
                         'not included in the response function.')
@@ -227,7 +228,7 @@ def _gen_ghf_response(mf, mo_coeff=None, mo_occ=None,
         ni = mf._numint
         assert isinstance(ni, (numint2c.NumInt2C, r_numint.RNumInt))
         ni.libxc.test_deriv_order(mf.xc, 2, raise_error=True)
-        if mf.nlc or ni.libxc.is_nlc(mf.xc):
+        if mf.do_nlc():
             raise NotImplementedError('NLC')
         omega, alpha, hyb = ni.rsh_and_hybrid_coeff(mf.xc, mol.spin)
         hybrid = ni.libxc.is_hybrid_xc(mf.xc)