fcdft 1.0.2__tar.gz → 1.1.2__tar.gz

fcdft-1.1.2/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: fcdft
+Version: 1.1.2
+License-File: LICENSE
+License-File: AUTHORS
+Dynamic: license-file

fcdft-1.1.2/fcdft/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.1.2'

{fcdft-1.0.2 → fcdft-1.1.2}/fcdft/df/grad/rks.py

@@ -95,7 +95,8 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
             tmp = tmpRe + 1.0j * tmpIm
             t2 = logger.timer_debug1 (mf_grad, "df grad einsum (P|mn') u_mi = dg_Pin", *t2)
             rhok = get_rhok (i, p0, p1)
-            vk[i] += lib.einsum('xpoi,pok->xik', tmp, rhok)
+            # vk[i] += lib.einsum('xpoi,pok->xik', tmp, rhok)
+            vk[i] += numpy.tensordot(tmp, rhok, axes=([1,2], [0,1]))
             t2 = logger.timer_debug1 (mf_grad, "df grad einsum D_Pim dg_Pin = v_ij", *t2)
             rhok = tmp = None
         int3c = None
@@ -114,7 +115,9 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
     # dPiu C_uj -> dPij. *Not* symmetric i<->j: "i" has an occupancy
     # factor and "j" must not.
     max_memory = mf_grad.max_memory - lib.current_memory()[0]
-    blksize = int(min(max(max_memory * .5e6/8 / (nao*max (nocc)), 20), naux))
+    # blksize = int(min(max(max_memory * .5e6/8 / (nao*max (nocc)), 20), naux))
+    # In principe, all occupation numbers are non-zero for open quantum systems.
+    blksize = int(min(max(max_memory * .5e6/8 / (nao*nao), 20), naux))
     rhok_oo = []
     for i, j in product (range (nset), repeat=2):
         tmp = numpy.empty ((naux,nocc[i],nocc[j]), numpy.complex128)
