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

pyscf/gto/mole.py

@@ -319,7 +319,7 @@ def format_atom(atoms, origin=0, axes=None,
     coordinates to AU, rotate and shift the molecule.
     If the :attr:`~Mole.atom` is a string, it takes ";" and "\\n"
     for the mark to separate atoms;  "," and arbitrary length of blank space
-    to spearate the individual terms for an atom.  Blank line will be ignored.
+    to separate the individual terms for an atom.  Blank line will be ignored.
 
     Args:
         atoms : list or str
@@ -459,7 +459,7 @@ def format_basis(basis_tab, sort_basis=True):
         if len(_basis) == 0:
             raise BasisNotFoundError('Basis not found for  %s' % symb)
 
-        # Sort basis accroding to angular momentum. This is important for method
+        # Sort basis according to angular momentum. This is important for method
         # decontract_basis, which assumes that basis functions with the same
         # angular momentum are grouped together. Related to issue #1620 #1770
         if sort_basis:
@@ -497,7 +497,7 @@ def _generate_basis_converter():
             _basis = load(raw_basis, _std_symbol_without_ghost(symb))
         elif (any(isinstance(x, str) for x in raw_basis)
               # The first element is the basis of internal format
-              or not isinstance(raw_basis[0][0], int)):
+              or not isinstance(raw_basis[0][0], (numpy.integer, int))):
             stdsymb = _std_symbol_without_ghost(symb)
             _basis = []
             for rawb in raw_basis:
@@ -572,7 +572,7 @@ def to_uncontracted_cartesian_basis(mol):
     '''
     return decontract_basis(mol, to_cart=True)
 
-def decontract_basis(mol, atoms=None, to_cart=False):
+def decontract_basis(mol, atoms=None, to_cart=False, aggregate=False):
     '''Decontract the basis of a Mole or a Cell.  Returns a Mole (Cell) object
     with the uncontracted basis environment and a list of coefficients that
     transform the uncontracted basis to the original basis. Each element in
@@ -584,6 +584,9 @@ def decontract_basis(mol, atoms=None, to_cart=False):
             are decontracted
         to_cart: bool
             Decontract basis and transfer to Cartesian basis
+        aggregate: bool
+            Whether to aggregate the transformation coefficients into a giant
+            transformation matrix
 
     Examples:
 
@@ -602,17 +605,27 @@ def decontract_basis(mol, atoms=None, to_cart=False):
     bas_exps = mol.bas_exps()
     def _to_full_contraction(mol, bas_idx):
         es = numpy.hstack([bas_exps[i] for i in bas_idx])
-        cs = scipy.linalg.block_diag(*[mol._libcint_ctr_coeff(ib) for ib in bas_idx])
-
-        es, e_idx, rev_idx = numpy.unique(es.round(9), True, True)
-        cs_new = numpy.zeros((es.size, cs.shape[1]))
-        for i, j in enumerate(rev_idx):
-            cs_new[j] += cs[i]
-        return es[::-1], cs_new[::-1]
+        _, e_idx, rev_idx = numpy.unique(es.round(9), True, True)
+        if aggregate:
+            cs = scipy.linalg.block_diag(
+                *[mol._libcint_ctr_coeff(i) for i in bas_idx])
+            if len(es) != len(e_idx):
+                cs_new = numpy.zeros((e_idx.size, cs.shape[1]))
+                for i, j in enumerate(rev_idx):
+                    cs_new[j] += cs[i]
+                es = es[e_idx][::-1]
+                cs = cs_new[::-1]
+            yield es, cs
+        else:
+            if len(es) != len(e_idx):
+                raise RuntimeError('Duplicated pGTOs across shells')
+            for i in bas_idx:
+                yield bas_exps[i], mol._libcint_ctr_coeff(i)
 
     _bas = []
-    _env = mol._env.copy()
+    env = [mol._env.copy()]
     contr_coeff = []
+    pexp = env[0].size
 
     lmax = mol._bas[:,ANG_OF].max()
     if mol.cart:
@@ -648,7 +661,7 @@ def decontract_basis(mol, atoms=None, to_cart=False):
                 continue
 
         lmax = mol._bas[ib0:ib1,ANG_OF].max()
-        pexp = mol._bas[ib0,PTR_EXP]
+
         for l in range(lmax+1):
             bas_idx = ib0 + numpy.where(mol._bas[ib0:ib1,ANG_OF] == l)[0]
             if len(bas_idx) == 0:
