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

pyscf/hessian/uhf.py

@@ -53,29 +53,15 @@ 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')
-        h1aoa = h1ao['0']
-        h1aob = h1ao['1']
-        h1aoa = {int(k): h1aoa[k] for k in h1aoa}
-        h1aob = {int(k): h1aob[k] for k in h1aob}
-    else:
-        h1aoa, h1aob = h1ao
-    if isinstance(mo1, str):
-        mo1 = lib.chkfile.load(mo1, 'scf_mo1')
-        mo1a = mo1['0']
-        mo1b = mo1['1']
-        mo1a = {int(k): mo1a[k] for k in mo1a}
-        mo1b = {int(k): mo1b[k] for k in mo1b}
-    else:
-        mo1a, mo1b = mo1
+    h1aoa, h1aob = h1ao
+    mo1a, mo1b = mo1
     mo_e1a, mo_e1b = mo_e1
 
     nao, nmo = mo_coeff[0].shape
@@ -159,9 +145,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))  # (A,B,dR_A,dR_B)
-    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))  # (A,B,dR_A,dR_B)
+    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
@@ -242,21 +231,11 @@ def make_h1(hessobj, mo_coeff, mo_occ, chkfile=None, atmlst=None, verbose=None):
         vhfa[:,p0:p1] += vj2 - vk2a
         vhfb[:,p0:p1] += vj2 - vk2b
         h1 = hcore_deriv(ia)
-        h1a = h1 + vhfa + vhfa.transpose(0,2,1)
-        h1b = h1 + vhfb + vhfb.transpose(0,2,1)
-
-        if chkfile is None:
-            h1aoa[ia] = h1a
-            h1aob[ia] = h1b
-        else:
-            lib.chkfile.save(chkfile, 'scf_f1ao/0/%d' % ia, h1a)
-            lib.chkfile.save(chkfile, 'scf_f1ao/1/%d' % ia, h1b)
-    if chkfile is None:
-        return (h1aoa,h1aob)
-    else:
-        return chkfile
-
-def solve_mo1(mf, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
+        h1aoa[ia] = h1 + vhfa + vhfa.transpose(0,2,1)
+        h1aob[ia] = h1 + vhfb + vhfb.transpose(0,2,1)
+    return (h1aoa,h1aob)
+
+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):
     mol = mf.mol
@@ -271,6 +250,7 @@ def solve_mo1(mf, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
     if fx is None:
         fx = gen_vind(mf, mo_coeff, mo_occ)
     s1a = -mol.intor('int1e_ipovlp', comp=3)
+    h1aoa, h1aob = h1ao
 
     def _ao2mo(mat, mo_coeff, mocc):
         return numpy.asarray([reduce(numpy.dot, (mo_coeff.T, x, mocc)) for x in mat])
@@ -296,14 +276,8 @@ def solve_mo1(mf, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
             s1ao[:,:,p0:p1] += s1a[:,p0:p1].transpose(0,2,1)
             s1voa.append(_ao2mo(s1ao, mo_coeff[0], mocca))
             s1vob.append(_ao2mo(s1ao, mo_coeff[1], moccb))
-            if isinstance(h1ao_or_chkfile, str):
-                h1aoa = lib.chkfile.load(h1ao_or_chkfile, 'scf_f1ao/0/%d'%ia)
-                h1aob = lib.chkfile.load(h1ao_or_chkfile, 'scf_f1ao/1/%d'%ia)
-            else:
-                h1aoa = h1ao_or_chkfile[0][ia]
-                h1aob = h1ao_or_chkfile[1][ia]
-            h1voa.append(_ao2mo(h1aoa, mo_coeff[0], mocca))
-            h1vob.append(_ao2mo(h1aob, mo_coeff[1], moccb))
+            h1voa.append(_ao2mo(h1aoa[ia], mo_coeff[0], mocca))
+            h1vob.append(_ao2mo(h1aob[ia], mo_coeff[1], moccb))
 
         h1vo = (numpy.vstack(h1voa), numpy.vstack(h1vob))
         s1vo = (numpy.vstack(s1voa), numpy.vstack(s1vob))
@@ -317,20 +291,13 @@ 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):
-                lib.chkfile.save(h1ao_or_chkfile, 'scf_mo1/0/%d'%ia, mo1a[k])
-                lib.chkfile.save(h1ao_or_chkfile, 'scf_mo1/1/%d'%ia, mo1b[k])
-            else:
-                mo1sa[ia] = mo1a[k]
-                mo1sb[ia] = mo1b[k]
+            mo1sa[ia] = mo1a[k]
+            mo1sb[ia] = mo1b[k]
             e1sa[ia] = e1a[k].reshape(3,nocca,nocca)
             e1sb[ia] = e1b[k].reshape(3,noccb,noccb)
         mo1 = e1 = mo1a = mo1b = e1a = e1b = None
 
-    if isinstance(h1ao_or_chkfile, str):
-        return h1ao_or_chkfile, (e1sa,e1sb)
-    else:
-        return (mo1sa,mo1sb), (e1sa,e1sb)
+    return (mo1sa,mo1sb), (e1sa,e1sb)
 
 def gen_vind(mf, mo_coeff, mo_occ):
     nao, nmoa = mo_coeff[0].shape
@@ -385,8 +352,8 @@ 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)
+    h1aoa_cache, h1aob_cache = h1ao_cache
 
     aoslices = mol.aoslice_by_atom()
     s1a = -mol.intor('int1e_ipovlp', comp=3)
