Moved rescale factors in Jastrow, removed kappa from names

org/qmckl_context.org

@@ -292,6 +292,9 @@ qmckl_context qmckl_context_create() {
 
     rc = qmckl_init_determinant(context);
     assert (rc == QMCKL_SUCCESS);
+
+    rc = qmckl_init_jastrow(context);
+    assert (rc == QMCKL_SUCCESS);
   }
 
  /* Allocate qmckl_memory_struct */

org/qmckl_determinant.org

@@ -1111,21 +1111,21 @@ const double*   nucl_charge   = chbrclf_charge;
 const double*   nucl_coord    = &(chbrclf_nucl_coord[0][0]);
 
 rc = qmckl_set_electron_num (context, chbrclf_elec_up_num, chbrclf_elec_dn_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
+
+rc = qmckl_set_electron_coord (context, 'N', chbrclf_walk_num, elec_coord, chbrclf_walk_num*chbrclf_elec_num*3);
+qmckl_check(context, rc);
 
 assert(qmckl_electron_provided(context));
 
-rc = qmckl_set_electron_coord (context, 'N', chbrclf_walk_num, elec_coord, chbrclf_walk_num*chbrclf_elec_num*3);
-assert(rc == QMCKL_SUCCESS);
-
 rc = qmckl_set_nucleus_num (context, chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_nucleus_coord (context, 'T', &(nucl_coord[0]), chbrclf_nucl_num*3);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_nucleus_charge(context, nucl_charge, chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 assert(qmckl_nucleus_provided(context));
 
@@ -1145,57 +1145,57 @@ const char typ = 'G';
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_type (context, typ);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_shell_num (context, chbrclf_shell_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_prim_num (context, chbrclf_prim_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_nucleus_index (context, nucleus_index, chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_nucleus_shell_num (context, nucleus_shell_num, chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_shell_ang_mom (context, shell_ang_mom, chbrclf_shell_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_shell_factor  (context, shell_factor, chbrclf_shell_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_shell_prim_num (context, shell_prim_num, chbrclf_shell_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_shell_prim_index (context, shell_prim_index, chbrclf_shell_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_exponent (context, exponent, chbrclf_prim_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_coefficient (context, coefficient, chbrclf_prim_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_ao_basis_provided(context));
 
 rc = qmckl_set_ao_basis_prim_factor (context, prim_factor, chbrclf_prim_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_ao_basis_ao_num(context, chbrclf_ao_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_ao_basis_ao_factor (context, ao_factor, chbrclf_ao_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 assert(qmckl_ao_basis_provided(context));
 
@@ -1203,22 +1203,22 @@ assert(qmckl_ao_basis_provided(context));
 double ao_vgl[chbrclf_walk_num*chbrclf_elec_num][5][chbrclf_ao_num];
 
 rc = qmckl_get_ao_basis_ao_vgl(context, &(ao_vgl[0][0][0]), (int64_t) 5*chbrclf_walk_num*chbrclf_elec_num*chbrclf_ao_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 /* Set up MO data */
 rc = qmckl_set_mo_basis_mo_num(context, chbrclf_mo_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 const double  * mo_coefficient          =  &(chbrclf_mo_coef[0]);
 
 rc = qmckl_set_mo_basis_coefficient(context, mo_coefficient);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 assert(qmckl_mo_basis_provided(context));
 
 double mo_vgl[chbrclf_walk_num*chbrclf_elec_num][5][chbrclf_mo_num];
 rc = qmckl_get_mo_basis_mo_vgl(context, &(mo_vgl[0][0][0]), 5*chbrclf_walk_num*chbrclf_elec_num*chbrclf_mo_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 /* Set up determinant data */
 
@@ -1238,19 +1238,19 @@ for(k = 0; k < det_num_beta; ++k)
       mo_index_beta[k][i][j] = j + 1;
 
 rc = qmckl_set_determinant_type (context, typ);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_determinant_det_num_alpha (context, det_num_alpha);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_determinant_det_num_beta (context, det_num_beta);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_determinant_mo_index_alpha (context, &(mo_index_alpha[0][0][0]));
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_set_determinant_mo_index_beta (context, &(mo_index_beta[0][0][0]));
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 // Get slater-determinant
 
@@ -1258,10 +1258,10 @@ double det_vgl_alpha[det_num_alpha][chbrclf_walk_num][5][chbrclf_elec_up_num][ch
 double det_vgl_beta[det_num_beta][chbrclf_walk_num][5][chbrclf_elec_dn_num][chbrclf_elec_dn_num];
 
 rc = qmckl_get_det_vgl_alpha(context, &(det_vgl_alpha[0][0][0][0][0]));
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_get_det_vgl_beta(context, &(det_vgl_beta[0][0][0][0][0]));
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
      #+end_src
 
@@ -2018,10 +2018,10 @@ double det_inv_matrix_alpha[det_num_alpha][chbrclf_walk_num][chbrclf_elec_up_num
 double det_inv_matrix_beta[det_num_beta][chbrclf_walk_num][chbrclf_elec_dn_num][chbrclf_elec_dn_num];
 
 rc = qmckl_get_det_inv_matrix_alpha(context, &(det_inv_matrix_alpha[0][0][0][0]));
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_get_det_inv_matrix_beta(context, &(det_inv_matrix_beta[0][0][0][0]));
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
      #+end_src
 
@@ -2034,7 +2034,7 @@ assert (rc == QMCKL_SUCCESS);
 *** Test
   #+begin_src c :tangle (eval c_test)
     rc = qmckl_context_destroy(context);
-    assert (rc == QMCKL_SUCCESS);
+    qmckl_check(context, rc);
 
     return 0;
 }

org/qmckl_error.org

@@ -608,6 +608,62 @@ qmckl_last_error(qmckl_context context, char* buffer) {
   end interface
    #+end_src
 
+* Helper functions for debugging
+
+  The following function prints to ~stderr~ an error message is the return code is
+  not ~QMCKL_SUCCESS~.
+
+  # Header
+   #+begin_src c :comments org :tangle (eval h_func)
+qmckl_exit_code
+qmckl_check(qmckl_context context, qmckl_exit_code rc);
+   #+end_src
+
+  # Source
+  #+begin_src c :tangle (eval c) :exports none
+#include <stdio.h>
+
+qmckl_exit_code
+qmckl_check(qmckl_context context, qmckl_exit_code rc)
+{  
+
+  char fname[QMCKL_MAX_FUN_LEN];
+  char message[QMCKL_MAX_MSG_LEN];
+
+  if (rc != QMCKL_SUCCESS) {
+    fprintf(stderr, "===========\nQMCKL ERROR\n%s\n", qmckl_string_of_error(rc));
+    qmckl_get_error(context, &rc, fname, message);
+    fprintf(stderr, "Function: %s\nMessage: %s\n===========\n", fname, message);
+  }
+
+  return rc;
+}
+    #+end_src
+    
+  It should be used as:
+
+    #+begin_src c
+rc = qmckl_check(context,
+                 qmckl_...(context, ...)
+                 );
+assert (rc == QMCKL_SUCCESS);
+     #+end_src
+    
+** Fortran inteface
+
+   #+begin_src f90 :tangle (eval fh_func) :exports none :noweb yes
+  interface
+     function qmckl_check (context, rc) bind(C, name='qmckl_check')
+       use, intrinsic :: iso_c_binding
+       import
+       implicit none
+       integer(qmckl_exit_code) :: qmckl_check
+       integer (c_int64_t) , intent(in), value :: context
+       integer(qmckl_exit_code), intent(in) :: rc
+     end function qmckl_check
+  end interface
+   #+end_src
+
 * End of files                                                    :noexport:
 
   #+begin_src c :comments link :tangle (eval h_private_type)
@@ -623,12 +679,13 @@ qmckl_last_error(qmckl_context context, char* buffer) {
   qmckl_exit_code exit_code;
   exit_code = 1;
 
-  assert (qmckl_set_error(context, exit_code, "qmckl_transpose", "Success") == QMCKL_SUCCESS);
+  assert (qmckl_set_error(context, exit_code, "my_function", "Message") == QMCKL_SUCCESS);
 
   assert (qmckl_get_error(context, &exit_code, function_name, message) == QMCKL_SUCCESS);
   assert (exit_code == 1);
-  assert (strcmp(function_name,"qmckl_transpose") == 0);
+
-  assert (strcmp(message,"Success") == 0);
+  assert (strcmp(function_name,"my_function") == 0);
+  assert (strcmp(message,"Message") == 0);
 
   exit_code = qmckl_context_destroy(context);
   assert(exit_code == QMCKL_SUCCESS);

org/qmckl_nucleus.org

@@ -74,15 +74,12 @@ int main() {
   | ~charge~               | qmckl_vector | Nuclear charges                           |
   | ~coord~                | qmckl_matrix | Nuclear coordinates, in transposed format |
   | ~coord_date~           | int64_t      | Nuclear coordinates, date if modified     |
-  | ~rescale_factor_kappa~ | double       | The distance scaling factor               |
 
   Computed data:
   
   |-----------------------------+--------------+------------------------------------------------------------|
   | ~nn_distance~               | qmckl_matrix | Nucleus-nucleus distances                                  |
   | ~nn_distance_date~          | int64_t      | Date when Nucleus-nucleus distances were computed          |
-  | ~nn_distance_rescaled~      | qmckl_matrix | Nucleus-nucleus rescaled distances                         |
-  | ~nn_distance_rescaled_date~ | int64_t      | Date when Nucleus-nucleus rescaled distances were computed |
   | ~repulsion~                 | double       | Nuclear repulsion energy                                   |
   | ~repulsion_date~            | int64_t      | Date when the nuclear repulsion energy was computed        |
 
@@ -93,14 +90,11 @@ typedef struct qmckl_nucleus_struct {
   int64_t      num;
   int64_t      repulsion_date;
   int64_t      nn_distance_date;
-  int64_t      nn_distance_rescaled_date;
   int64_t      coord_date;
   qmckl_vector charge;
   qmckl_matrix coord;
   qmckl_matrix nn_distance;
-  qmckl_matrix nn_distance_rescaled;
   double       repulsion;
-  double       rescale_factor_kappa;
   int32_t      uninitialized;
   bool         provided;
 } qmckl_nucleus_struct;
@@ -131,7 +125,6 @@ qmckl_exit_code qmckl_init_nucleus(qmckl_context context) {
   ctx->nucleus.uninitialized = (1 << 3) - 1;
 
  /* Default values */
-  ctx->nucleus.rescale_factor_kappa = 1.0;
 
   return QMCKL_SUCCESS;
 }
@@ -265,53 +258,6 @@ end interface
 
    #+begin_src c :comments org :tangle (eval h_func) :exports none
 qmckl_exit_code
-qmckl_get_nucleus_rescale_factor(const qmckl_context context,
-                                 double* const rescale_factor_kappa);
-   #+end_src
-
-   #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
-qmckl_exit_code
-qmckl_get_nucleus_rescale_factor (const qmckl_context context,
-                                  double* const rescale_factor_kappa)
-{
-
-  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
-    return QMCKL_INVALID_CONTEXT;
-  }
-
-  if (rescale_factor_kappa == NULL) {
-    return qmckl_failwith( context,
-                           QMCKL_INVALID_ARG_2,
-                           "qmckl_get_nucleus_rescale_factor",
-                           "rescale_factor_kappa is a null pointer");
-  }
-
-  qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
-  assert (ctx != NULL);
-
-  assert (ctx->nucleus.rescale_factor_kappa > 0.0);
-
-  (*rescale_factor_kappa) = ctx->nucleus.rescale_factor_kappa;
-
-  return QMCKL_SUCCESS;
-}
-   #+end_src
-
-    #+begin_src f90 :tangle (eval fh_func) :comments org :exports none
-interface
-  integer(c_int32_t) function qmckl_get_nucleus_rescale_factor(context, kappa) &
-    bind(C)
-    use, intrinsic :: iso_c_binding
-    import
-    implicit none
-    integer (c_int64_t) , intent(in)  , value :: context
-    real    (c_double)  , intent(out)         :: kappa
-  end function qmckl_get_nucleus_rescale_factor
-end interface
-    #+end_src
-
-   #+begin_src c :comments org :tangle (eval h_func) :exports none
-qmckl_exit_code
 qmckl_get_nucleus_coord(const qmckl_context context,
                         const char transp,
                         double* const coord,
@@ -631,55 +577,12 @@ interface
 end interface
     #+end_src
 
-   #+begin_src c :comments org :tangle (eval h_func)
-qmckl_exit_code
-qmckl_set_nucleus_rescale_factor(qmckl_context context,
-                                 const double kappa);
-   #+end_src
-
-    Sets the rescale parameter for the nuclear distances.
-
-   #+begin_src c :comments org :tangle (eval c) :noweb yes  :exports none
-qmckl_exit_code
-qmckl_set_nucleus_rescale_factor(qmckl_context context,
-                                 const double rescale_factor_kappa)
-{
-  int32_t mask = 0; // Can be updated
-  
-  <<pre2>>
-
-  if (rescale_factor_kappa <= 0.0) {
-    return qmckl_failwith( context,
-                           QMCKL_INVALID_ARG_2,
-                           "qmckl_set_nucleus_rescale_factor",
-                           "rescale_factor_kappa cannot be <= 0.");
-  }
-
-  ctx->nucleus.rescale_factor_kappa = rescale_factor_kappa;
-
-  return QMCKL_SUCCESS;
-}
-    #+end_src
-
-    #+begin_src f90 :tangle (eval fh_func) :comments org :exports none
-interface
-  integer(c_int32_t) function qmckl_set_nucleus_rescale_factor(context, kappa) &
-    bind(C)
-    use, intrinsic :: iso_c_binding
-    import
-    implicit none
-    integer (c_int64_t) , intent(in)  , value :: context
-    real    (c_double)  , intent(in)  , value :: kappa
-  end function qmckl_set_nucleus_rescale_factor
-end interface
-    #+end_src
 
 ** Test
 
     #+begin_src c :tangle (eval c_test)
 const double*   nucl_charge   = chbrclf_charge;
 const double*   nucl_coord    = &(chbrclf_nucl_coord[0][0]);
-const double    nucl_rescale_factor_kappa = 2.0;
 
 /* --- */
 
@@ -693,38 +596,25 @@ assert(rc == QMCKL_NOT_PROVIDED);
 
 
 rc = qmckl_set_nucleus_num (context, chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(!qmckl_nucleus_provided(context));
 
 rc = qmckl_get_nucleus_num (context, &n);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert(n == chbrclf_nucl_num);
 
-double k;
-rc = qmckl_get_nucleus_rescale_factor (context, &k);
-assert(rc == QMCKL_SUCCESS);
-assert(k == 1.0);
-
-
-rc = qmckl_set_nucleus_rescale_factor (context, nucl_rescale_factor_kappa);
-assert(rc == QMCKL_SUCCESS);
-
-rc = qmckl_get_nucleus_rescale_factor (context, &k);
-assert(rc == QMCKL_SUCCESS);
-assert(k == nucl_rescale_factor_kappa);
-
 double nucl_coord2[3*chbrclf_nucl_num];
 
 rc = qmckl_get_nucleus_coord (context, 'T', nucl_coord2, 3*chbrclf_nucl_num);
 assert(rc == QMCKL_NOT_PROVIDED);
 
 rc = qmckl_set_nucleus_coord (context, 'T', &(nucl_coord[0]), 3*chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 assert(!qmckl_nucleus_provided(context));
 
 rc = qmckl_get_nucleus_coord (context, 'N', nucl_coord2, 3*chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (size_t k=0 ; k<3 ; ++k) {
   for (int64_t i=0 ; i<chbrclf_nucl_num ; ++i) {
     assert( nucl_coord[chbrclf_nucl_num*k+i] == nucl_coord2[3*i+k] );
@@ -732,7 +622,7 @@ for (size_t k=0 ; k<3 ; ++k) {
 }
 
 rc = qmckl_get_nucleus_coord (context, 'T', nucl_coord2, 3*chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int64_t i=0 ; i<3*chbrclf_nucl_num ; ++i) {
   assert( nucl_coord[i] == nucl_coord2[i] );
 }
@@ -743,10 +633,10 @@ rc = qmckl_get_nucleus_charge(context, nucl_charge2, chbrclf_nucl_num);
 assert(rc == QMCKL_NOT_PROVIDED);
 
 rc = qmckl_set_nucleus_charge(context, nucl_charge, chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 
 rc = qmckl_get_nucleus_charge(context, nucl_charge2, chbrclf_nucl_num);
-assert(rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int64_t i=0 ; i<chbrclf_nucl_num ; ++i) {
   assert( nucl_charge[i] == nucl_charge2[i] );
  }
@@ -952,202 +842,6 @@ assert(fabs(distance[1]-2.070304721365169) < 1.e-12);
 
      #+end_src
 
-** Nucleus-nucleus rescaled distances
-
-*** Get
-
-    #+begin_src c :comments org :tangle (eval h_func) :noweb yes
-qmckl_exit_code
-qmckl_get_nucleus_nn_distance_rescaled(qmckl_context context,
-                                       double* distance_rescaled,
-                                       const int64_t size_max);
-    #+end_src
-
-    #+begin_src c :comments org :tangle (eval c) :noweb yes  :exports none
-qmckl_exit_code
-qmckl_get_nucleus_nn_distance_rescaled(qmckl_context context,
-                                       double* distance_rescaled,
-                                       const int64_t size_max)
-{
- /* Check input parameters */
-  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
-    return (char) 0;
-  }
-
-  qmckl_exit_code rc = qmckl_provide_nn_distance_rescaled(context);
-  if (rc != QMCKL_SUCCESS) return rc;
-
-  qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
-  assert (ctx != NULL);
-
-  const int64_t sze = ctx->nucleus.num * ctx->nucleus.num;
-  if (sze > size_max) {
-    return qmckl_failwith(context,
-                          QMCKL_INVALID_ARG_3,
-                          "qmckl_get_nucleus_nn_distance_rescaled",
-                          "Array too small");
-  }
-  rc = qmckl_double_of_matrix(context,
-                              ctx->nucleus.nn_distance_rescaled,
-                              distance_rescaled,
-                              size_max);
-  return rc;
-}
-    #+end_src
-
-    #+begin_src f90 :tangle (eval fh_func) :comments org :exports none
-interface
-  integer(c_int32_t) function qmckl_get_nucleus_nn_distance_rescaled(context, distance_rescaled, size_max) &
-    bind(C)
-    use, intrinsic :: iso_c_binding
-    import
-    implicit none
-    integer (c_int64_t) , intent(in)  , value :: context
-    real    (c_double ) , intent(out)         :: distance_rescaled(*)
-    integer (c_int64_t) , intent(in)  , value :: size_max
-  end function
-end interface
-    #+end_src
-
-*** Provide                                                        :noexport:
-
-    #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none
-qmckl_exit_code qmckl_provide_nn_distance_rescaled(qmckl_context context);
-    #+end_src
-
-    #+begin_src c :comments org :tangle (eval c) :noweb yes  :exports none
-qmckl_exit_code qmckl_provide_nn_distance_rescaled(qmckl_context context)
-{
- /* Check input parameters */
-  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
-    return (char) 0;
-  }
-
-  qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
-  assert (ctx != NULL);
-
-  if (!ctx->nucleus.provided) return QMCKL_NOT_PROVIDED;
-
- /* Allocate array */
-  if (ctx->nucleus.nn_distance_rescaled.data == NULL) {
-    ctx->nucleus.nn_distance_rescaled =
-      qmckl_matrix_alloc(context, ctx->nucleus.num, ctx->nucleus.num);
-
-    if (ctx->nucleus.nn_distance_rescaled.data == NULL) {
-      return qmckl_failwith( context,
-                             QMCKL_ALLOCATION_FAILED,
-                             "qmckl_nn_distance_rescaled",
-                             NULL);
-    }
-  }
-
-  qmckl_exit_code rc =
-    qmckl_compute_nn_distance_rescaled(context,
-                              ctx->nucleus.num,
-                              ctx->nucleus.rescale_factor_kappa,
-                              ctx->nucleus.coord.data,
-                              ctx->nucleus.nn_distance_rescaled.data);
-  if (rc != QMCKL_SUCCESS) {
-    return rc;
-  }
-
-  ctx->nucleus.nn_distance_rescaled_date = ctx->date;
-
-  return QMCKL_SUCCESS;
-}
-    #+end_src
-
-*** Compute
-
-    #+NAME: qmckl_nn_distance_rescaled_args
-   | qmckl_context | context                                  | in  | Global state                            |
-   | int64_t       | nucl_num                                 | in  | Number of nuclei                        |
-   | double        | coord[3][nucl_num]                       | in  | Nuclear coordinates (au)                |
-   | double        | nn_distance_rescaled[nucl_num][nucl_num] | out | Nucleus-nucleus rescaled distances (au) |
-
-    #+begin_src f90 :comments org :tangle (eval f) :noweb yes
-integer function qmckl_compute_nn_distance_rescaled_f(context, nucl_num, rescale_factor_kappa, coord, nn_distance_rescaled) &
-     result(info)
-  use qmckl
-  implicit none
-  integer(qmckl_context), intent(in)  :: context
-  integer*8             , intent(in)  :: nucl_num
-  double precision      , intent(in)  :: rescale_factor_kappa
-  double precision      , intent(in)  :: coord(nucl_num,3)
-  double precision      , intent(out) :: nn_distance_rescaled(nucl_num,nucl_num)
-
-  integer*8 :: k
-
-  info = QMCKL_SUCCESS
-
-  if (context == QMCKL_NULL_CONTEXT) then
-     info = QMCKL_INVALID_CONTEXT
-     return
-  endif
-
-  if (nucl_num <= 0) then
-     info = QMCKL_INVALID_ARG_2
-     return
-  endif
-
-  info = qmckl_distance_rescaled(context, 'T', 'T', nucl_num, nucl_num, &
-          coord, nucl_num, &
-          coord, nucl_num, &
-          nn_distance_rescaled, nucl_num, rescale_factor_kappa)
-
-end function qmckl_compute_nn_distance_rescaled_f
-    #+end_src
-
-    #+begin_src c :tangle (eval h_private_func) :comments org :exports none
-qmckl_exit_code qmckl_compute_nn_distance_rescaled (
-                                                    const qmckl_context context,
-          const int64_t nucl_num,
-          const double  rescale_factor_kappa,
-          const double* coord,
-          double* const nn_distance_rescaled );
-    #+end_src
-
-
-    #+CALL: generate_c_interface(table=qmckl_nn_distance_rescaled_args,rettyp="qmckl_exit_code",fname="qmckl_compute_nn_distance")
-
-    #+RESULTS:
-    #+begin_src f90 :tangle (eval f) :comments org :exports none
-    integer(c_int32_t) function qmckl_compute_nn_distance_rescaled &
-        (context, nucl_num, rescale_factor_kappa, coord, nn_distance_rescaled) &
-        bind(C) result(info)
-
-      use, intrinsic :: iso_c_binding
-      implicit none
-
-      integer (c_int64_t) , intent(in)  , value :: context
-      integer (c_int64_t) , intent(in)  , value :: nucl_num
-      real    (c_double ) , intent(in)  , value :: rescale_factor_kappa
-      real    (c_double ) , intent(in)          :: coord(nucl_num,3)
-      real    (c_double ) , intent(out)         :: nn_distance_rescaled(nucl_num,nucl_num)
-
-      integer(c_int32_t), external :: qmckl_compute_nn_distance_rescaled_f
-      info = qmckl_compute_nn_distance_rescaled_f &
-             (context, nucl_num, rescale_factor_kappa, coord, nn_distance_rescaled)
-
-    end function qmckl_compute_nn_distance_rescaled
-    #+end_src
-
-*** Test
-
-     #+begin_src c :tangle (eval c_test)
-/* Reference input data */
-/* TODO */
-
-//assert(qmckl_nucleus_provided(context));
-//
-//double distance[nucl_num*nucl_num];
-//rc = qmckl_get_nucleus_nn_distance(context, distance, nucl_num*nucl_num);
-//assert(distance[0] == 0.);
-//assert(distance[1] == distance[nucl_num]);
-//assert(fabs(distance[1]-2.070304721365169) < 1.e-12);
-
-     #+end_src
-
 ** Nuclear repulsion energy
 
    \[

org/qmckl_trexio.org

@@ -1097,37 +1097,25 @@ qmckl_trexio_read(const qmckl_context context, const char* file_name, const int6
   rc = qmckl_trexio_read_electron_X(context, file);
   if (rc != QMCKL_SUCCESS) {
     trexio_close(file);
-    return qmckl_failwith( context,
+    return rc;
-                           QMCKL_FAILURE,
-                           "qmckl_trexio_read",
-                           "Error reading electron");
   }
 
   rc = qmckl_trexio_read_nucleus_X(context, file);
   if (rc != QMCKL_SUCCESS) {
     trexio_close(file);
-    return qmckl_failwith( context,
+    return rc;
-                           QMCKL_FAILURE,
-                           "qmckl_trexio_read",
-                           "Error reading nucleus");
   }
 
   rc = qmckl_trexio_read_ao_X(context, file);
   if (rc != QMCKL_SUCCESS) {
     trexio_close(file);
-    return qmckl_failwith( context,
+    return rc;
-                           QMCKL_FAILURE,
-                           "qmckl_trexio_read",
-                           "Error reading AOs");
   }
 
   rc = qmckl_trexio_read_mo_X(context, file);
   if (rc != QMCKL_SUCCESS) {
     trexio_close(file);
-    return qmckl_failwith( context,
+    return rc;
-                           QMCKL_FAILURE,
-                           "qmckl_trexio_read",
-                           "Error reading MOs");
   }
 
   trexio_close(file);
@@ -1149,27 +1137,19 @@ qmckl_trexio_read(const qmckl_context context, const char* file_name, const int6
 #ifdef HAVE_TREXIO
 
 qmckl_exit_code rc;
-char fname[256];
+char filename[256];
-char message[256];
 
 #ifndef QMCKL_TEST_DIR
 #error "QMCKL_TEST_DIR is not defined"
 #endif
 
-strncpy(fname, QMCKL_TEST_DIR,255);
+strncpy(filename, QMCKL_TEST_DIR,255);
-strncat(fname, "/chbrclf", 255);
+strncat(filename, "/chbrclf", 255);
-printf("Test file: %s\n", fname);
+printf("Test file: %s\n", filename);
 
-rc = qmckl_trexio_read(context, fname, 255);
+rc = qmckl_trexio_read(context, filename, 255);
 
-if (rc != QMCKL_SUCCESS) {
+qmckl_check(context, rc);
-  printf("%s\n", qmckl_string_of_error(rc));
-  qmckl_get_error(context, &rc, fname, message);
-  printf("%s\n", fname);
-  printf("%s\n", message);
- }
-
-assert ( rc == QMCKL_SUCCESS );
 
   #+end_src
 
@@ -1179,11 +1159,11 @@ assert ( rc == QMCKL_SUCCESS );
 printf("Electrons\n");
 int64_t up_num, dn_num;
 rc = qmckl_get_electron_up_num(context, &up_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert (up_num == chbrclf_elec_up_num);
 
 rc = qmckl_get_electron_down_num(context, &dn_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert (dn_num == chbrclf_elec_dn_num);
 
   #+end_src
@@ -1195,13 +1175,13 @@ printf("Nuclei\n");
 
 int64_t nucl_num;
 rc = qmckl_get_nucleus_num(context, &nucl_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 assert (nucl_num == chbrclf_nucl_num);
 
 printf("Nuclear charges\n");
 double * charge = (double*) malloc (nucl_num * sizeof(double));
 rc = qmckl_get_nucleus_charge(context, charge, nucl_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<nucl_num ; i++) {
   assert (charge[i] == chbrclf_charge[i]);
  }
@@ -1211,7 +1191,7 @@ charge = NULL;
 printf("Nuclear coordinates\n");
 double * coord  = (double*) malloc (nucl_num * 3 * sizeof(double));
 rc = qmckl_get_nucleus_coord(context, 'T', coord, 3*nucl_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 int k=0;
 for (int j=0 ; j<3 ; ++j) {
   for (int i=0 ; i<nucl_num ; ++i) {
@@ -1248,7 +1228,7 @@ assert (ao_num == chbrclf_ao_num);
 
 int64_t* nucleus_index = (int64_t*) malloc (nucl_num * sizeof(int64_t));
 rc = qmckl_get_ao_basis_nucleus_index(context, nucleus_index, nucl_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<nucl_num ; i++) {
   assert (nucleus_index[i] == chbrclf_basis_nucleus_index[i]);
  }
@@ -1257,7 +1237,7 @@ nucleus_index = NULL;
 
 int64_t* nucleus_shell_num  = (int64_t*) malloc (nucl_num * sizeof(int64_t));
 rc = qmckl_get_ao_basis_nucleus_shell_num(context, nucleus_shell_num, nucl_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<nucl_num ; i++) {
   assert (nucleus_shell_num[i] == chbrclf_basis_nucleus_shell_num[i]);
  }
@@ -1266,7 +1246,7 @@ nucleus_shell_num = NULL;
 
 int32_t* shell_ang_mom  = (int32_t*) malloc (shell_num * sizeof(int32_t));
 rc = qmckl_get_ao_basis_shell_ang_mom(context, shell_ang_mom, shell_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<shell_num ; i++) {
   assert (shell_ang_mom[i] == chbrclf_basis_shell_ang_mom[i]);
  }
@@ -1275,7 +1255,7 @@ shell_ang_mom = NULL;
 
 int64_t* shell_prim_num  = (int64_t*) malloc (shell_num * sizeof(int64_t));
 rc = qmckl_get_ao_basis_shell_prim_num(context, shell_prim_num, shell_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<shell_num ; i++) {
   assert (shell_prim_num[i] == chbrclf_basis_shell_prim_num[i]);
  }
@@ -1284,7 +1264,7 @@ shell_prim_num = NULL;
 
 int64_t* shell_prim_index  = (int64_t*) malloc (shell_num * sizeof(int64_t));
 rc = qmckl_get_ao_basis_shell_prim_index(context, shell_prim_index, shell_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<shell_num ; i++) {
   assert (shell_prim_index[i] == chbrclf_basis_shell_prim_index[i]);
  }
@@ -1293,7 +1273,7 @@ shell_prim_index = NULL;
 
 double* shell_factor = (double*) malloc (shell_num * sizeof(double));
 rc = qmckl_get_ao_basis_shell_factor(context, shell_factor, shell_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<shell_num ; i++) {
   assert (fabs(shell_factor[i] - chbrclf_basis_shell_factor[i]) < 1.e-6);
  }
@@ -1302,7 +1282,7 @@ shell_factor = NULL;
 
 double* exponent = (double*) malloc (prim_num * sizeof(double));
 rc = qmckl_get_ao_basis_exponent(context, exponent, prim_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<prim_num ; i++) {
   assert (fabs((exponent[i] - chbrclf_basis_exponent[i])/chbrclf_basis_exponent[i]) < 1.e-7);
  }
@@ -1311,7 +1291,7 @@ exponent = NULL;
 
 double* coefficient = (double*) malloc (prim_num * sizeof(double));
 rc = qmckl_get_ao_basis_coefficient(context, coefficient, prim_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<prim_num ; i++) {
   assert (fabs((coefficient[i] - chbrclf_basis_coefficient[i])/chbrclf_basis_coefficient[i]) < 1.e-7);
  }
@@ -1320,7 +1300,7 @@ coefficient = NULL;
 
 double* prim_factor = (double*) malloc (prim_num * sizeof(double));
 rc = qmckl_get_ao_basis_prim_factor(context, prim_factor, prim_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<prim_num ; i++) {
   assert (fabs((prim_factor[i] - chbrclf_basis_prim_factor[i])/chbrclf_basis_prim_factor[i]) < 1.e-7);
  }
@@ -1337,13 +1317,14 @@ printf("MOs\n");
 
 int64_t mo_num;
 rc = qmckl_get_mo_basis_mo_num(context, &mo_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
+
 assert (mo_num == chbrclf_mo_num);
 
 printf("MO coefs\n");
 double * mo_coef = (double*) malloc (ao_num * mo_num * sizeof(double));
 rc = qmckl_get_mo_basis_coefficient(context, mo_coef, mo_num*ao_num);
-assert (rc == QMCKL_SUCCESS);
+qmckl_check(context, rc);
 for (int i=0 ; i<ao_num * mo_num ; i++) {
   printf("%d %e %e %e\n", i, mo_coef[i], chbrclf_mo_coef[i], 
          ( fabs(mo_coef[i] - chbrclf_mo_coef[i])/fabs(mo_coef[i])) );