@@ -656,30 +669,27 @@ def decontract_basis(mol, atoms=None, to_cart=False):
             if bas_idx[0] + len(bas_idx) != bas_idx[-1] + 1:
                 raise NotImplementedError('Discontinuous bases of same angular momentum')
 
-            mol_exps, b_coeff = _to_full_contraction(mol, bas_idx)
-            nprim, nc = b_coeff.shape
-            bs = numpy.zeros((nprim, BAS_SLOTS), dtype=numpy.int32)
-            bs[:,ATOM_OF] = ia
-            bs[:,ANG_OF ] = l
-            bs[:,NCTR_OF] = bs[:,NPRIM_OF] = 1
-            norm = gto_norm(l, mol_exps)
-            if atoms is None:
+            for mol_exps, b_coeff in _to_full_contraction(mol, bas_idx):
+                nprim, nc = b_coeff.shape
+                bs = numpy.zeros((nprim, BAS_SLOTS), dtype=numpy.int32)
+                bs[:,ATOM_OF] = ia
+                bs[:,ANG_OF ] = l
+                bs[:,NCTR_OF] = bs[:,NPRIM_OF] = 1
                 bs[:,PTR_EXP] = pexp + numpy.arange(nprim)
                 bs[:,PTR_COEFF] = pexp + numpy.arange(nprim, nprim*2)
-                _env[pexp:pexp+nprim] = mol_exps
-                _env[pexp+nprim:pexp+nprim*2] = norm
+                norm = gto_norm(l, mol_exps)
+                env.append(mol_exps)
+                env.append(norm)
                 pexp += nprim * 2
-            else:
-                bs[:,PTR_EXP] = _env.size + numpy.arange(nprim)
-                bs[:,PTR_COEFF] = _env.size + numpy.arange(nprim, nprim*2)
-                _env = np.hstack([_env, mol_exps, norm])
-            _bas.append(bs)
+                _bas.append(bs)
 
-            c = numpy.einsum('pi,p,xm->pxim', b_coeff, 1./norm, c2s[l])
-            contr_coeff.append(c.reshape(nprim * c2s[l].shape[0], -1))
+                c = numpy.einsum('pi,p,xm->pxim', b_coeff, 1./norm, c2s[l])
+                contr_coeff.append(c.reshape(nprim * c2s[l].shape[0], -1))
 
     pmol._bas = numpy.asarray(numpy.vstack(_bas), dtype=numpy.int32)
-    pmol._env = _env
+    pmol._env = numpy.hstack(env)
+    if aggregate:
+        contr_coeff = scipy.linalg.block_diag(*contr_coeff)
     return pmol, contr_coeff
 
 def format_ecp(ecp_tab):
@@ -1244,12 +1254,12 @@ def unpack(moldic):
 def dumps(mol):
     '''Serialize Mole object to a JSON formatted str.
     '''
-    exclude_keys = {'output', 'stdout', '_keys',
-                        # Constructing in function loads
-                        'symm_orb', 'irrep_id', 'irrep_name'}
+    exclude_keys = {'output', 'stdout', '_keys', '_ctx_lock',
+                    # Constructing in function loads
+                    'symm_orb', 'irrep_id', 'irrep_name'}
     # FIXME: nparray and kpts for cell objects may need to be excluded
     nparray_keys = {'_atm', '_bas', '_env', '_ecpbas',
-                        '_symm_orig', '_symm_axes'}
+                    '_symm_orig', '_symm_axes'}
 
     moldic = dict(mol.__dict__)
     for k in exclude_keys:
@@ -1961,7 +1971,7 @@ def same_mol(mol1, mol2, tol=1e-5, cmp_basis=True, ignore_chiral=False):
 is_same_mol = same_mol
 
 def chiral_mol(mol1, mol2=None):