@@ -400,10 +367,8 @@ 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/0/%d' % ia)
-            h1aoa += numpy.einsum('x,xij->ij', x[ia], h1ao_i)
-            h1ao_i = lib.chkfile.load(hobj.chkfile, 'scf_f1ao/1/%d' % ia)
-            h1aob += numpy.einsum('x,xij->ij', x[ia], h1ao_i)
+            h1aoa += numpy.einsum('x,xij->ij', x[ia], h1aoa_cache[ia])
+            h1aob += numpy.einsum('x,xij->ij', x[ia], h1aob_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)
@@ -429,10 +394,8 @@ 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:]
-            h1aoa = lib.chkfile.load(hobj.chkfile, 'scf_f1ao/0/%d' % ja)
-            h1aob = lib.chkfile.load(hobj.chkfile, 'scf_f1ao/1/%d' % ja)
-            hx[ja] += numpy.einsum('xpq,pq->x', h1aoa, dm1a) * 2
-            hx[ja] += numpy.einsum('xpq,pq->x', h1aob, dm1b) * 2
+            hx[ja] += numpy.einsum('xpq,pq->x', h1aoa_cache[ja], dm1a) * 2
+            hx[ja] += numpy.einsum('xpq,pq->x', h1aob_cache[ja], dm1b) * 2
             hx[ja] -= numpy.einsum('xpq,pq->x', s1a[:,q0:q1], dme1[q0:q1])
             hx[ja] -= numpy.einsum('xpq,qp->x', s1a[:,q0:q1], dme1[:,q0:q1])
         return hx.ravel()
@@ -449,84 +412,11 @@ class Hessian(rhf_hess.HessianBase):
     make_h1 = make_h1
     gen_hop = gen_hop
 
-    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)
 
 from pyscf import scf
 scf.uhf.UHF.Hessian = lib.class_as_method(Hessian)
-
-if __name__ == '__main__':
-    from pyscf import gto
-    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.UHF(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)
-
-    mol.spin = 2
-    mf = scf.UHF(mol)
-    mf.conv_tol = 1e-14
-    mf.scf()
-    n3 = mol.natm * 3
-    hobj = Hessian(mf)
-    e2 = hobj.kernel().transpose(0,2,1,3).reshape(n3,n3)
-
-    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.UHF(mol).run(conv_tol=1e-14)
-            e1a = mf.nuc_grad_method().kernel()
-            mol._env[ptr+i] = coord[i] - inc
-            mf = scf.UHF(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-3) 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-4))
-
-# \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/uks.py

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

pyscf/lib/ao2mo/nr_ao2mo.c

