diff --git a/org/qmckl_jastrow_champ.org b/org/qmckl_jastrow_champ.org
index c22bb58..e4b1a51 100644
--- a/org/qmckl_jastrow_champ.org
+++ b/org/qmckl_jastrow_champ.org
@@ -166,11 +166,11 @@ int main() {
     | ~dtmp_c~                       | ~double[walk_num][elec_num][4][nucl_num][cord_num+1][cord_num]~ | vector of non-zero coefficients                                                                         |
     | ~ee_distance_rescaled~         | ~double[walk_num][num][num]~                                    | Electron-electron rescaled distances                                                                    |
     | ~ee_distance_rescaled_date~    | ~uint64_t~                                                      | Last modification date of the electron-electron distances                                               |
-    | ~ee_distance_rescaled_gl~      | ~double[walk_num][4][num][num]~                                 | Electron-electron rescaled distances derivatives                                                        |
+    | ~ee_distance_rescaled_gl~      | ~double[walk_num][num][num][4]~                                 | Electron-electron rescaled distances derivatives                                                        |
     | ~ee_distance_rescaled_gl_date~ | ~uint64_t~                                                      | Last modification date of the electron-electron distance derivatives                                    |
     | ~en_distance_rescaled~         | ~double[walk_num][nucl_num][num]~                               | Electron-nucleus distances                                                                              |
     | ~en_distance_rescaled_date~    | ~uint64_t~                                                      | Last modification date of the electron-electron distances                                               |
-    | ~en_distance_rescaled_gl~      | ~double[walk_num][4][nucl_num][num]~                            | Electron-electron rescaled distances derivatives                                                        |
+    | ~en_distance_rescaled_gl~      | ~double[walk_num][nucl_num][num][4]~                            | Electron-electron rescaled distances derivatives                                                        |
     | ~en_distance_rescaled_gl_date~ | ~uint64_t~                                                      | Last modification date of the electron-electron distance derivatives                                    |
     | ~een_rescaled_n~               | ~double[walk_num][cord_num+1][nucl_num][elec_num]~              | The electron-electron rescaled distances raised to the powers defined by cord                           |
     | ~een_rescaled_n_date~          | ~uint64_t~                                                      | Keep track of the date of creation                                                                      |
@@ -1927,12 +1927,11 @@ qmckl_exit_code qmckl_compute_jastrow_champ_asymp_jasb (
 	  double* const asymp_jasb )
 {
 #ifdef HAVE_HPC
-  return qmckl_compute_jastrow_champ_asymp_jasb_hpc (context,
-	  bord_num, b_vector, rescale_factor_ee, asymp_jasb);
+  return qmckl_compute_jastrow_champ_asymp_jasb_hpc
 #else
-  return qmckl_compute_jastrow_champ_asymp_jasb_doc (context,
-	  bord_num, b_vector, rescale_factor_ee, asymp_jasb);
+  return qmckl_compute_jastrow_champ_asymp_jasb_doc
 #endif
+    (context, bord_num, b_vector, rescale_factor_ee, asymp_jasb);
 }
  #+end_src
 **** Test
@@ -2455,14 +2454,12 @@ qmckl_compute_jastrow_champ_factor_ee (const qmckl_context context,
 {
 
 #ifdef HAVE_HPC
-  return qmckl_compute_jastrow_champ_factor_ee_hpc(context, walk_num, elec_num,
-      up_num, bord_num, b_vector, ee_distance_rescaled, asymp_jasb,
-      factor_ee);
+  return qmckl_compute_jastrow_champ_factor_ee_hpc
 #else
-  return qmckl_compute_jastrow_champ_factor_ee_doc(context, walk_num, elec_num,
-      up_num, bord_num, b_vector, ee_distance_rescaled, asymp_jasb,
-      factor_ee);
+  return qmckl_compute_jastrow_champ_factor_ee_doc
 #endif
+    (context, walk_num, elec_num, up_num, bord_num, b_vector,
+     ee_distance_rescaled, asymp_jasb, factor_ee);
 }
  #+end_src
 **** Test
@@ -2811,31 +2808,25 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl_hpc(
       const double* ee_distance_rescaled_gl,
       double* const factor_ee_gl ) {
 
-  if (context == QMCKL_NULL_CONTEXT) {
-    return QMCKL_INVALID_CONTEXT;
-  }
-
-  if (walk_num <= 0) {
-    return QMCKL_INVALID_ARG_2;
-  }
-
-  if (elec_num <= 0) {
-    return QMCKL_INVALID_ARG_3;
-  }
-
-  if (bord_num < 0) {
-    return QMCKL_INVALID_ARG_4;
-  }
-
-
-  memset(factor_ee_gl, 0, elec_num*4*walk_num*sizeof(double));
+  if (context == QMCKL_NULL_CONTEXT) return QMCKL_INVALID_CONTEXT;
+  if (walk_num <= 0) return QMCKL_INVALID_ARG_2;
+  if (elec_num <= 0) return QMCKL_INVALID_ARG_3;
+  if (up_num <= 0) return QMCKL_INVALID_ARG_4;
+  if (bord_num < 0) return QMCKL_INVALID_ARG_5;
+  if (b_vector == NULL) return QMCKL_INVALID_ARG_6;
+  if (ee_distance_rescaled == NULL) return QMCKL_INVALID_ARG_7;
+  if (ee_distance_rescaled_gl == NULL) return QMCKL_INVALID_ARG_8;
+  if (factor_ee_gl == NULL) return QMCKL_INVALID_ARG_9;
 
   double kf[bord_num+1];
   for (int k=0 ; k<=bord_num ; ++k) {
      kf[k] = (double) k;
   }
 
+  #pragma omp parallel for
   for (int nw = 0; nw < walk_num; ++nw) {
+    memset(&(factor_ee_gl[nw*4*elec_num]), 0, elec_num*4*sizeof(double));
+
     for (int j = 0; j < elec_num; ++j) {
       const double* dxj = &ee_distance_rescaled_gl[4*elec_num*(j+nw*elec_num)];
       const double*  xj = &ee_distance_rescaled   [  elec_num*(j+nw*elec_num)];
@@ -2982,7 +2973,7 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_gl_doc &
 
 
      #+begin_src c :comments org :tangle (eval c) :noweb yes
-    qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl (
+qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl (
       const qmckl_context context,
       const int64_t walk_num,
       const int64_t elec_num,
@@ -2993,11 +2984,13 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_gl_doc &
       const double* ee_distance_rescaled_gl,
       double* const factor_ee_gl ) {
 
-      #ifdef HAVE_HPC
-      return qmckl_compute_jastrow_champ_factor_ee_gl_hpc(context, walk_num, elec_num, up_num, bord_num, b_vector, ee_distance_rescaled, ee_distance_rescaled_gl, factor_ee_gl );
-      #else
-      return qmckl_compute_jastrow_champ_factor_ee_gl_doc(context, walk_num, elec_num, up_num, bord_num, b_vector, ee_distance_rescaled, ee_distance_rescaled_gl, factor_ee_gl );
-      #endif
+#ifdef HAVE_HPC
+ return qmckl_compute_jastrow_champ_factor_ee_gl_hpc
+#else
+ return qmckl_compute_jastrow_champ_factor_ee_gl_doc
+#endif
+    (context, walk_num, elec_num, up_num, bord_num, b_vector,
+     ee_distance_rescaled, ee_distance_rescaled_gl, factor_ee_gl );
 }
      #+end_src
 
@@ -3024,7 +3017,6 @@ def make_dist(elec_coord):
 
 
 
-
 def make_dist_deriv(elec_coord):
 
     elec_dist_d = np.zeros(shape=(4, elec_num, elec_num),dtype=float)
@@ -3272,7 +3264,7 @@ qmckl_exit_code qmckl_provide_ee_distance_rescaled(qmckl_context context)
      | ~ee_distance~       | ~double[walk_num][elec_num][elec_num]~ | out    | Electron-electron rescaled distances |
 
      #+begin_src f90 :comments org :tangle (eval f) :noweb yes
-integer function qmckl_compute_ee_distance_rescaled_f(context, elec_num, rescale_factor_ee, walk_num, &
+integer function qmckl_compute_ee_distance_rescaled_doc_f(context, elec_num, rescale_factor_ee, walk_num, &
      coord, ee_distance_rescaled) &
      result(info)
   use qmckl
@@ -3313,10 +3305,26 @@ integer function qmckl_compute_ee_distance_rescaled_f(context, elec_num, rescale
      endif
   end do
 
-end function qmckl_compute_ee_distance_rescaled_f
+end function qmckl_compute_ee_distance_rescaled_doc_f
      #+end_src
 
      #+begin_src c :tangle (eval h_private_func) :comments org :exports none
+qmckl_exit_code qmckl_compute_ee_distance_rescaled_doc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled );
+
+qmckl_exit_code qmckl_compute_ee_distance_rescaled_hpc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled );
+
 qmckl_exit_code qmckl_compute_ee_distance_rescaled (
           const qmckl_context context,
           const int64_t elec_num,
@@ -3326,29 +3334,98 @@ qmckl_exit_code qmckl_compute_ee_distance_rescaled (
           double* const ee_distance_rescaled );
      #+end_src
 
-     #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_args,rettyp=get_value("CRetType"),fname=get_value("Name"))
+     #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code qmckl_compute_ee_distance_rescaled_hpc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled )
+{
+  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
+    return QMCKL_INVALID_CONTEXT;
+  }
+
+  if (elec_num <= 0) {
+    return QMCKL_INVALID_ARG_2;
+  }
+
+  if (walk_num <= 0) {
+    return QMCKL_INVALID_ARG_4;
+  }
+
+  if (coord == NULL) {
+    return QMCKL_INVALID_ARG_5;
+  }
+
+  if (ee_distance_rescaled == NULL) {
+    return QMCKL_INVALID_ARG_6;
+  }
+
+
+  int64_t sze = elec_num*walk_num;
+  int64_t elec_num2= elec_num*elec_num;
+  
+
+  qmckl_exit_code result = QMCKL_SUCCESS;
+  #pragma omp parallel
+  {
+    qmckl_exit_code rc = QMCKL_SUCCESS;
+    #pragma omp for
+    for (int64_t k=0 ; k<walk_num ; ++k)
+    {
+      rc |= qmckl_distance_rescaled(context, 'T', 'T', elec_num, elec_num, 
+                                    &(coord[k*elec_num]), sze, &(coord[k*elec_num]), sze,
+                                    &(ee_distance_rescaled[k*elec_num2]), elec_num, rescale_factor_ee);
+    }
+    #pragma omp critical
+    result |= rc;
+  }
+  return result;
+}
+     #+end_src
+
+     #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code qmckl_compute_ee_distance_rescaled (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled )
+{ 
+#ifdef HAVE_HPC
+  return qmckl_compute_ee_distance_rescaled_hpc
+#else
+  return qmckl_compute_ee_distance_rescaled_doc
+#endif
+ (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled);
+}
+     #+end_src
+     #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_args,rettyp=get_value("CRetType"),fname="qmckl_compute_ee_distance_rescaled_doc")
 
      #+RESULTS:
      #+begin_src f90 :tangle (eval f) :comments org :exports none
-    integer(c_int32_t) function qmckl_compute_ee_distance_rescaled &
-        (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled) &
-        bind(C) result(info)
+     integer(c_int32_t) function qmckl_compute_ee_distance_rescaled_doc &
+         (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance) &
+         bind(C) result(info)
 
-      use, intrinsic :: iso_c_binding
-      implicit none
+       use, intrinsic :: iso_c_binding
+       implicit none
 
-      integer (c_int64_t) , intent(in)  , value :: context
-      integer (c_int64_t) , intent(in)  , value :: elec_num
-      real    (c_double ) , intent(in)  , value :: rescale_factor_ee
-      integer (c_int64_t) , intent(in)  , value :: walk_num
-      real    (c_double ) , intent(in)          :: coord(elec_num,3,walk_num)
-      real    (c_double ) , intent(out)         :: ee_distance_rescaled(elec_num,elec_num,walk_num)
+       integer (c_int64_t) , intent(in)  , value :: context
+       integer (c_int64_t) , intent(in)  , value :: elec_num
+       real    (c_double ) , intent(in)  , value :: rescale_factor_ee
+       integer (c_int64_t) , intent(in)  , value :: walk_num
+       real    (c_double ) , intent(in)          :: coord(elec_num,walk_num,3)
+       real    (c_double ) , intent(out)         :: ee_distance(elec_num,elec_num,walk_num)
 
-      integer(c_int32_t), external :: qmckl_compute_ee_distance_rescaled_f
-      info = qmckl_compute_ee_distance_rescaled_f &
-             (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled)
+       integer(c_int32_t), external :: qmckl_compute_ee_distance_rescaled_doc_f
+       info = qmckl_compute_ee_distance_rescaled_doc_f &
+              (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance)
 
-    end function qmckl_compute_ee_distance_rescaled
+     end function qmckl_compute_ee_distance_rescaled_doc
      #+end_src
 
 **** Test
@@ -3520,17 +3597,17 @@ qmckl_exit_code qmckl_provide_ee_distance_rescaled_gl(qmckl_context context)
      :END:
 
      #+NAME: qmckl_ee_distance_rescaled_gl_args
-     | Variable              | Type                                      | In/Out | Description                                     |
-     |-----------------------+-------------------------------------------+--------+-------------------------------------------------|
-     | ~context~             | ~qmckl_context~                           | in     | Global state                                    |
-     | ~elec_num~            | ~int64_t~                                 | in     | Number of electrons                             |
-     | ~rescale_factor_ee~   | ~double~                                  | in     | Factor to rescale ee distances                  |
-     | ~walk_num~            | ~int64_t~                                 | in     | Number of walkers                               |
-     | ~coord~               | ~double[3][walk_num][elec_num]~           | in     | Electron coordinates                            |
-     | ~ee_distance_gl~ | ~double[walk_num][4][elec_num][elec_num]~ | out    | Electron-electron rescaled distance derivatives |
+     | Variable            | Type                                      | In/Out | Description                                     |
+     |---------------------+-------------------------------------------+--------+-------------------------------------------------|
+     | ~context~           | ~qmckl_context~                           | in     | Global state                                    |
+     | ~elec_num~          | ~int64_t~                                 | in     | Number of electrons                             |
+     | ~rescale_factor_ee~ | ~double~                                  | in     | Factor to rescale ee distances                  |
+     | ~walk_num~          | ~int64_t~                                 | in     | Number of walkers                               |
+     | ~coord~             | ~double[3][walk_num][elec_num]~           | in     | Electron coordinates                            |
+     | ~ee_distance_gl~    | ~double[walk_num][4][elec_num][elec_num]~ | out    | Electron-electron rescaled distance derivatives |
 
      #+begin_src f90 :comments org :tangle (eval f) :noweb yes
-integer function qmckl_compute_ee_distance_rescaled_gl_f(context, elec_num, rescale_factor_ee, walk_num, &
+integer function qmckl_compute_ee_distance_rescaled_gl_doc_f(context, elec_num, rescale_factor_ee, walk_num, &
      coord, ee_distance_rescaled_gl) &
      result(info)
   use qmckl
@@ -3571,10 +3648,26 @@ integer function qmckl_compute_ee_distance_rescaled_gl_f(context, elec_num, resc
      endif
   end do
 
-end function qmckl_compute_ee_distance_rescaled_gl_f
+end function qmckl_compute_ee_distance_rescaled_gl_doc_f
      #+end_src
 
      #+begin_src c :tangle (eval h_private_func) :comments org :exports none
+qmckl_exit_code qmckl_compute_ee_distance_rescaled_gl_doc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled_gl );
+
+qmckl_exit_code qmckl_compute_ee_distance_rescaled_gl_hpc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled_gl );
+
 qmckl_exit_code qmckl_compute_ee_distance_rescaled_gl (
           const qmckl_context context,
           const int64_t elec_num,
@@ -3584,29 +3677,87 @@ qmckl_exit_code qmckl_compute_ee_distance_rescaled_gl (
           double* const ee_distance_rescaled_gl );
      #+end_src
 
-     #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name"))
+
+     #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code qmckl_compute_ee_distance_rescaled_gl_hpc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled_gl )
+{
+  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) return QMCKL_INVALID_CONTEXT;
+  if (elec_num <= 0) return QMCKL_INVALID_ARG_2;
+  if (walk_num <= 0) return QMCKL_INVALID_ARG_4;
+  if (coord == NULL) return QMCKL_INVALID_ARG_5;
+  if (ee_distance_rescaled_gl == NULL) return QMCKL_INVALID_ARG_6;
+
+  int64_t sze = elec_num*walk_num;
+  int64_t elec_num2= elec_num*elec_num*4;
+
+  qmckl_exit_code result = QMCKL_SUCCESS;
+  #pragma omp parallel
+  {
+    qmckl_exit_code rc = QMCKL_SUCCESS;
+    #pragma omp for
+    for (int64_t k=0 ; k<walk_num ; ++k)
+    {
+      rc |= qmckl_distance_rescaled_gl(context, 'T', 'T', elec_num, elec_num, 
+                                       &(coord[k*elec_num]), sze,
+                                       &(coord[k*elec_num]), sze,
+                                       &(ee_distance_rescaled_gl[k*elec_num2]), elec_num,
+                                       rescale_factor_ee);
+    }
+    #pragma omp critical
+    result |= rc;
+  }
+  return result;
+}
+     #+end_src
+
+     #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code qmckl_compute_ee_distance_rescaled_gl (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const double rescale_factor_ee,
+          const int64_t walk_num,
+          const double* coord,
+          double* const ee_distance_rescaled_gl )
+{
+#ifdef HAVE_HPC
+  return qmckl_compute_ee_distance_rescaled_gl_hpc
+#else
+  return qmckl_compute_ee_distance_rescaled_gl_doc
+#endif
+   (context, elec_num, rescale_factor_ee, walk_num, coord,
+   ee_distance_rescaled_gl);
+}
+     #+end_src
+
+     #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_ee_distance_rescaled_gl_doc")
 
      #+RESULTS:
      #+begin_src f90 :tangle (eval f) :comments org :exports none
-    integer(c_int32_t) function qmckl_compute_ee_distance_rescaled_gl &
-        (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled_gl) &
-        bind(C) result(info)
+     integer(c_int32_t) function qmckl_compute_ee_distance_rescaled_gl_doc &
+         (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_gl) &
+         bind(C) result(info)
 
-      use, intrinsic :: iso_c_binding
-      implicit none
+       use, intrinsic :: iso_c_binding
+       implicit none
 
-      integer (c_int64_t) , intent(in)  , value :: context
-      integer (c_int64_t) , intent(in)  , value :: elec_num
-      real    (c_double ) , intent(in)  , value :: rescale_factor_ee
-      integer (c_int64_t) , intent(in)  , value :: walk_num
-      real    (c_double ) , intent(in)          :: coord(elec_num,3,walk_num)
-      real    (c_double ) , intent(out)         :: ee_distance_rescaled_gl(4,elec_num,elec_num,walk_num)
+       integer (c_int64_t) , intent(in)  , value :: context
+       integer (c_int64_t) , intent(in)  , value :: elec_num
+       real    (c_double ) , intent(in)  , value :: rescale_factor_ee
+       integer (c_int64_t) , intent(in)  , value :: walk_num
+       real    (c_double ) , intent(in)          :: coord(elec_num,walk_num,3)
+       real    (c_double ) , intent(out)         :: ee_distance_gl(elec_num,elec_num,4,walk_num)
 
-      integer(c_int32_t), external :: qmckl_compute_ee_distance_rescaled_gl_f
-      info = qmckl_compute_ee_distance_rescaled_gl_f &
-             (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled_gl)
+       integer(c_int32_t), external :: qmckl_compute_ee_distance_rescaled_gl_doc_f
+       info = qmckl_compute_ee_distance_rescaled_gl_doc_f &
+              (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_gl)
 
-    end function qmckl_compute_ee_distance_rescaled_gl
+     end function qmckl_compute_ee_distance_rescaled_gl_doc
      #+end_src
 
 **** Test
@@ -4243,6 +4394,19 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_doc (
          const double* en_distance_rescaled,
          const double* asymp_jasa,
          double* const factor_en );
+
+qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_hpc (
+         const qmckl_context context,
+         const int64_t walk_num,
+         const int64_t elec_num,
+         const int64_t nucl_num,
+         const int64_t type_nucl_num,
+         const int64_t* type_nucl_vector,
+         const int64_t aord_num,
+         const double* a_vector,
+         const double* en_distance_rescaled,
+         const double* asymp_jasa,
+         double* const factor_en );
     #+end_src
 
     #+begin_src c :tangle (eval c) :comments org
@@ -4260,16 +4424,70 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_en (
          double* const factor_en )
 {
 #ifdef HAVE_HPC
-  return qmckl_compute_jastrow_champ_factor_en_doc (context, walk_num, elec_num, nucl_num, type_nucl_num,
-                                      type_nucl_vector, aord_num, a_vector, en_distance_rescaled,
-                                      asymp_jasa, factor_en );
+  return qmckl_compute_jastrow_champ_factor_en_hpc
 #else
-  return qmckl_compute_jastrow_champ_factor_en_doc (context, walk_num, elec_num, nucl_num, type_nucl_num,
-                                      type_nucl_vector, aord_num, a_vector, en_distance_rescaled,
-                                      asymp_jasa, factor_en );
+  return qmckl_compute_jastrow_champ_factor_en_doc
 #endif
+    (context, walk_num, elec_num, nucl_num, type_nucl_num,
+     type_nucl_vector, aord_num, a_vector, en_distance_rescaled,
+     asymp_jasa, factor_en );
 }
     #+end_src
+
+    #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_hpc (
+         const qmckl_context context,
+         const int64_t walk_num,
+         const int64_t elec_num,
+         const int64_t nucl_num,
+         const int64_t type_nucl_num,
+         const int64_t* type_nucl_vector,
+         const int64_t aord_num,
+         const double* a_vector,
+         const double* en_distance_rescaled,
+         const double* asymp_jasa,
+         double* const factor_en )
+{
+  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) return QMCKL_NULL_CONTEXT;
+  if (walk_num <= 0) return QMCKL_INVALID_ARG_3;
+  if (elec_num <= 0) return QMCKL_INVALID_ARG_3;
+  if (nucl_num <= 0) return QMCKL_INVALID_ARG_4;
+  if (type_nucl_num <= 0) return QMCKL_INVALID_ARG_5;
+  if (type_nucl_vector == NULL) return QMCKL_INVALID_ARG_6;
+  if (aord_num < 0) return QMCKL_INVALID_ARG_7;
+  if (a_vector == NULL) return QMCKL_INVALID_ARG_8;
+  if (en_distance_rescaled == NULL) return QMCKL_INVALID_ARG_9;
+  if (asymp_jasa == NULL) return QMCKL_INVALID_ARG_10;
+  if (factor_en == NULL) return QMCKL_INVALID_ARG_11;
+
+  const double de = (double) elec_num;
+  #pragma omp parallel for
+  for (int64_t nw=0 ; nw<walk_num ; ++nw) {
+    factor_en[nw] = 0.;
+    const double* en_distance_rescaled_ = &(en_distance_rescaled[nw*elec_num*nucl_num]);
+
+    for (int64_t a=0 ; a<nucl_num ; ++a) {
+      const double* en_distance_rescaled__ = &(en_distance_rescaled_[a*elec_num]);
+      const double* a_vec = &(a_vector[type_nucl_vector[a]]);
+
+      factor_en[nw] -= asymp_jasa[type_nucl_vector[a]]*de;
+
+      for (int64_t i=0 ; i<elec_num ; ++i) {
+        double x = en_distance_rescaled__[i];
+        factor_en[nw] += a_vec[0]*x / (1.0 + a_vec[1]*x);
+
+        for (int64_t p=2 ; p <= aord_num ; ++p) {
+          x *= en_distance_rescaled__[i];
+          factor_en[nw] += a_vec[p]*x;
+        }
+      }
+    }
+
+  }
+  return QMCKL_SUCCESS;
+}
+    #+end_src
+
 **** Test
      #+begin_src python :results output :exports none :noweb yes
 import numpy as np
@@ -4487,7 +4705,7 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_gl(qmckl_context context)
      | ~factor_en_gl~            | ~double[walk_num][4][elec_num]~           | out    | Electron-nucleus jastrow              |
 
      #+begin_src f90 :comments org :tangle (eval f) :noweb yes
-integer function qmckl_compute_jastrow_champ_factor_en_gl_f( &
+integer function qmckl_compute_jastrow_champ_factor_en_gl_doc_f( &
      context, walk_num, elec_num, nucl_num, type_nucl_num, &
      type_nucl_vector, aord_num, a_vector, &
      en_distance_rescaled, en_distance_rescaled_gl, factor_en_gl) &
@@ -4502,11 +4720,11 @@ integer function qmckl_compute_jastrow_champ_factor_en_gl_f( &
   double precision      , intent(in)  :: en_distance_rescaled_gl(4, elec_num, nucl_num, walk_num)
   double precision      , intent(out) :: factor_en_gl(elec_num,4,walk_num)
 
-  integer*8 :: i, a, p, ipar, nw, ii
-  double precision   :: x, den, invden, invden2, invden3, xinv
-  double precision   :: y, lap1, lap2, lap3, third
-  double precision, dimension(3) :: power_ser_g
-  double precision, dimension(4) :: dx
+  integer*8 :: i, a, k, nw, ii
+  double precision   :: x, x1, kf
+  double precision   :: denom, invdenom, invdenom2, f
+  double precision   :: grad_c2
+  double precision   :: dx(4)
 
   info = QMCKL_SUCCESS
 
@@ -4535,63 +4753,174 @@ integer function qmckl_compute_jastrow_champ_factor_en_gl_f( &
      return
   endif
 
-  factor_en_gl = 0.0d0
-  third = 1.0d0 / 3.0d0
-
   do nw =1, walk_num
-  do a = 1, nucl_num
-     do i = 1, elec_num
-        x = en_distance_rescaled(i,a,nw)
-        if(abs(x) < 1.0d-18) continue
-        power_ser_g = 0.0d0
-        den = 1.0d0 + a_vector(2, type_nucl_vector(a)+1) * x
-        invden = 1.0d0 / den
-        invden2 = invden * invden
-        invden3 = invden2 * invden
-        xinv = 1.0d0 / x
+    factor_en_gl(:,:,nw) = 0.0d0
+    do a = 1, nucl_num
+       do i = 1, elec_num
 
-        do ii = 1, 4
-          dx(ii) = en_distance_rescaled_gl(ii,i,a,nw)
+          x = en_distance_rescaled(i,a,nw)
+          if(abs(x) < 1.d-12) continue
+
+          denom = 1.0d0 + a_vector(2, type_nucl_vector(a)+1) * x
+          invdenom = 1.0d0 / denom
+          invdenom2 = invdenom*invdenom
+
+          dx(1) = en_distance_rescaled_gl(1,i,a,nw)
+          dx(2) = en_distance_rescaled_gl(2,i,a,nw)
+          dx(3) = en_distance_rescaled_gl(3,i,a,nw)
+          dx(4) = en_distance_rescaled_gl(4,i,a,nw)
+
+          f = a_vector(1, type_nucl_vector(a)+1) * invdenom2
+          grad_c2 = dx(1)*dx(1) + dx(2)*dx(2) + dx(3)*dx(3)
+          
+          factor_en_gl(i,1,nw) = factor_en_gl(i,1,nw) + f * dx(1)
+          factor_en_gl(i,2,nw) = factor_en_gl(i,2,nw) + f * dx(2)
+          factor_en_gl(i,3,nw) = factor_en_gl(i,3,nw) + f * dx(3)
+          factor_en_gl(i,4,nw) = factor_en_gl(i,4,nw) &
+               + f * (dx(4) - 2.d0 * a_vector(2, type_nucl_vector(a)+1) * grad_c2 * invdenom)
+
+
+           kf = 2.d0
+           x1 = x
+           x = 1.d0
+           do k=2, aord_num
+              f = a_vector(k+1,type_nucl_vector(a)+1) * kf * x
+              factor_en_gl(i,1,nw) = factor_en_gl(i,1,nw) + f * x1 * dx(1)
+              factor_en_gl(i,2,nw) = factor_en_gl(i,2,nw) + f * x1 * dx(2)
+              factor_en_gl(i,3,nw) = factor_en_gl(i,3,nw) + f * x1 * dx(3)
+              factor_en_gl(i,4,nw) = factor_en_gl(i,4,nw) &
+                   + f * (x1 * dx(4) + (kf-1.d0) * grad_c2)
+              x = x*x1
+              kf = kf + 1.d0
+           end do
+           
         end do
-
-        lap1 = 0.0d0
-        lap2 = 0.0d0
-        lap3 = 0.0d0
-        do ii = 1, 3
-          x = en_distance_rescaled(i, a, nw)
-          do p = 2, aord_num
-            y = p * a_vector(p + 1, type_nucl_vector(a)+1) * x
-            power_ser_g(ii) = power_ser_g(ii) + y * dx(ii)
-            lap1 = lap1 + (p - 1) * y * xinv * dx(ii) * dx(ii)
-            lap2 = lap2 + y
-            x = x * en_distance_rescaled(i, a, nw)
-          end do
-
-          lap3 = lap3 - 2.0d0 * a_vector(2, type_nucl_vector(a)+1) * dx(ii) * dx(ii)
-
-          factor_en_gl(i, ii, nw) = factor_en_gl(i, ii, nw) + a_vector(1, type_nucl_vector(a)+1) &
-                                  ,* dx(ii) * invden2                                                        &
-                                  + power_ser_g(ii)
-
-        end do
-
-        ii = 4
-        lap2 = lap2 * dx(ii) * third
-        lap3 = lap3 + den * dx(ii)
-        lap3 = lap3 * a_vector(1, type_nucl_vector(a)+1) * invden3
-        factor_en_gl(i, ii, nw) = factor_en_gl(i, ii, nw) + lap1 + lap2 + lap3
-
      end do
   end do
-  end do
 
-end function qmckl_compute_jastrow_champ_factor_en_gl_f
+end function qmckl_compute_jastrow_champ_factor_en_gl_doc_f
      #+end_src
 
+    #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code
+qmckl_compute_jastrow_champ_factor_en_gl_hpc (const qmckl_context context,
+                                              const int64_t walk_num,
+                                              const int64_t elec_num,
+                                              const int64_t nucl_num,
+                                              const int64_t type_nucl_num,
+                                              const int64_t* type_nucl_vector,
+                                              const int64_t aord_num,
+                                              const double* a_vector,
+                                              const double* en_distance_rescaled,
+                                              const double* en_distance_rescaled_gl,
+                                              double* const factor_en_gl )
+{
+  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) return QMCKL_NULL_CONTEXT;
+  if (walk_num <= 0) return QMCKL_INVALID_ARG_3;
+  if (elec_num <= 0) return QMCKL_INVALID_ARG_3;
+  if (nucl_num <= 0) return QMCKL_INVALID_ARG_4;
+  if (type_nucl_num <= 0) return QMCKL_INVALID_ARG_5;
+  if (type_nucl_vector == NULL) return QMCKL_INVALID_ARG_6;
+  if (aord_num < 0) return QMCKL_INVALID_ARG_7;
+  if (a_vector == NULL) return QMCKL_INVALID_ARG_8;
+  if (en_distance_rescaled == NULL) return QMCKL_INVALID_ARG_9;
+  if (en_distance_rescaled_gl == NULL) return QMCKL_INVALID_ARG_10;
+  if (factor_en_gl == NULL) return QMCKL_INVALID_ARG_11;
+
+  double kf[aord_num+1];
+  for (int k=0 ; k<=aord_num ; ++k) {
+    kf[k] = (double) k;
+  }
+
+#pragma omp parallel for
+  for (int64_t nw = 0; nw < walk_num; ++nw) {
+    memset(&(factor_en_gl[nw*4*elec_num]), 0, elec_num*4*sizeof(double));
+
+    for (int64_t a = 0; a < nucl_num; ++a) {
+      const double* dxj = &en_distance_rescaled_gl[4*elec_num*(a+nw*nucl_num)];
+      const double*  xj = &en_distance_rescaled   [  elec_num*(a+nw*nucl_num)];
+      const double* a_vec = &( a_vector[(aord_num+1)*type_nucl_vector[a]] );
+
+      double * restrict factor_en_gl_0 = &(factor_en_gl[nw*elec_num*4]);
+      double * restrict factor_en_gl_1 = factor_en_gl_0 + elec_num;
+      double * restrict factor_en_gl_2 = factor_en_gl_1 + elec_num;
+      double * restrict factor_en_gl_3 = factor_en_gl_2 + elec_num;
+
+      for (int64_t i = 0; i < elec_num; ++i) {
+
+        double x = xj[i];
+        if (x < 1.e-12) continue;
+
+        const double denom      = 1.0 + a_vec[1]*x;
+        const double invdenom   = 1.0  / denom;
+        const double invdenom2  = invdenom * invdenom;
+
+        const double* restrict dx = dxj + 4*i;
+
+        const double grad_c2 = dx[0]*dx[0] + dx[1]*dx[1] + dx[2]*dx[2];
+
+        double f = a_vec[0] * invdenom2;
+
+        factor_en_gl_0[i] += f*dx[0];
+        factor_en_gl_1[i] += f*dx[1];
+        factor_en_gl_2[i] += f*dx[2];
+        factor_en_gl_3[i] += f*dx[3];
+        factor_en_gl_3[i] -= f*grad_c2*invdenom*2.0 * a_vec[1];
+
+
+        double xk[aord_num+1];
+        xk[0] = 1.0;
+        for (int k=1 ; k<= aord_num ; ++k) {
+          xk[k] = xk[k-1]*x;
+        }
+
+        for (int k=2 ; k<= aord_num ; ++k) {
+          const double f1 = a_vec[k] * kf[k] * xk[k-2];
+          const double f2 = f1*xk[1];
+          factor_en_gl_0[i] += f2*dx[0];
+          factor_en_gl_1[i] += f2*dx[1];
+          factor_en_gl_2[i] += f2*dx[2];
+          factor_en_gl_3[i] += f2*dx[3];
+          factor_en_gl_3[i] += f1*kf[k-1]*grad_c2;
+        }
+      }
+    }
+  }
+
+  return QMCKL_SUCCESS;
+}
+    #+end_src
+
  #   #+CALL: generate_c_header(table=qmckl_factor_en_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name"))
 
      #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none
-    qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_gl (
+qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_gl_doc (
+          const qmckl_context context,
+          const int64_t walk_num,
+          const int64_t elec_num,
+          const int64_t nucl_num,
+          const int64_t type_nucl_num,
+          const int64_t* type_nucl_vector,
+          const int64_t aord_num,
+          const double* a_vector,
+          const double* en_distance_rescaled,
+          const double* en_distance_rescaled_gl,
+          double* const factor_en_gl );
+
+qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_gl_hpc (
+          const qmckl_context context,
+          const int64_t walk_num,
+          const int64_t elec_num,
+          const int64_t nucl_num,
+          const int64_t type_nucl_num,
+          const int64_t* type_nucl_vector,
+          const int64_t aord_num,
+          const double* a_vector,
+          const double* en_distance_rescaled,
+          const double* en_distance_rescaled_gl,
+          double* const factor_en_gl );
+
+qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_gl (
           const qmckl_context context,
           const int64_t walk_num,
           const int64_t elec_num,
@@ -4606,54 +4935,78 @@ end function qmckl_compute_jastrow_champ_factor_en_gl_f
      #+end_src
 
 
-     #+CALL: generate_c_interface(table=qmckl_factor_en_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name"))
+    #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code
+qmckl_compute_jastrow_champ_factor_en_gl (const qmckl_context context,
+                                          const int64_t walk_num,
+                                          const int64_t elec_num,
+                                          const int64_t nucl_num,
+                                          const int64_t type_nucl_num,
+                                          const int64_t* type_nucl_vector,
+                                          const int64_t aord_num,
+                                          const double* a_vector,
+                                          const double* en_distance_rescaled,
+                                          const double* en_distance_rescaled_gl,
+                                          double* const factor_en_gl )
+{
+#ifdef HAVE_HPC
+  return qmckl_compute_jastrow_champ_factor_en_gl_hpc
+#else 
+  return qmckl_compute_jastrow_champ_factor_en_gl_doc
+#endif
+    (context, walk_num, elec_num, nucl_num, type_nucl_num, type_nucl_vector, aord_num,
+     a_vector, en_distance_rescaled, en_distance_rescaled_gl, factor_en_gl );
+}
+  #+end_src
+
+     #+CALL: generate_c_interface(table=qmckl_factor_en_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_en_gl_doc")
 
      #+RESULTS:
      #+begin_src f90 :tangle (eval f) :comments org :exports none
-    integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_en_gl &
-        (context, &
-         walk_num, &
-         elec_num, &
-         nucl_num, &
-         type_nucl_num, &
-         type_nucl_vector, &
-         aord_num, &
-         a_vector, &
-         en_distance_rescaled, &
-         en_distance_rescaled_gl, &
-         factor_en_gl) &
-        bind(C) result(info)
+     integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_en_gl_doc &
+         (context, &
+          walk_num, &
+          elec_num, &
+          nucl_num, &
+          type_nucl_num, &
+          type_nucl_vector, &
+          aord_num, &
+          a_vector, &
+          en_distance_rescaled, &
+          en_distance_rescaled_gl, &
+          factor_en_gl) &
+         bind(C) result(info)
 
-      use, intrinsic :: iso_c_binding
-      implicit none
+       use, intrinsic :: iso_c_binding
+       implicit none
 
-      integer (c_int64_t) , intent(in)  , value :: context
-      integer (c_int64_t) , intent(in)  , value :: walk_num
-      integer (c_int64_t) , intent(in)  , value :: elec_num
-      integer (c_int64_t) , intent(in)  , value :: nucl_num
-      integer (c_int64_t) , intent(in)  , value :: type_nucl_num
-      integer (c_int64_t) , intent(in)          :: type_nucl_vector(nucl_num)
-      integer (c_int64_t) , intent(in)  , value :: aord_num
-      real    (c_double ) , intent(in)          :: a_vector(type_nucl_num,aord_num+1)
-      real    (c_double ) , intent(in)          :: en_distance_rescaled(elec_num,nucl_num,walk_num)
-      real    (c_double ) , intent(in)          :: en_distance_rescaled_gl(elec_num,nucl_num,4,walk_num)
-      real    (c_double ) , intent(out)         :: factor_en_gl(elec_num,4,walk_num)
+       integer (c_int64_t) , intent(in)  , value :: context
+       integer (c_int64_t) , intent(in)  , value :: walk_num
+       integer (c_int64_t) , intent(in)  , value :: elec_num
+       integer (c_int64_t) , intent(in)  , value :: nucl_num
+       integer (c_int64_t) , intent(in)  , value :: type_nucl_num
+       integer (c_int64_t) , intent(in)          :: type_nucl_vector(nucl_num)
+       integer (c_int64_t) , intent(in)  , value :: aord_num
+       real    (c_double ) , intent(in)          :: a_vector(type_nucl_num,aord_num+1)
+       real    (c_double ) , intent(in)          :: en_distance_rescaled(elec_num,nucl_num,walk_num)
+       real    (c_double ) , intent(in)          :: en_distance_rescaled_gl(elec_num,nucl_num,4,walk_num)
+       real    (c_double ) , intent(out)         :: factor_en_gl(elec_num,4,walk_num)
 
-      integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_en_gl_f
-      info = qmckl_compute_jastrow_champ_factor_en_gl_f &
-             (context, &
-         walk_num, &
-         elec_num, &
-         nucl_num, &
-         type_nucl_num, &
-         type_nucl_vector, &
-         aord_num, &
-         a_vector, &
-         en_distance_rescaled, &
-         en_distance_rescaled_gl, &
-         factor_en_gl)
+       integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_en_gl_doc_f
+       info = qmckl_compute_jastrow_champ_factor_en_gl_doc_f &
+              (context, &
+          walk_num, &
+          elec_num, &
+          nucl_num, &
+          type_nucl_num, &
+          type_nucl_vector, &
+          aord_num, &
+          a_vector, &
+          en_distance_rescaled, &
+          en_distance_rescaled_gl, &
+          factor_en_gl)
 
-    end function qmckl_compute_jastrow_champ_factor_en_gl
+     end function qmckl_compute_jastrow_champ_factor_en_gl_doc
      #+end_src
 
 **** Test
@@ -5220,7 +5573,7 @@ qmckl_exit_code qmckl_provide_en_distance_rescaled_gl(qmckl_context context)
      | ~en_distance_rescaled_gl~ | ~double[walk_num][nucl_num][elec_num][4]~ | out    | Electron-nucleus distance derivatives |
 
      #+begin_src f90 :comments org :tangle (eval f) :noweb yes
-integer function qmckl_compute_en_distance_rescaled_gl_f(context, elec_num, nucl_num, &
+integer function qmckl_compute_en_distance_rescaled_gl_doc_f(context, elec_num, nucl_num, &
      type_nucl_num, type_nucl_vector, rescale_factor_en, walk_num, elec_coord, &
      nucl_coord, en_distance_rescaled_gl) &
      result(info)
@@ -5274,10 +5627,34 @@ integer function qmckl_compute_en_distance_rescaled_gl_f(context, elec_num, nucl
      end do
   end do
 
-end function qmckl_compute_en_distance_rescaled_gl_f
+end function qmckl_compute_en_distance_rescaled_gl_doc_f
      #+end_src
 
      #+begin_src c :tangle (eval h_private_func) :comments org :exports none
+qmckl_exit_code qmckl_compute_en_distance_rescaled_gl_doc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const int64_t nucl_num,
+          const int64_t type_nucl_num,
+          int64_t* const type_nucl_vector,
+          const double*  rescale_factor_en,
+          const int64_t walk_num,
+          const double* elec_coord,
+          const double* nucl_coord,
+          double* const en_distance_rescaled_gl );
+
+qmckl_exit_code qmckl_compute_en_distance_rescaled_gl_hpc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const int64_t nucl_num,
+          const int64_t type_nucl_num,
+          int64_t* const type_nucl_vector,
+          const double*  rescale_factor_en,
+          const int64_t walk_num,
+          const double* elec_coord,
+          const double* nucl_coord,
+          double* const en_distance_rescaled_gl );
+
 qmckl_exit_code qmckl_compute_en_distance_rescaled_gl (
           const qmckl_context context,
           const int64_t elec_num,
@@ -5291,51 +5668,123 @@ qmckl_exit_code qmckl_compute_en_distance_rescaled_gl (
           double* const en_distance_rescaled_gl );
      #+end_src
 
-     #+CALL: generate_c_interface(table=qmckl_en_distance_rescaled_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name"))
+     #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code qmckl_compute_en_distance_rescaled_gl_hpc (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const int64_t nucl_num,
+          const int64_t type_nucl_num,
+          int64_t* const type_nucl_vector,
+          const double*  rescale_factor_en,
+          const int64_t walk_num,
+          const double* elec_coord,
+          const double* nucl_coord,
+          double* const en_distance_rescaled_gl )
+{ 
+  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) return QMCKL_INVALID_CONTEXT;
+  if (elec_num <= 0) return QMCKL_INVALID_ARG_2;
+  if (nucl_num <= 0) return QMCKL_INVALID_ARG_3;
+  if (type_nucl_num <= 0) return QMCKL_INVALID_ARG_4;
+  if (type_nucl_vector == NULL) return QMCKL_INVALID_ARG_5;
+  if (rescale_factor_en == NULL) return QMCKL_INVALID_ARG_6;
+  if (walk_num <= 0) return QMCKL_INVALID_ARG_7;
+  if (elec_coord == NULL) return QMCKL_INVALID_ARG_8;
+  if (nucl_coord == NULL) return QMCKL_INVALID_ARG_9;
+  if (en_distance_rescaled_gl == NULL) return QMCKL_INVALID_ARG_10;
+
+  
+  int64_t sze = elec_num*walk_num;
+
+  qmckl_exit_code result = QMCKL_SUCCESS;
+  #pragma omp parallel
+  {
+    qmckl_exit_code rc = QMCKL_SUCCESS;
+    #pragma omp for
+    for (int64_t k=0 ; k<walk_num ; ++k)
+    {
+      for (int64_t a=0 ; a<nucl_num ; ++a) {
+        const double coord[3] = { nucl_coord[a], nucl_coord[a+nucl_num], nucl_coord[a+2*nucl_num] };
+        rc |= qmckl_distance_rescaled_gl(context, 'T', 'T', elec_num, 1, 
+                                         &(elec_coord[k*elec_num]), sze,
+                                         coord, 1,
+                                         &(en_distance_rescaled_gl[4*elec_num*(a+nucl_num*k)]), elec_num,
+                                         rescale_factor_en[type_nucl_vector[a]]);
+      }
+    }
+    #pragma omp critical
+    result |= rc;
+  }
+  return result;
+}
+     #+end_src
+
+     #+begin_src c :tangle (eval c) :comments org :exports none
+qmckl_exit_code qmckl_compute_en_distance_rescaled_gl (
+          const qmckl_context context,
+          const int64_t elec_num,
+          const int64_t nucl_num,
+          const int64_t type_nucl_num,
+          int64_t* const type_nucl_vector,
+          const double*  rescale_factor_en,
+          const int64_t walk_num,
+          const double* elec_coord,
+          const double* nucl_coord,
+          double* const en_distance_rescaled_gl )
+{ 
+#ifdef HAVE_HPC
+  return qmckl_compute_en_distance_rescaled_gl_hpc
+#else
+  return qmckl_compute_en_distance_rescaled_gl_doc
+#endif
+    (context, elec_num, nucl_num, type_nucl_num, type_nucl_vector, rescale_factor_en,
+     walk_num, elec_coord, nucl_coord, en_distance_rescaled_gl );
+}
+     #+end_src
+     #+CALL: generate_c_interface(table=qmckl_en_distance_rescaled_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_en_distance_rescaled_gl_doc")
 
      #+RESULTS:
      #+begin_src f90 :tangle (eval f) :comments org :exports none
-    integer(c_int32_t) function qmckl_compute_en_distance_rescaled_gl &
-        (context, &
-         elec_num, &
-         nucl_num, &
-         type_nucl_num, &
-         type_nucl_vector, &
-         rescale_factor_en, &
-         walk_num, &
-         elec_coord, &
-         nucl_coord, &
-         en_distance_rescaled_gl) &
-        bind(C) result(info)
+     integer(c_int32_t) function qmckl_compute_en_distance_rescaled_gl_doc &
+         (context, &
+          elec_num, &
+          nucl_num, &
+          type_nucl_num, &
+          type_nucl_vector, &
+          rescale_factor_en, &
+          walk_num, &
+          elec_coord, &
+          nucl_coord, &
+          en_distance_rescaled_gl) &
+         bind(C) result(info)
 
-      use, intrinsic :: iso_c_binding
-      implicit none
+       use, intrinsic :: iso_c_binding
+       implicit none
 
-      integer (c_int64_t) , intent(in)  , value :: context
-      integer (c_int64_t) , intent(in)  , value :: elec_num
-      integer (c_int64_t) , intent(in)  , value :: nucl_num
-      integer (c_int64_t) , intent(in)  , value :: type_nucl_num
-      integer (c_int64_t) , intent(in)          :: type_nucl_vector(nucl_num)
-      real    (c_double ) , intent(in)          :: rescale_factor_en(nucl_num)
-      integer (c_int64_t) , intent(in)  , value :: walk_num
-      real    (c_double ) , intent(in)          :: elec_coord(elec_num,walk_num,3)
-      real    (c_double ) , intent(in)          :: nucl_coord(elec_num,3)
-      real    (c_double ) , intent(out)         :: en_distance_rescaled_gl(4,elec_num,nucl_num,walk_num)
+       integer (c_int64_t) , intent(in)  , value :: context
+       integer (c_int64_t) , intent(in)  , value :: elec_num
+       integer (c_int64_t) , intent(in)  , value :: nucl_num
+       integer (c_int64_t) , intent(in)  , value :: type_nucl_num
+       integer (c_int64_t) , intent(in)          :: type_nucl_vector(nucl_num)
+       real    (c_double ) , intent(in)          :: rescale_factor_en(nucl_num)
+       integer (c_int64_t) , intent(in)  , value :: walk_num
+       real    (c_double ) , intent(in)          :: elec_coord(elec_num,walk_num,3)
+       real    (c_double ) , intent(in)          :: nucl_coord(elec_num,3)
+       real    (c_double ) , intent(out)         :: en_distance_rescaled_gl(4,elec_num,nucl_num,walk_num)
 
-      integer(c_int32_t), external :: qmckl_compute_en_distance_rescaled_gl_f
-      info = qmckl_compute_en_distance_rescaled_gl_f &
-             (context, &
-         elec_num, &
-         nucl_num, &
-         type_nucl_num, &
-         type_nucl_vector, &
-         rescale_factor_en, &
-         walk_num, &
-         elec_coord, &
-         nucl_coord, &
-         en_distance_rescaled_gl)
+       integer(c_int32_t), external :: qmckl_compute_en_distance_rescaled_gl_doc_f
+       info = qmckl_compute_en_distance_rescaled_gl_doc_f &
+              (context, &
+          elec_num, &
+          nucl_num, &
+          type_nucl_num, &
+          type_nucl_vector, &
+          rescale_factor_en, &
+          walk_num, &
+          elec_coord, &
+          nucl_coord, &
+          en_distance_rescaled_gl)
 
-    end function qmckl_compute_en_distance_rescaled_gl
+     end function qmckl_compute_en_distance_rescaled_gl_doc
      #+end_src
 
 **** Test
@@ -5819,11 +6268,12 @@ qmckl_exit_code qmckl_compute_een_rescaled_e_hpc (
 	  const double* ee_distance,
 	  double* const een_rescaled_e ) {
 
-    #ifdef HAVE_HPC
-    return qmckl_compute_een_rescaled_e_hpc(context, walk_num, elec_num, cord_num, rescale_factor_ee, ee_distance, een_rescaled_e);
-    #else
-    return qmckl_compute_een_rescaled_e_doc(context, walk_num, elec_num, cord_num, rescale_factor_ee, ee_distance, een_rescaled_e);
-    #endif
+#ifdef HAVE_HPC
+    return qmckl_compute_een_rescaled_e_hpc
+#else
+    return qmckl_compute_een_rescaled_e_doc
+#endif
+      (context, walk_num, elec_num, cord_num, rescale_factor_ee, ee_distance, een_rescaled_e);
     }
      #+end_src
 
@@ -7727,11 +8177,12 @@ qmckl_exit_code qmckl_compute_c_vector_full (
 	  const double* c_vector,
 	  double* const c_vector_full ) {
 
-    #ifdef HAVE_HPC
-      return qmckl_compute_c_vector_full_hpc(context, nucl_num, dim_c_vector, type_nucl_num, type_nucl_vector, c_vector, c_vector_full);
-    #else
-      return qmckl_compute_c_vector_full_doc(context, nucl_num, dim_c_vector, type_nucl_num, type_nucl_vector, c_vector, c_vector_full);
-    #endif
+#ifdef HAVE_HPC
+      return qmckl_compute_c_vector_full_hpc
+#else
+      return qmckl_compute_c_vector_full_doc
+#endif
+(context, nucl_num, dim_c_vector, type_nucl_num, type_nucl_vector, c_vector, c_vector_full);
     }
      #+end_src
 
@@ -7861,10 +8312,11 @@ qmckl_exit_code qmckl_compute_lkpm_combined_index (
       int64_t* const lkpm_combined_index ) {
 
     #ifdef HAVE_HPC
-      return qmckl_compute_lkpm_combined_index_hpc(context, cord_num, dim_c_vector, lkpm_combined_index);
+      return qmckl_compute_lkpm_combined_index_hpc
     #else
-      return qmckl_compute_lkpm_combined_index_doc(context, cord_num, dim_c_vector, lkpm_combined_index);
+      return qmckl_compute_lkpm_combined_index_doc
     #endif
+        (context, cord_num, dim_c_vector, lkpm_combined_index);
 }
      #+end_src
 
@@ -7947,10 +8399,12 @@ qmckl_exit_code qmckl_compute_tmp_c (const qmckl_context context,
                                      double* const tmp_c )
 {
 #ifdef HAVE_HPC
-  return qmckl_compute_tmp_c_hpc(context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e, een_rescaled_n, tmp_c);
+  return qmckl_compute_tmp_c_hpc
 #else
-  return qmckl_compute_tmp_c_doc(context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e, een_rescaled_n, tmp_c);
+  return qmckl_compute_tmp_c_doc
 #endif
+    (context, cord_num, elec_num, nucl_num, walk_num,
+     een_rescaled_e, een_rescaled_n, tmp_c);
 }
      #+end_src
 
@@ -8208,12 +8662,12 @@ qmckl_compute_dtmp_c (const qmckl_context context,
                       double* const dtmp_c )
 {
 #ifdef HAVE_HPC
-  return qmckl_compute_dtmp_c_hpc (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_gl,
-                                   een_rescaled_n, dtmp_c );
+  return qmckl_compute_dtmp_c_hpc 
 #else
-  return qmckl_compute_dtmp_c_doc (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_gl,
-                                   een_rescaled_n, dtmp_c );
+  return qmckl_compute_dtmp_c_doc
 #endif
+    (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_gl,
+     een_rescaled_n, dtmp_c );
 }
       #+end_src
 
@@ -8931,14 +9385,13 @@ qmckl_compute_jastrow_champ_factor_een (const qmckl_context context,
                           double* const factor_een )
 {
 #ifdef HAVE_HPC
-  return qmckl_compute_jastrow_champ_factor_een_doc (context, walk_num, elec_num, nucl_num, cord_num, dim_c_vector,
-                          c_vector_full, lkpm_combined_index, tmp_c, een_rescaled_n,
-                          factor_een );
+  return qmckl_compute_jastrow_champ_factor_een_doc
 #else
-  return qmckl_compute_jastrow_champ_factor_een_doc (context, walk_num, elec_num, nucl_num, cord_num, dim_c_vector,
-                          c_vector_full, lkpm_combined_index, tmp_c, een_rescaled_n,
-                          factor_een );
+  return qmckl_compute_jastrow_champ_factor_een_doc
 #endif
+    (context, walk_num, elec_num, nucl_num, cord_num, dim_c_vector,
+     c_vector_full, lkpm_combined_index, tmp_c, een_rescaled_n,
+     factor_een );
 }
  #+end_src
    #+CALL: generate_c_interface(table=qmckl_factor_een_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_doc"))
@@ -9613,18 +10066,15 @@ qmckl_compute_jastrow_champ_factor_een_gl(const qmckl_context context,
                                                double* const factor_een_gl)
 {
 #ifdef HAVE_HPC
-  return qmckl_compute_jastrow_champ_factor_een_gl_hpc(context, walk_num, elec_num, nucl_num,
-                                                            cord_num, dim_c_vector, c_vector_full,
-                                                            lkpm_combined_index, tmp_c, dtmp_c,
-                                                            een_rescaled_n, een_rescaled_n_gl,
-                                                            factor_een_gl);
+  return qmckl_compute_jastrow_champ_factor_een_gl_hpc
 #else
-  return qmckl_compute_jastrow_champ_factor_een_gl_doc(context, walk_num, elec_num, nucl_num,
-                                                            cord_num, dim_c_vector, c_vector_full,
-                                                            lkpm_combined_index, tmp_c, dtmp_c,
-                                                            een_rescaled_n, een_rescaled_n_gl,
-                                                            factor_een_gl);
+  return qmckl_compute_jastrow_champ_factor_een_gl_doc
 #endif
+    (context, walk_num, elec_num, nucl_num,
+     cord_num, dim_c_vector, c_vector_full,
+     lkpm_combined_index, tmp_c, dtmp_c,
+     een_rescaled_n, een_rescaled_n_gl,
+     factor_een_gl);
 }
 #+end_src
 ***** HPC implementation                                           :noexport:
@@ -10168,12 +10618,11 @@ qmckl_exit_code qmckl_compute_jastrow_champ_value (
 {
 
 #ifdef HAVE_HPC
-  return qmckl_compute_jastrow_champ_value_hpc (
-          context, walk_num, factor_ee, factor_en, factor_een, value);
+  return qmckl_compute_jastrow_champ_value_hpc
 #else
-  return qmckl_compute_jastrow_champ_value_doc (
-          context, walk_num, factor_ee, factor_en, factor_een, value);
+  return qmckl_compute_jastrow_champ_value_doc
 #endif
+    (context, walk_num, factor_ee, factor_en, factor_een, value);
 }
  #+end_src
 
@@ -10570,12 +11019,11 @@ qmckl_exit_code qmckl_compute_jastrow_champ_gl (
 {
 
 #ifdef HAVE_HPC
-  return qmckl_compute_jastrow_champ_gl_hpc (context,
-      walk_num, elec_num, value, gl_ee, gl_en, gl_een, gl);
+  return qmckl_compute_jastrow_champ_gl_hpc
 #else
-  return qmckl_compute_jastrow_champ_gl_doc (context,
-      walk_num, elec_num, value, gl_ee, gl_en, gl_een, gl);
+  return qmckl_compute_jastrow_champ_gl_doc
 #endif
+    (context, walk_num, elec_num, value, gl_ee, gl_en, gl_een, gl);
 }
  #+end_src