-    '''Detect whether the given molelcule is chiral molecule or two molecules
+    '''Detect whether the given molecule is chiral molecule or two molecules
     are chiral isomers.
     '''
     if mol2 is None:
@@ -2197,7 +2207,7 @@ class MoleBase(lib.StreamObject):
             subgroup
 
         atom : list or str
-            To define molecluar structure.  The internal format is
+            To define molecular structure.  The internal format is
 
             | atom = [[atom1, (x, y, z)],
             |         [atom2, (x, y, z)],
@@ -2457,7 +2467,7 @@ class MoleBase(lib.StreamObject):
               atom=None, basis=None, unit=None, nucmod=None, ecp=None, pseudo=None,
               charge=None, spin=0, symmetry=None, symmetry_subgroup=None,
               cart=None, magmom=None):
-        '''Setup moleclue and initialize some control parameters.  Whenever you
+        '''Setup molecule and initialize some control parameters.  Whenever you
         change the value of the attributes of :class:`Mole`, you need call
         this function to refresh the internal data of Mole.
 
@@ -2473,7 +2483,7 @@ class MoleBase(lib.StreamObject):
             max_memory : int, float
                 Allowd memory in MB.  If given, overwrite :attr:`Mole.max_memory`
             atom : list or str
-                To define molecluar structure.
+                To define molecular structure.
             basis : dict or str
                 To define basis set.
             nucmod : dict or str
@@ -2750,7 +2760,7 @@ class MoleBase(lib.StreamObject):
                           '          X                Y                Z       unit  Magmom\n')
         for ia,atom in enumerate(self._atom):
             coorda = tuple([x * param.BOHR for x in atom[1]])
-            coordb = tuple([x for x in atom[1]])
+            coordb = tuple(atom[1])
             magmom = self.magmom[ia]
             self.stdout.write('[INPUT]%3d %-4s %16.12f %16.12f %16.12f AA  '
                               '%16.12f %16.12f %16.12f Bohr  %4.1f\n'
@@ -3070,7 +3080,7 @@ class MoleBase(lib.StreamObject):
             logger.info(mol, 'New geometry')
             for ia, atom in enumerate(mol._atom):
                 coorda = tuple([x * param.BOHR for x in atom[1]])
-                coordb = tuple([x for x in atom[1]])
+                coordb = tuple(atom[1])
                 coords = coorda + coordb
                 logger.info(mol, ' %3d %-4s %16.12f %16.12f %16.12f AA  '
                             '%16.12f %16.12f %16.12f Bohr\n',
@@ -3431,6 +3441,11 @@ class MoleBase(lib.StreamObject):
                 | 1 : hermitian
                 | 2 : anti-hermitian
 
+            shls_slice : 4-element, 6-element or 8-element tuple
+                Label the start-stop shells for each index in the integral.
+                For example, the 8-element tuple for the 2-electron integral
+                tensor (ij|kl) = intor('int2e') are specified as
+                (ish_start, ish_end, jsh_start, jsh_end, ksh_start, ksh_end, lsh_start, lsh_end)
             grids : ndarray
                 Coordinates of grids for the int1e_grids integrals
 
@@ -3748,7 +3763,7 @@ class Mole(MoleBase):
     def ao2mo(self, mo_coeffs, erifile=None, dataname='eri_mo', intor='int2e',
               **kwargs):
         '''Integral transformation for arbitrary orbitals and arbitrary
-        integrals.  See more detalied documentation in func:`ao2mo.kernel`.
+        integrals.  See more detailed documentation in func:`ao2mo.kernel`.
 
         Args:
             mo_coeffs (an np array or a list of arrays) : A matrix of orbital
@@ -3800,7 +3815,7 @@ class Mole(MoleBase):
         return ao2mo.kernel(self, mo_coeffs, erifile, dataname, intor, **kwargs)
 
     def to_cell(self, a, dimension=3):
-        '''Put a molecule in a cell with periodic boundary condictions
+        '''Put a molecule in a cell with periodic boundary conditions
 
         Args:
             a : (3,3) ndarray
@@ -4054,7 +4069,7 @@ def fakemol_for_charges(coords, expnt=1e16):
         # approximate point charge with gaussian distribution exp(-1e16*r^2)
         fakebas[:,PTR_EXP] = ptr
         fakebas[:,PTR_COEFF] = ptr+1
-        fakeenv.append([expnt, 1/(2*numpy.sqrt(numpy.pi)*gaussian_int(2,expnt))])
+        fakeenv.append([expnt, 1 / (2*numpy.sqrt(numpy.pi)*gaussian_int(2,expnt))])
         ptr += 2
     else:
         assert expnt.size == nbas
@@ -4071,6 +4086,46 @@ def fakemol_for_charges(coords, expnt=1e16):
     fakemol._built = True
     return fakemol
 