@@ -1225,7 +1225,7 @@ void AO2MOnr_e1_drv(int (*intor)(), void (*fill)(), void (*ftrans)(), int (*fmmm
         int nao = ao_loc[nbas];
         double *eri_ao = malloc(sizeof(double) * nao*nao*nkl*ncomp);
         if (eri_ao == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in AO2MOnr_e1_drv\n",
+                fprintf(stderr, "malloc(%zu) failed in AO2MOnr_e1_drv\n",
                         sizeof(double) * nao*nao*nkl*ncomp);
                 exit(1);
         }

pyscf/lib/ao2mo/nrr_ao2mo.c

@@ -239,7 +239,7 @@ void AO2MOnrr_e1_drv(int (*intor)(), void (*fill)(),
 
         double *eri_ao = malloc(sizeof(double)* nao*nao*nkl*ncomp);
         if (eri_ao == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in AO2MOnrr_e1_drv\n",
+                fprintf(stderr, "malloc(%zu) failed in AO2MOnrr_e1_drv\n",
                         sizeof(double) * nao*nao*nkl*ncomp);
                 exit(1);
         }

pyscf/lib/ao2mo/r_ao2mo.c

@@ -835,7 +835,7 @@ void AO2MOr_e1_drv(int (*intor)(), void (*fill)(),
         double complex *eri_ao = malloc(sizeof(double complex)
                                         * nao*nao*nkl*ncomp);
         if (eri_ao == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in AO2MOr_e1_drv\n",
+                fprintf(stderr, "malloc(%zu) failed in AO2MOr_e1_drv\n",
                         sizeof(double complex) * nao*nao*nkl*ncomp);
                 exit(1);
         }

pyscf/lib/cc/ccsd_pack.c

@@ -106,7 +106,7 @@ void CCmake_021(double *out, double *v1, double *v2, int count, int m,
 /*
  * if matrix B is symmetric for the contraction A_ij B_ij,
  * Tr(AB) ~ A_ii B_ii + (A_ij + A_ji) B_ij where i > j
- * This function extract the A_ii and the lower triangluar part of A_ij + A_ji
+ * This function extract the A_ii and the lower triangular part of A_ij + A_ji
  */
 void CCprecontract(double *out, double *in, int count, int m, double diagfac)
 {

pyscf/lib/cc/ccsd_t.c

@@ -400,7 +400,7 @@ void CCsd_t_contract(double *e_tot,
         size_t k;
         double *cache1 = malloc(sizeof(double) * (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in CCsd_t_contract\n",
+                fprintf(stderr, "malloc(%zu) failed in CCsd_t_contract\n",
                         sizeof(double) * nocc*nocc*nocc*3);
                 exit(1);
         }
@@ -455,7 +455,7 @@ void QCIsd_t_contract(double *e_tot,
         size_t k;
         double *cache1 = malloc(sizeof(double) * (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in QCIsd_t_contract\n",
+                fprintf(stderr, "malloc(%zu) failed in QCIsd_t_contract\n",
                         sizeof(double) * nocc*nocc*nocc*3);
                 exit(1);
         }
@@ -636,7 +636,7 @@ void CCsd_t_zcontract(double complex *e_tot,
         size_t k;
         double complex *cache1 = malloc(sizeof(double complex) * (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in CCsd_t_zcontract\n",
+                fprintf(stderr, "malloc(%zu) failed in CCsd_t_zcontract\n",
                         sizeof(double complex) * nocc*nocc*nocc*3);
                 exit(1);
         }
@@ -694,7 +694,7 @@ void QCIsd_t_zcontract(double complex *e_tot,
         size_t k;
         double complex *cache1 = malloc(sizeof(double complex) * (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in QCIsd_t_zcontract\n",
+                fprintf(stderr, "malloc(%zu) failed in QCIsd_t_zcontract\n",
                         sizeof(double complex) * nocc*nocc*nocc*3);
                 exit(1);
         }
@@ -880,7 +880,7 @@ void MPICCsd_t_contract(double *e_tot, double *mo_energy, double *t1T,
         size_t k;
         double *cache1 = malloc(sizeof(double) * (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in MPICCsd_t_contract\n",
+                fprintf(stderr, "malloc(%zu) failed in MPICCsd_t_contract\n",
                         sizeof(double) * nocc*nocc*nocc*3);
                 exit(1);
         }
@@ -1113,7 +1113,7 @@ void CCsd_zcontract_t3T(double complex *t3Tw, double complex *t3Tv, double *mo_e
         size_t k;
         complex double *cache1 = malloc(sizeof(double complex) * (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in CCsd_zcontract_t3T\n",
+                fprintf(stderr, "malloc(%zu) failed in CCsd_zcontract_t3T\n",
                         sizeof(double complex) * nocc*nocc*nocc*3);
                 exit(1);
         }

pyscf/lib/cc/uccsd_t.c

@@ -308,7 +308,7 @@ void CCuccsd_t_aaa(double complex *e_tot,
         size_t k;
         double *cache1 = malloc(sizeof(double) * (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in CCuccsd_t_aaa\n",
+                fprintf(stderr, "malloc(%zu) failed in CCuccsd_t_aaa\n",
                         sizeof(double) * nocc*nocc*nocc*3);
                 exit(1);
         }
@@ -557,7 +557,7 @@ void CCuccsd_t_baa(double complex *e_tot,
         double *cache1 = malloc(sizeof(double) * (noccb*nocca*nocca*5+1 +
                                                   nocca*2+noccb*2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in CCuccsd_t_baa\n",
+                fprintf(stderr, "malloc(%zu) failed in CCuccsd_t_baa\n",
                         sizeof(double) * noccb*nocca*nocca*5);
                 exit(1);
         }
@@ -715,7 +715,7 @@ void CCuccsd_t_zaaa(double complex *e_tot,
         double complex *cache1 = malloc(sizeof(double complex) *
                                         (nocc*nocc*nocc*3+2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in CCuccsd_t_zaaa\n",
+                fprintf(stderr, "malloc(%zu) failed in CCuccsd_t_zaaa\n",
                         sizeof(double complex) * nocc*nocc*nocc*3);
                 exit(1);
         }
@@ -924,7 +924,7 @@ void CCuccsd_t_zbaa(double complex *e_tot,
                                         (noccb*nocca*nocca*5+1 +
                                          nocca*2+noccb*2));
         if (cache1 == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in CCuccsd_t_zbaa\n",
+                fprintf(stderr, "malloc(%zu) failed in CCuccsd_t_zbaa\n",
                         sizeof(double complex) * noccb*nocca*nocca*5);
                 exit(1);
         }

pyscf/lib/deps/include/XCFun/XCFunExport.h

@@ -33,6 +33,7 @@
 #  define XCFUN_DEPRECATED_NO_EXPORT XCFUN_NO_EXPORT XCFUN_DEPRECATED
 #endif
 
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
 #if 1 /* DEFINE_NO_DEPRECATED */
 #  ifndef XCFUN_NO_DEPRECATED
 #    define XCFUN_NO_DEPRECATED

pyscf/lib/dft/grid_common.c

@@ -242,7 +242,7 @@ int orth_components(double *xs_exp, int* bounds, double dx, double radius,
         }
     }
 
-    // add up contributions from all images to the referece image
+    // add up contributions from all images to the reference image
     if (ngridx >= nx_per_cell) {
         memset(xs_exp, 0, (topl+1)*nx_per_cell*sizeof(double));
         int ix, l, lb, ub, size_x;

pyscf/lib/dft/libxc_itrf.c

@@ -1153,6 +1153,7 @@ void LIBXC_xc_reference(int xc_id, const char **refs)
                 }
                 refs[i] = func.info->refs[i]->ref;
         }
+	xc_func_end(&func);
 }
 
 int LIBXC_is_nlc(int xc_id)
@@ -1162,5 +1163,7 @@ int LIBXC_is_nlc(int xc_id)
                 fprintf(stderr, "XC functional %d not found\n", xc_id);
                 raise_error -1;
         }
-        return func.info->flags & XC_FLAGS_VV10;
+	int is_nlc = func.info->flags & XC_FLAGS_VV10;
+	xc_func_end(&func);
+        return is_nlc; 
 }

pyscf/lib/dft/xcfun_itrf.c

@@ -102,7 +102,7 @@ int XCFUN_eval_xc(int nfn, int *fn_id, double *fac, double *omega,
                         rho = rho_u;
                         err = eval_xc(fun, deriv, XC_N, np, 1, outlen, rho, output);
                 }
-// xcfun computed rho*Exc[rho] for zeroth order deriviative instead of Exc[rho]
+// xcfun computed rho*Exc[rho] for zeroth order derivative instead of Exc[rho]
                 for (i = 0; i < np; i++) {
                         output[i*outlen] /= rho_u[i] + 1e-150;
                 }

pyscf/lib/diis.py

@@ -135,7 +135,7 @@ class DIIS:
             else:
                 self._diisfile[key] = value
 # to avoid "Unable to find a valid file signature" error when reload the hdf5
-# file from a crashed claculation
+# file from a crashed calculation
             self._diisfile.flush()
 
     def push_err_vec(self, xerr):

pyscf/lib/exceptions.py

@@ -20,3 +20,6 @@ class BasisNotFoundError(RuntimeError):
 
 class PointGroupSymmetryError(RuntimeError):
     pass
+
+class WfnSymmetryError(RuntimeError):
+    pass

pyscf/lib/gto/fill_grids_int2c.c

@@ -34,24 +34,26 @@
 #define BLKSIZE         312
 
 // for grids integrals only
-int _max_cache_size(int (*intor)(), int *shls_slice, int ncenter,
-                    int *atm, int natm, int *bas, int nbas, double *env)
+size_t _max_cache_size(int (*intor)(), int *shls_slice, int ncenter,
+                       int *atm, int natm, int *bas, int nbas, double *env)
 {
-        int i, n;
+        int i;
         int i0 = shls_slice[0];
         int i1 = shls_slice[1];
         for (i = 1; i < ncenter; i++) {
                 i0 = MIN(i0, shls_slice[i*2  ]);
                 i1 = MAX(i1, shls_slice[i*2+1]);
         }
+        size_t (*f)() = (size_t (*)())intor;
+        size_t cache_size = 0;
+        size_t n;
         int shls[4];
-        int cache_size = 0;
         for (i = i0; i < i1; i++) {
                 shls[0] = i;
                 shls[1] = i;
                 shls[2] = 0;
                 shls[3] = BLKSIZE;
-                n = (*intor)(NULL, NULL, shls, atm, natm, bas, nbas, env, NULL, NULL);
+                n = (*f)(NULL, NULL, shls, atm, natm, bas, nbas, env, NULL, NULL);
                 cache_size = MAX(cache_size, n);
         }
         return cache_size;
@@ -73,8 +75,8 @@ void GTOgrids_int2c(int (*intor)(), double *mat, int comp, int hermi,
         const int njsh = jsh1 - jsh0;
         const size_t naoi = ao_loc[ish1] - ao_loc[ish0];
         const size_t naoj = ao_loc[jsh1] - ao_loc[jsh0];
-        const int cache_size = _max_cache_size(intor, shls_slice, 2,
-                                               atm, natm, bas, nbas, env);
+        const size_t cache_size = _max_cache_size(intor, shls_slice, 2,
+                                                  atm, natm, bas, nbas, env);
         const int dims[] = {naoi, naoj, ngrids};
 #pragma omp parallel
 {
@@ -151,8 +153,8 @@ void GTOgrids_int2c_spinor(int (*intor)(), double complex *mat, int comp, int he
         const int njsh = jsh1 - jsh0;
         const size_t naoi = ao_loc[ish1] - ao_loc[ish0];
         const size_t naoj = ao_loc[jsh1] - ao_loc[jsh0];
-        const int cache_size = _max_cache_size(intor, shls_slice, 2,
-                                               atm, natm, bas, nbas, env);
+        const size_t cache_size = _max_cache_size(intor, shls_slice, 2,
+                                                  atm, natm, bas, nbas, env);
         int dims[] = {naoi, naoj, ngrids};
 #pragma omp parallel
 {

pyscf/lib/gto/fill_int2e.c

@@ -39,24 +39,26 @@ int GTOmax_shell_dim(const int *ao_loc, const int *shls_slice, int ncenter)
         }
         return di;
 }
-int GTOmax_cache_size(int (*intor)(), int *shls_slice, int ncenter,
-                      int *atm, int natm, int *bas, int nbas, double *env)
+size_t GTOmax_cache_size(int (*intor)(), int *shls_slice, int ncenter,
+                         int *atm, int natm, int *bas, int nbas, double *env)
 {
-        int i, n;
+        int i;
         int i0 = shls_slice[0];
         int i1 = shls_slice[1];
         for (i = 1; i < ncenter; i++) {
                 i0 = MIN(i0, shls_slice[i*2  ]);
                 i1 = MAX(i1, shls_slice[i*2+1]);
         }
+        size_t (*f)() = (size_t (*)())intor;
+        size_t cache_size = 0;
+        size_t n;
         int shls[4];
-        int cache_size = 0;
         for (i = i0; i < i1; i++) {
                 shls[0] = i;
                 shls[1] = i;
                 shls[2] = i;
                 shls[3] = i;
-                n = (*intor)(NULL, NULL, shls, atm, natm, bas, nbas, env, NULL, NULL);
+                n = (*f)(NULL, NULL, shls, atm, natm, bas, nbas, env, NULL, NULL);
                 cache_size = MAX(cache_size, n);
         }
         return cache_size;

pyscf/lib/gto/fill_r_4c.c

@@ -88,7 +88,7 @@ void GTOr4c_drv(int (*intor)(), void (*fill)(), int (*prescreen)(),
         int ish, jsh, ij;
         double *buf = malloc(sizeof(double) * cache_size);
         if (buf == NULL) {
-                fprintf(stderr, "malloc(%zu) falied in GTOr4c_drv\n",
+                fprintf(stderr, "malloc(%zu) failed in GTOr4c_drv\n",
                         sizeof(double) * cache_size);
                 exit(1);
         }

pyscf/lib/gto/ft_ao.c

@@ -803,7 +803,7 @@ int GTO_ft_aopair_drv(double *outR, double *outI, int *dims,
                 size_t cache_size = ft_aopair_cache_size(envs) * (size_t)block_size;
                 stack = malloc(sizeof(double)*cache_size);
                 if (stack == NULL) {
-                        fprintf(stderr, "gctr = malloc(%zu) falied in GTO_ft_aopair_drv\n",
+                        fprintf(stderr, "gctr = malloc(%zu) failed in GTO_ft_aopair_drv\n",
                                 sizeof(double) * cache_size);
                         return 0;
                 }

pyscf/lib/gto/ft_ao.h

@@ -32,7 +32,7 @@ typedef struct {
 
         int i_l;
         int j_l;
-        int nfi;  // number of cartesion components
+        int nfi;  // number of cartesian components
         int nfj;
         int nf;  // = nfi*nfj
         int ngrids;  // number of grids or planewaves

pyscf/lib/gto/gto.h

@@ -14,5 +14,5 @@
  */
 
 int GTOmax_shell_dim(const int *ao_loc, const int *shls, int ncenter);
-int GTOmax_cache_size(int (*intor)(), int *shls_slice, int ncenter,
-                      int *atm, int natm, int *bas, int nbas, double *env);
+size_t GTOmax_cache_size(int (*intor)(), int *shls_slice, int ncenter,
+                         int *atm, int natm, int *bas, int nbas, double *env);

pyscf/lib/gto/nr_ecp.c

@@ -5553,7 +5553,7 @@ int ECPtype_so_cart(double *gctr, int *shls, int *ecpbas, int necpbas,
         // be careful with the factor 1/2 for the spin operator  s = 1/2 Pauli matrix
         // The ECPso_cart and ECPso_sph integral code evaluates the integrals
         // <i|H^{SO}|j> as shown in NWChem ECP doc
-        //   http://www.nwchem-sw.org/index.php/ECP
+        //   https://nwchemgit.github.io/ECP.html
         // Note when calling ECPso_spinor function to evaluate the integrals in
         // spinor basis pyscf evaluates the expression like
         //      einsum('sxy,spq,xpi,yqj->ij', pauli_matrix, so_sph, ui.conj(), uj)
@@ -5872,7 +5872,8 @@ int ECPtype1_cart(double *gctr, int *shls, int *ecpbas, int necpbas,
         for (i = 0; i < d3; i++) { rad_all[i] = 0; }
 
         for (iloc = 0; iloc < nslots; iloc++) {
-                if (ecpbas[ANG_OF+ecploc[iloc]*BAS_SLOTS] != -1) {
+                if (ecpbas[ANG_OF+ecploc[iloc]*BAS_SLOTS] != -1 ||
+                    ecpbas[SO_TYPE_OF+ecploc[iloc]*BAS_SLOTS] == 1) {
                         continue;
                 }
                 atm_id = ecpbas[ATOM_OF+ecploc[iloc]*BAS_SLOTS];