@@ -182,7 +185,8 @@ def get_jk(mf_grad, mol=None, dm=None, hermi=0, with_j=True, with_k=True,
     for i, j in product (range (nset), repeat=2):
         k = (i*nset) + j
         l = (j*nset) + i
-        tmp = lib.einsum('pij,qji->pq', rhok_oo[k], rhok_oo[l])
+        # tmp = lib.einsum('pij,qji->pq', rhok_oo[k], rhok_oo[l])
+        tmp = numpy.tensordot(rhok_oo[k], rhok_oo[l], axes=([1,2], [2,1]))
         vkaux[i,j] -= lib.einsum('xpq,pq->xp', int2c_e1, tmp)
     t1 = logger.timer_debug1 (mf_grad, "df grad vj and vk aux (P'|Q) eval", *t1)
 
@@ -237,7 +241,8 @@ def get_j(mf_grad, mol=None, dm=None, hermi=0):
     for shl0, shl1, nL in ao_ranges:
         int3c = get_int3c_s1((0, nbas, 0, nbas, shl0, shl1))  # (i,j|P)
         p0, p1 = aux_loc[shl0], aux_loc[shl1]
-        rhoj[:,p0:p1] = lib.einsum('ijp,aij->ap', int3c, dms)
+        # rhoj[:,p0:p1] = lib.einsum('ijp,aij->ap', int3c, dms)
+        rhoj[:,p0:p1] = numpy.tensordot(dms, int3c, axes=([1,2], [0,1]))
         int3c = None
 
     # (P|Q), (naux, naux)
@@ -250,7 +255,8 @@ def get_j(mf_grad, mol=None, dm=None, hermi=0):
     for shl0, shl1, nL in ao_ranges:
         int3c = get_int3c_ip1((0, nbas, 0, nbas, shl0, shl1))
         p0, p1 = aux_loc[shl0], aux_loc[shl1]
-        vj += lib.einsum('xijp,ap->axij', int3c, rhoj[:,p0:p1])
+        # vj += lib.einsum('xijp,ap->axij', int3c, rhoj[:,p0:p1])
+        vj += numpy.tensordot(rhoj[:,p0:p1], int3c, axes=([1], [3]))
         int3c = None
     
     if mf_grad.auxbasis_response:

{fcdft-1.0.2 → fcdft-1.1.2}/fcdft/grad/rks.py

@@ -42,10 +42,10 @@ def grad_elec(mf_grad, mo_energy=None, mo_coeff=None, mo_occ=None, atmlst=None):
     for k, ia in enumerate(atmlst):
         p0, p1 = aoslices [ia,2:]
         h1ao = hcore_deriv(ia)
-        de[k] += numpy.einsum('xij,ij->x', h1ao, dm0)
+        de[k] += numpy.tensordot(h1ao, dm0, axes=([1,2], [0,1]))
 # nabla was applied on bra in vhf, *2 for the contributions of nabla|ket>
-        de[k] += numpy.einsum('xij,ij->x', vhf[:,p0:p1], dm0[p0:p1]) * 2
-        de[k] -= numpy.einsum('xij,ij->x', s1[:,p0:p1], dme0[p0:p1]) * 2
+        de[k] += numpy.tensordot(vhf[:,p0:p1], dm0[p0:p1], axes=([1,2], [0,1])) * 2
+        de[k] -= numpy.tensordot(s1[:,p0:p1], dme0[p0:p1], axes=([1,2], [0,1])) * 2
 
         de[k] += mf_grad.extra_force(ia, locals())
 

{fcdft-1.0.2 → fcdft-1.1.2}/fcdft/lib/dft/quadrature.c

@@ -4,6 +4,8 @@
 #include <omp.h>
 #include <stdio.h>
 
+double const TWO_PI = 2.0 * M_PI;
+
 void roots_legendre(int n, double *abscissas, double *weights){
     double z, z1, pp, p1, p2, p3;
     int m = (n + 1) / 2;
@@ -34,26 +36,60 @@ void roots_legendre(int n, double *abscissas, double *weights){
 
 double occ_drv(double sampling, double moe_energy, double fermi, double broad, double smear) {
     double dist = 1 / (exp((sampling - fermi)/smear) + 1);
-    return dist * broad / (pow(sampling - moe_energy, 2) + pow(broad / 2, 2)) / 2.0 / M_PI;
+    return dist * broad / (pow(sampling - moe_energy, 2) + pow(broad / 2, 2)) / TWO_PI;
 }
 
 double occ_grad_drv(double sampling, double moe_energy, double fermi, double broad, double smear) {
     double dist = 1 / (exp((sampling - fermi)/smear) + 1);
-    return dist * (1 - dist) * broad / (pow(sampling - moe_energy, 2) + pow(broad / 2, 2)) / 2.0 / M_PI / smear;
+    return dist * (1 - dist) * broad / (pow(sampling - moe_energy, 2) + pow(broad / 2, 2)) / TWO_PI / smear;
 }
 
 void fermi_level_drv(double *moe_energy, double *abscissas, double *weights, double fermi, double broad, double smear, double window, int pts, int nbas, double *mo_occ, double *mo_grad) {
     int i, n;
     double sampling;
     double _mo_grad = 0.0;
+    double *window_weights = (double *)malloc(sizeof(double) * pts);
+
+    #pragma omp parallel for private(n)
+    for (n = 0; n < pts; n++) {
+        window_weights[n] = window * weights[n];
+    }
+
     #pragma omp parallel for private(n, sampling) reduction(+:_mo_grad)
     for (i = 0; i < nbas; i++) {
         mo_occ[i] = 0;
         for (n = 0; n < pts; n++) {
             sampling = abscissas[n] * window + moe_energy[i];
-            mo_occ[i] += window * weights[n] * occ_drv(sampling, moe_energy[i], fermi, broad, smear);
-            _mo_grad += window * weights[n] * occ_grad_drv(sampling, moe_energy[i], fermi, broad, smear);
+            mo_occ[i] += window_weights[n] * occ_drv(sampling, moe_energy[i], fermi, broad, smear);
+            _mo_grad += window_weights[n] * occ_grad_drv(sampling, moe_energy[i], fermi, broad, smear);
         }
     }
     *mo_grad = _mo_grad;
+    free(window_weights);
 }
+
+void occupation_drv(double *moe_energy, double *abscissas, double *weights, double fermi, double broad, double smear, double window, int pts, int nbas, double *mo_occ) {
+    int i, n;
+    double sampling;
+    #pragma omp parallel for private(n, sampling)
+    for (i = 0; i < nbas; i++) {
+        mo_occ[i] = 0;
+        for (n = 0; n < pts; n++) {
+            sampling = abscissas[n] * window + moe_energy[i];
+            mo_occ[i] += window * weights[n] * occ_drv(sampling, moe_energy[i], fermi, broad, smear);
+        }
+    }
+}
+
+void occupation_grad_drv(double *moe_energy, double *abscissas, double *weights, double fermi, double broad, double smear, double window, int pts, int nbas, double *occ_grad) {
+    int i, n;
+    double sampling;
+    #pragma omp parallel for private(n, sampling)
+    for (i = 0; i < nbas; i++) {
+        occ_grad[i] = 0;
+        for (n = 0; n < pts; n++) {
+            sampling = abscissas[n] * window + moe_energy[i];
+            occ_grad[i] += window * weights[n] * occ_grad_drv(sampling, moe_energy[i], fermi, broad, smear);
+        }
+    }        
+}