+def fakemol_for_cgtf_charge(coord, expnt=1e16, contr_coeff=1):
+    '''Constructs a "fake" Mole object that has a Gaussian charge
+    distribution at the specified coordinate (coord).  The charge
+    can be given as a linear combination of Gaussians with
+    exponents expnt and contraction coefficients contr_coeff.
+    '''
+    assert coord.shape[0] == 1
+    expnt = numpy.asarray(expnt).ravel()
+    contr_coeff = numpy.asarray(contr_coeff).ravel()
+
+    fakeatm = numpy.zeros((1,ATM_SLOTS), dtype=numpy.int32)
+    fakebas = numpy.zeros((1,BAS_SLOTS), dtype=numpy.int32)
+    fakeenv = [0] * PTR_ENV_START
+    ptr = PTR_ENV_START
+    fakeatm[:,PTR_COORD] = numpy.arange(ptr, ptr+3, 3)
+    fakeenv.append(coord.ravel())
+    ptr += 3
+    fakebas[:,ATOM_OF] = 0#numpy.arange(nbas)
+    fakebas[:,NPRIM_OF] = contr_coeff.size
+    fakebas[:,NCTR_OF] = 1
+    if expnt.size == 1:
+        expnt = expnt[0]
+        fakebas[:,PTR_EXP] = ptr
+        fakebas[:,PTR_COEFF] = ptr+1
+        fakeenv.append([expnt, 1 / (2*numpy.sqrt(numpy.pi)*gaussian_int(2,expnt))])
+        ptr += 2
+    else:
+        assert expnt.size == contr_coeff.size
+        fakebas[:,PTR_EXP] = ptr
+        fakebas[:,PTR_COEFF] = ptr + contr_coeff.size
+        coeff = contr_coeff / (2 * numpy.sqrt(numpy.pi) * gaussian_int(2, expnt))
+        fakeenv.append(numpy.vstack((expnt, coeff)).ravel())
+
+    fakemol = Mole()
+    fakemol._atm = fakeatm
+    fakemol._bas = fakebas
+    fakemol._env = numpy.hstack(fakeenv)
+    fakemol._built = True
+    return fakemol
+
 def classify_ecp_pseudo(mol, ecp, pp):
     '''
     Check whether ecp keywords are presented in pp and whether pp keywords are

pyscf/gw/gw_ac.py

@@ -20,7 +20,7 @@
 Spin-restricted G0W0 approximation with analytic continuation
 This implementation has N^4 scaling, and is faster than GW-CD (N^4)
 and analytic GW (N^6) methods.
-GW-AC is recommended for valence states only, and is inaccuarate for core states.
+GW-AC is recommended for valence states only, and is inaccurate for core states.
 
 Method:
     See T. Zhu and G.K.-L. Chan, arxiv:2007.03148 (2020) for details
@@ -230,7 +230,7 @@ def _get_scaled_legendre_roots(nw):
 
 def _get_clenshaw_curtis_roots(nw):
     """
-    Clenshaw-Curtis qaudrature on [0,inf)
+    Clenshaw-Curtis quadrature on [0,inf)
     Ref: J. Chem. Phys. 132, 234114 (2010)
     Returns:
         freqs : 1D ndarray

pyscf/gw/gw_cd.py

@@ -192,7 +192,7 @@ def get_rho_response_R(gw, omega, Lpq):
 
 def get_sigmaR_diag(gw, omega, orbp, ef, Lpq):
     '''
-    Compute self-energy for poles inside coutour
+    Compute self-energy for poles inside contour
     (more and more expensive away from Fermi surface)
     '''
     mo_energy = gw._scf.mo_energy
@@ -234,7 +234,7 @@ def _get_scaled_legendre_roots(nw):
 
 def _get_clenshaw_curtis_roots(nw):
     """
-    Clenshaw-Curtis qaudrature on [0,inf)
+    Clenshaw-Curtis quadrature on [0,inf)
     Ref: J. Chem. Phys. 132, 234114 (2010)
     Returns:
         freqs : 1D ndarray

pyscf/gw/rpa.py

@@ -21,7 +21,7 @@ Spin-restricted random phase approximation (direct RPA/dRPA in chemistry)
 with N^4 scaling
 
 Method:
-    Main routines are based on GW-AC method descirbed in:
+    Main routines are based on GW-AC method described in:
     T. Zhu and G.K.-L. Chan, J. Chem. Theory. Comput. 17, 727-741 (2021)
     X. Ren et al., New J. Phys. 14, 053020 (2012)
 """
@@ -172,7 +172,7 @@ def _get_scaled_legendre_roots(nw, x0=0.5):
 
 def _get_clenshaw_curtis_roots(nw):
     """
-    Clenshaw-Curtis qaudrature on [0,inf)
+    Clenshaw-Curtis quadrature on [0,inf)
     Ref: J. Chem. Phys. 132, 234114 (2010)
 
     Returns:

pyscf/gw/ugw_ac.py

@@ -21,7 +21,7 @@ Spin-unrestricted G0W0 approximation with analytic continuation
 
 This implementation has N^4 scaling, and is faster than GW-CD (N^4)
 and analytic GW (N^6) methods.
-GW-AC is recommended for valence states only, and is inaccuarate for core states.
+GW-AC is recommended for valence states only, and is inaccurate for core states.
 
 Method:
     See T. Zhu and G.K.-L. Chan, arxiv:2007.03148 (2020) for details
@@ -277,7 +277,7 @@ def _get_scaled_legendre_roots(nw):
 
 def _get_clenshaw_curtis_roots(nw):
     """
-    Clenshaw-Curtis qaudrature on [0,inf)
+    Clenshaw-Curtis quadrature on [0,inf)
     Ref: J. Chem. Phys. 132, 234114 (2010)
     Returns:
         freqs : 1D ndarray

pyscf/gw/urpa.py

@@ -21,7 +21,7 @@ Spin-unrestricted random phase approximation (direct RPA/dRPA in chemistry)
 with N^4 scaling
 
 Method:
-    Main routines are based on GW-AC method descirbed in:
+    Main routines are based on GW-AC method described in:
     T. Zhu and G.K.-L. Chan, J. Chem. Theory. Comput. 17, 727-741 (2021)
     X. Ren et al., New J. Phys. 14, 053020 (2012)
 """

pyscf/hessian/rhf.py

@@ -53,20 +53,13 @@ def hess_elec(hessobj, mo_energy=None, mo_coeff=None, mo_occ=None,
                                     max_memory, log)
 
     if h1ao is None:
-        h1ao = hessobj.make_h1(mo_coeff, mo_occ, hessobj.chkfile, atmlst, log)
+        h1ao = hessobj.make_h1(mo_coeff, mo_occ, None, atmlst, log)
         t1 = log.timer_debug1('making H1', *time0)
     if mo1 is None or mo_e1 is None:
         mo1, mo_e1 = hessobj.solve_mo1(mo_energy, mo_coeff, mo_occ, h1ao,
                                        None, atmlst, max_memory, log)
         t1 = log.timer_debug1('solving MO1', *t1)
 
-    if isinstance(h1ao, str):
-        h1ao = lib.chkfile.load(h1ao, 'scf_f1ao')
-        h1ao = {int(k): h1ao[k] for k in h1ao}
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1 = {int(k): mo1[k] for k in mo1}
-
     nao, nmo = mo_coeff.shape
     mocc = mo_coeff[:,mo_occ>0]
     s1a = -mol.intor('int1e_ipovlp', comp=3)
@@ -136,9 +129,12 @@ def _partial_hess_ejk(hessobj, mo_energy=None, mo_coeff=None, mo_occ=None,
     ip1ip2_opt = _make_vhfopt(mol, dm0, 'ip1ip2', 'int2e_ip1ip2')
     ipvip1_opt = _make_vhfopt(mol, dm0, 'ipvip1', 'int2e_ipvip1ipvip2')
     aoslices = mol.aoslice_by_atom()
-    e1 = numpy.zeros((mol.natm,mol.natm,3,3))
-    ej = numpy.zeros((mol.natm,mol.natm,3,3))
-    ek = numpy.zeros((mol.natm,mol.natm,3,3))
+
+    natm = len(atmlst)
+    e1 = numpy.zeros((natm, natm, 3, 3))
+    ej = numpy.zeros((natm, natm, 3, 3))
+    ek = numpy.zeros((natm, natm, 3, 3))
+
     for i0, ia in enumerate(atmlst):
         shl0, shl1, p0, p1 = aoslices[ia]
         shls_slice = (shl0, shl1) + (0, mol.nbas)*3
@@ -159,24 +155,24 @@ def _partial_hess_ejk(hessobj, mo_energy=None, mo_coeff=None, mo_occ=None,
         vk1 = vk1.reshape(3,3,nao,nao)
         t1 = log.timer_debug1('contracting int2e_ipvip1 for atom %d'%ia, *t1)
 
-        ej[i0,i0] += numpy.einsum('xypq,pq->xy', vj1_diag[:,:,p0:p1], dm0[p0:p1])*2
-        ek[i0,i0] += numpy.einsum('xypq,pq->xy', vk1_diag[:,:,p0:p1], dm0[p0:p1])
-        e1[i0,i0] -= numpy.einsum('xypq,pq->xy', s1aa[:,:,p0:p1], dme0[p0:p1])*2
+        ej[i0, i0] += numpy.einsum('xypq,pq->xy', vj1_diag[:,:,p0:p1], dm0[p0:p1])*2
+        ek[i0, i0] += numpy.einsum('xypq,pq->xy', vk1_diag[:,:,p0:p1], dm0[p0:p1])
+        e1[i0, i0] -= numpy.einsum('xypq,pq->xy', s1aa[:,:,p0:p1], dme0[p0:p1])*2
 
         for j0, ja in enumerate(atmlst[:i0+1]):
             q0, q1 = aoslices[ja][2:]
             # *2 for +c.c.
-            ej[i0,j0] += numpy.einsum('xypq,pq->xy', vj1[:,:,q0:q1], dm0[q0:q1])*4
-            ek[i0,j0] += numpy.einsum('xypq,pq->xy', vk1[:,:,q0:q1], dm0[q0:q1])
-            e1[i0,j0] -= numpy.einsum('xypq,pq->xy', s1ab[:,:,p0:p1,q0:q1], dme0[p0:p1,q0:q1])*2
+            ej[i0, j0] += numpy.einsum('xypq,pq->xy', vj1[:,:,q0:q1], dm0[q0:q1])*4
+            ek[i0, j0] += numpy.einsum('xypq,pq->xy', vk1[:,:,q0:q1], dm0[q0:q1])
+            e1[i0, j0] -= numpy.einsum('xypq,pq->xy', s1ab[:,:,p0:p1,q0:q1], dme0[p0:p1,q0:q1])*2
 
             h1ao = hcore_deriv(ia, ja)
-            e1[i0,j0] += numpy.einsum('xypq,pq->xy', h1ao, dm0)
+            e1[i0, j0] += numpy.einsum('xypq,pq->xy', h1ao, dm0)
 
         for j0 in range(i0):
-            e1[j0,i0] = e1[i0,j0].T
-            ej[j0,i0] = ej[i0,j0].T
-            ek[j0,i0] = ek[i0,j0].T
+            e1[j0, i0] = e1[i0, j0].T
+            ej[j0, i0] = ej[i0, j0].T
+            ek[j0, i0] = ek[i0, j0].T
 
     log.timer('RHF partial hessian', *time0)
     return e1, ej, ek
@@ -237,16 +233,8 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
         vhf[:,p0:p1] += vj2 - vk2*.5
         h1 = vhf + vhf.transpose(0,2,1)
         h1 += hcore_deriv(ia)
-
-        if chkfile is None:
-            h1ao[ia] = h1
-        else:
-            key = 'scf_f1ao/%d' % ia
-            lib.chkfile.save(chkfile, key, h1)
-    if chkfile is None:
-        return h1ao
-    else:
-        return chkfile
+        h1ao[ia] = h1
+    return h1ao
 
 def get_hcore(mol):
     '''Part of the second derivatives of core Hamiltonian'''
@@ -295,7 +283,7 @@ def _get_jk(mol, intor, comp, aosym, script_dms,
                 lib.hermi_triu(vs[k], hermi=hermi, inplace=True)
     return vs
 
-def solve_mo1(mf, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
+def solve_mo1(mf, mo_energy, mo_coeff, mo_occ, h1ao,
               fx=None, atmlst=None, max_memory=4000, verbose=None,
               max_cycle=50, level_shift=0):
     '''Solve the first order equation
@@ -335,12 +323,7 @@ def solve_mo1(mf, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
             s1ao[:,p0:p1] += s1a[:,p0:p1]
             s1ao[:,:,p0:p1] += s1a[:,p0:p1].transpose(0,2,1)
             s1vo.append(_ao2mo(s1ao))
-            if isinstance(h1ao_or_chkfile, str):
-                key = 'scf_f1ao/%d' % ia
-                h1ao = lib.chkfile.load(h1ao_or_chkfile, key)
-            else:
-                h1ao = h1ao_or_chkfile[ia]
-            h1vo.append(_ao2mo(h1ao))
+            h1vo.append(_ao2mo(h1ao[ia]))
 
         h1vo = numpy.vstack(h1vo)
         s1vo = numpy.vstack(s1vo)
@@ -352,18 +335,10 @@ def solve_mo1(mf, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
 
         for k in range(ia1-ia0):
             ia = atmlst[k+ia0]
-            if isinstance(h1ao_or_chkfile, str):
-                key = 'scf_mo1/%d' % ia
-                lib.chkfile.save(h1ao_or_chkfile, key, mo1[k])
-            else:
-                mo1s[ia] = mo1[k]
+            mo1s[ia] = mo1[k]
             e1s[ia] = e1[k].reshape(3,nocc,nocc)
         mo1 = e1 = None
-
-    if isinstance(h1ao_or_chkfile, str):
-        return h1ao_or_chkfile, e1s
-    else:
-        return mo1s, e1s
+    return mo1s, e1s
 
 def gen_vind(mf, mo_coeff, mo_occ):
     nao, nmo = mo_coeff.shape
@@ -428,8 +403,7 @@ def gen_hop(hobj, mo_energy=None, mo_coeff=None, mo_occ=None, verbose=None):
                                  max_memory, log)
     de2 += hobj.hess_nuc()
 
-    # Compute H1 integrals and store in hobj.chkfile
-    hobj.make_h1(mo_coeff, mo_occ, hobj.chkfile, atmlst, log)
+    h1ao_cache = hobj.make_h1(mo_coeff, mo_occ, None, atmlst, log)
 
     aoslices = mol.aoslice_by_atom()
     s1a = -mol.intor('int1e_ipovlp', comp=3)
@@ -442,8 +416,7 @@ def gen_hop(hobj, mo_energy=None, mo_coeff=None, mo_occ=None, verbose=None):
         s1ao = 0
         for ia in range(natm):
             shl0, shl1, p0, p1 = aoslices[ia]
-            h1ao_i = lib.chkfile.load(hobj.chkfile, 'scf_f1ao/%d' % ia)
-            h1ao += numpy.einsum('x,xij->ij', x[ia], h1ao_i)
+            h1ao += numpy.einsum('x,xij->ij', x[ia], h1ao_cache[ia])
             s1ao_i = numpy.zeros((3,nao,nao))
             s1ao_i[:,p0:p1] += s1a[:,p0:p1]
             s1ao_i[:,:,p0:p1] += s1a[:,p0:p1].transpose(0,2,1)
@@ -460,8 +433,7 @@ def gen_hop(hobj, mo_energy=None, mo_coeff=None, mo_occ=None, verbose=None):
 
         for ja in range(natm):
             q0, q1 = aoslices[ja][2:]
-            h1ao = lib.chkfile.load(hobj.chkfile, 'scf_f1ao/%s'%ja)
-            hx[ja] += numpy.einsum('xpq,pq->x', h1ao, dm1) * 4
+            hx[ja] += numpy.einsum('xpq,pq->x', h1ao_cache[ja], dm1) * 4
             hx[ja] -= numpy.einsum('xpq,pq->x', s1a[:,q0:q1], dme1[q0:q1]) * 2
             hx[ja] -= numpy.einsum('xpq,qp->x', s1a[:,q0:q1], dme1[:,q0:q1]) * 2
         return hx.ravel()
@@ -481,16 +453,15 @@ class HessianBase(lib.StreamObject):
     level_shift = 0
 
     _keys = {
-        'mol', 'base', 'chkfile', 'atmlst', 'de', 'max_cycle', 'level_shift'
+        'mol', 'base', 'atmlst', 'de', 'max_cycle', 'level_shift'
     }
 
     def __init__(self, scf_method):
         self.verbose = scf_method.verbose
         self.stdout = scf_method.stdout
         self.mol = scf_method.mol
-        self.chkfile = scf_method.chkfile
-        self.max_memory = self.mol.max_memory
         self.base = scf_method
+        self.max_memory = self.mol.max_memory
         self.atmlst = range(self.mol.natm)
         self.de = numpy.zeros((0,0,3,3))  # (A,B,dR_A,dR_B)
 
@@ -572,9 +543,9 @@ class HessianBase(lib.StreamObject):
             return hcore + hcore.conj().transpose(0,1,3,2)
         return get_hcore
 
-    def solve_mo1(self, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
+    def solve_mo1(self, mo_energy, mo_coeff, mo_occ, h1ao,
                   fx=None, atmlst=None, max_memory=4000, verbose=None):
-        return solve_mo1(self.base, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
+        return solve_mo1(self.base, mo_energy, mo_coeff, mo_occ, h1ao,
                          fx, atmlst, max_memory, verbose,
                          max_cycle=self.max_cycle, level_shift=self.level_shift)
 
@@ -619,72 +590,3 @@ class Hessian(HessianBase):
 from pyscf import scf
 scf.hf.RHF.Hessian = lib.class_as_method(Hessian)
 scf.rohf.ROHF.Hessian = lib.invalid_method('Hessian')
-
-
-if __name__ == '__main__':
-    from pyscf import scf
-
-    mol = gto.Mole()
-    mol.verbose = 0
-    mol.output = None
-    mol.atom = [
-        [1 , (1. ,  0.     , 0.000)],
-        [1 , (0. ,  1.     , 0.000)],
-        [1 , (0. , -1.517  , 1.177)],
-        [1 , (0. ,  1.517  , 1.177)] ]
-    mol.basis = '631g'
-    mol.unit = 'B'
-    mol.build()
-    mf = scf.RHF(mol)
-    mf.conv_tol = 1e-14
-    mf.scf()
-    n3 = mol.natm * 3
-    hobj = mf.Hessian()
-    e2 = hobj.kernel().transpose(0,2,1,3).reshape(n3,n3)
-    print(lib.fp(e2) - -0.50693144355876429)
-    #from hessian import rhf_o0
-    #e2ref = rhf_o0.Hessian(mf).kernel().transpose(0,2,1,3).reshape(n3,n3)
-    #print numpy.linalg.norm(e2-e2ref)
-    #print numpy.allclose(e2,e2ref)
-
-    def grad_full(ia, inc):
-        coord = mol.atom_coord(ia).copy()
-        ptr = mol._atm[ia,gto.PTR_COORD]
-        de = []
-        for i in range(3):
-            mol._env[ptr+i] = coord[i] + inc
-            mf = scf.RHF(mol).run(conv_tol=1e-14)
-            e1a = mf.nuc_grad_method().kernel()
-            mol._env[ptr+i] = coord[i] - inc
-            mf = scf.RHF(mol).run(conv_tol=1e-14)
-            e1b = mf.nuc_grad_method().kernel()
-            mol._env[ptr+i] = coord[i]
-            de.append((e1a-e1b)/(2*inc))
-        return de
-    e2ref = [grad_full(ia, .5e-4) for ia in range(mol.natm)]
-    e2ref = numpy.asarray(e2ref).reshape(n3,n3)
-    print(numpy.linalg.norm(e2-e2ref))
-    print(abs(e2-e2ref).max())
-    print(numpy.allclose(e2,e2ref,atol=1e-6))
-
-# \partial^2 E / \partial R \partial R'
-    e2 = hobj.partial_hess_elec(mf.mo_energy, mf.mo_coeff, mf.mo_occ)
-    e2 += hobj.hess_nuc(mol)
-    e2 = e2.transpose(0,2,1,3).reshape(n3,n3)
-    def grad_partial_R(ia, inc):
-        coord = mol.atom_coord(ia).copy()
-        ptr = mol._atm[ia,gto.PTR_COORD]
-        de = []
-        for i in range(3):
-            mol._env[ptr+i] = coord[i] + inc
-            e1a = mf.nuc_grad_method().kernel()
-            mol._env[ptr+i] = coord[i] - inc
-            e1b = mf.nuc_grad_method().kernel()
-            mol._env[ptr+i] = coord[i]
-            de.append((e1a-e1b)/(2*inc))
-        return de
-    e2ref = [grad_partial_R(ia, .5e-4) for ia in range(mol.natm)]
-    e2ref = numpy.asarray(e2ref).reshape(n3,n3)
-    print(numpy.linalg.norm(e2-e2ref))
-    print(abs(e2-e2ref).max())
-    print(numpy.allclose(e2,e2ref,atol=1e-8))

pyscf/hessian/rks.py

@@ -161,12 +161,7 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
         h1ao[ia] += veff + veff.transpose(0,2,1)
         h1ao[ia] += hcore_deriv(ia)
 
-    if chkfile is None:
-        return h1ao
-    else:
-        for ia in atmlst:
-            lib.chkfile.save(chkfile, 'scf_f1ao/%d'%ia, h1ao[ia])
-        return chkfile
+    return h1ao
 
 XX, XY, XZ = 4, 5, 6
 YX, YY, YZ = 5, 7, 8