diff --git a/org/qmckl_distance.org b/org/qmckl_distance.org index ecb9601..301a542 100644 --- a/org/qmckl_distance.org +++ b/org/qmckl_distance.org @@ -1167,14 +1167,14 @@ end function qmckl_distance_rescaled_f *** Test :noexport: * Rescaled Distance Derivatives -** ~qmckl_distance_rescaled_deriv_e~ +** ~qmckl_distance_rescaled_gl~ :PROPERTIES: - :Name: qmckl_distance_rescaled_deriv_e + :Name: qmckl_distance_rescaled_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - ~qmckl_distance_rescaled_deriv_e~ computes the matrix of the gradient and laplacian of the + ~qmckl_distance_rescaled_gl~ computes the matrix of the gradient and laplacian of the rescaled distance with respect to the electron coordinates. The derivative is a rank 3 tensor. The first dimension has a dimension of 4 of which the first three coordinates contains the gradient vector and the last index is the laplacian. @@ -1217,7 +1217,7 @@ end function qmckl_distance_rescaled_f If the input array is normal (~'N'~), the xyz coordinates are in the leading dimension: ~[n][3]~ in C and ~(3,n)~ in Fortran. - #+NAME: qmckl_distance_rescaled_deriv_e_args + #+NAME: qmckl_distance_rescaled_gl_args | Variable | Type | In/Out | Description | |------------------------+---------------------+--------+-------------------------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -1247,11 +1247,11 @@ end function qmckl_distance_rescaled_f - ~B~ is allocated with at least $3 \times n \times 8$ bytes - ~C~ is allocated with at least $4 \times m \times n \times 8$ bytes - #+CALL: generate_c_header(table=qmckl_distance_rescaled_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_header(table=qmckl_distance_rescaled_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src c :tangle (eval h_func) :comments org - qmckl_exit_code qmckl_distance_rescaled_deriv_e ( + qmckl_exit_code qmckl_distance_rescaled_gl ( const qmckl_context context, const char transa, const char transb, @@ -1267,7 +1267,7 @@ end function qmckl_distance_rescaled_f #+end_src #+begin_src f90 :tangle (eval f) -integer function qmckl_distance_rescaled_deriv_e_f(context, transa, transb, m, n, & +integer function qmckl_distance_rescaled_gl_f(context, transa, transb, m, n, & A, LDA, B, LDB, C, LDC, rescale_factor_kappa) & result(info) use qmckl @@ -1449,16 +1449,16 @@ integer function qmckl_distance_rescaled_deriv_e_f(context, transa, transb, m, n end select -end function qmckl_distance_rescaled_deriv_e_f +end function qmckl_distance_rescaled_gl_f #+end_src This function is more efficient when ~A~ and ~B~ are transposed. - #+CALL: generate_c_interface(table=qmckl_distance_rescaled_deriv_e_args,fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_distance_rescaled_gl_args,fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_distance_rescaled_deriv_e & + integer(c_int32_t) function qmckl_distance_rescaled_gl & (context, transa, transb, m, n, A, lda, B, ldb, C, ldc, rescale_factor_kappa) & bind(C) result(info) @@ -1478,19 +1478,19 @@ end function qmckl_distance_rescaled_deriv_e_f integer (c_int64_t) , intent(in) , value :: ldc real (c_double ) , intent(in) , value :: rescale_factor_kappa - integer(c_int32_t), external :: qmckl_distance_rescaled_deriv_e_f - info = qmckl_distance_rescaled_deriv_e_f & + integer(c_int32_t), external :: qmckl_distance_rescaled_gl_f + info = qmckl_distance_rescaled_gl_f & (context, transa, transb, m, n, A, lda, B, ldb, C, ldc, rescale_factor_kappa) - end function qmckl_distance_rescaled_deriv_e + end function qmckl_distance_rescaled_gl #+end_src - #+CALL: generate_f_interface(table=qmckl_distance_rescaled_deriv_e_args,rettyp=get_value("FRetType"),fname=get_value("Name")) + #+CALL: generate_f_interface(table=qmckl_distance_rescaled_gl_args,rettyp=get_value("FRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval fh_func) :comments org :exports none interface - integer(c_int32_t) function qmckl_distance_rescaled_deriv_e & + integer(c_int32_t) function qmckl_distance_rescaled_gl & (context, transa, transb, m, n, A, lda, B, ldb, C, ldc, rescale_factor_kappa) & bind(C) use, intrinsic :: iso_c_binding @@ -1510,7 +1510,7 @@ end function qmckl_distance_rescaled_deriv_e_f integer (c_int64_t) , intent(in) , value :: ldc real (c_double ) , intent(in) , value :: rescale_factor_kappa - end function qmckl_distance_rescaled_deriv_e + end function qmckl_distance_rescaled_gl end interface #+end_src diff --git a/org/qmckl_jastrow_champ.org b/org/qmckl_jastrow_champ.org index 1470b90..0fb7d79 100644 --- a/org/qmckl_jastrow_champ.org +++ b/org/qmckl_jastrow_champ.org @@ -150,50 +150,50 @@ int main() { Computed data: - | Variable | Type | In/Out | - |-------------------------------------+-----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------| - | ~dim_c_vector~ | ~int64_t~ | Number of unique C coefficients | - | ~dim_c_vector_date~ | ~uint64_t~ | Number of unique C coefficients | - | ~asymp_jasa~ | ~double[type_nucl_num]~ | Asymptotic component | - | ~asymp_jasa_date~ | ~uint64_t~ | Ladt modification of the asymptotic component | - | ~asymp_jasb~ | ~double[2]~ | Asymptotic component (up- or down-spin) | - | ~asymp_jasb_date~ | ~uint64_t~ | Ladt modification of the asymptotic component | - | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | vector of non-zero coefficients | - | ~c_vector_full_date~ | ~uint64_t~ | Keep track of changes here | - | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | Transform l,k,p, and m into consecutive indices | - | ~lkpm_combined_index_date~ | ~uint64_t~ | Transform l,k,p, and m into consecutive indices | - | ~tmp_c~ | ~double[walk_num][cord_num][cord_num+1][nucl_num][elec_num]~ | vector of non-zero coefficients | - | ~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_deriv_e~ | ~double[walk_num][4][num][num]~ | Electron-electron rescaled distances derivatives | - | ~ee_distance_rescaled_deriv_e_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_deriv_e~ | ~double[walk_num][4][nucl_num][num]~ | Electron-electron rescaled distances derivatives | - | ~en_distance_rescaled_deriv_e_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 | - | ~een_rescaled_e_deriv_e~ | ~double[walk_num][cord_num+1][elec_num][4][elec_num]~ | The electron-electron rescaled distances raised to the powers defined by cord derivatives wrt electrons | - | ~een_rescaled_e_deriv_e_date~ | ~uint64_t~ | Keep track of the date of creation | - | ~een_rescaled_n_deriv_e~ | ~double[walk_num][cord_num+1][nucl_num][4][elec_num]~ | The electron-electron rescaled distances raised to the powers defined by cord derivatives wrt electrons | - | ~een_rescaled_n_deriv_e_date~ | ~uint64_t~ | Keep track of the date of creation | - | ~factor_ee~ | ~double[walk_num]~ | Jastrow factor: electron-electron part | - | ~factor_ee_date~ | ~uint64_t~ | Jastrow factor: electron-electron part | - | ~factor_en~ | ~double[walk_num]~ | Jastrow factor: electron-nucleus part | - | ~factor_en_date~ | ~uint64_t~ | Jastrow factor: electron-nucleus part | - | ~factor_een~ | ~double[walk_num]~ | Jastrow factor: electron-electron-nucleus part | - | ~factor_een_date~ | ~uint64_t~ | Jastrow factor: electron-electron-nucleus part | - | ~factor_ee_deriv_e~ | ~double[walk_num][4][elec_num]~ | Derivative of the Jastrow factor: electron-electron-nucleus part | - | ~factor_ee_deriv_e_date~ | ~uint64_t~ | Keep track of the date for the derivative | - | ~factor_en_deriv_e~ | ~double[walk_num][4][elec_num]~ | Derivative of the Jastrow factor: electron-electron-nucleus part | - | ~factor_en_deriv_e_date~ | ~uint64_t~ | Keep track of the date for the en derivative | - | ~factor_een_deriv_e~ | ~double[walk_num][4][elec_num]~ | Derivative of the Jastrow factor: electron-electron-nucleus part | - | ~factor_een_deriv_e_date~ | ~uint64_t~ | Keep track of the date for the een derivative | - | ~value~ | ~double[walk_num]~ | Value of the Jastrow factor | - | ~value_date~ | ~uint64_t~ | Keep track of the date | - | ~gl~ | ~double[walk_num][4][elec_num]~ | Gradient and Laplacian of the Jastrow factor | - | ~value_date~ | ~uint64_t~ | Keep track of the date | + | Variable | Type | In/Out | + |--------------------------------+-----------------------------------------------------------------+---------------------------------------------------------------------------------------------------------| + | ~dim_c_vector~ | ~int64_t~ | Number of unique C coefficients | + | ~dim_c_vector_date~ | ~uint64_t~ | Number of unique C coefficients | + | ~asymp_jasa~ | ~double[type_nucl_num]~ | Asymptotic component | + | ~asymp_jasa_date~ | ~uint64_t~ | Ladt modification of the asymptotic component | + | ~asymp_jasb~ | ~double[2]~ | Asymptotic component (up- or down-spin) | + | ~asymp_jasb_date~ | ~uint64_t~ | Ladt modification of the asymptotic component | + | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | vector of non-zero coefficients | + | ~c_vector_full_date~ | ~uint64_t~ | Keep track of changes here | + | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | Transform l,k,p, and m into consecutive indices | + | ~lkpm_combined_index_date~ | ~uint64_t~ | Transform l,k,p, and m into consecutive indices | + | ~tmp_c~ | ~double[walk_num][cord_num][cord_num+1][nucl_num][elec_num]~ | vector of non-zero coefficients | + | ~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_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_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 | + | ~een_rescaled_e_gl~ | ~double[walk_num][cord_num+1][elec_num][4][elec_num]~ | The electron-electron rescaled distances raised to the powers defined by cord derivatives wrt electrons | + | ~een_rescaled_e_gl_date~ | ~uint64_t~ | Keep track of the date of creation | + | ~een_rescaled_n_gl~ | ~double[walk_num][cord_num+1][nucl_num][4][elec_num]~ | The electron-electron rescaled distances raised to the powers defined by cord derivatives wrt electrons | + | ~een_rescaled_n_gl_date~ | ~uint64_t~ | Keep track of the date of creation | + | ~factor_ee~ | ~double[walk_num]~ | Jastrow factor: electron-electron part | + | ~factor_ee_date~ | ~uint64_t~ | Jastrow factor: electron-electron part | + | ~factor_en~ | ~double[walk_num]~ | Jastrow factor: electron-nucleus part | + | ~factor_en_date~ | ~uint64_t~ | Jastrow factor: electron-nucleus part | + | ~factor_een~ | ~double[walk_num]~ | Jastrow factor: electron-electron-nucleus part | + | ~factor_een_date~ | ~uint64_t~ | Jastrow factor: electron-electron-nucleus part | + | ~factor_ee_gl~ | ~double[walk_num][4][elec_num]~ | Derivative of the Jastrow factor: electron-electron-nucleus part | + | ~factor_ee_gl_date~ | ~uint64_t~ | Keep track of the date for the derivative | + | ~factor_en_gl~ | ~double[walk_num][4][elec_num]~ | Derivative of the Jastrow factor: electron-electron-nucleus part | + | ~factor_en_gl_date~ | ~uint64_t~ | Keep track of the date for the en derivative | + | ~factor_een_gl~ | ~double[walk_num][4][elec_num]~ | Derivative of the Jastrow factor: electron-electron-nucleus part | + | ~factor_een_gl_date~ | ~uint64_t~ | Keep track of the date for the een derivative | + | ~value~ | ~double[walk_num]~ | Value of the Jastrow factor | + | ~value_date~ | ~uint64_t~ | Keep track of the date | + | ~gl~ | ~double[walk_num][4][elec_num]~ | Gradient and Laplacian of the Jastrow factor | + | ~value_date~ | ~uint64_t~ | Keep track of the date | #+NAME: jastrow_data #+BEGIN_SRC python :results none :exports none @@ -361,19 +361,19 @@ typedef struct qmckl_jastrow_champ_struct{ double * restrict c_vector_full; double * restrict dtmp_c; double * restrict ee_distance_rescaled; - double * restrict ee_distance_rescaled_deriv_e; + double * restrict ee_distance_rescaled_gl; double * restrict een_rescaled_e; - double * restrict een_rescaled_e_deriv_e; + double * restrict een_rescaled_e_gl; double * restrict een_rescaled_n; - double * restrict een_rescaled_n_deriv_e; + double * restrict een_rescaled_n_gl; double * restrict en_distance_rescaled; - double * restrict en_distance_rescaled_deriv_e; + double * restrict en_distance_rescaled_gl; double * restrict factor_ee; - double * restrict factor_ee_deriv_e; + double * restrict factor_ee_gl; double * restrict factor_een; - double * restrict factor_een_deriv_e; + double * restrict factor_een_gl; double * restrict factor_en; - double * restrict factor_en_deriv_e; + double * restrict factor_en_gl; double * restrict rescale_factor_en; double * restrict tmp_c; double * restrict value; @@ -389,19 +389,19 @@ typedef struct qmckl_jastrow_champ_struct{ uint64_t dim_c_vector_date; uint64_t dtmp_c_date; uint64_t ee_distance_rescaled_date; - uint64_t ee_distance_rescaled_deriv_e_date; + uint64_t ee_distance_rescaled_gl_date; uint64_t een_rescaled_e_date; - uint64_t een_rescaled_e_deriv_e_date; + uint64_t een_rescaled_e_gl_date; uint64_t een_rescaled_n_date; - uint64_t een_rescaled_n_deriv_e_date; + uint64_t een_rescaled_n_gl_date; uint64_t en_distance_rescaled_date; - uint64_t en_distance_rescaled_deriv_e_date; + uint64_t en_distance_rescaled_gl_date; uint64_t factor_ee_date; - uint64_t factor_ee_deriv_e_date; + uint64_t factor_ee_gl_date; uint64_t factor_een_date; - uint64_t factor_een_deriv_e_date; + uint64_t factor_een_gl_date; uint64_t factor_en_date; - uint64_t factor_en_deriv_e_date; + uint64_t factor_en_gl_date; uint64_t lkpm_combined_index_date; uint64_t tmp_c_date; uint64_t value_date; @@ -2546,7 +2546,8 @@ assert(fabs(factor_ee[0]+4.282760865958113) < 1.e-12); *** Derivative The derivative of ~factor_ee~ is computed using the ~ee_distance_rescaled~ and - the electron-electron rescaled distances derivatives ~ee_distance_rescaled_deriv_e~. + the electron-electron rescaled distances derivatives + ~ee_distance_rescaled_gl~. There are four components, the gradient which has 3 components in the \(x, y, z\) directions and the laplacian as the last component. @@ -2564,15 +2565,15 @@ assert(fabs(factor_ee[0]+4.282760865958113) < 1.e-12); **** Get #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code -qmckl_get_jastrow_champ_factor_ee_deriv_e(qmckl_context context, - double* const factor_ee_deriv_e, +qmckl_get_jastrow_champ_factor_ee_gl(qmckl_context context, + double* const factor_ee_gl, const int64_t size_max); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code -qmckl_get_jastrow_champ_factor_ee_deriv_e(qmckl_context context, - double* const factor_ee_deriv_e, +qmckl_get_jastrow_champ_factor_ee_gl(qmckl_context context, + double* const factor_ee_gl, const int64_t size_max) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -2581,7 +2582,7 @@ qmckl_get_jastrow_champ_factor_ee_deriv_e(qmckl_context context, qmckl_exit_code rc; - rc = qmckl_provide_jastrow_champ_factor_ee_deriv_e(context); + rc = qmckl_provide_jastrow_champ_factor_ee_gl(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; @@ -2591,11 +2592,11 @@ qmckl_get_jastrow_champ_factor_ee_deriv_e(qmckl_context context, if (size_max < sze) { return qmckl_failwith( context, QMCKL_INVALID_ARG_3, - "qmckl_get_jastrow_champ_factor_ee_deriv_e", + "qmckl_get_jastrow_champ_factor_ee_gl", "Array too small. Expected 4*walk_num*elec_num"); } - memcpy(factor_ee_deriv_e, ctx->jastrow_champ.factor_ee_deriv_e, sze * sizeof(double)); + memcpy(factor_ee_gl, ctx->jastrow_champ.factor_ee_gl, sze * sizeof(double)); return QMCKL_SUCCESS; } @@ -2605,25 +2606,25 @@ qmckl_get_jastrow_champ_factor_ee_deriv_e(qmckl_context context, #+begin_src f90 :tangle (eval fh_func) :comments org interface - integer(qmckl_exit_code) function qmckl_get_jastrow_champ_factor_ee_deriv_e (context, & - factor_ee_deriv_e, size_max) bind(C) + integer(qmckl_exit_code) function qmckl_get_jastrow_champ_factor_ee_gl (context, & + factor_ee_gl, size_max) bind(C) use, intrinsic :: iso_c_binding import implicit none integer (qmckl_context) , intent(in), value :: context integer(c_int64_t), intent(in), value :: size_max - double precision, intent(out) :: factor_ee_deriv_e(size_max) - end function qmckl_get_jastrow_champ_factor_ee_deriv_e + double precision, intent(out) :: factor_ee_gl(size_max) + end function qmckl_get_jastrow_champ_factor_ee_gl 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_jastrow_champ_factor_ee_deriv_e(qmckl_context context); +qmckl_exit_code qmckl_provide_jastrow_champ_factor_ee_gl(qmckl_context context); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_provide_jastrow_champ_factor_ee_deriv_e(qmckl_context context) +qmckl_exit_code qmckl_provide_jastrow_champ_factor_ee_gl(qmckl_context context) { qmckl_exit_code rc; @@ -2631,7 +2632,7 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_ee_deriv_e(qmckl_context cont if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { return qmckl_failwith( context, QMCKL_INVALID_CONTEXT, - "qmckl_provide_jastrow_champ_factor_ee_deriv_e", + "qmckl_provide_jastrow_champ_factor_ee_gl", NULL); } @@ -2641,7 +2642,7 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_ee_deriv_e(qmckl_context cont if (!ctx->jastrow_champ.provided) { return qmckl_failwith( context, QMCKL_NOT_PROVIDED, - "qmckl_provide_jastrow_champ_factor_ee_deriv_e", + "qmckl_provide_jastrow_champ_factor_ee_gl", NULL); } @@ -2650,49 +2651,49 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_ee_deriv_e(qmckl_context cont if(rc != QMCKL_SUCCESS) return rc; /* Check if ee rescaled distance deriv e is provided */ - rc = qmckl_provide_ee_distance_rescaled_deriv_e(context); + rc = qmckl_provide_ee_distance_rescaled_gl(context); if(rc != QMCKL_SUCCESS) return rc; /* Compute if necessary */ - if (ctx->date > ctx->jastrow_champ.factor_ee_deriv_e_date) { + if (ctx->date > ctx->jastrow_champ.factor_ee_gl_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow_champ.factor_ee_deriv_e != NULL) { - rc = qmckl_free(context, ctx->jastrow_champ.factor_ee_deriv_e); + if (ctx->jastrow_champ.factor_ee_gl != NULL) { + rc = qmckl_free(context, ctx->jastrow_champ.factor_ee_gl); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_jastrow_champ_factor_ee_deriv_e", - "Unable to free ctx->jastrow_champ.factor_ee_deriv_e"); + "qmckl_provide_jastrow_champ_factor_ee_gl", + "Unable to free ctx->jastrow_champ.factor_ee_gl"); } - ctx->jastrow_champ.factor_ee_deriv_e = NULL; + ctx->jastrow_champ.factor_ee_gl = NULL; } } /* Allocate array */ - if (ctx->jastrow_champ.factor_ee_deriv_e == NULL) { + if (ctx->jastrow_champ.factor_ee_gl == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; mem_info.size = ctx->electron.walker.num * 4 * ctx->electron.num * sizeof(double); - double* factor_ee_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* factor_ee_gl = (double*) qmckl_malloc(context, mem_info); - if (factor_ee_deriv_e == NULL) { + if (factor_ee_gl == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_jastrow_champ_factor_ee_deriv_e", + "qmckl_provide_jastrow_champ_factor_ee_gl", NULL); } - ctx->jastrow_champ.factor_ee_deriv_e = factor_ee_deriv_e; + ctx->jastrow_champ.factor_ee_gl = factor_ee_gl; } - rc = qmckl_compute_jastrow_champ_factor_ee_deriv_e(context, + rc = qmckl_compute_jastrow_champ_factor_ee_gl(context, ctx->electron.walker.num, ctx->electron.num, ctx->electron.up_num, ctx->jastrow_champ.bord_num, ctx->jastrow_champ.b_vector, ctx->jastrow_champ.ee_distance_rescaled, - ctx->jastrow_champ.ee_distance_rescaled_deriv_e, - ctx->jastrow_champ.factor_ee_deriv_e); + ctx->jastrow_champ.ee_distance_rescaled_gl, + ctx->jastrow_champ.factor_ee_gl); if (rc != QMCKL_SUCCESS) { return rc; } @@ -2706,29 +2707,29 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_ee_deriv_e(qmckl_context cont **** Compute :PROPERTIES: - :Name: qmckl_compute_jastrow_champ_factor_ee_deriv_e + :Name: qmckl_compute_jastrow_champ_factor_ee_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_factor_ee_deriv_e_args - | Variable | Type | In/Out | Description | - |--------------------------------+-------------------------------------------+--------+-----------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~walk_num~ | ~int64_t~ | in | Number of walkers | - | ~elec_num~ | ~int64_t~ | in | Number of electrons | - | ~up_num~ | ~int64_t~ | in | Number of alpha electrons | - | ~bord_num~ | ~int64_t~ | in | Number of coefficients | - | ~b_vector~ | ~double[bord_num+1]~ | in | List of coefficients | - | ~ee_distance_rescaled~ | ~double[walk_num][elec_num][elec_num]~ | in | Electron-electron distances | - | ~ee_distance_rescaled_deriv_e~ | ~double[walk_num][4][elec_num][elec_num]~ | in | Electron-electron distances | - | ~factor_ee_deriv_e~ | ~double[walk_num][4][elec_num]~ | out | Electron-electron distances | + #+NAME: qmckl_factor_ee_gl_args + | Variable | Type | In/Out | Description | + |---------------------------+-------------------------------------------+--------+-----------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~walk_num~ | ~int64_t~ | in | Number of walkers | + | ~elec_num~ | ~int64_t~ | in | Number of electrons | + | ~up_num~ | ~int64_t~ | in | Number of alpha electrons | + | ~bord_num~ | ~int64_t~ | in | Number of coefficients | + | ~b_vector~ | ~double[bord_num+1]~ | in | List of coefficients | + | ~ee_distance_rescaled~ | ~double[walk_num][elec_num][elec_num]~ | in | Electron-electron distances | + | ~ee_distance_rescaled_gl~ | ~double[walk_num][4][elec_num][elec_num]~ | in | Electron-electron distances | + | ~factor_ee_gl~ | ~double[walk_num][4][elec_num]~ | out | Electron-electron distances | #+begin_src f90 :comments org :tangle (eval f) :noweb yes -integer function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f( & +integer function qmckl_compute_jastrow_champ_factor_ee_gl_doc_f( & context, walk_num, elec_num, up_num, bord_num, & - b_vector, ee_distance_rescaled, ee_distance_rescaled_deriv_e, & - factor_ee_deriv_e) & + b_vector, ee_distance_rescaled, ee_distance_rescaled_gl, & + factor_ee_gl) & result(info) use qmckl implicit none @@ -2736,8 +2737,8 @@ integer function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f( & integer*8 , intent(in) :: walk_num, elec_num, bord_num, up_num double precision , intent(in) :: b_vector(bord_num + 1) double precision , intent(in) :: ee_distance_rescaled(elec_num, elec_num,walk_num) - double precision , intent(in) :: ee_distance_rescaled_deriv_e(4,elec_num, elec_num,walk_num) !TODO - double precision , intent(out) :: factor_ee_deriv_e(elec_num,4,walk_num) + double precision , intent(in) :: ee_distance_rescaled_gl(4,elec_num, elec_num,walk_num) !TODO + double precision , intent(out) :: factor_ee_gl(elec_num,4,walk_num) integer*8 :: i, j, k, nw, ii double precision :: x, x1, kf @@ -2768,7 +2769,7 @@ integer function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f( & endif do nw =1, walk_num - factor_ee_deriv_e(:,:,nw) = 0.0d0 + factor_ee_gl(:,:,nw) = 0.0d0 do i = 1, elec_num do j = 1, elec_num @@ -2780,10 +2781,10 @@ integer function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f( & invdenom = 1.0d0 / denom invdenom2 = invdenom * invdenom - dx(1) = ee_distance_rescaled_deriv_e(1, j, i, nw) - dx(2) = ee_distance_rescaled_deriv_e(2, j, i, nw) - dx(3) = ee_distance_rescaled_deriv_e(3, j, i, nw) - dx(4) = ee_distance_rescaled_deriv_e(4, j, i, nw) + dx(1) = ee_distance_rescaled_gl(1, j, i, nw) + dx(2) = ee_distance_rescaled_gl(2, j, i, nw) + dx(3) = ee_distance_rescaled_gl(3, j, i, nw) + dx(4) = ee_distance_rescaled_gl(4, j, i, nw) grad_c2 = dx(1)*dx(1) + dx(2)*dx(2) + dx(3)*dx(3) @@ -2793,10 +2794,10 @@ integer function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f( & f = b_vector(1) * invdenom2 end if - factor_ee_deriv_e(i,1,nw) = factor_ee_deriv_e(i,1,nw) + f * dx(1) - factor_ee_deriv_e(i,2,nw) = factor_ee_deriv_e(i,2,nw) + f * dx(2) - factor_ee_deriv_e(i,3,nw) = factor_ee_deriv_e(i,3,nw) + f * dx(3) - factor_ee_deriv_e(i,4,nw) = factor_ee_deriv_e(i,4,nw) & + factor_ee_gl(i,1,nw) = factor_ee_gl(i,1,nw) + f * dx(1) + factor_ee_gl(i,2,nw) = factor_ee_gl(i,2,nw) + f * dx(2) + factor_ee_gl(i,3,nw) = factor_ee_gl(i,3,nw) + f * dx(3) + factor_ee_gl(i,4,nw) = factor_ee_gl(i,4,nw) & + f * (dx(4) - 2.d0 * b_vector(2) * grad_c2 * invdenom) @@ -2805,10 +2806,10 @@ integer function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f( & x = 1.d0 do k=2, bord_num f = b_vector(k+1) * kf * x - factor_ee_deriv_e(i,1,nw) = factor_ee_deriv_e(i,1,nw) + f * x1 * dx(1) - factor_ee_deriv_e(i,2,nw) = factor_ee_deriv_e(i,2,nw) + f * x1 * dx(2) - factor_ee_deriv_e(i,3,nw) = factor_ee_deriv_e(i,3,nw) + f * x1 * dx(3) - factor_ee_deriv_e(i,4,nw) = factor_ee_deriv_e(i,4,nw) & + factor_ee_gl(i,1,nw) = factor_ee_gl(i,1,nw) + f * x1 * dx(1) + factor_ee_gl(i,2,nw) = factor_ee_gl(i,2,nw) + f * x1 * dx(2) + factor_ee_gl(i,3,nw) = factor_ee_gl(i,3,nw) + f * x1 * dx(3) + factor_ee_gl(i,4,nw) = factor_ee_gl(i,4,nw) & + f * (x1 * dx(4) + (kf-1.d0) * grad_c2) x = x*x1 kf = kf + 1.d0 @@ -2819,11 +2820,11 @@ integer function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f( & end do -end function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f +end function qmckl_compute_jastrow_champ_factor_ee_gl_doc_f #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes -qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( +qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl_hpc( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -2831,8 +2832,8 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( const int64_t bord_num, const double* b_vector, const double* ee_distance_rescaled, - const double* ee_distance_rescaled_deriv_e, - double* const factor_ee_deriv_e ) { + const double* ee_distance_rescaled_gl, + double* const factor_ee_gl ) { if (context == QMCKL_NULL_CONTEXT) { return QMCKL_INVALID_CONTEXT; @@ -2854,7 +2855,7 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( for (int nw = 0; nw < walk_num; ++nw) { for (int ii = 0; ii < 4; ++ii) { for (int j = 0; j < elec_num; ++j) { - factor_ee_deriv_e[j + ii * elec_num + nw * elec_num * 4] = 0.0; + factor_ee_gl[j + ii * elec_num + nw * elec_num * 4] = 0.0; } } } @@ -2874,16 +2875,16 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( const double xinv = 1.0 / (x0 + 1.0e-18); double dx[4]; - dx[0] = ee_distance_rescaled_deriv_e[0 \ + dx[0] = ee_distance_rescaled_gl[0 \ + j * 4 + i * 4 * elec_num \ + nw * 4 * elec_num * elec_num]; - dx[1] = ee_distance_rescaled_deriv_e[1 \ + dx[1] = ee_distance_rescaled_gl[1 \ + j * 4 + i * 4 * elec_num \ + nw * 4 * elec_num * elec_num]; - dx[2] = ee_distance_rescaled_deriv_e[2 \ + dx[2] = ee_distance_rescaled_gl[2 \ + j * 4 + i * 4 * elec_num \ + nw * 4 * elec_num * elec_num]; - dx[3] = ee_distance_rescaled_deriv_e[3 \ + dx[3] = ee_distance_rescaled_gl[3 \ + j * 4 + i * 4 * elec_num \ + nw * 4 * elec_num * elec_num]; @@ -2908,7 +2909,7 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( lap3 = lap3 - 2.0 * b_vector[1] * dx[ii] * dx[ii]; - factor_ee_deriv_e[i + ii * elec_num + nw * elec_num * 4 ] += \ + factor_ee_gl[i + ii * elec_num + nw * elec_num * 4 ] += \ + spin_fact * b_vector[0] * dx[ii] * invden2 \ + pow_ser_g[ii] ; } @@ -2917,7 +2918,7 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( lap2 = lap2 * dx[ii] * third; lap3 = lap3 + den * dx[ii]; lap3 = lap3 * (spin_fact * b_vector[0] * invden3); - factor_ee_deriv_e[i + ii*elec_num + nw * elec_num * 4] += lap1 + lap2 + lap3; + factor_ee_gl[i + ii*elec_num + nw * elec_num * 4] += lap1 + lap2 + lap3; } } @@ -2927,11 +2928,11 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( } #+end_src - # #+CALL: generate_c_header(table=qmckl_factor_ee_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_ee_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_ee_deriv_e ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -2939,16 +2940,16 @@ qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc( const int64_t bord_num, const double* b_vector, const double* ee_distance_rescaled, - const double* ee_distance_rescaled_deriv_e, - double* const factor_ee_deriv_e ); + const double* ee_distance_rescaled_gl, + double* const factor_ee_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_ee_deriv_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc") + #+CALL: generate_c_interface(table=qmckl_factor_ee_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_ee_gl_doc") #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none -integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc & +integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_gl_doc & (context, & walk_num, & elec_num, & @@ -2956,8 +2957,8 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc & bord_num, & b_vector, & ee_distance_rescaled, & - ee_distance_rescaled_deriv_e, & - factor_ee_deriv_e) & + ee_distance_rescaled_gl, & + factor_ee_gl) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -2970,11 +2971,11 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc & integer (c_int64_t) , intent(in) , value :: bord_num real (c_double ) , intent(in) :: b_vector(bord_num+1) real (c_double ) , intent(in) :: ee_distance_rescaled(elec_num,elec_num,walk_num) - real (c_double ) , intent(in) :: ee_distance_rescaled_deriv_e(elec_num,elec_num,4,walk_num) - real (c_double ) , intent(out) :: factor_ee_deriv_e(elec_num,4,walk_num) + real (c_double ) , intent(in) :: ee_distance_rescaled_gl(elec_num,elec_num,4,walk_num) + real (c_double ) , intent(out) :: factor_ee_gl(elec_num,4,walk_num) - integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f - info = qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc_f & + integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_ee_gl_doc_f + info = qmckl_compute_jastrow_champ_factor_ee_gl_doc_f & (context, & walk_num, & elec_num, & @@ -2982,14 +2983,14 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc & bord_num, & b_vector, & ee_distance_rescaled, & - ee_distance_rescaled_deriv_e, & - factor_ee_deriv_e) + ee_distance_rescaled_gl, & + factor_ee_gl) - end function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc + end function qmckl_compute_jastrow_champ_factor_ee_gl_doc #+end_src #+begin_src c :tangle (eval h_private_func) :comments org - qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl_hpc ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -2997,13 +2998,13 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc & const int64_t bord_num, const double* b_vector, const double* ee_distance_rescaled, - const double* ee_distance_rescaled_deriv_e, - double* const factor_ee_deriv_e ); + const double* ee_distance_rescaled_gl, + double* const factor_ee_gl ); #+end_src #+begin_src c :tangle (eval h_private_func) :comments org - qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl_doc ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -3011,13 +3012,13 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc & const int64_t bord_num, const double* b_vector, const double* ee_distance_rescaled, - const double* ee_distance_rescaled_deriv_e, - double* const factor_ee_deriv_e ); + const double* ee_distance_rescaled_gl, + double* const factor_ee_gl ); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes - qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_deriv_e ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_ee_gl ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -3025,13 +3026,13 @@ integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_ee_deriv_e_doc & const int64_t bord_num, const double* b_vector, const double* ee_distance_rescaled, - const double* ee_distance_rescaled_deriv_e, - double* const factor_ee_deriv_e ) { + const double* ee_distance_rescaled_gl, + double* const factor_ee_gl ) { #ifdef HAVE_HPC - return qmckl_compute_jastrow_champ_factor_ee_deriv_e_hpc(context, walk_num, elec_num, up_num, bord_num, b_vector, ee_distance_rescaled, ee_distance_rescaled_deriv_e, factor_ee_deriv_e ); + 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_deriv_e_doc(context, walk_num, elec_num, up_num, bord_num, b_vector, ee_distance_rescaled, ee_distance_rescaled_deriv_e, factor_ee_deriv_e ); + 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 } #+end_src @@ -3082,37 +3083,37 @@ def func(elec_coord): elec_dist = make_dist(elec_coord) - elec_dist_deriv_e = np.zeros(shape=(4,elec_num, elec_num),dtype=float) + elec_dist_gl = np.zeros(shape=(4,elec_num, elec_num),dtype=float) for j in range(elec_num): for i in range(elec_num): rij_inv = 1.0 / elec_dist[i, j] for ii in range(3): - elec_dist_deriv_e[ii, i, j] = (elec_coord[j][ii] - elec_coord[i][ii]) * rij_inv - elec_dist_deriv_e[3, i, j] = 2.0 * rij_inv - elec_dist_deriv_e[:, j, j] = 6.0 + elec_dist_gl[ii, i, j] = (elec_coord[j][ii] - elec_coord[i][ii]) * rij_inv + elec_dist_gl[3, i, j] = 2.0 * rij_inv + elec_dist_gl[:, j, j] = 6.0 - ee_distance_rescaled_deriv_e = np.zeros(shape=(4,elec_num,elec_num),dtype=float) + ee_distance_rescaled_gl = np.zeros(shape=(4,elec_num,elec_num),dtype=float) for j in range(elec_num): for i in range(elec_num): f = 1.0 - kappa * ee_distance_rescaled[i][j] for ii in range(4): - ee_distance_rescaled_deriv_e[ii][i][j] = elec_dist_deriv_e[ii][i][j] - ee_distance_rescaled_deriv_e[3][i][j] = ee_distance_rescaled_deriv_e[3][i][j] + \ - (-kappa * ee_distance_rescaled_deriv_e[0][i][j] * ee_distance_rescaled_deriv_e[0][i][j]) + \ - (-kappa * ee_distance_rescaled_deriv_e[1][i][j] * ee_distance_rescaled_deriv_e[1][i][j]) + \ - (-kappa * ee_distance_rescaled_deriv_e[2][i][j] * ee_distance_rescaled_deriv_e[2][i][j]) + ee_distance_rescaled_gl[ii][i][j] = elec_dist_gl[ii][i][j] + ee_distance_rescaled_gl[3][i][j] = ee_distance_rescaled_gl[3][i][j] + \ + (-kappa * ee_distance_rescaled_gl[0][i][j] * ee_distance_rescaled_gl[0][i][j]) + \ + (-kappa * ee_distance_rescaled_gl[1][i][j] * ee_distance_rescaled_gl[1][i][j]) + \ + (-kappa * ee_distance_rescaled_gl[2][i][j] * ee_distance_rescaled_gl[2][i][j]) for ii in range(4): - ee_distance_rescaled_deriv_e[ii][i][j] = ee_distance_rescaled_deriv_e[ii][i][j] * f + ee_distance_rescaled_gl[ii][i][j] = ee_distance_rescaled_gl[ii][i][j] * f - return ee_distance_rescaled_deriv_e, elec_dist_deriv_e + return ee_distance_rescaled_gl, elec_dist_gl -ee_distance_rescaled_deriv_e, elec_dist_deriv_e = func(elec_coord) +ee_distance_rescaled_gl, elec_dist_gl = func(elec_coord) -#print(elec_dist_deriv_e[3,:,:]) +#print(elec_dist_gl[3,:,:]) #print(make_dist_deriv(elec_coord)[3,:,:]) -factor_ee_deriv_e = np.zeros(shape=(4,elec_num),dtype=float) +factor_ee_gl = np.zeros(shape=(4,elec_num),dtype=float) dx = np.zeros(shape=(4),dtype=float) pow_ser_g = np.zeros(shape=(4),dtype=float) for j in range(elec_num): @@ -3126,59 +3127,59 @@ for j in range(elec_num): xinv = 1.0 / x ipar = 1 - dx[:] = ee_distance_rescaled_deriv_e[:,j,i] + dx[:] = ee_distance_rescaled_gl[:,j,i] if((i < up_num and j < up_num) or (i >= up_num and j >= up_num) ): spin_fact = 0.5 else: spin_fact = 1.0 - factor_ee_deriv_e[:,j] += spin_fact * b_vector[0] * dx[:] * invden2 + factor_ee_gl[:,j] += spin_fact * b_vector[0] * dx[:] * invden2 for k in range(2,bord_num+1): - factor_ee_deriv_e[:,j] += b_vector[k]*k*x**(k-1)*dx[:] + factor_ee_gl[:,j] += b_vector[k]*k*x**(k-1)*dx[:] - grad_c2 = np.dot(ee_distance_rescaled_deriv_e[:3,j,i], ee_distance_rescaled_deriv_e[:3,j,i]) - factor_ee_deriv_e[3,j] -= spin_fact * b_vector[0] * 2. * b_vector[1] * grad_c2 * invden3 + grad_c2 = np.dot(ee_distance_rescaled_gl[:3,j,i], ee_distance_rescaled_gl[:3,j,i]) + factor_ee_gl[3,j] -= spin_fact * b_vector[0] * 2. * b_vector[1] * grad_c2 * invden3 for k in range(2,bord_num+1): - factor_ee_deriv_e[3,j] += b_vector[k]*k*(k-1)*x**(k-2)*grad_c2 + factor_ee_gl[3,j] += b_vector[k]*k*(k-1)*x**(k-2)*grad_c2 -print("factor_ee_deriv_e[0][0]:",factor_ee_deriv_e[0][0]) -print("factor_ee_deriv_e[1][0]:",factor_ee_deriv_e[1][0]) -print("factor_ee_deriv_e[2][0]:",factor_ee_deriv_e[2][0]) -print("factor_ee_deriv_e[3][0]:",factor_ee_deriv_e[3][0]) +print("factor_ee_gl[0][0]:",factor_ee_gl[0][0]) +print("factor_ee_gl[1][0]:",factor_ee_gl[1][0]) +print("factor_ee_gl[2][0]:",factor_ee_gl[2][0]) +print("factor_ee_gl[3][0]:",factor_ee_gl[3][0]) #+end_src #+RESULTS: : asym_one : 0.43340325572525706 : asymp_jasb[0] : 0.31567342786262853 : asymp_jasb[1] : 0.5323750557252571 - : factor_ee_deriv_e[0][0]: 0.16364894652107934 - : factor_ee_deriv_e[1][0]: -0.6927548119830084 - : factor_ee_deriv_e[2][0]: 0.073267755223968 - : factor_ee_deriv_e[3][0]: 1.5111672803213185 + : factor_ee_gl[0][0]: 0.16364894652107934 + : factor_ee_gl[1][0]: -0.6927548119830084 + : factor_ee_gl[2][0]: 0.073267755223968 + : factor_ee_gl[3][0]: 1.5111672803213185 #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_champ_provided(context)); -// calculate factor_ee_deriv_e -double factor_ee_deriv_e[walk_num][4][elec_num]; -rc = qmckl_get_jastrow_champ_factor_ee_deriv_e(context, &(factor_ee_deriv_e[0][0][0]),walk_num*4*elec_num); +// calculate factor_ee_gl +double factor_ee_gl[walk_num][4][elec_num]; +rc = qmckl_get_jastrow_champ_factor_ee_gl(context, &(factor_ee_gl[0][0][0]),walk_num*4*elec_num); -// check factor_ee_deriv_e -printf("%f %f\n", factor_ee_deriv_e[0][0][0], 0.16364894652107934); -assert(fabs(factor_ee_deriv_e[0][0][0]-0.16364894652107934) < 1.e-12); +// check factor_ee_gl +printf("%f %f\n", factor_ee_gl[0][0][0], 0.16364894652107934); +assert(fabs(factor_ee_gl[0][0][0]-0.16364894652107934) < 1.e-12); -printf("%f %f\n", factor_ee_deriv_e[0][1][0],-0.6927548119830084 ); -assert(fabs(factor_ee_deriv_e[0][1][0]+0.6927548119830084 ) < 1.e-12); +printf("%f %f\n", factor_ee_gl[0][1][0],-0.6927548119830084 ); +assert(fabs(factor_ee_gl[0][1][0]+0.6927548119830084 ) < 1.e-12); -printf("%f %f\n", factor_ee_deriv_e[0][2][0], 0.073267755223968 ); -assert(fabs(factor_ee_deriv_e[0][2][0]-0.073267755223968 ) < 1.e-12); +printf("%f %f\n", factor_ee_gl[0][2][0], 0.073267755223968 ); +assert(fabs(factor_ee_gl[0][2][0]-0.073267755223968 ) < 1.e-12); -printf("%f %f\n", factor_ee_deriv_e[0][3][0], 1.5111672803213185 ); -assert(fabs(factor_ee_deriv_e[0][3][0]-1.5111672803213185 ) < 1.e-12); +printf("%f %f\n", factor_ee_gl[0][3][0], 1.5111672803213185 ); +assert(fabs(factor_ee_gl[0][3][0]-1.5111672803213185 ) < 1.e-12); #+end_src *** Electron-electron rescaled distances @@ -3446,18 +3447,18 @@ assert(fabs(ee_distance_rescaled[5*elec_num+6]-0.3622098222364193) < 1.e-12); The rescaled distances, represented by $C_{ij} = (1 - e^{-\kappa_\text{e} r_{ij}})/\kappa_\text{e}$ are differentiated with respect to the electron coordinates. This information is stored in the tensor - ~ee_distance_rescaled_deriv_e~. The initial three sequential + ~ee_distance_rescaled_gl~. The initial three sequential elements of this three-dimensional tensor provide the $x$, $y$, and $z$ direction derivatives, while the fourth index corresponds to the Laplacian. **** Get #+begin_src c :comments org :tangle (eval h_func) :noweb yes -qmckl_exit_code qmckl_get_jastrow_champ_ee_distance_rescaled_deriv_e(qmckl_context context, double* const distance_rescaled_deriv_e); +qmckl_exit_code qmckl_get_jastrow_champ_ee_distance_rescaled_gl(qmckl_context context, double* const distance_rescaled_gl); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_get_jastrow_champ_ee_distance_rescaled_deriv_e(qmckl_context context, double* const distance_rescaled_deriv_e) +qmckl_exit_code qmckl_get_jastrow_champ_ee_distance_rescaled_gl(qmckl_context context, double* const distance_rescaled_gl) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { return QMCKL_NULL_CONTEXT; @@ -3465,14 +3466,14 @@ qmckl_exit_code qmckl_get_jastrow_champ_ee_distance_rescaled_deriv_e(qmckl_conte qmckl_exit_code rc; - rc = qmckl_provide_ee_distance_rescaled_deriv_e(context); + rc = qmckl_provide_ee_distance_rescaled_gl(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; assert (ctx != NULL); size_t sze = 4 * ctx->electron.num * ctx->electron.num * ctx->electron.walker.num; - memcpy(distance_rescaled_deriv_e, ctx->jastrow_champ.ee_distance_rescaled_deriv_e, sze * sizeof(double)); + memcpy(distance_rescaled_gl, ctx->jastrow_champ.ee_distance_rescaled_gl, sze * sizeof(double)); return QMCKL_SUCCESS; } @@ -3481,11 +3482,11 @@ qmckl_exit_code qmckl_get_jastrow_champ_ee_distance_rescaled_deriv_e(qmckl_conte **** Provide :noexport: #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_ee_distance_rescaled_deriv_e(qmckl_context context); +qmckl_exit_code qmckl_provide_ee_distance_rescaled_gl(qmckl_context context); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_provide_ee_distance_rescaled_deriv_e(qmckl_context context) +qmckl_exit_code qmckl_provide_ee_distance_rescaled_gl(qmckl_context context) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -3497,44 +3498,44 @@ qmckl_exit_code qmckl_provide_ee_distance_rescaled_deriv_e(qmckl_context context /* Compute if necessary */ - if (ctx->electron.walker.point.date > ctx->jastrow_champ.ee_distance_rescaled_deriv_e_date) { + if (ctx->electron.walker.point.date > ctx->jastrow_champ.ee_distance_rescaled_gl_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow_champ.ee_distance_rescaled_deriv_e != NULL) { - qmckl_exit_code rc = qmckl_free(context, ctx->jastrow_champ.ee_distance_rescaled_deriv_e); + if (ctx->jastrow_champ.ee_distance_rescaled_gl != NULL) { + qmckl_exit_code rc = qmckl_free(context, ctx->jastrow_champ.ee_distance_rescaled_gl); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_ee_distance_rescaled_deriv_e", - "Unable to free ctx->jastrow_champ.ee_distance_rescaled_deriv_e"); + "qmckl_provide_ee_distance_rescaled_gl", + "Unable to free ctx->jastrow_champ.ee_distance_rescaled_gl"); } - ctx->jastrow_champ.ee_distance_rescaled_deriv_e = NULL; + ctx->jastrow_champ.ee_distance_rescaled_gl = NULL; } } /* Allocate array */ - if (ctx->jastrow_champ.ee_distance_rescaled_deriv_e == NULL) { + if (ctx->jastrow_champ.ee_distance_rescaled_gl == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; mem_info.size = 4 * ctx->electron.num * ctx->electron.num * ctx->electron.walker.num * sizeof(double); - double* ee_distance_rescaled_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* ee_distance_rescaled_gl = (double*) qmckl_malloc(context, mem_info); - if (ee_distance_rescaled_deriv_e == NULL) { + if (ee_distance_rescaled_gl == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_ee_distance_rescaled_deriv_e", + "qmckl_provide_ee_distance_rescaled_gl", NULL); } - ctx->jastrow_champ.ee_distance_rescaled_deriv_e = ee_distance_rescaled_deriv_e; + ctx->jastrow_champ.ee_distance_rescaled_gl = ee_distance_rescaled_gl; } qmckl_exit_code rc = - qmckl_compute_ee_distance_rescaled_deriv_e(context, + qmckl_compute_ee_distance_rescaled_gl(context, ctx->electron.num, ctx->jastrow_champ.rescale_factor_ee, ctx->electron.walker.num, ctx->electron.walker.point.coord.data, - ctx->jastrow_champ.ee_distance_rescaled_deriv_e); + ctx->jastrow_champ.ee_distance_rescaled_gl); if (rc != QMCKL_SUCCESS) { return rc; } @@ -3548,12 +3549,12 @@ qmckl_exit_code qmckl_provide_ee_distance_rescaled_deriv_e(qmckl_context context **** Compute :PROPERTIES: - :Name: qmckl_compute_ee_distance_rescaled_deriv_e + :Name: qmckl_compute_ee_distance_rescaled_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_ee_distance_rescaled_deriv_e_args + #+NAME: qmckl_ee_distance_rescaled_gl_args | Variable | Type | In/Out | Description | |-----------------------+-------------------------------------------+--------+-------------------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -3561,11 +3562,11 @@ qmckl_exit_code qmckl_provide_ee_distance_rescaled_deriv_e(qmckl_context context | ~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_deriv_e~ | ~double[walk_num][4][elec_num][elec_num]~ | out | Electron-electron rescaled distance derivatives | + | ~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_deriv_e_f(context, elec_num, rescale_factor_ee, walk_num, & - coord, ee_distance_rescaled_deriv_e) & +integer function qmckl_compute_ee_distance_rescaled_gl_f(context, elec_num, rescale_factor_ee, walk_num, & + coord, ee_distance_rescaled_gl) & result(info) use qmckl implicit none @@ -3574,7 +3575,7 @@ integer function qmckl_compute_ee_distance_rescaled_deriv_e_f(context, elec_num, double precision , intent(in) :: rescale_factor_ee integer*8 , intent(in) :: walk_num double precision , intent(in) :: coord(elec_num,walk_num,3) - double precision , intent(out) :: ee_distance_rescaled_deriv_e(4,elec_num,elec_num,walk_num) + double precision , intent(out) :: ee_distance_rescaled_gl(4,elec_num,elec_num,walk_num) integer*8 :: k @@ -3596,34 +3597,34 @@ integer function qmckl_compute_ee_distance_rescaled_deriv_e_f(context, elec_num, endif do k=1,walk_num - info = qmckl_distance_rescaled_deriv_e(context, 'T', 'T', elec_num, elec_num, & + info = qmckl_distance_rescaled_gl(context, 'T', 'T', elec_num, elec_num, & coord(1,k,1), elec_num*walk_num, & coord(1,k,1), elec_num*walk_num, & - ee_distance_rescaled_deriv_e(1,1,1,k), elec_num, rescale_factor_ee) + ee_distance_rescaled_gl(1,1,1,k), elec_num, rescale_factor_ee) if (info /= QMCKL_SUCCESS) then exit endif end do -end function qmckl_compute_ee_distance_rescaled_deriv_e_f +end function qmckl_compute_ee_distance_rescaled_gl_f #+end_src #+begin_src c :tangle (eval h_private_func) :comments org :exports none -qmckl_exit_code qmckl_compute_ee_distance_rescaled_deriv_e ( +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_deriv_e ); + double* const ee_distance_rescaled_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_compute_ee_distance_rescaled_deriv_e & - (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled_deriv_e) & + 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) use, intrinsic :: iso_c_binding @@ -3634,13 +3635,13 @@ qmckl_exit_code qmckl_compute_ee_distance_rescaled_deriv_e ( 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_deriv_e(4,elec_num,elec_num,walk_num) + real (c_double ) , intent(out) :: ee_distance_rescaled_gl(4,elec_num,elec_num,walk_num) - integer(c_int32_t), external :: qmckl_compute_ee_distance_rescaled_deriv_e_f - info = qmckl_compute_ee_distance_rescaled_deriv_e_f & - (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled_deriv_e) + 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) - end function qmckl_compute_ee_distance_rescaled_deriv_e + end function qmckl_compute_ee_distance_rescaled_gl #+end_src **** Test @@ -3655,8 +3656,8 @@ import numpy as np assert(qmckl_electron_provided(context)); -double ee_distance_rescaled_deriv_e[4 * walk_num * elec_num * elec_num]; -rc = qmckl_get_jastrow_champ_ee_distance_rescaled_deriv_e(context, ee_distance_rescaled_deriv_e); +double ee_distance_rescaled_gl[4 * walk_num * elec_num * elec_num]; +rc = qmckl_get_jastrow_champ_ee_distance_rescaled_gl(context, ee_distance_rescaled_gl); // TODO: Get exact values //// (e1,e2,w) @@ -4349,24 +4350,24 @@ assert(fabs(-5.1052574308112755 - factor_en[0]) < 1.e-12); #+end_src *** Derivative - Calculate the electron-electron jastrow component ~factor_en_deriv_e~ derivative + Calculate the electron-electron jastrow component ~factor_en_gl~ derivative with respect to the electron coordinates using the ~en_distance_rescaled~ and - ~en_distance_rescaled_deriv_e~ which are already calculated previously. + ~en_distance_rescaled_gl~ which are already calculated previously. TODO: write equations. **** Get #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code -qmckl_get_jastrow_champ_factor_en_deriv_e(qmckl_context context, - double* const factor_en_deriv_e, +qmckl_get_jastrow_champ_factor_en_gl(qmckl_context context, + double* const factor_en_gl, const int64_t size_max); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code -qmckl_get_jastrow_champ_factor_en_deriv_e(qmckl_context context, - double* const factor_en_deriv_e, +qmckl_get_jastrow_champ_factor_en_gl(qmckl_context context, + double* const factor_en_gl, const int64_t size_max) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -4375,7 +4376,7 @@ qmckl_get_jastrow_champ_factor_en_deriv_e(qmckl_context context, qmckl_exit_code rc; - rc = qmckl_provide_jastrow_champ_factor_en_deriv_e(context); + rc = qmckl_provide_jastrow_champ_factor_en_gl(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; @@ -4385,10 +4386,10 @@ qmckl_get_jastrow_champ_factor_en_deriv_e(qmckl_context context, if (size_max < sze) { return qmckl_failwith( context, QMCKL_INVALID_ARG_3, - "qmckl_get_jastrow_champ_factor_en_deriv_e", + "qmckl_get_jastrow_champ_factor_en_gl", "Array too small. Expected 4*walker.num*elec_num"); } - memcpy(factor_en_deriv_e, ctx->jastrow_champ.factor_en_deriv_e, sze*sizeof(double)); + memcpy(factor_en_gl, ctx->jastrow_champ.factor_en_gl, sze*sizeof(double)); return QMCKL_SUCCESS; } @@ -4396,11 +4397,11 @@ qmckl_get_jastrow_champ_factor_en_deriv_e(qmckl_context context, **** Provide :noexport: #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context context); +qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_gl(qmckl_context context); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context context) +qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_gl(qmckl_context context) { qmckl_exit_code rc; @@ -4408,7 +4409,7 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context cont if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { return qmckl_failwith( context, QMCKL_INVALID_CONTEXT, - "qmckl_provide_jastrow_champ_factor_en_deriv_e", + "qmckl_provide_jastrow_champ_factor_en_gl", NULL); } @@ -4418,7 +4419,7 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context cont if (!ctx->jastrow_champ.provided) { return qmckl_failwith( context, QMCKL_NOT_PROVIDED, - "qmckl_provide_jastrow_champ_factor_en_deriv_e", + "qmckl_provide_jastrow_champ_factor_en_gl", NULL); } @@ -4427,41 +4428,41 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context cont if(rc != QMCKL_SUCCESS) return rc; /* Check if en rescaled distance derivatives is provided */ - rc = qmckl_provide_en_distance_rescaled_deriv_e(context); + rc = qmckl_provide_en_distance_rescaled_gl(context); if(rc != QMCKL_SUCCESS) return rc; /* Compute if necessary */ - if (ctx->date > ctx->jastrow_champ.factor_en_deriv_e_date) { + if (ctx->date > ctx->jastrow_champ.factor_en_gl_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow_champ.factor_en_deriv_e != NULL) { - rc = qmckl_free(context, ctx->jastrow_champ.factor_en_deriv_e); + if (ctx->jastrow_champ.factor_en_gl != NULL) { + rc = qmckl_free(context, ctx->jastrow_champ.factor_en_gl); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_jastrow_champ_factor_en_deriv_e", - "Unable to free ctx->jastrow_champ.factor_en_deriv_e"); + "qmckl_provide_jastrow_champ_factor_en_gl", + "Unable to free ctx->jastrow_champ.factor_en_gl"); } - ctx->jastrow_champ.factor_en_deriv_e = NULL; + ctx->jastrow_champ.factor_en_gl = NULL; } } /* Allocate array */ - if (ctx->jastrow_champ.factor_en_deriv_e == NULL) { + if (ctx->jastrow_champ.factor_en_gl == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; mem_info.size = ctx->electron.walker.num * 4 * ctx->electron.num * sizeof(double); - double* factor_en_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* factor_en_gl = (double*) qmckl_malloc(context, mem_info); - if (factor_en_deriv_e == NULL) { + if (factor_en_gl == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_jastrow_champ_factor_en_deriv_e", + "qmckl_provide_jastrow_champ_factor_en_gl", NULL); } - ctx->jastrow_champ.factor_en_deriv_e = factor_en_deriv_e; + ctx->jastrow_champ.factor_en_gl = factor_en_gl; } - rc = qmckl_compute_jastrow_champ_factor_en_deriv_e(context, + rc = qmckl_compute_jastrow_champ_factor_en_gl(context, ctx->electron.walker.num, ctx->electron.num, ctx->nucleus.num, @@ -4470,13 +4471,13 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context cont ctx->jastrow_champ.aord_num, ctx->jastrow_champ.a_vector, ctx->jastrow_champ.en_distance_rescaled, - ctx->jastrow_champ.en_distance_rescaled_deriv_e, - ctx->jastrow_champ.factor_en_deriv_e); + ctx->jastrow_champ.en_distance_rescaled_gl, + ctx->jastrow_champ.factor_en_gl); if (rc != QMCKL_SUCCESS) { return rc; } - ctx->jastrow_champ.factor_en_deriv_e_date = ctx->date; + ctx->jastrow_champ.factor_en_gl_date = ctx->date; } return QMCKL_SUCCESS; @@ -4485,12 +4486,12 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context cont **** Compute :PROPERTIES: - :Name: qmckl_compute_jastrow_champ_factor_en_deriv_e + :Name: qmckl_compute_jastrow_champ_factor_en_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_factor_en_deriv_e_args + #+NAME: qmckl_factor_en_gl_args | Variable | Type | In/Out | Description | |--------------------------------+-------------------------------------------+--------+---------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -4502,14 +4503,14 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_en_deriv_e(qmckl_context cont | ~aord_num~ | ~int64_t~ | in | Number of coefficients | | ~a_vector~ | ~double[aord_num+1][type_nucl_num]~ | in | List of coefficients | | ~en_distance_rescaled~ | ~double[walk_num][nucl_num][elec_num]~ | in | Electron-nucleus distances | - | ~en_distance_rescaled_deriv_e~ | ~double[walk_num][4][nucl_num][elec_num]~ | in | Electron-nucleus distance derivatives | - | ~factor_en_deriv_e~ | ~double[walk_num][4][elec_num]~ | out | Electron-nucleus jastrow | + | ~en_distance_rescaled_gl~ | ~double[walk_num][4][nucl_num][elec_num]~ | in | Electron-nucleus distance derivatives | + | ~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_deriv_e_f( & +integer function 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_deriv_e, factor_en_deriv_e) & + en_distance_rescaled, en_distance_rescaled_gl, factor_en_gl) & result(info) use qmckl implicit none @@ -4518,8 +4519,8 @@ integer function qmckl_compute_jastrow_champ_factor_en_deriv_e_f( & integer*8 , intent(in) :: type_nucl_vector(nucl_num) double precision , intent(in) :: a_vector(aord_num + 1, type_nucl_num) double precision , intent(in) :: en_distance_rescaled(elec_num, nucl_num, walk_num) - double precision , intent(in) :: en_distance_rescaled_deriv_e(4, elec_num, nucl_num, walk_num) - double precision , intent(out) :: factor_en_deriv_e(elec_num,4,walk_num) + 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 @@ -4554,7 +4555,7 @@ integer function qmckl_compute_jastrow_champ_factor_en_deriv_e_f( & return endif - factor_en_deriv_e = 0.0d0 + factor_en_gl = 0.0d0 third = 1.0d0 / 3.0d0 do nw =1, walk_num @@ -4570,7 +4571,7 @@ integer function qmckl_compute_jastrow_champ_factor_en_deriv_e_f( & xinv = 1.0d0 / x do ii = 1, 4 - dx(ii) = en_distance_rescaled_deriv_e(ii,i,a,nw) + dx(ii) = en_distance_rescaled_gl(ii,i,a,nw) end do lap1 = 0.0d0 @@ -4588,7 +4589,7 @@ integer function qmckl_compute_jastrow_champ_factor_en_deriv_e_f( & lap3 = lap3 - 2.0d0 * a_vector(2, type_nucl_vector(a)+1) * dx(ii) * dx(ii) - factor_en_deriv_e(i, ii, nw) = factor_en_deriv_e(i, ii, nw) - a_vector(1, type_nucl_vector(a)+1) & + 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) @@ -4598,19 +4599,19 @@ integer function qmckl_compute_jastrow_champ_factor_en_deriv_e_f( & lap2 = lap2 * dx(ii) * third lap3 = lap3 + den * dx(ii) lap3 = lap3 * a_vector(1, type_nucl_vector(a)+1) * invden3 - factor_en_deriv_e(i, ii, nw) = factor_en_deriv_e(i, ii, nw) - lap1 - lap2 - lap3 + 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_deriv_e_f +end function qmckl_compute_jastrow_champ_factor_en_gl_f #+end_src - # #+CALL: generate_c_header(table=qmckl_factor_en_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+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_deriv_e ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_en_gl ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -4620,16 +4621,16 @@ end function qmckl_compute_jastrow_champ_factor_en_deriv_e_f const int64_t aord_num, const double* a_vector, const double* en_distance_rescaled, - const double* en_distance_rescaled_deriv_e, - double* const factor_en_deriv_e ); + const double* en_distance_rescaled_gl, + double* const factor_en_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_en_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_factor_en_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_en_deriv_e & + integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_en_gl & (context, & walk_num, & elec_num, & @@ -4639,8 +4640,8 @@ end function qmckl_compute_jastrow_champ_factor_en_deriv_e_f aord_num, & a_vector, & en_distance_rescaled, & - en_distance_rescaled_deriv_e, & - factor_en_deriv_e) & + en_distance_rescaled_gl, & + factor_en_gl) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -4655,11 +4656,11 @@ end function qmckl_compute_jastrow_champ_factor_en_deriv_e_f 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_deriv_e(elec_num,nucl_num,4,walk_num) - real (c_double ) , intent(out) :: factor_en_deriv_e(elec_num,4,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_deriv_e_f - info = qmckl_compute_jastrow_champ_factor_en_deriv_e_f & + 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, & @@ -4669,10 +4670,10 @@ end function qmckl_compute_jastrow_champ_factor_en_deriv_e_f aord_num, & a_vector, & en_distance_rescaled, & - en_distance_rescaled_deriv_e, & - factor_en_deriv_e) + en_distance_rescaled_gl, & + factor_en_gl) - end function qmckl_compute_jastrow_champ_factor_en_deriv_e + end function qmckl_compute_jastrow_champ_factor_en_gl #+end_src **** Test @@ -4690,29 +4691,29 @@ for i in range(elec_num): for j in range(nucl_num): elnuc_dist[i, j] = np.linalg.norm(elec_coord[i] - nucl_coord[:,j]) -elnuc_dist_deriv_e = np.zeros(shape=(4, elec_num, nucl_num),dtype=float) +elnuc_dist_gl = np.zeros(shape=(4, elec_num, nucl_num),dtype=float) for a in range(nucl_num): for i in range(elec_num): rij_inv = 1.0 / elnuc_dist[i, a] for ii in range(3): - elnuc_dist_deriv_e[ii, i, a] = (elec_coord[i][ii] - nucl_coord[ii][a]) * rij_inv - elnuc_dist_deriv_e[3, i, a] = 2.0 * rij_inv + elnuc_dist_gl[ii, i, a] = (elec_coord[i][ii] - nucl_coord[ii][a]) * rij_inv + elnuc_dist_gl[3, i, a] = 2.0 * rij_inv -en_distance_rescaled_deriv_e = np.zeros(shape=(4,elec_num,nucl_num),dtype=float) +en_distance_rescaled_gl = np.zeros(shape=(4,elec_num,nucl_num),dtype=float) for a in range(nucl_num): for i in range(elec_num): f = 1.0 - kappa * en_distance_rescaled[i][a] for ii in range(4): - en_distance_rescaled_deriv_e[ii][i][a] = elnuc_dist_deriv_e[ii][i][a] - en_distance_rescaled_deriv_e[3][i][a] = en_distance_rescaled_deriv_e[3][i][a] + \ - (-kappa * en_distance_rescaled_deriv_e[0][i][a] * en_distance_rescaled_deriv_e[0][i][a]) + \ - (-kappa * en_distance_rescaled_deriv_e[1][i][a] * en_distance_rescaled_deriv_e[1][i][a]) + \ - (-kappa * en_distance_rescaled_deriv_e[2][i][a] * en_distance_rescaled_deriv_e[2][i][a]) + en_distance_rescaled_gl[ii][i][a] = elnuc_dist_gl[ii][i][a] + en_distance_rescaled_gl[3][i][a] = en_distance_rescaled_gl[3][i][a] + \ + (-kappa * en_distance_rescaled_gl[0][i][a] * en_distance_rescaled_gl[0][i][a]) + \ + (-kappa * en_distance_rescaled_gl[1][i][a] * en_distance_rescaled_gl[1][i][a]) + \ + (-kappa * en_distance_rescaled_gl[2][i][a] * en_distance_rescaled_gl[2][i][a]) for ii in range(4): - en_distance_rescaled_deriv_e[ii][i][a] = en_distance_rescaled_deriv_e[ii][i][a] * f + en_distance_rescaled_gl[ii][i][a] = en_distance_rescaled_gl[ii][i][a] * f third = 1.0 / 3.0 -factor_en_deriv_e = np.zeros(shape=(4,elec_num),dtype=float) +factor_en_gl = np.zeros(shape=(4,elec_num),dtype=float) dx = np.zeros(shape=(4),dtype=float) pow_ser_g = np.zeros(shape=(3),dtype=float) for a in range(nucl_num): @@ -4728,7 +4729,7 @@ for a in range(nucl_num): xinv = 1.0 / (x + 1.0E-18) for ii in range(4): - dx[ii] = en_distance_rescaled_deriv_e[ii][i][a] + dx[ii] = en_distance_rescaled_gl[ii][i][a] lap1 = 0.0 lap2 = 0.0 @@ -4746,48 +4747,48 @@ for a in range(nucl_num): lap3 = lap3 - 2.0 * a_vector[1][type_nucl_vector[a]] * dx[ii] * dx[ii] - factor_en_deriv_e[ii][i] = factor_en_deriv_e[ii][i] - a_vector[0][type_nucl_vector[a]] * \ + factor_en_gl[ii][i] = factor_en_gl[ii][i] - a_vector[0][type_nucl_vector[a]] * \ dx[ii] * invden2 - pow_ser_g[ii] ii = 3 lap2 = lap2 * dx[ii] * third lap3 = lap3 + den * dx[ii] lap3 = lap3 * (a_vector[0][type_nucl_vector[a]] * invden3) - factor_en_deriv_e[ii][i] = factor_en_deriv_e[ii][i] - lap1 - lap2 - lap3 + factor_en_gl[ii][i] = factor_en_gl[ii][i] - lap1 - lap2 - lap3 -print("factor_en_deriv_e[0][0]:",factor_en_deriv_e[0][0]) -print("factor_en_deriv_e[1][0]:",factor_en_deriv_e[1][0]) -print("factor_en_deriv_e[2][0]:",factor_en_deriv_e[2][0]) -print("factor_en_deriv_e[3][0]:",factor_en_deriv_e[3][0]) +print("factor_en_gl[0][0]:",factor_en_gl[0][0]) +print("factor_en_gl[1][0]:",factor_en_gl[1][0]) +print("factor_en_gl[2][0]:",factor_en_gl[2][0]) +print("factor_en_gl[3][0]:",factor_en_gl[3][0]) #+end_src #+RESULTS: - : factor_en_deriv_e[0][0]: -0.11609919541763383 - : factor_en_deriv_e[1][0]: 0.23301394780804574 - : factor_en_deriv_e[2][0]: -0.17548337641865783 - : factor_en_deriv_e[3][0]: 0.9667363412285741 + : factor_en_gl[0][0]: -0.11609919541763383 + : factor_en_gl[1][0]: 0.23301394780804574 + : factor_en_gl[2][0]: -0.17548337641865783 + : factor_en_gl[3][0]: 0.9667363412285741 - : factor_en_deriv_e[0][0]: 0.11609919541763383 - : factor_en_deriv_e[1][0]: -0.23301394780804574 - : factor_en_deriv_e[2][0]: 0.17548337641865783 - : factor_en_deriv_e[3][0]: -0.9667363412285741 + : factor_en_gl[0][0]: 0.11609919541763383 + : factor_en_gl[1][0]: -0.23301394780804574 + : factor_en_gl[2][0]: 0.17548337641865783 + : factor_en_gl[3][0]: -0.9667363412285741 #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_champ_provided(context)); -// calculate factor_en_deriv_e -double factor_en_deriv_e[walk_num][4][elec_num]; -rc = qmckl_get_jastrow_champ_factor_en_deriv_e(context, &(factor_en_deriv_e[0][0][0]),walk_num*4*elec_num); +// calculate factor_en_gl +double factor_en_gl[walk_num][4][elec_num]; +rc = qmckl_get_jastrow_champ_factor_en_gl(context, &(factor_en_gl[0][0][0]),walk_num*4*elec_num); -// check factor_en_deriv_e -assert(fabs(factor_en_deriv_e[0][0][0]+0.11609919541763383) < 1.e-12); -assert(fabs(factor_en_deriv_e[0][1][0]-0.23301394780804574) < 1.e-12); -assert(fabs(factor_en_deriv_e[0][2][0]+0.17548337641865783) < 1.e-12); -assert(fabs(factor_en_deriv_e[0][3][0]-0.9667363412285741 ) < 1.e-12); +// check factor_en_gl +assert(fabs(factor_en_gl[0][0][0]+0.11609919541763383) < 1.e-12); +assert(fabs(factor_en_gl[0][1][0]-0.23301394780804574) < 1.e-12); +assert(fabs(factor_en_gl[0][2][0]+0.17548337641865783) < 1.e-12); +assert(fabs(factor_en_gl[0][3][0]-0.9667363412285741 ) < 1.e-12); #+end_src @@ -5117,18 +5118,18 @@ assert(fabs(en_distance_rescaled[0][0][6] - 0.42640469987268914) < 1.e-12); The rescaled distances, represented by $C_{i\alpha} = (1 - e^{-\kappa_\alpha R_{i\alpha}})/\kappa$ are differentiated with respect to the electron coordinates. This information is stored in the tensor - ~en_distance_rescaled_deriv_e~. The initial three sequential + ~en_distance_rescaled_gl~. The initial three sequential elements of this three-index tensor provide the $x$, $y$, and $z$ direction derivatives, while the fourth index corresponds to the Laplacian. **** Get #+begin_src c :comments org :tangle (eval h_func) :noweb yes -qmckl_exit_code qmckl_get_electron_en_distance_rescaled_deriv_e(qmckl_context context, double* distance_rescaled_deriv_e); +qmckl_exit_code qmckl_get_electron_en_distance_rescaled_gl(qmckl_context context, double* distance_rescaled_gl); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_get_electron_en_distance_rescaled_deriv_e(qmckl_context context, double* distance_rescaled_deriv_e) +qmckl_exit_code qmckl_get_electron_en_distance_rescaled_gl(qmckl_context context, double* distance_rescaled_gl) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -5137,14 +5138,14 @@ qmckl_exit_code qmckl_get_electron_en_distance_rescaled_deriv_e(qmckl_context co qmckl_exit_code rc; - rc = qmckl_provide_en_distance_rescaled_deriv_e(context); + rc = qmckl_provide_en_distance_rescaled_gl(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; assert (ctx != NULL); size_t sze = 4 * ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num; - memcpy(distance_rescaled_deriv_e, ctx->jastrow_champ.en_distance_rescaled_deriv_e, sze * sizeof(double)); + memcpy(distance_rescaled_gl, ctx->jastrow_champ.en_distance_rescaled_gl, sze * sizeof(double)); return QMCKL_SUCCESS; } @@ -5153,11 +5154,11 @@ qmckl_exit_code qmckl_get_electron_en_distance_rescaled_deriv_e(qmckl_context co **** Provide :noexport: #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_en_distance_rescaled_deriv_e(qmckl_context context); +qmckl_exit_code qmckl_provide_en_distance_rescaled_gl(qmckl_context context); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_provide_en_distance_rescaled_deriv_e(qmckl_context context) +qmckl_exit_code qmckl_provide_en_distance_rescaled_gl(qmckl_context context) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -5172,39 +5173,39 @@ qmckl_exit_code qmckl_provide_en_distance_rescaled_deriv_e(qmckl_context context } /* Compute if necessary */ - if (ctx->electron.walker.point.date > ctx->jastrow_champ.en_distance_rescaled_deriv_e_date) { + if (ctx->electron.walker.point.date > ctx->jastrow_champ.en_distance_rescaled_gl_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow_champ.en_distance_rescaled_deriv_e != NULL) { - qmckl_exit_code rc = qmckl_free(context, ctx->jastrow_champ.en_distance_rescaled_deriv_e); + if (ctx->jastrow_champ.en_distance_rescaled_gl != NULL) { + qmckl_exit_code rc = qmckl_free(context, ctx->jastrow_champ.en_distance_rescaled_gl); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_en_distance_rescaled_deriv_e", - "Unable to free ctx->jastrow_champ.en_distance_rescaled_deriv_e"); + "qmckl_provide_en_distance_rescaled_gl", + "Unable to free ctx->jastrow_champ.en_distance_rescaled_gl"); } - ctx->jastrow_champ.en_distance_rescaled_deriv_e = NULL; + ctx->jastrow_champ.en_distance_rescaled_gl = NULL; } } /* Allocate array */ - if (ctx->jastrow_champ.en_distance_rescaled_deriv_e == NULL) { + if (ctx->jastrow_champ.en_distance_rescaled_gl == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; mem_info.size = 4 * ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num * sizeof(double); - double* en_distance_rescaled_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* en_distance_rescaled_gl = (double*) qmckl_malloc(context, mem_info); - if (en_distance_rescaled_deriv_e == NULL) { + if (en_distance_rescaled_gl == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_en_distance_rescaled_deriv_e", + "qmckl_provide_en_distance_rescaled_gl", NULL); } - ctx->jastrow_champ.en_distance_rescaled_deriv_e = en_distance_rescaled_deriv_e; + ctx->jastrow_champ.en_distance_rescaled_gl = en_distance_rescaled_gl; } qmckl_exit_code rc = - qmckl_compute_en_distance_rescaled_deriv_e(context, + qmckl_compute_en_distance_rescaled_gl(context, ctx->electron.num, ctx->nucleus.num, ctx->jastrow_champ.type_nucl_num, @@ -5213,12 +5214,12 @@ qmckl_exit_code qmckl_provide_en_distance_rescaled_deriv_e(qmckl_context context ctx->electron.walker.num, ctx->electron.walker.point.coord.data, ctx->nucleus.coord.data, - ctx->jastrow_champ.en_distance_rescaled_deriv_e); + ctx->jastrow_champ.en_distance_rescaled_gl); if (rc != QMCKL_SUCCESS) { return rc; } - ctx->jastrow_champ.en_distance_rescaled_deriv_e_date = ctx->date; + ctx->jastrow_champ.en_distance_rescaled_gl_date = ctx->date; } return QMCKL_SUCCESS; @@ -5227,12 +5228,12 @@ qmckl_exit_code qmckl_provide_en_distance_rescaled_deriv_e(qmckl_context context **** Compute :PROPERTIES: - :Name: qmckl_compute_en_distance_rescaled_deriv_e + :Name: qmckl_compute_en_distance_rescaled_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_en_distance_rescaled_deriv_e_args + #+NAME: qmckl_en_distance_rescaled_gl_args | Variable | Type | In/Out | Description | |--------------------------------+-------------------------------------------+--------+---------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -5244,12 +5245,12 @@ qmckl_exit_code qmckl_provide_en_distance_rescaled_deriv_e(qmckl_context context | ~walk_num~ | ~int64_t~ | in | Number of walkers | | ~elec_coord~ | ~double[3][walk_num][elec_num]~ | in | Electron coordinates | | ~nucl_coord~ | ~double[3][elec_num]~ | in | Nuclear coordinates | - | ~en_distance_rescaled_deriv_e~ | ~double[walk_num][nucl_num][elec_num][4]~ | out | Electron-nucleus distance derivatives | + | ~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_deriv_e_f(context, elec_num, nucl_num, & +integer function 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_deriv_e) & + nucl_coord, en_distance_rescaled_gl) & result(info) use qmckl implicit none @@ -5262,7 +5263,7 @@ integer function qmckl_compute_en_distance_rescaled_deriv_e_f(context, elec_num, integer*8 , intent(in) :: walk_num double precision , intent(in) :: elec_coord(elec_num,walk_num,3) double precision , intent(in) :: nucl_coord(nucl_num,3) - double precision , intent(out) :: en_distance_rescaled_deriv_e(4,elec_num,nucl_num,walk_num) + double precision , intent(out) :: en_distance_rescaled_gl(4,elec_num,nucl_num,walk_num) integer*8 :: i, k double precision :: coord(3) @@ -5292,20 +5293,20 @@ integer function qmckl_compute_en_distance_rescaled_deriv_e_f(context, elec_num, do i=1, nucl_num coord(1:3) = nucl_coord(i,1:3) do k=1,walk_num - info = qmckl_distance_rescaled_deriv_e(context, 'T', 'T', elec_num, 1_8, & + info = qmckl_distance_rescaled_gl(context, 'T', 'T', elec_num, 1_8, & elec_coord(1,k,1), elec_num*walk_num, coord, 1_8, & - en_distance_rescaled_deriv_e(1,1,i,k), elec_num, rescale_factor_en(type_nucl_vector(i)+1)) + en_distance_rescaled_gl(1,1,i,k), elec_num, rescale_factor_en(type_nucl_vector(i)+1)) if (info /= QMCKL_SUCCESS) then return endif end do end do -end function qmckl_compute_en_distance_rescaled_deriv_e_f +end function qmckl_compute_en_distance_rescaled_gl_f #+end_src #+begin_src c :tangle (eval h_private_func) :comments org :exports none -qmckl_exit_code qmckl_compute_en_distance_rescaled_deriv_e ( +qmckl_exit_code qmckl_compute_en_distance_rescaled_gl ( const qmckl_context context, const int64_t elec_num, const int64_t nucl_num, @@ -5315,14 +5316,14 @@ qmckl_exit_code qmckl_compute_en_distance_rescaled_deriv_e ( const int64_t walk_num, const double* elec_coord, const double* nucl_coord, - double* const en_distance_rescaled_deriv_e ); + double* const en_distance_rescaled_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_en_distance_rescaled_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_en_distance_rescaled_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_compute_en_distance_rescaled_deriv_e & + integer(c_int32_t) function qmckl_compute_en_distance_rescaled_gl & (context, & elec_num, & nucl_num, & @@ -5332,7 +5333,7 @@ qmckl_exit_code qmckl_compute_en_distance_rescaled_deriv_e ( walk_num, & elec_coord, & nucl_coord, & - en_distance_rescaled_deriv_e) & + en_distance_rescaled_gl) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -5347,10 +5348,10 @@ qmckl_exit_code qmckl_compute_en_distance_rescaled_deriv_e ( 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_deriv_e(4,elec_num,nucl_num,walk_num) + 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_deriv_e_f - info = qmckl_compute_en_distance_rescaled_deriv_e_f & + 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, & @@ -5360,9 +5361,9 @@ qmckl_exit_code qmckl_compute_en_distance_rescaled_deriv_e ( walk_num, & elec_coord, & nucl_coord, & - en_distance_rescaled_deriv_e) + en_distance_rescaled_gl) - end function qmckl_compute_en_distance_rescaled_deriv_e + end function qmckl_compute_en_distance_rescaled_gl #+end_src **** Test @@ -5380,10 +5381,10 @@ assert(qmckl_electron_provided(context)); assert(qmckl_nucleus_provided(context)); -double en_distance_rescaled_deriv_e[walk_num][4][nucl_num][elec_num]; +double en_distance_rescaled_gl[walk_num][4][nucl_num][elec_num]; rc = qmckl_check(context, - qmckl_get_electron_en_distance_rescaled_deriv_e(context, &(en_distance_rescaled_deriv_e[0][0][0][0])) + qmckl_get_electron_en_distance_rescaled_gl(context, &(en_distance_rescaled_gl[0][0][0][0])) ); assert (rc == QMCKL_SUCCESS); @@ -5931,7 +5932,7 @@ assert(fabs(een_rescaled_e[0][2][1][5]-0.3424402276009091) < 1.e-12); *** Electron-electron rescaled distances derivatives in $J_\text{eeN}$ - ~een_rescaled_e_deriv_e~ stores the table of the derivatives of the + ~een_rescaled_e_gl~ stores the table of the derivatives of the rescaled distances between all pairs of electrons and raised to the power $p$ defined by ~cord_num~. Here we take its derivatives required for the een jastrow_champ. @@ -5944,14 +5945,14 @@ assert(fabs(een_rescaled_e[0][2][1][5]-0.3424402276009091) < 1.e-12); #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code -qmckl_get_jastrow_champ_een_rescaled_e_deriv_e(qmckl_context context, +qmckl_get_jastrow_champ_een_rescaled_e_gl(qmckl_context context, double* const 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_jastrow_champ_een_rescaled_e_deriv_e(qmckl_context context, +qmckl_get_jastrow_champ_een_rescaled_e_gl(qmckl_context context, double* const distance_rescaled, const int64_t size_max) { @@ -5961,7 +5962,7 @@ qmckl_get_jastrow_champ_een_rescaled_e_deriv_e(qmckl_context context, qmckl_exit_code rc; - rc = qmckl_provide_een_rescaled_e_deriv_e(context); + rc = qmckl_provide_een_rescaled_e_gl(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; @@ -5971,10 +5972,10 @@ qmckl_get_jastrow_champ_een_rescaled_e_deriv_e(qmckl_context context, if (size_max < sze) { return qmckl_failwith( context, QMCKL_INVALID_ARG_3, - "qmckl_get_jastrow_champ_factor_een_deriv_e", + "qmckl_get_jastrow_champ_factor_een_gl", "Array too small. Expected ctx->electron.num * 4 * ctx->electron.num * ctx->electron.walker.num * (ctx->jastrow_champ.cord_num + 1)"); } - memcpy(distance_rescaled, ctx->jastrow_champ.een_rescaled_e_deriv_e, sze * sizeof(double)); + memcpy(distance_rescaled, ctx->jastrow_champ.een_rescaled_e_gl, sze * sizeof(double)); return QMCKL_SUCCESS; } @@ -5983,11 +5984,11 @@ qmckl_get_jastrow_champ_een_rescaled_e_deriv_e(qmckl_context context, **** Provide :noexport: #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_een_rescaled_e_deriv_e(qmckl_context context); +qmckl_exit_code qmckl_provide_een_rescaled_e_gl(qmckl_context context); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_provide_een_rescaled_e_deriv_e(qmckl_context context) +qmckl_exit_code qmckl_provide_een_rescaled_e_gl(qmckl_context context) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -6002,38 +6003,38 @@ qmckl_exit_code qmckl_provide_een_rescaled_e_deriv_e(qmckl_context context) if(rc != QMCKL_SUCCESS) return rc; /* Compute if necessary */ - if (ctx->date > ctx->jastrow_champ.een_rescaled_e_deriv_e_date) { + if (ctx->date > ctx->jastrow_champ.een_rescaled_e_gl_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow_champ.een_rescaled_e_deriv_e != NULL) { - rc = qmckl_free(context, ctx->jastrow_champ.een_rescaled_e_deriv_e); + if (ctx->jastrow_champ.een_rescaled_e_gl != NULL) { + rc = qmckl_free(context, ctx->jastrow_champ.een_rescaled_e_gl); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_een_rescaled_e_deriv_e", - "Unable to free ctx->jastrow_champ.een_rescaled_e_deriv_e"); + "qmckl_provide_een_rescaled_e_gl", + "Unable to free ctx->jastrow_champ.een_rescaled_e_gl"); } - ctx->jastrow_champ.een_rescaled_e_deriv_e = NULL; + ctx->jastrow_champ.een_rescaled_e_gl = NULL; } } /* Allocate array */ - if (ctx->jastrow_champ.een_rescaled_e_deriv_e == NULL) { + if (ctx->jastrow_champ.een_rescaled_e_gl == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; mem_info.size = ctx->electron.num * 4 * ctx->electron.num * ctx->electron.walker.num * (ctx->jastrow_champ.cord_num + 1) * sizeof(double); - double* een_rescaled_e_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* een_rescaled_e_gl = (double*) qmckl_malloc(context, mem_info); - if (een_rescaled_e_deriv_e == NULL) { + if (een_rescaled_e_gl == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_een_rescaled_e_deriv_e", + "qmckl_provide_een_rescaled_e_gl", NULL); } - ctx->jastrow_champ.een_rescaled_e_deriv_e = een_rescaled_e_deriv_e; + ctx->jastrow_champ.een_rescaled_e_gl = een_rescaled_e_gl; } - rc = qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e(context, + rc = qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl(context, ctx->electron.walker.num, ctx->electron.num, ctx->jastrow_champ.cord_num, @@ -6041,12 +6042,12 @@ qmckl_exit_code qmckl_provide_een_rescaled_e_deriv_e(qmckl_context context) ctx->electron.walker.point.coord.data, ctx->electron.ee_distance, ctx->jastrow_champ.een_rescaled_e, - ctx->jastrow_champ.een_rescaled_e_deriv_e); + ctx->jastrow_champ.een_rescaled_e_gl); if (rc != QMCKL_SUCCESS) { return rc; } - ctx->jastrow_champ.een_rescaled_e_deriv_e_date = ctx->date; + ctx->jastrow_champ.een_rescaled_e_gl_date = ctx->date; } return QMCKL_SUCCESS; @@ -6055,12 +6056,12 @@ qmckl_exit_code qmckl_provide_een_rescaled_e_deriv_e(qmckl_context context) **** Compute :PROPERTIES: - :Name: qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e + :Name: qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_factor_een_rescaled_e_deriv_e_args + #+NAME: qmckl_factor_een_rescaled_e_gl_args | Variable | Type | In/Out | Description | |--------------------------+-------------------------------------------------------+--------+--------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -6071,12 +6072,12 @@ qmckl_exit_code qmckl_provide_een_rescaled_e_deriv_e(qmckl_context context) | ~coord_ee~ | ~double[walk_num][3][elec_num]~ | in | Electron coordinates | | ~ee_distance~ | ~double[walk_num][elec_num][elec_num]~ | in | Electron-electron distances | | ~een_rescaled_e~ | ~double[walk_num][0:cord_num][elec_num][elec_num]~ | in | Electron-electron distances | - | ~een_rescaled_e_deriv_e~ | ~double[walk_num][0:cord_num][elec_num][4][elec_num]~ | out | Electron-electron rescaled distances | + | ~een_rescaled_e_gl~ | ~double[walk_num][0:cord_num][elec_num][4][elec_num]~ | out | Electron-electron rescaled distances | #+begin_src f90 :comments org :tangle (eval f) :noweb yes -integer function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f( & +integer function qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl_f( & context, walk_num, elec_num, cord_num, rescale_factor_ee, & - coord_ee, ee_distance, een_rescaled_e, een_rescaled_e_deriv_e) & + coord_ee, ee_distance, een_rescaled_e, een_rescaled_e_gl) & result(info) use qmckl implicit none @@ -6088,12 +6089,12 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f( & double precision , intent(in) :: coord_ee(elec_num,3,walk_num) double precision , intent(in) :: ee_distance(elec_num,elec_num,walk_num) double precision , intent(in) :: een_rescaled_e(elec_num,elec_num,0:cord_num,walk_num) - double precision , intent(out) :: een_rescaled_e_deriv_e(elec_num,4,elec_num,0:cord_num,walk_num) - double precision,dimension(:,:,:),allocatable :: elec_dist_deriv_e + double precision , intent(out) :: een_rescaled_e_gl(elec_num,4,elec_num,0:cord_num,walk_num) + double precision,dimension(:,:,:),allocatable :: elec_dist_gl double precision :: x, rij_inv, kappa_l integer*8 :: i, j, k, l, nw, ii - allocate(elec_dist_deriv_e(4,elec_num,elec_num)) + allocate(elec_dist_gl(4,elec_num,elec_num)) info = QMCKL_SUCCESS @@ -6118,17 +6119,17 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f( & endif ! Prepare table of exponentiated distances raised to appropriate power - een_rescaled_e_deriv_e = 0.0d0 + een_rescaled_e_gl = 0.0d0 do nw = 1, walk_num do j = 1, elec_num do i = 1, elec_num rij_inv = 1.0d0 / ee_distance(i, j, nw) do ii = 1, 3 - elec_dist_deriv_e(ii, i, j) = (coord_ee(i, ii, nw) - coord_ee(j, ii, nw)) * rij_inv + elec_dist_gl(ii, i, j) = (coord_ee(i, ii, nw) - coord_ee(j, ii, nw)) * rij_inv end do - elec_dist_deriv_e(4, i, j) = 2.0d0 * rij_inv + elec_dist_gl(4, i, j) = 2.0d0 * rij_inv end do - elec_dist_deriv_e(:, j, j) = 0.0d0 + elec_dist_gl(:, j, j) = 0.0d0 end do ! prepare the actual een table @@ -6136,36 +6137,36 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f( & kappa_l = - dble(l) * rescale_factor_ee do j = 1, elec_num do i = 1, elec_num - een_rescaled_e_deriv_e(i, 1, j, l, nw) = kappa_l * elec_dist_deriv_e(1, i, j) - een_rescaled_e_deriv_e(i, 2, j, l, nw) = kappa_l * elec_dist_deriv_e(2, i, j) - een_rescaled_e_deriv_e(i, 3, j, l, nw) = kappa_l * elec_dist_deriv_e(3, i, j) - een_rescaled_e_deriv_e(i, 4, j, l, nw) = kappa_l * elec_dist_deriv_e(4, i, j) + een_rescaled_e_gl(i, 1, j, l, nw) = kappa_l * elec_dist_gl(1, i, j) + een_rescaled_e_gl(i, 2, j, l, nw) = kappa_l * elec_dist_gl(2, i, j) + een_rescaled_e_gl(i, 3, j, l, nw) = kappa_l * elec_dist_gl(3, i, j) + een_rescaled_e_gl(i, 4, j, l, nw) = kappa_l * elec_dist_gl(4, i, j) - een_rescaled_e_deriv_e(i, 4, j, l, nw) = een_rescaled_e_deriv_e(i, 4, j, l, nw) & - + een_rescaled_e_deriv_e(i, 1, j, l, nw) * een_rescaled_e_deriv_e(i, 1, j, l, nw) & - + een_rescaled_e_deriv_e(i, 2, j, l, nw) * een_rescaled_e_deriv_e(i, 2, j, l, nw) & - + een_rescaled_e_deriv_e(i, 3, j, l, nw) * een_rescaled_e_deriv_e(i, 3, j, l, nw) + een_rescaled_e_gl(i, 4, j, l, nw) = een_rescaled_e_gl(i, 4, j, l, nw) & + + een_rescaled_e_gl(i, 1, j, l, nw) * een_rescaled_e_gl(i, 1, j, l, nw) & + + een_rescaled_e_gl(i, 2, j, l, nw) * een_rescaled_e_gl(i, 2, j, l, nw) & + + een_rescaled_e_gl(i, 3, j, l, nw) * een_rescaled_e_gl(i, 3, j, l, nw) - een_rescaled_e_deriv_e(i, 1, j, l, nw) = een_rescaled_e_deriv_e(i, 1, j, l, nw) * & + een_rescaled_e_gl(i, 1, j, l, nw) = een_rescaled_e_gl(i, 1, j, l, nw) * & een_rescaled_e(i, j, l, nw) - een_rescaled_e_deriv_e(i, 3, j, l, nw) = een_rescaled_e_deriv_e(i, 2, j, l, nw) * & + een_rescaled_e_gl(i, 3, j, l, nw) = een_rescaled_e_gl(i, 2, j, l, nw) * & een_rescaled_e(i, j, l, nw) - een_rescaled_e_deriv_e(i, 3, j, l, nw) = een_rescaled_e_deriv_e(i, 3, j, l, nw) * & + een_rescaled_e_gl(i, 3, j, l, nw) = een_rescaled_e_gl(i, 3, j, l, nw) * & een_rescaled_e(i, j, l, nw) - een_rescaled_e_deriv_e(i, 4, j, l, nw) = een_rescaled_e_deriv_e(i, 4, j, l, nw) * & + een_rescaled_e_gl(i, 4, j, l, nw) = een_rescaled_e_gl(i, 4, j, l, nw) * & een_rescaled_e(i, j, l, nw) end do end do end do end do -end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f +end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl_f #+end_src - # #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_e_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_e_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_een_rescaled_e_deriv_e ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -6174,15 +6175,15 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f const double* coord_ee, const double* ee_distance, const double* een_rescaled_e, - double* const een_rescaled_e_deriv_e ); + double* const een_rescaled_e_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_rescaled_e_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_factor_een_rescaled_e_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e & + integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl & (context, & walk_num, & elec_num, & @@ -6191,7 +6192,7 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f coord_ee, & ee_distance, & een_rescaled_e, & - een_rescaled_e_deriv_e) & + een_rescaled_e_gl) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -6205,10 +6206,10 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f real (c_double ) , intent(in) :: coord_ee(elec_num,3,walk_num) real (c_double ) , intent(in) :: ee_distance(elec_num,elec_num,walk_num) real (c_double ) , intent(in) :: een_rescaled_e(elec_num,elec_num,0:cord_num,walk_num) - real (c_double ) , intent(out) :: een_rescaled_e_deriv_e(elec_num,4,elec_num,0:cord_num,walk_num) + real (c_double ) , intent(out) :: een_rescaled_e_gl(elec_num,4,elec_num,0:cord_num,walk_num) - integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f - info = qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f & + integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl_f + info = qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl_f & (context, & walk_num, & elec_num, & @@ -6217,13 +6218,13 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e_f coord_ee, & ee_distance, & een_rescaled_e, & - een_rescaled_e_deriv_e) + een_rescaled_e_gl) - end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_deriv_e + end function qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl #+end_src **** Test - #+name: een_e_deriv_e + #+name: een_e_gl #+begin_src python :results output :exports none :noweb yes import numpy as np @@ -6235,14 +6236,14 @@ for i in range(elec_num): for j in range(elec_num): elec_dist[i, j] = np.linalg.norm(elec_coord[i] - elec_coord[j]) -elec_dist_deriv_e = np.zeros(shape=(4,elec_num, elec_num),dtype=float) +elec_dist_gl = np.zeros(shape=(4,elec_num, elec_num),dtype=float) for j in range(elec_num): for i in range(elec_num): rij_inv = 1.0 / elec_dist[i, j] for ii in range(3): - elec_dist_deriv_e[ii, i, j] = -(elec_coord[j][ii] - elec_coord[i][ii]) * rij_inv - elec_dist_deriv_e[3, i, j] = 2.0 * rij_inv - elec_dist_deriv_e[:, j, j] = 0.0 + elec_dist_gl[ii, i, j] = -(elec_coord[j][ii] - elec_coord[i][ii]) * rij_inv + elec_dist_gl[3, i, j] = 2.0 * rij_inv + elec_dist_gl[:, j, j] = 0.0 kappa = 1.0 @@ -6272,50 +6273,50 @@ for l in range(1,cord_num+1): een_rescaled_e[j, i, l] = x k = k + 1 -een_rescaled_e_deriv_e = np.zeros(shape=(elec_num,4,elec_num,cord_num+1),dtype=float) +een_rescaled_e_gl = np.zeros(shape=(elec_num,4,elec_num,cord_num+1),dtype=float) for l in range(0,cord_num+1): kappa_l = -1.0 * kappa * l for j in range(0,elec_num): for i in range(0,elec_num): for ii in range(0,4): - een_rescaled_e_deriv_e[i,ii,j,l] = kappa_l * elec_dist_deriv_e[ii,i,j] - een_rescaled_e_deriv_e[i,3,j,l] = een_rescaled_e_deriv_e[i,3,j,l] + \ - een_rescaled_e_deriv_e[i,0,j,l] * een_rescaled_e_deriv_e[i,0,j,l] + \ - een_rescaled_e_deriv_e[i,1,j,l] * een_rescaled_e_deriv_e[i,1,j,l] + \ - een_rescaled_e_deriv_e[i,2,j,l] * een_rescaled_e_deriv_e[i,2,j,l] + een_rescaled_e_gl[i,ii,j,l] = kappa_l * elec_dist_gl[ii,i,j] + een_rescaled_e_gl[i,3,j,l] = een_rescaled_e_gl[i,3,j,l] + \ + een_rescaled_e_gl[i,0,j,l] * een_rescaled_e_gl[i,0,j,l] + \ + een_rescaled_e_gl[i,1,j,l] * een_rescaled_e_gl[i,1,j,l] + \ + een_rescaled_e_gl[i,2,j,l] * een_rescaled_e_gl[i,2,j,l] for ii in range(0,4): - een_rescaled_e_deriv_e[i,ii,j,l] = een_rescaled_e_deriv_e[i,ii,j,l] * een_rescaled_e[i,j,l] + een_rescaled_e_gl[i,ii,j,l] = een_rescaled_e_gl[i,ii,j,l] * een_rescaled_e[i,j,l] -#print(" een_rescaled_e_deriv_e[1, 1, 3, 1] = ",een_rescaled_e_deriv_e[0, 0, 2, 1]) -#print(" een_rescaled_e_deriv_e[1, 1, 4, 1] = ",een_rescaled_e_deriv_e[0, 0, 3, 1]) -#print(" een_rescaled_e_deriv_e[1, 1, 5, 1] = ",een_rescaled_e_deriv_e[0, 0, 4, 1]) -#print(" een_rescaled_e_deriv_e[2, 1, 4, 2] = ",een_rescaled_e_deriv_e[1, 0, 3, 2]) -#print(" een_rescaled_e_deriv_e[2, 1, 5, 2] = ",een_rescaled_e_deriv_e[1, 0, 4, 2]) -#print(" een_rescaled_e_deriv_e[2, 1, 6, 2] = ",een_rescaled_e_deriv_e[1, 0, 5, 2]) +#print(" een_rescaled_e_gl[1, 1, 3, 1] = ",een_rescaled_e_gl[0, 0, 2, 1]) +#print(" een_rescaled_e_gl[1, 1, 4, 1] = ",een_rescaled_e_gl[0, 0, 3, 1]) +#print(" een_rescaled_e_gl[1, 1, 5, 1] = ",een_rescaled_e_gl[0, 0, 4, 1]) +#print(" een_rescaled_e_gl[2, 1, 4, 2] = ",een_rescaled_e_gl[1, 0, 3, 2]) +#print(" een_rescaled_e_gl[2, 1, 5, 2] = ",een_rescaled_e_gl[1, 0, 4, 2]) +#print(" een_rescaled_e_gl[2, 1, 6, 2] = ",een_rescaled_e_gl[1, 0, 5, 2]) #+end_src - #+RESULTS: een_e_deriv_e - : een_rescaled_e_deriv_e[1, 1, 3, 1] = 0.05991352796887283 - : een_rescaled_e_deriv_e[1, 1, 4, 1] = 0.011714035071545248 - : een_rescaled_e_deriv_e[1, 1, 5, 1] = 0.00441398875758468 - : een_rescaled_e_deriv_e[2, 1, 4, 2] = 0.013553180060167595 - : een_rescaled_e_deriv_e[2, 1, 5, 2] = 0.00041342909359870457 - : een_rescaled_e_deriv_e[2, 1, 6, 2] = 0.5880599146214673 + #+RESULTS: een_e_gl + : een_rescaled_e_gl[1, 1, 3, 1] = 0.05991352796887283 + : een_rescaled_e_gl[1, 1, 4, 1] = 0.011714035071545248 + : een_rescaled_e_gl[1, 1, 5, 1] = 0.00441398875758468 + : een_rescaled_e_gl[2, 1, 4, 2] = 0.013553180060167595 + : een_rescaled_e_gl[2, 1, 5, 2] = 0.00041342909359870457 + : een_rescaled_e_gl[2, 1, 6, 2] = 0.5880599146214673 #+begin_src c :tangle (eval c_test) -double een_rescaled_e_deriv_e[walk_num][(cord_num + 1)][elec_num][4][elec_num]; +double een_rescaled_e_gl[walk_num][(cord_num + 1)][elec_num][4][elec_num]; size_max=walk_num*(cord_num + 1)*elec_num*4*elec_num; -rc = qmckl_get_jastrow_champ_een_rescaled_e_deriv_e(context, - &(een_rescaled_e_deriv_e[0][0][0][0][0]),size_max); +rc = qmckl_get_jastrow_champ_een_rescaled_e_gl(context, + &(een_rescaled_e_gl[0][0][0][0][0]),size_max); // value of (0,0,0,2,1) -assert(fabs(een_rescaled_e_deriv_e[0][1][0][0][2] + 0.05991352796887283 ) < 1.e-12); -assert(fabs(een_rescaled_e_deriv_e[0][1][0][0][3] + 0.011714035071545248 ) < 1.e-12); -assert(fabs(een_rescaled_e_deriv_e[0][1][0][0][4] + 0.00441398875758468 ) < 1.e-12); -assert(fabs(een_rescaled_e_deriv_e[0][2][1][0][3] + 0.013553180060167595 ) < 1.e-12); -assert(fabs(een_rescaled_e_deriv_e[0][2][1][0][4] + 0.00041342909359870457) < 1.e-12); -assert(fabs(een_rescaled_e_deriv_e[0][2][1][0][5] + 0.5880599146214673 ) < 1.e-12); +assert(fabs(een_rescaled_e_gl[0][1][0][0][2] + 0.05991352796887283 ) < 1.e-12); +assert(fabs(een_rescaled_e_gl[0][1][0][0][3] + 0.011714035071545248 ) < 1.e-12); +assert(fabs(een_rescaled_e_gl[0][1][0][0][4] + 0.00441398875758468 ) < 1.e-12); +assert(fabs(een_rescaled_e_gl[0][2][1][0][3] + 0.013553180060167595 ) < 1.e-12); +assert(fabs(een_rescaled_e_gl[0][2][1][0][4] + 0.00041342909359870457) < 1.e-12); +assert(fabs(een_rescaled_e_gl[0][2][1][0][5] + 0.5880599146214673 ) < 1.e-12); #+end_src *** Electron-nucleus rescaled distances in $J_\text{eeN}$ @@ -6360,7 +6361,7 @@ qmckl_get_jastrow_champ_een_rescaled_n(qmckl_context context, if (size_max < sze) { return qmckl_failwith( context, QMCKL_INVALID_ARG_3, - "qmckl_get_jastrow_champ_factor_een_deriv_e", + "qmckl_get_jastrow_champ_factor_een_gl", "Array too small. Expected ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num * (ctx->jastrow_champ.cord_num + 1)"); } memcpy(distance_rescaled, ctx->jastrow_champ.een_rescaled_n, sze * sizeof(double)); @@ -6729,7 +6730,7 @@ assert(fabs(een_rescaled_n[0][2][1][5]-0.01343938025140174) < 1.e-12); *** Electron-nucleus rescaled distances derivatives in $J_\text{eeN}$ - ~een_rescaled_n_deriv_e~ stores the table of the derivatives of the + ~een_rescaled_n_gl~ stores the table of the derivatives of the rescaled distances between all electron-nucleus pairs and raised to the power $p$ defined by ~cord_num~. Here we take its derivatives required for the een jastrow_champ. @@ -6747,14 +6748,14 @@ assert(fabs(een_rescaled_n[0][2][1][5]-0.01343938025140174) < 1.e-12); #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code -qmckl_get_jastrow_champ_een_rescaled_n_deriv_e(qmckl_context context, +qmckl_get_jastrow_champ_een_rescaled_n_gl(qmckl_context context, double* const 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_jastrow_champ_een_rescaled_n_deriv_e(qmckl_context context, +qmckl_get_jastrow_champ_een_rescaled_n_gl(qmckl_context context, double* const distance_rescaled, const int64_t size_max) { @@ -6764,7 +6765,7 @@ qmckl_get_jastrow_champ_een_rescaled_n_deriv_e(qmckl_context context, qmckl_exit_code rc; - rc = qmckl_provide_een_rescaled_n_deriv_e(context); + rc = qmckl_provide_een_rescaled_n_gl(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; @@ -6774,10 +6775,10 @@ qmckl_get_jastrow_champ_een_rescaled_n_deriv_e(qmckl_context context, if (size_max < sze) { return qmckl_failwith( context, QMCKL_INVALID_ARG_3, - "qmckl_get_jastrow_champ_factor_een_deriv_e", + "qmckl_get_jastrow_champ_factor_een_gl", "Array too small. Expected ctx->electron.num * 4 * ctx->nucleus.num * ctx->electron.walker.num * (ctx->jastrow_champ.cord_num + 1)"); } - memcpy(distance_rescaled, ctx->jastrow_champ.een_rescaled_n_deriv_e, sze * sizeof(double)); + memcpy(distance_rescaled, ctx->jastrow_champ.een_rescaled_n_gl, sze * sizeof(double)); return QMCKL_SUCCESS; } @@ -6786,11 +6787,11 @@ qmckl_get_jastrow_champ_een_rescaled_n_deriv_e(qmckl_context context, **** Provide :noexport: #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_een_rescaled_n_deriv_e(qmckl_context context); +qmckl_exit_code qmckl_provide_een_rescaled_n_gl(qmckl_context context); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_provide_een_rescaled_n_deriv_e(qmckl_context context) +qmckl_exit_code qmckl_provide_een_rescaled_n_gl(qmckl_context context) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -6809,38 +6810,38 @@ qmckl_exit_code qmckl_provide_een_rescaled_n_deriv_e(qmckl_context context) if(rc != QMCKL_SUCCESS) return rc; /* Compute if necessary */ - if (ctx->date > ctx->jastrow_champ.een_rescaled_n_deriv_e_date) { + if (ctx->date > ctx->jastrow_champ.een_rescaled_n_gl_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow_champ.een_rescaled_n_deriv_e != NULL) { - rc = qmckl_free(context, ctx->jastrow_champ.een_rescaled_n_deriv_e); + if (ctx->jastrow_champ.een_rescaled_n_gl != NULL) { + rc = qmckl_free(context, ctx->jastrow_champ.een_rescaled_n_gl); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_een_rescaled_n_deriv_e", - "Unable to free ctx->jastrow_champ.een_rescaled_n_deriv_e"); + "qmckl_provide_een_rescaled_n_gl", + "Unable to free ctx->jastrow_champ.een_rescaled_n_gl"); } - ctx->jastrow_champ.een_rescaled_n_deriv_e = NULL; + ctx->jastrow_champ.een_rescaled_n_gl = NULL; } } /* Allocate array */ - if (ctx->jastrow_champ.een_rescaled_n_deriv_e == NULL) { + if (ctx->jastrow_champ.een_rescaled_n_gl == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; mem_info.size = ctx->electron.num * 4 * ctx->nucleus.num * ctx->electron.walker.num * (ctx->jastrow_champ.cord_num + 1) * sizeof(double); - double* een_rescaled_n_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* een_rescaled_n_gl = (double*) qmckl_malloc(context, mem_info); - if (een_rescaled_n_deriv_e == NULL) { + if (een_rescaled_n_gl == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_een_rescaled_n_deriv_e", + "qmckl_provide_een_rescaled_n_gl", NULL); } - ctx->jastrow_champ.een_rescaled_n_deriv_e = een_rescaled_n_deriv_e; + ctx->jastrow_champ.een_rescaled_n_gl = een_rescaled_n_gl; } - rc = qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e(context, + rc = qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl(context, ctx->electron.walker.num, ctx->electron.num, ctx->nucleus.num, @@ -6852,12 +6853,12 @@ qmckl_exit_code qmckl_provide_een_rescaled_n_deriv_e(qmckl_context context) ctx->nucleus.coord.data, ctx->electron.en_distance, ctx->jastrow_champ.een_rescaled_n, - ctx->jastrow_champ.een_rescaled_n_deriv_e); + ctx->jastrow_champ.een_rescaled_n_gl); if (rc != QMCKL_SUCCESS) { return rc; } - ctx->jastrow_champ.een_rescaled_n_deriv_e_date = ctx->date; + ctx->jastrow_champ.een_rescaled_n_gl_date = ctx->date; } return QMCKL_SUCCESS; @@ -6866,12 +6867,12 @@ qmckl_exit_code qmckl_provide_een_rescaled_n_deriv_e(qmckl_context context) **** Compute :PROPERTIES: - :Name: qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e + :Name: qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_args + #+NAME: qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl_args | Variable | Type | In/Out | Description | |--------------------------+-------------------------------------------------------+--------+-------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -6886,13 +6887,13 @@ qmckl_exit_code qmckl_provide_een_rescaled_n_deriv_e(qmckl_context context) | ~coord_en~ | ~double[3][nucl_num]~ | in | Nuclear coordinates | | ~en_distance~ | ~double[walk_num][elec_num][nucl_num]~ | in | Electron-nucleus distances | | ~een_rescaled_n~ | ~double[walk_num][0:cord_num][nucl_num][elec_num]~ | in | Electron-nucleus distances | - | ~een_rescaled_n_deriv_e~ | ~double[walk_num][0:cord_num][nucl_num][4][elec_num]~ | out | Electron-nucleus rescaled distances | + | ~een_rescaled_n_gl~ | ~double[walk_num][0:cord_num][nucl_num][4][elec_num]~ | out | Electron-nucleus rescaled distances | #+begin_src f90 :comments org :tangle (eval f) :noweb yes -integer function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f( & +integer function qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl_f( & context, walk_num, elec_num, nucl_num, type_nucl_num, type_nucl_vector, & cord_num, rescale_factor_en, & - coord_ee, coord_en, en_distance, een_rescaled_n, een_rescaled_n_deriv_e) & + coord_ee, coord_en, en_distance, een_rescaled_n, een_rescaled_n_gl) & result(info) use qmckl implicit none @@ -6908,12 +6909,12 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f( & double precision , intent(in) :: coord_en(nucl_num,3) double precision , intent(in) :: en_distance(nucl_num,elec_num,walk_num) double precision , intent(in) :: een_rescaled_n(elec_num,nucl_num,0:cord_num,walk_num) - double precision , intent(out) :: een_rescaled_n_deriv_e(elec_num,4,nucl_num,0:cord_num,walk_num) - double precision,dimension(:,:,:),allocatable :: elnuc_dist_deriv_e + double precision , intent(out) :: een_rescaled_n_gl(elec_num,4,nucl_num,0:cord_num,walk_num) + double precision,dimension(:,:,:),allocatable :: elnuc_dist_gl double precision :: x, ria_inv, kappa_l integer*8 :: i, a, k, l, nw, ii - allocate(elnuc_dist_deriv_e(4, elec_num, nucl_num)) + allocate(elnuc_dist_gl(4, elec_num, nucl_num)) info = QMCKL_SUCCESS @@ -6943,7 +6944,7 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f( & endif ! Prepare table of exponentiated distances raised to appropriate power - een_rescaled_n_deriv_e = 0.0d0 + een_rescaled_n_gl = 0.0d0 do nw = 1, walk_num ! prepare the actual een table @@ -6951,9 +6952,9 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f( & do i = 1, elec_num ria_inv = 1.0d0 / en_distance(a, i, nw) do ii = 1, 3 - elnuc_dist_deriv_e(ii, i, a) = (coord_ee(i, ii, nw) - coord_en(a, ii)) * ria_inv + elnuc_dist_gl(ii, i, a) = (coord_ee(i, ii, nw) - coord_en(a, ii)) * ria_inv end do - elnuc_dist_deriv_e(4, i, a) = 2.0d0 * ria_inv + elnuc_dist_gl(4, i, a) = 2.0d0 * ria_inv end do end do @@ -6961,36 +6962,36 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f( & do a = 1, nucl_num kappa_l = - dble(l) * rescale_factor_en(type_nucl_vector(a)+1) do i = 1, elec_num - een_rescaled_n_deriv_e(i, 1, a, l, nw) = kappa_l * elnuc_dist_deriv_e(1, i, a) - een_rescaled_n_deriv_e(i, 2, a, l, nw) = kappa_l * elnuc_dist_deriv_e(2, i, a) - een_rescaled_n_deriv_e(i, 3, a, l, nw) = kappa_l * elnuc_dist_deriv_e(3, i, a) - een_rescaled_n_deriv_e(i, 4, a, l, nw) = kappa_l * elnuc_dist_deriv_e(4, i, a) + een_rescaled_n_gl(i, 1, a, l, nw) = kappa_l * elnuc_dist_gl(1, i, a) + een_rescaled_n_gl(i, 2, a, l, nw) = kappa_l * elnuc_dist_gl(2, i, a) + een_rescaled_n_gl(i, 3, a, l, nw) = kappa_l * elnuc_dist_gl(3, i, a) + een_rescaled_n_gl(i, 4, a, l, nw) = kappa_l * elnuc_dist_gl(4, i, a) - een_rescaled_n_deriv_e(i, 4, a, l, nw) = een_rescaled_n_deriv_e(i, 4, a, l, nw) & - + een_rescaled_n_deriv_e(i, 1, a, l, nw) * een_rescaled_n_deriv_e(i, 1, a, l, nw) & - + een_rescaled_n_deriv_e(i, 2, a, l, nw) * een_rescaled_n_deriv_e(i, 2, a, l, nw) & - + een_rescaled_n_deriv_e(i, 3, a, l, nw) * een_rescaled_n_deriv_e(i, 3, a, l, nw) + een_rescaled_n_gl(i, 4, a, l, nw) = een_rescaled_n_gl(i, 4, a, l, nw) & + + een_rescaled_n_gl(i, 1, a, l, nw) * een_rescaled_n_gl(i, 1, a, l, nw) & + + een_rescaled_n_gl(i, 2, a, l, nw) * een_rescaled_n_gl(i, 2, a, l, nw) & + + een_rescaled_n_gl(i, 3, a, l, nw) * een_rescaled_n_gl(i, 3, a, l, nw) - een_rescaled_n_deriv_e(i, 1, a, l, nw) = een_rescaled_n_deriv_e(i, 1, a, l, nw) * & + een_rescaled_n_gl(i, 1, a, l, nw) = een_rescaled_n_gl(i, 1, a, l, nw) * & een_rescaled_n(i, a, l, nw) - een_rescaled_n_deriv_e(i, 2, a, l, nw) = een_rescaled_n_deriv_e(i, 2, a, l, nw) * & + een_rescaled_n_gl(i, 2, a, l, nw) = een_rescaled_n_gl(i, 2, a, l, nw) * & een_rescaled_n(i, a, l, nw) - een_rescaled_n_deriv_e(i, 3, a, l, nw) = een_rescaled_n_deriv_e(i, 3, a, l, nw) * & + een_rescaled_n_gl(i, 3, a, l, nw) = een_rescaled_n_gl(i, 3, a, l, nw) * & een_rescaled_n(i, a, l, nw) - een_rescaled_n_deriv_e(i, 4, a, l, nw) = een_rescaled_n_deriv_e(i, 4, a, l, nw) * & + een_rescaled_n_gl(i, 4, a, l, nw) = een_rescaled_n_gl(i, 4, a, l, nw) * & een_rescaled_n(i, a, l, nw) end do end do end do end do -end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f +end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl_f #+end_src - # #+CALL: generate_c_header(table=qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_compute_jastrow_champ_factor_een_rescaled_n_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_een_rescaled_n_deriv_e ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -7003,14 +7004,14 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f const double* coord_en, const double* en_distance, const double* een_rescaled_n, - double* const een_rescaled_n_deriv_e ); + double* const een_rescaled_n_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e & + integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl & (context, & walk_num, & elec_num, & @@ -7023,7 +7024,7 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f coord_en, & en_distance, & een_rescaled_n, & - een_rescaled_n_deriv_e) & + een_rescaled_n_gl) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -7041,10 +7042,10 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f real (c_double ) , intent(in) :: coord_en(nucl_num,3) real (c_double ) , intent(in) :: en_distance(nucl_num,elec_num,walk_num) real (c_double ) , intent(in) :: een_rescaled_n(elec_num,nucl_num,0:cord_num,walk_num) - real (c_double ) , intent(out) :: een_rescaled_n_deriv_e(elec_num,4,nucl_num,0:cord_num,walk_num) + real (c_double ) , intent(out) :: een_rescaled_n_gl(elec_num,4,nucl_num,0:cord_num,walk_num) - integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f - info = qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f & + integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl_f + info = qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl_f & (context, & walk_num, & elec_num, & @@ -7057,9 +7058,9 @@ end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e_f coord_en, & en_distance, & een_rescaled_n, & - een_rescaled_n_deriv_e) + een_rescaled_n_gl) - end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_deriv_e + end function qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl #+end_src **** Test @@ -7076,13 +7077,13 @@ for i in range(elec_num): for a in range(nucl_num): elnuc_dist[i, a] = np.linalg.norm(elec_coord[i] - nucl_coord[:,a]) -elnuc_dist_deriv_e = np.zeros(shape=(4, elec_num, nucl_num),dtype=float) +elnuc_dist_gl = np.zeros(shape=(4, elec_num, nucl_num),dtype=float) for a in range(nucl_num): for i in range(elec_num): rij_inv = 1.0 / elnuc_dist[i, a] for ii in range(3): - elnuc_dist_deriv_e[ii, i, a] = (elec_coord[i][ii] - nucl_coord[ii][a]) * rij_inv - elnuc_dist_deriv_e[3, i, a] = 2.0 * rij_inv + elnuc_dist_gl[ii, i, a] = (elec_coord[i][ii] - nucl_coord[ii][a]) * rij_inv + elnuc_dist_gl[3, i, a] = 2.0 * rij_inv kappa = 1.0 @@ -7098,51 +7099,51 @@ for l in range(2,cord_num+1): for i in range(elec_num): een_rescaled_n[a, i, l] = een_rescaled_n[a, i, l - 1] * een_rescaled_n[a, i, 1] -een_rescaled_n_deriv_e = np.zeros(shape=(elec_num,4,nucl_num,cord_num+1),dtype=float) +een_rescaled_n_gl = np.zeros(shape=(elec_num,4,nucl_num,cord_num+1),dtype=float) for l in range(0,cord_num+1): kappa_l = -1.0 * kappa * l for j in range(0,elec_num): for a in range(0,nucl_num): for ii in range(0,4): - een_rescaled_n_deriv_e[j,ii,a,l] = kappa_l * elnuc_dist_deriv_e[ii,j,a] - een_rescaled_n_deriv_e[j,3,a,l] = een_rescaled_n_deriv_e[j,3,a,l] + \ - een_rescaled_n_deriv_e[j,0,a,l] * een_rescaled_n_deriv_e[j,0,a,l] + \ - een_rescaled_n_deriv_e[j,1,a,l] * een_rescaled_n_deriv_e[j,1,a,l] + \ - een_rescaled_n_deriv_e[j,2,a,l] * een_rescaled_n_deriv_e[j,2,a,l] + een_rescaled_n_gl[j,ii,a,l] = kappa_l * elnuc_dist_gl[ii,j,a] + een_rescaled_n_gl[j,3,a,l] = een_rescaled_n_gl[j,3,a,l] + \ + een_rescaled_n_gl[j,0,a,l] * een_rescaled_n_gl[j,0,a,l] + \ + een_rescaled_n_gl[j,1,a,l] * een_rescaled_n_gl[j,1,a,l] + \ + een_rescaled_n_gl[j,2,a,l] * een_rescaled_n_gl[j,2,a,l] for ii in range(0,4): - een_rescaled_n_deriv_e[j,ii,a,l] = een_rescaled_n_deriv_e[j,ii,a,l] * een_rescaled_n[a,j,l] + een_rescaled_n_gl[j,ii,a,l] = een_rescaled_n_gl[j,ii,a,l] * een_rescaled_n[a,j,l] -print(" een_rescaled_n_deriv_e[1, 1, 3, 1] = ",een_rescaled_n_deriv_e[2, 0, 0, 1]) -print(" een_rescaled_n_deriv_e[1, 1, 4, 1] = ",een_rescaled_n_deriv_e[3, 0, 0, 1]) -print(" een_rescaled_n_deriv_e[1, 1, 5, 1] = ",een_rescaled_n_deriv_e[4, 0, 0, 1]) -print(" een_rescaled_n_deriv_e[2, 1, 4, 2] = ",een_rescaled_n_deriv_e[3, 0, 1, 2]) -print(" een_rescaled_n_deriv_e[2, 1, 5, 2] = ",een_rescaled_n_deriv_e[4, 0, 1, 2]) -print(" een_rescaled_n_deriv_e[2, 1, 6, 2] = ",een_rescaled_n_deriv_e[5, 0, 1, 2]) +print(" een_rescaled_n_gl[1, 1, 3, 1] = ",een_rescaled_n_gl[2, 0, 0, 1]) +print(" een_rescaled_n_gl[1, 1, 4, 1] = ",een_rescaled_n_gl[3, 0, 0, 1]) +print(" een_rescaled_n_gl[1, 1, 5, 1] = ",een_rescaled_n_gl[4, 0, 0, 1]) +print(" een_rescaled_n_gl[2, 1, 4, 2] = ",een_rescaled_n_gl[3, 0, 1, 2]) +print(" een_rescaled_n_gl[2, 1, 5, 2] = ",een_rescaled_n_gl[4, 0, 1, 2]) +print(" een_rescaled_n_gl[2, 1, 6, 2] = ",een_rescaled_n_gl[5, 0, 1, 2]) #+end_src #+RESULTS: - : een_rescaled_n_deriv_e[1, 1, 3, 1] = -0.07633444246999128 - : een_rescaled_n_deriv_e[1, 1, 4, 1] = 0.00033282346259738276 - : een_rescaled_n_deriv_e[1, 1, 5, 1] = -0.004775370547333061 - : een_rescaled_n_deriv_e[2, 1, 4, 2] = 0.1362654644223866 - : een_rescaled_n_deriv_e[2, 1, 5, 2] = -0.0231253431662794 - : een_rescaled_n_deriv_e[2, 1, 6, 2] = 0.001593334817691633 + : een_rescaled_n_gl[1, 1, 3, 1] = -0.07633444246999128 + : een_rescaled_n_gl[1, 1, 4, 1] = 0.00033282346259738276 + : een_rescaled_n_gl[1, 1, 5, 1] = -0.004775370547333061 + : een_rescaled_n_gl[2, 1, 4, 2] = 0.1362654644223866 + : een_rescaled_n_gl[2, 1, 5, 2] = -0.0231253431662794 + : een_rescaled_n_gl[2, 1, 6, 2] = 0.001593334817691633 #+begin_src c :tangle (eval c_test) assert(qmckl_electron_provided(context)); -double een_rescaled_n_deriv_e[walk_num][(cord_num + 1)][nucl_num][4][elec_num]; +double een_rescaled_n_gl[walk_num][(cord_num + 1)][nucl_num][4][elec_num]; size_max=walk_num*(cord_num + 1)*nucl_num*4*elec_num; -rc = qmckl_get_jastrow_champ_een_rescaled_n_deriv_e(context, &(een_rescaled_n_deriv_e[0][0][0][0][0]),size_max); +rc = qmckl_get_jastrow_champ_een_rescaled_n_gl(context, &(een_rescaled_n_gl[0][0][0][0][0]),size_max); // value of (0,2,1) -assert(fabs(een_rescaled_n_deriv_e[0][1][0][0][2]+0.07633444246999128 ) < 1.e-12); -assert(fabs(een_rescaled_n_deriv_e[0][1][0][0][3]-0.00033282346259738276) < 1.e-12); -assert(fabs(een_rescaled_n_deriv_e[0][1][0][0][4]+0.004775370547333061 ) < 1.e-12); -assert(fabs(een_rescaled_n_deriv_e[0][2][1][0][3]-0.1362654644223866 ) < 1.e-12); -assert(fabs(een_rescaled_n_deriv_e[0][2][1][0][4]+0.0231253431662794 ) < 1.e-12); -assert(fabs(een_rescaled_n_deriv_e[0][2][1][0][5]-0.001593334817691633 ) < 1.e-12); +assert(fabs(een_rescaled_n_gl[0][1][0][0][2]+0.07633444246999128 ) < 1.e-12); +assert(fabs(een_rescaled_n_gl[0][1][0][0][3]-0.00033282346259738276) < 1.e-12); +assert(fabs(een_rescaled_n_gl[0][1][0][0][4]+0.004775370547333061 ) < 1.e-12); +assert(fabs(een_rescaled_n_gl[0][2][1][0][3]-0.1362654644223866 ) < 1.e-12); +assert(fabs(een_rescaled_n_gl[0][2][1][0][4]+0.0231253431662794 ) < 1.e-12); +assert(fabs(een_rescaled_n_gl[0][2][1][0][5]-0.001593334817691633 ) < 1.e-12); #+end_src @@ -7150,7 +7151,7 @@ assert(fabs(een_rescaled_n_deriv_e[0][2][1][0][5]-0.001593334817691633 ) < 1.e Prepare ~c_vector_full~ and ~lkpm_combined_index~ tables required for the calculation of the three-body jastrow ~factor_een~ and its derivative - ~factor_een_deriv_e~. + ~factor_een_gl~. **** Get @@ -7410,7 +7411,7 @@ qmckl_exit_code qmckl_provide_dtmp_c(qmckl_context context) qmckl_context_struct* const ctx = (qmckl_context_struct*) context; assert (ctx != NULL); - rc = qmckl_provide_een_rescaled_e_deriv_e(context); + rc = qmckl_provide_een_rescaled_e_gl(context); if (rc != QMCKL_SUCCESS) return rc; rc = qmckl_provide_een_rescaled_n(context); @@ -7454,7 +7455,7 @@ qmckl_exit_code qmckl_provide_dtmp_c(qmckl_context context) ctx->electron.num, ctx->nucleus.num, ctx->electron.walker.num, - ctx->jastrow_champ.een_rescaled_e_deriv_e, + ctx->jastrow_champ.een_rescaled_e_gl, ctx->jastrow_champ.een_rescaled_n, ctx->jastrow_champ.dtmp_c); @@ -8168,7 +8169,7 @@ qmckl_exit_code qmckl_compute_tmp_c_hpc (const qmckl_context context, | ~elec_num~ | ~int64_t~ | in | Number of electrons | | ~nucl_num~ | ~int64_t~ | in | Number of nuclei | | ~walk_num~ | ~int64_t~ | in | Number of walkers | - | ~een_rescaled_e_deriv_e~ | ~double[walk_num][0:cord_num][elec_num][4][elec_num]~ | in | Electron-electron rescaled factor derivatives | + | ~een_rescaled_e_gl~ | ~double[walk_num][0:cord_num][elec_num][4][elec_num]~ | in | Electron-electron rescaled factor derivatives | | ~een_rescaled_n~ | ~double[walk_num][0:cord_num][nucl_num][elec_num]~ | in | Electron-nucleus rescaled factor | | ~dtmp_c~ | ~double[walk_num][0:cord_num-1][0:cord_num][nucl_num][elec_num]~ | out | vector of non-zero coefficients | @@ -8180,7 +8181,7 @@ qmckl_compute_dtmp_c (const qmckl_context context, const int64_t elec_num, const int64_t nucl_num, const int64_t walk_num, - const double* een_rescaled_e_deriv_e, + const double* een_rescaled_e_gl, const double* een_rescaled_n, double* const dtmp_c ); #+end_src @@ -8192,15 +8193,15 @@ qmckl_compute_dtmp_c (const qmckl_context context, const int64_t elec_num, const int64_t nucl_num, const int64_t walk_num, - const double* een_rescaled_e_deriv_e, + const double* een_rescaled_e_gl, const double* een_rescaled_n, 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_deriv_e, + return qmckl_compute_dtmp_c_hpc (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_gl, een_rescaled_n, dtmp_c ); #else - return qmckl_compute_dtmp_c_doc (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_deriv_e, + return qmckl_compute_dtmp_c_doc (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_gl, een_rescaled_n, dtmp_c ); #endif } @@ -8209,7 +8210,7 @@ qmckl_compute_dtmp_c (const qmckl_context context, #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_dtmp_c_doc_f( & context, cord_num, elec_num, nucl_num, & - walk_num, een_rescaled_e_deriv_e, een_rescaled_n, dtmp_c) & + walk_num, een_rescaled_e_gl, een_rescaled_n, dtmp_c) & result(info) use qmckl implicit none @@ -8218,7 +8219,7 @@ integer function qmckl_compute_dtmp_c_doc_f( & integer*8 , intent(in) :: elec_num integer*8 , intent(in) :: nucl_num integer*8 , intent(in) :: walk_num - double precision , intent(in) :: een_rescaled_e_deriv_e(elec_num, 4, elec_num, 0:cord_num, walk_num) + double precision , intent(in) :: een_rescaled_e_gl(elec_num, 4, elec_num, 0:cord_num, walk_num) double precision , intent(in) :: een_rescaled_n(elec_num, nucl_num, 0:cord_num, walk_num) double precision , intent(out) :: dtmp_c(elec_num, 4, nucl_num,0:cord_num, 0:cord_num-1, walk_num) double precision :: x @@ -8257,14 +8258,14 @@ integer function qmckl_compute_dtmp_c_doc_f( & M = 4*elec_num N = nucl_num*(cord_num + 1) K = elec_num - LDA = 4*size(een_rescaled_e_deriv_e,1) + LDA = 4*size(een_rescaled_e_gl,1) LDB = size(een_rescaled_n,1) LDC = 4*size(dtmp_c,1) do nw=1, walk_num do i=0, cord_num-1 info = qmckl_dgemm(context,TransA, TransB, M, N, K, alpha, & - een_rescaled_e_deriv_e(1,1,1,i,nw),LDA*1_8, & + een_rescaled_e_gl(1,1,1,i,nw),LDA*1_8, & een_rescaled_n(1,1,0,nw),LDB*1_8, & beta, & dtmp_c(1,1,1,0,i,nw),LDC) @@ -8279,7 +8280,7 @@ end function qmckl_compute_dtmp_c_doc_f #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_dtmp_c_doc & - (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_deriv_e, een_rescaled_n, dtmp_c) & + (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_gl, een_rescaled_n, dtmp_c) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -8290,13 +8291,13 @@ integer(c_int32_t) function qmckl_compute_dtmp_c_doc & 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 :: walk_num - real (c_double ) , intent(in) :: een_rescaled_e_deriv_e(elec_num,4,elec_num,0:cord_num,walk_num) + real (c_double ) , intent(in) :: een_rescaled_e_gl(elec_num,4,elec_num,0:cord_num,walk_num) real (c_double ) , intent(in) :: een_rescaled_n(elec_num,nucl_num,0:cord_num,walk_num) real (c_double ) , intent(out) :: dtmp_c(elec_num,nucl_num,0:cord_num,0:cord_num-1,walk_num) integer(c_int32_t), external :: qmckl_compute_dtmp_c_doc_f info = qmckl_compute_dtmp_c_doc_f & - (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_deriv_e, een_rescaled_n, dtmp_c) + (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e_gl, een_rescaled_n, dtmp_c) end function qmckl_compute_dtmp_c_doc #+end_src @@ -8308,7 +8309,7 @@ qmckl_exit_code qmckl_compute_dtmp_c_doc ( const int64_t elec_num, const int64_t nucl_num, const int64_t walk_num, - const double* een_rescaled_e_deriv_e, + const double* een_rescaled_e_gl, const double* een_rescaled_n, double* const dtmp_c ); #+end_src @@ -8322,7 +8323,7 @@ qmckl_compute_dtmp_c_hpc (const qmckl_context context, const int64_t elec_num, const int64_t nucl_num, const int64_t walk_num, - const double* een_rescaled_e_deriv_e, + const double* een_rescaled_e_gl, const double* een_rescaled_n, double* const dtmp_c ) { @@ -8372,7 +8373,7 @@ qmckl_compute_dtmp_c_hpc (const qmckl_context context, for (int64_t nw=0; nw < walk_num; ++nw) { for (int64_t i=0; i < cord_num; ++i) { info = qmckl_dgemm(context, TransA, TransB, M, N, K, alpha, - &(een_rescaled_e_deriv_e[af*(i+nw*(cord_num+1))]), LDA, + &(een_rescaled_e_gl[af*(i+nw*(cord_num+1))]), LDA, &(een_rescaled_n[bf*nw]), LDB, beta, &(dtmp_c[cf*(i+nw*cord_num)]), LDC); } @@ -8389,7 +8390,7 @@ qmckl_exit_code qmckl_compute_dtmp_c_hpc ( const int64_t elec_num, const int64_t nucl_num, const int64_t walk_num, - const double* een_rescaled_e_deriv_e, + const double* een_rescaled_e_gl, const double* een_rescaled_n, double* const dtmp_c ); #+end_src @@ -9052,7 +9053,7 @@ assert(fabs(factor_een[0] + 0.37407972141304213) < 1e-12); *** Electron-electron-nucleus Jastrow $f_{een}$ derivative - Calculate the electron-electron-nuclear three-body jastrow component ~factor_een_deriv_e~ + Calculate the electron-electron-nuclear three-body jastrow component ~factor_een_gl~ using the above prepared tables. TODO: write equations. @@ -9060,15 +9061,15 @@ assert(fabs(factor_een[0] + 0.37407972141304213) < 1e-12); **** Get #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code -qmckl_get_jastrow_champ_factor_een_deriv_e(qmckl_context context, - double* const factor_een_deriv_e, +qmckl_get_jastrow_champ_factor_een_gl(qmckl_context context, + double* const factor_een_gl, const int64_t size_max); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code -qmckl_get_jastrow_champ_factor_een_deriv_e(qmckl_context context, - double* const factor_een_deriv_e, +qmckl_get_jastrow_champ_factor_een_gl(qmckl_context context, + double* const factor_een_gl, const int64_t size_max) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -9077,7 +9078,7 @@ qmckl_get_jastrow_champ_factor_een_deriv_e(qmckl_context context, qmckl_exit_code rc; - rc = qmckl_provide_jastrow_champ_factor_een_deriv_e(context); + rc = qmckl_provide_jastrow_champ_factor_een_gl(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; @@ -9087,10 +9088,10 @@ qmckl_get_jastrow_champ_factor_een_deriv_e(qmckl_context context, if (size_max < sze) { return qmckl_failwith( context, QMCKL_INVALID_ARG_3, - "qmckl_get_jastrow_champ_factor_een_deriv_e", + "qmckl_get_jastrow_champ_factor_een_gl", "Array too small. Expected 4*walk_num*elec_num"); } - memcpy(factor_een_deriv_e, ctx->jastrow_champ.factor_een_deriv_e, sze*sizeof(double)); + memcpy(factor_een_gl, ctx->jastrow_champ.factor_een_gl, sze*sizeof(double)); return QMCKL_SUCCESS; } @@ -9098,11 +9099,11 @@ qmckl_get_jastrow_champ_factor_een_deriv_e(qmckl_context context, **** Provide :noexport: #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_deriv_e(qmckl_context context); +qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_gl(qmckl_context context); #+end_src #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_deriv_e(qmckl_context context) +qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_gl(qmckl_context context) { qmckl_exit_code rc; @@ -9125,11 +9126,11 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_deriv_e(qmckl_context con if(rc != QMCKL_SUCCESS) return rc; /* Check if en rescaled distance is provided */ - rc = qmckl_provide_een_rescaled_e_deriv_e(context); + rc = qmckl_provide_een_rescaled_e_gl(context); if(rc != QMCKL_SUCCESS) return rc; /* Check if en rescaled distance derivatives is provided */ - rc = qmckl_provide_een_rescaled_n_deriv_e(context); + rc = qmckl_provide_een_rescaled_n_gl(context); if(rc != QMCKL_SUCCESS) return rc; /* Check if en rescaled distance derivatives is provided */ @@ -9151,37 +9152,37 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_deriv_e(qmckl_context con } /* Compute if necessary */ - if (ctx->date > ctx->jastrow_champ.factor_een_deriv_e_date) { + if (ctx->date > ctx->jastrow_champ.factor_een_gl_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow_champ.factor_een_deriv_e != NULL) { - rc = qmckl_free(context, ctx->jastrow_champ.factor_een_deriv_e); + if (ctx->jastrow_champ.factor_een_gl != NULL) { + rc = qmckl_free(context, ctx->jastrow_champ.factor_een_gl); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_jastrow_champ_factor_een_deriv_e", - "Unable to free ctx->jastrow_champ.factor_een_deriv_e"); + "qmckl_provide_jastrow_champ_factor_een_gl", + "Unable to free ctx->jastrow_champ.factor_een_gl"); } - ctx->jastrow_champ.factor_een_deriv_e = NULL; + ctx->jastrow_champ.factor_een_gl = NULL; } } /* Allocate array */ - if (ctx->jastrow_champ.factor_een_deriv_e == NULL) { + if (ctx->jastrow_champ.factor_een_gl == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; mem_info.size = 4 * ctx->electron.num * ctx->electron.walker.num * sizeof(double); - double* factor_een_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* factor_een_gl = (double*) qmckl_malloc(context, mem_info); - if (factor_een_deriv_e == NULL) { + if (factor_een_gl == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_jastrow_champ_factor_een_deriv_e", + "qmckl_provide_jastrow_champ_factor_een_gl", NULL); } - ctx->jastrow_champ.factor_een_deriv_e = factor_een_deriv_e; + ctx->jastrow_champ.factor_een_gl = factor_een_gl; } - rc = qmckl_compute_jastrow_champ_factor_een_deriv_e(context, + rc = qmckl_compute_jastrow_champ_factor_een_gl(context, ctx->electron.walker.num, ctx->electron.num, ctx->nucleus.num, @@ -9192,13 +9193,13 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_deriv_e(qmckl_context con ctx->jastrow_champ.tmp_c, ctx->jastrow_champ.dtmp_c, ctx->jastrow_champ.een_rescaled_n, - ctx->jastrow_champ.een_rescaled_n_deriv_e, - ctx->jastrow_champ.factor_een_deriv_e); + ctx->jastrow_champ.een_rescaled_n_gl, + ctx->jastrow_champ.factor_een_gl); if (rc != QMCKL_SUCCESS) { return rc; } - ctx->jastrow_champ.factor_een_deriv_e_date = ctx->date; + ctx->jastrow_champ.factor_een_gl_date = ctx->date; } return QMCKL_SUCCESS; @@ -9207,12 +9208,12 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_deriv_e(qmckl_context con **** Compute Naive :PROPERTIES: - :Name: qmckl_compute_jastrow_champ_factor_een_deriv_e_naive + :Name: qmckl_compute_jastrow_champ_factor_een_gl_naive :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_factor_een_deriv_e_naive_args + #+NAME: qmckl_factor_een_gl_naive_args | Variable | Type | In/Out | Description | |--------------------------+-------------------------------------------------------+--------+--------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -9225,15 +9226,15 @@ qmckl_exit_code qmckl_provide_jastrow_champ_factor_een_deriv_e(qmckl_context con | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | in | combined indices | | ~een_rescaled_e~ | ~double[walk_num][elec_num][elec_num][0:cord_num]~ | in | Electron-nucleus rescaled | | ~een_rescaled_n~ | ~double[walk_num][elec_num][nucl_num][0:cord_num]~ | in | Electron-nucleus rescaled factor | - | ~een_rescaled_e_deriv_e~ | ~double[walk_num][elec_num][4][elec_num][0:cord_num]~ | in | Electron-nucleus rescaled | - | ~een_rescaled_n_deriv_e~ | ~double[walk_num][elec_num][4][nucl_num][0:cord_num]~ | in | Electron-nucleus rescaled factor | - | ~factor_een_deriv_e~ | ~double[walk_num][4][elec_num]~ | out | Electron-nucleus jastrow | + | ~een_rescaled_e_gl~ | ~double[walk_num][elec_num][4][elec_num][0:cord_num]~ | in | Electron-nucleus rescaled | + | ~een_rescaled_n_gl~ | ~double[walk_num][elec_num][4][nucl_num][0:cord_num]~ | in | Electron-nucleus rescaled factor | + | ~factor_een_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_een_deriv_e_naive_f( & +integer function qmckl_compute_jastrow_champ_factor_een_gl_naive_f( & context, walk_num, elec_num, nucl_num, cord_num, dim_c_vector, & c_vector_full, lkpm_combined_index, een_rescaled_e, een_rescaled_n, & - een_rescaled_e_deriv_e, een_rescaled_n_deriv_e, factor_een_deriv_e)& + een_rescaled_e_gl, een_rescaled_n_gl, factor_een_gl)& result(info) use qmckl implicit none @@ -9243,9 +9244,9 @@ integer function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f( & double precision , intent(in) :: c_vector_full(nucl_num, dim_c_vector) double precision , intent(in) :: een_rescaled_e(0:cord_num, elec_num, elec_num, walk_num) double precision , intent(in) :: een_rescaled_n(0:cord_num, nucl_num, elec_num, walk_num) - double precision , intent(in) :: een_rescaled_e_deriv_e(0:cord_num, elec_num, 4, elec_num, walk_num) - double precision , intent(in) :: een_rescaled_n_deriv_e(0:cord_num, nucl_num, 4, elec_num, walk_num) - double precision , intent(out) :: factor_een_deriv_e(elec_num, 4, walk_num) + double precision , intent(in) :: een_rescaled_e_gl(0:cord_num, elec_num, 4, elec_num, walk_num) + double precision , intent(in) :: een_rescaled_n_gl(0:cord_num, nucl_num, 4, elec_num, walk_num) + double precision , intent(out) :: factor_een_gl(elec_num, 4, walk_num) integer*8 :: i, a, j, l, k, p, m, n, nw double precision :: accu, accu2, cn @@ -9278,7 +9279,7 @@ integer function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f( & return endif - factor_een_deriv_e = 0.0d0 + factor_een_gl = 0.0d0 do nw =1, walk_num do n = 1, dim_c_vector @@ -9299,37 +9300,37 @@ integer function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f( & een_rescaled_n(m, a, i, nw) accu2 = accu2 + een_rescaled_e(k, i, j, nw) * & een_rescaled_n(m + l, a, i, nw) - daccu(1:4) = daccu(1:4) + een_rescaled_e_deriv_e(k, j, 1:4, i, nw) * & + daccu(1:4) = daccu(1:4) + een_rescaled_e_gl(k, j, 1:4, i, nw) * & een_rescaled_n(m, a, i, nw) - daccu2(1:4) = daccu2(1:4) + een_rescaled_e_deriv_e(k, j, 1:4, i, nw) * & + daccu2(1:4) = daccu2(1:4) + een_rescaled_e_gl(k, j, 1:4, i, nw) * & een_rescaled_n(m + l, a, i, nw) end do - factor_een_deriv_e(j, 1:4, nw) = factor_een_deriv_e(j, 1:4, nw) + & - (accu * een_rescaled_n_deriv_e(m + l, a, 1:4, j, nw) & + factor_een_gl(j, 1:4, nw) = factor_een_gl(j, 1:4, nw) + & + (accu * een_rescaled_n_gl(m + l, a, 1:4, j, nw) & + daccu(1:4) * een_rescaled_n(m + l, a, j, nw) & + daccu2(1:4) * een_rescaled_n(m, a, j, nw) & - + accu2 * een_rescaled_n_deriv_e(m, a, 1:4, j, nw)) * cn + + accu2 * een_rescaled_n_gl(m, a, 1:4, j, nw)) * cn - factor_een_deriv_e(j, 4, nw) = factor_een_deriv_e(j, 4, nw) + 2.0d0 * ( & - daccu (1) * een_rescaled_n_deriv_e(m + l, a, 1, j, nw) + & - daccu (2) * een_rescaled_n_deriv_e(m + l, a, 2, j, nw) + & - daccu (3) * een_rescaled_n_deriv_e(m + l, a, 3, j, nw) + & - daccu2(1) * een_rescaled_n_deriv_e(m, a, 1, j, nw ) + & - daccu2(2) * een_rescaled_n_deriv_e(m, a, 2, j, nw ) + & - daccu2(3) * een_rescaled_n_deriv_e(m, a, 3, j, nw ) ) * cn + factor_een_gl(j, 4, nw) = factor_een_gl(j, 4, nw) + 2.0d0 * ( & + daccu (1) * een_rescaled_n_gl(m + l, a, 1, j, nw) + & + daccu (2) * een_rescaled_n_gl(m + l, a, 2, j, nw) + & + daccu (3) * een_rescaled_n_gl(m + l, a, 3, j, nw) + & + daccu2(1) * een_rescaled_n_gl(m, a, 1, j, nw ) + & + daccu2(2) * een_rescaled_n_gl(m, a, 2, j, nw ) + & + daccu2(3) * een_rescaled_n_gl(m, a, 3, j, nw ) ) * cn end do end do end do end do -end function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f +end function qmckl_compute_jastrow_champ_factor_een_gl_naive_f #+end_src - # #+CALL: generate_c_header(table=qmckl_factor_een_deriv_e_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_een_gl_naive_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_een_deriv_e_naive ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_een_gl_naive ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -9340,17 +9341,17 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f const int64_t* lkpm_combined_index, const double* een_rescaled_e, const double* een_rescaled_n, - const double* een_rescaled_e_deriv_e, - const double* een_rescaled_n_deriv_e, - double* const factor_een_deriv_e ); + const double* een_rescaled_e_gl, + const double* een_rescaled_n_gl, + double* const factor_een_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_deriv_e_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_factor_een_gl_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive & + integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_gl_naive & (context, & walk_num, & elec_num, & @@ -9361,9 +9362,9 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f lkpm_combined_index, & een_rescaled_e, & een_rescaled_n, & - een_rescaled_e_deriv_e, & - een_rescaled_n_deriv_e, & - factor_een_deriv_e) & + een_rescaled_e_gl, & + een_rescaled_n_gl, & + factor_een_gl) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -9379,12 +9380,12 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f integer (c_int64_t) , intent(in) :: lkpm_combined_index(dim_c_vector,4) real (c_double ) , intent(in) :: een_rescaled_e(0:cord_num,elec_num,elec_num,walk_num) real (c_double ) , intent(in) :: een_rescaled_n(0:cord_num,nucl_num,elec_num,walk_num) - real (c_double ) , intent(in) :: een_rescaled_e_deriv_e(0:cord_num,elec_num,4,elec_num,walk_num) - real (c_double ) , intent(in) :: een_rescaled_n_deriv_e(0:cord_num,nucl_num,4,elec_num,walk_num) - real (c_double ) , intent(out) :: factor_een_deriv_e(elec_num,4,walk_num) + real (c_double ) , intent(in) :: een_rescaled_e_gl(0:cord_num,elec_num,4,elec_num,walk_num) + real (c_double ) , intent(in) :: een_rescaled_n_gl(0:cord_num,nucl_num,4,elec_num,walk_num) + real (c_double ) , intent(out) :: factor_een_gl(elec_num,4,walk_num) - integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f - info = qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f & + integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_gl_naive_f + info = qmckl_compute_jastrow_champ_factor_een_gl_naive_f & (context, & walk_num, & elec_num, & @@ -9395,21 +9396,21 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f lkpm_combined_index, & een_rescaled_e, & een_rescaled_n, & - een_rescaled_e_deriv_e, & - een_rescaled_n_deriv_e, & - factor_een_deriv_e) + een_rescaled_e_gl, & + een_rescaled_n_gl, & + factor_een_gl) - end function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive + end function qmckl_compute_jastrow_champ_factor_een_gl_naive #+end_src **** Compute :PROPERTIES: - :Name: qmckl_compute_jastrow_champ_factor_een_deriv_e + :Name: qmckl_compute_jastrow_champ_factor_een_gl :CRetType: qmckl_exit_code :FRetType: qmckl_exit_code :END: - #+NAME: qmckl_factor_een_deriv_e_args + #+NAME: qmckl_factor_een_gl_args | Variable | Type | In/Out | Description | |--------------------------+---------------------------------------------------------------------+--------+------------------------------------------------| | ~context~ | ~qmckl_context~ | in | Global state | @@ -9423,15 +9424,15 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_naive_f | ~tmp_c~ | ~double[walk_num][0:cord_num-1][0:cord_num][nucl_num][elec_num]~ | in | Temporary intermediate tensor | | ~dtmp_c~ | ~double[walk_num][0:cord_num-1][0:cord_num][nucl_num][4][elec_num]~ | in | vector of non-zero coefficients | | ~een_rescaled_n~ | ~double[walk_num][0:cord_num][nucl_num][elec_num]~ | in | Electron-nucleus rescaled factor | - | ~een_rescaled_n_deriv_e~ | ~double[walk_num][0:cord_num][nucl_num][4][elec_num]~ | in | Derivative of Electron-nucleus rescaled factor | - | ~factor_een_deriv_e~ | ~double[walk_num][4][elec_num]~ | out | Derivative of Electron-nucleus jastrow | + | ~een_rescaled_n_gl~ | ~double[walk_num][0:cord_num][nucl_num][4][elec_num]~ | in | Derivative of Electron-nucleus rescaled factor | + | ~factor_een_gl~ | ~double[walk_num][4][elec_num]~ | out | Derivative of Electron-nucleus jastrow | #+begin_src f90 :comments org :tangle (eval f) :noweb yes -integer function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f( & +integer function qmckl_compute_jastrow_champ_factor_een_gl_doc_f( & 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_deriv_e, factor_een_deriv_e)& + tmp_c, dtmp_c, een_rescaled_n, een_rescaled_n_gl, factor_een_gl)& result(info) use qmckl implicit none @@ -9442,8 +9443,8 @@ integer function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f( & double precision , intent(in) :: tmp_c(elec_num, nucl_num,0:cord_num, 0:cord_num-1, walk_num) double precision , intent(in) :: dtmp_c(elec_num, 4, nucl_num,0:cord_num, 0:cord_num-1, walk_num) double precision , intent(in) :: een_rescaled_n(elec_num, nucl_num, 0:cord_num, walk_num) - double precision , intent(in) :: een_rescaled_n_deriv_e(elec_num, 4, nucl_num, 0:cord_num, walk_num) - double precision , intent(out) :: factor_een_deriv_e(elec_num,4,walk_num) + double precision , intent(in) :: een_rescaled_n_gl(elec_num, 4, nucl_num, 0:cord_num, walk_num) + double precision , intent(out) :: factor_een_gl(elec_num,4,walk_num) integer*8 :: i, a, j, l, k, m, n, nw, ii double precision :: accu, accu2, cn @@ -9475,7 +9476,7 @@ integer function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f( & return endif - factor_een_deriv_e = 0.0d0 + factor_een_gl = 0.0d0 if (cord_num == 0) return @@ -9491,38 +9492,38 @@ integer function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f( & do ii = 1, 4 do j = 1, elec_num - factor_een_deriv_e(j,ii,nw) = factor_een_deriv_e(j,ii,nw) + ( & - tmp_c(j,a,m,k,nw) * een_rescaled_n_deriv_e(j,ii,a,m+l,nw) + & + factor_een_gl(j,ii,nw) = factor_een_gl(j,ii,nw) + ( & + tmp_c(j,a,m,k,nw) * een_rescaled_n_gl(j,ii,a,m+l,nw) + & (dtmp_c(j,ii,a,m,k,nw)) * een_rescaled_n(j,a,m+l,nw) + & (dtmp_c(j,ii,a,m+l,k,nw)) * een_rescaled_n(j,a,m ,nw) + & - tmp_c(j,a,m+l,k,nw) * een_rescaled_n_deriv_e(j,ii,a,m,nw) & + tmp_c(j,a,m+l,k,nw) * een_rescaled_n_gl(j,ii,a,m,nw) & ) * cn end do end do cn = cn + cn do j = 1, elec_num - factor_een_deriv_e(j,4,nw) = factor_een_deriv_e(j,4,nw) + ( & - (dtmp_c(j,1,a,m ,k,nw)) * een_rescaled_n_deriv_e(j,1,a,m+l,nw) + & - (dtmp_c(j,2,a,m ,k,nw)) * een_rescaled_n_deriv_e(j,2,a,m+l,nw) + & - (dtmp_c(j,3,a,m ,k,nw)) * een_rescaled_n_deriv_e(j,3,a,m+l,nw) + & - (dtmp_c(j,1,a,m+l,k,nw)) * een_rescaled_n_deriv_e(j,1,a,m ,nw) + & - (dtmp_c(j,2,a,m+l,k,nw)) * een_rescaled_n_deriv_e(j,2,a,m ,nw) + & - (dtmp_c(j,3,a,m+l,k,nw)) * een_rescaled_n_deriv_e(j,3,a,m ,nw) & + factor_een_gl(j,4,nw) = factor_een_gl(j,4,nw) + ( & + (dtmp_c(j,1,a,m ,k,nw)) * een_rescaled_n_gl(j,1,a,m+l,nw) + & + (dtmp_c(j,2,a,m ,k,nw)) * een_rescaled_n_gl(j,2,a,m+l,nw) + & + (dtmp_c(j,3,a,m ,k,nw)) * een_rescaled_n_gl(j,3,a,m+l,nw) + & + (dtmp_c(j,1,a,m+l,k,nw)) * een_rescaled_n_gl(j,1,a,m ,nw) + & + (dtmp_c(j,2,a,m+l,k,nw)) * een_rescaled_n_gl(j,2,a,m ,nw) + & + (dtmp_c(j,3,a,m+l,k,nw)) * een_rescaled_n_gl(j,3,a,m ,nw) & ) * cn end do end do end do end do -end function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f +end function qmckl_compute_jastrow_champ_factor_een_gl_doc_f #+end_src - #+CALL: generate_private_c_header(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_deriv_e_doc" ) + #+CALL: generate_private_c_header(table=qmckl_factor_een_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_gl_doc" ) #+RESULTS: #+begin_src c :tangle (eval h_private_func) :comments org - qmckl_exit_code qmckl_compute_jastrow_champ_factor_een_deriv_e_doc ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_een_gl_doc ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -9534,15 +9535,15 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f const double* tmp_c, const double* dtmp_c, const double* een_rescaled_n, - const double* een_rescaled_n_deriv_e, - double* const factor_een_deriv_e ); + const double* een_rescaled_n_gl, + double* const factor_een_gl ); #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_deriv_e_doc")) + #+CALL: generate_c_interface(table=qmckl_factor_een_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_gl_doc")) #+RESULTS: #+begin_src f90 :tangle (eval f) :comments org :exports none - integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc & + integer(c_int32_t) function qmckl_compute_jastrow_champ_factor_een_gl_doc & (context, & walk_num, & elec_num, & @@ -9554,8 +9555,8 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f tmp_c, & dtmp_c, & een_rescaled_n, & - een_rescaled_n_deriv_e, & - factor_een_deriv_e) & + een_rescaled_n_gl, & + factor_een_gl) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -9572,11 +9573,11 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f real (c_double ) , intent(in) :: tmp_c(elec_num,nucl_num,0:cord_num,0:cord_num-1,walk_num) real (c_double ) , intent(in) :: dtmp_c(elec_num,4,nucl_num,0:cord_num,0:cord_num-1,walk_num) real (c_double ) , intent(in) :: een_rescaled_n(elec_num,nucl_num,0:cord_num,walk_num) - real (c_double ) , intent(in) :: een_rescaled_n_deriv_e(elec_num,4,nucl_num,0:cord_num,walk_num) - real (c_double ) , intent(out) :: factor_een_deriv_e(elec_num,4,walk_num) + real (c_double ) , intent(in) :: een_rescaled_n_gl(elec_num,4,nucl_num,0:cord_num,walk_num) + real (c_double ) , intent(out) :: factor_een_gl(elec_num,4,walk_num) - integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f - info = qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f & + integer(c_int32_t), external :: qmckl_compute_jastrow_champ_factor_een_gl_doc_f + info = qmckl_compute_jastrow_champ_factor_een_gl_doc_f & (context, & walk_num, & elec_num, & @@ -9588,17 +9589,17 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f tmp_c, & dtmp_c, & een_rescaled_n, & - een_rescaled_n_deriv_e, & - factor_een_deriv_e) + een_rescaled_n_gl, & + factor_een_gl) - end function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc + end function qmckl_compute_jastrow_champ_factor_een_gl_doc #+end_src - #+CALL: generate_private_c_header(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_deriv_e" ) + #+CALL: generate_private_c_header(table=qmckl_factor_een_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_gl" ) #+RESULTS: #+begin_src c :tangle (eval h_private_func) :comments org - qmckl_exit_code qmckl_compute_jastrow_champ_factor_een_deriv_e ( + qmckl_exit_code qmckl_compute_jastrow_champ_factor_een_gl ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -9610,13 +9611,13 @@ end function qmckl_compute_jastrow_champ_factor_een_deriv_e_doc_f const double* tmp_c, const double* dtmp_c, const double* een_rescaled_n, - const double* een_rescaled_n_deriv_e, - double* const factor_een_deriv_e ); + const double* een_rescaled_n_gl, + double* const factor_een_gl ); #+end_src #+begin_src c :tangle (eval c) :comments org qmckl_exit_code -qmckl_compute_jastrow_champ_factor_een_deriv_e(const qmckl_context context, +qmckl_compute_jastrow_champ_factor_een_gl(const qmckl_context context, const int64_t walk_num, const int64_t elec_num, const int64_t nucl_num, @@ -9627,31 +9628,31 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e(const qmckl_context context, const double *tmp_c, const double *dtmp_c, const double *een_rescaled_n, - const double *een_rescaled_n_deriv_e, - double* const factor_een_deriv_e) + const double *een_rescaled_n_gl, + double* const factor_een_gl) { #ifdef HAVE_HPC - return qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(context, walk_num, elec_num, nucl_num, + 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_deriv_e, - factor_een_deriv_e); + een_rescaled_n, een_rescaled_n_gl, + factor_een_gl); #else - return qmckl_compute_jastrow_champ_factor_een_deriv_e_doc(context, walk_num, elec_num, nucl_num, + 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_deriv_e, - factor_een_deriv_e); + een_rescaled_n, een_rescaled_n_gl, + factor_een_gl); #endif } #+end_src ***** HPC implementation :noexport: - #+CALL: generate_private_c_header(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc" ) + #+CALL: generate_private_c_header(table=qmckl_factor_een_gl_args,rettyp=get_value("CRetType"),fname="qmckl_compute_jastrow_champ_factor_een_gl_hpc" ) #+RESULTS: #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code -qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc ( +qmckl_compute_jastrow_champ_factor_een_gl_hpc ( const qmckl_context context, const int64_t walk_num, const int64_t elec_num, @@ -9663,13 +9664,13 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc ( const double* tmp_c, const double* dtmp_c, const double* een_rescaled_n, - const double* een_rescaled_n_deriv_e, - double* const factor_een_deriv_e ); + const double* een_rescaled_n_gl, + double* const factor_een_gl ); #+end_src #+begin_src c :tangle (eval c) :comments org qmckl_exit_code -qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(const qmckl_context context, +qmckl_compute_jastrow_champ_factor_een_gl_hpc(const qmckl_context context, const int64_t walk_num, const int64_t elec_num, const int64_t nucl_num, @@ -9680,8 +9681,8 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(const qmckl_context context, const double *tmp_c, const double *dtmp_c, const double *een_rescaled_n, - const double *een_rescaled_n_deriv_e, - double* const factor_een_deriv_e) + const double *een_rescaled_n_gl, + double* const factor_een_gl) { int64_t info = QMCKL_SUCCESS; @@ -9692,7 +9693,7 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(const qmckl_context context, if (nucl_num <= 0) return QMCKL_INVALID_ARG_4; if (cord_num < 0) return QMCKL_INVALID_ARG_5; - memset(factor_een_deriv_e, 0, elec_num*4*walk_num*sizeof(double)); + memset(factor_een_gl, 0, elec_num*4*walk_num*sizeof(double)); if (cord_num == 0) return QMCKL_SUCCESS; @@ -9703,7 +9704,7 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(const qmckl_context context, #pragma omp parallel for schedule(dynamic) #endif for (size_t nw = 0; nw < (size_t) walk_num; ++nw) { - double* const restrict factor_een_deriv_e_0nw = &(factor_een_deriv_e[elec_num*4*nw]); + double* const restrict factor_een_gl_0nw = &(factor_een_gl[elec_num*4*nw]); for (size_t n = 0; n < (size_t) dim_c_vector; ++n) { const size_t l = lkpm_combined_index[n]; const size_t k = lkpm_combined_index[n+ dim_c_vector]; @@ -9723,8 +9724,8 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(const qmckl_context context, const double* restrict een_rescaled_n_mlnw = een_rescaled_n_mnw + len; const double* restrict dtmp_c_mknw = &(dtmp_c[addr0 << 2]); const double* restrict dtmp_c_mlknw = dtmp_c_mknw + len4; - const double* restrict een_rescaled_n_deriv_e_mnw = &(een_rescaled_n_deriv_e[addr1 << 2]); - const double* restrict een_rescaled_n_deriv_e_mlnw = een_rescaled_n_deriv_e_mnw + len4; + const double* restrict een_rescaled_n_gl_mnw = &(een_rescaled_n_gl[addr1 << 2]); + const double* restrict een_rescaled_n_gl_mlnw = een_rescaled_n_gl_mnw + len4; for (size_t a = 0; a < (size_t) nucl_num; a++) { double cn = c_vector_full[a+n*nucl_num]; if (cn == 0.0) continue; @@ -9738,8 +9739,8 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(const qmckl_context context, const double* restrict een_rescaled_n_amlnw = een_rescaled_n_mlnw + ishift; const double* restrict dtmp_c_0amknw = dtmp_c_mknw + ishift4; const double* restrict dtmp_c_0amlknw = dtmp_c_mlknw + ishift4; - const double* restrict een_rescaled_n_deriv_e_0amnw = een_rescaled_n_deriv_e_mnw + ishift4; - const double* restrict een_rescaled_n_deriv_e_0amlnw = een_rescaled_n_deriv_e_mlnw + ishift4; + const double* restrict een_rescaled_n_gl_0amnw = een_rescaled_n_gl_mnw + ishift4; + const double* restrict een_rescaled_n_gl_0amlnw = een_rescaled_n_gl_mlnw + ishift4; const double* restrict dtmp_c_1amknw = dtmp_c_0amknw + elec_num; const double* restrict dtmp_c_1amlknw = dtmp_c_0amlknw + elec_num; @@ -9747,57 +9748,57 @@ qmckl_compute_jastrow_champ_factor_een_deriv_e_hpc(const qmckl_context context, const double* restrict dtmp_c_2amlknw = dtmp_c_0amlknw + elec_num2; const double* restrict dtmp_c_3amknw = dtmp_c_0amknw + elec_num3; const double* restrict dtmp_c_3amlknw = dtmp_c_0amlknw + elec_num3; - const double* restrict een_rescaled_n_deriv_e_1amnw = een_rescaled_n_deriv_e_0amnw + elec_num; - const double* restrict een_rescaled_n_deriv_e_1amlnw = een_rescaled_n_deriv_e_0amlnw + elec_num; - const double* restrict een_rescaled_n_deriv_e_2amnw = een_rescaled_n_deriv_e_0amnw + elec_num2; - const double* restrict een_rescaled_n_deriv_e_2amlnw = een_rescaled_n_deriv_e_0amlnw + elec_num2; - const double* restrict een_rescaled_n_deriv_e_3amnw = een_rescaled_n_deriv_e_0amnw + elec_num3; - const double* restrict een_rescaled_n_deriv_e_3amlnw = een_rescaled_n_deriv_e_0amlnw + elec_num3; - double* const restrict factor_een_deriv_e_1nw = factor_een_deriv_e_0nw + elec_num; - double* const restrict factor_een_deriv_e_2nw = factor_een_deriv_e_0nw + elec_num2; - double* const restrict factor_een_deriv_e_3nw = factor_een_deriv_e_0nw + elec_num3; + const double* restrict een_rescaled_n_gl_1amnw = een_rescaled_n_gl_0amnw + elec_num; + const double* restrict een_rescaled_n_gl_1amlnw = een_rescaled_n_gl_0amlnw + elec_num; + const double* restrict een_rescaled_n_gl_2amnw = een_rescaled_n_gl_0amnw + elec_num2; + const double* restrict een_rescaled_n_gl_2amlnw = een_rescaled_n_gl_0amlnw + elec_num2; + const double* restrict een_rescaled_n_gl_3amnw = een_rescaled_n_gl_0amnw + elec_num3; + const double* restrict een_rescaled_n_gl_3amlnw = een_rescaled_n_gl_0amlnw + elec_num3; + double* const restrict factor_een_gl_1nw = factor_een_gl_0nw + elec_num; + double* const restrict factor_een_gl_2nw = factor_een_gl_0nw + elec_num2; + double* const restrict factor_een_gl_3nw = factor_een_gl_0nw + elec_num3; double tmp3[elec_num]; for (size_t j = 0; j < (size_t) elec_num; ++j) { - factor_een_deriv_e_0nw[j] += cn * - (tmp_c_amkn[j] * een_rescaled_n_deriv_e_0amlnw[j] + + factor_een_gl_0nw[j] += cn * + (tmp_c_amkn[j] * een_rescaled_n_gl_0amlnw[j] + dtmp_c_0amknw[j] * een_rescaled_n_amlnw[j] + dtmp_c_0amlknw[j] * een_rescaled_n_amnw[j] + - tmp_c_amlkn[j] * een_rescaled_n_deriv_e_0amnw[j]); + tmp_c_amlkn[j] * een_rescaled_n_gl_0amnw[j]); tmp3[j] = - dtmp_c_0amknw[j] * een_rescaled_n_deriv_e_0amlnw[j] + - dtmp_c_0amlknw[j] * een_rescaled_n_deriv_e_0amnw[j]; + dtmp_c_0amknw[j] * een_rescaled_n_gl_0amlnw[j] + + dtmp_c_0amlknw[j] * een_rescaled_n_gl_0amnw[j]; } for (size_t j = 0; j < (size_t) elec_num; ++j) { - factor_een_deriv_e_1nw[j] += cn * - (tmp_c_amkn[j] * een_rescaled_n_deriv_e_1amlnw[j] + + factor_een_gl_1nw[j] += cn * + (tmp_c_amkn[j] * een_rescaled_n_gl_1amlnw[j] + dtmp_c_1amknw[j] * een_rescaled_n_amlnw[j] + dtmp_c_1amlknw[j] * een_rescaled_n_amnw[j] + - tmp_c_amlkn[j] * een_rescaled_n_deriv_e_1amnw[j]); + tmp_c_amlkn[j] * een_rescaled_n_gl_1amnw[j]); tmp3[j] += - dtmp_c_1amknw[j] * een_rescaled_n_deriv_e_1amlnw[j] + - dtmp_c_1amlknw[j] * een_rescaled_n_deriv_e_1amnw[j]; + dtmp_c_1amknw[j] * een_rescaled_n_gl_1amlnw[j] + + dtmp_c_1amlknw[j] * een_rescaled_n_gl_1amnw[j]; } for (size_t j = 0; j < (size_t) elec_num; ++j) { - factor_een_deriv_e_2nw[j] += cn * - (tmp_c_amkn[j] * een_rescaled_n_deriv_e_2amlnw[j] + + factor_een_gl_2nw[j] += cn * + (tmp_c_amkn[j] * een_rescaled_n_gl_2amlnw[j] + dtmp_c_2amknw[j] * een_rescaled_n_amlnw[j] + dtmp_c_2amlknw[j] * een_rescaled_n_amnw[j] + - tmp_c_amlkn[j] * een_rescaled_n_deriv_e_2amnw[j]); + tmp_c_amlkn[j] * een_rescaled_n_gl_2amnw[j]); tmp3[j] += - dtmp_c_2amknw[j] * een_rescaled_n_deriv_e_2amlnw[j] + - dtmp_c_2amlknw[j] * een_rescaled_n_deriv_e_2amnw[j]; + dtmp_c_2amknw[j] * een_rescaled_n_gl_2amlnw[j] + + dtmp_c_2amlknw[j] * een_rescaled_n_gl_2amnw[j]; } for (size_t j = 0; j < (size_t) elec_num; ++j) { - factor_een_deriv_e_3nw[j] += cn * - (tmp_c_amkn[j] * een_rescaled_n_deriv_e_3amlnw[j] + + factor_een_gl_3nw[j] += cn * + (tmp_c_amkn[j] * een_rescaled_n_gl_3amlnw[j] + dtmp_c_3amknw[j] * een_rescaled_n_amlnw[j] + dtmp_c_3amlknw[j] * een_rescaled_n_amnw[j] + - tmp_c_amlkn[j] * een_rescaled_n_deriv_e_3amnw[j] + + tmp_c_amlkn[j] * een_rescaled_n_gl_3amnw[j] + tmp3[j]*2.0); } @@ -9813,7 +9814,7 @@ import numpy as np <> -<> +<> <> @@ -9823,8 +9824,8 @@ factor_een = 0.0 daccu = np.zeros(4, dtype=float) daccu2 = np.zeros(4, dtype=float) -een_rescaled_e_deriv_e_t = een_rescaled_e_deriv_e.T -print(een_rescaled_e_deriv_e_t.shape) +een_rescaled_e_gl_t = een_rescaled_e_gl.T +print(een_rescaled_e_gl_t.shape) for n in range(0, dim_c_vector): l = lkpm_of_cindex[0,n] k = lkpm_of_cindex[1,n] @@ -9842,9 +9843,9 @@ for n in range(0, dim_c_vector): een_rescaled_n[a,i,m] accu2 = accu2 + een_rescaled_e[i,j,k] * \ een_rescaled_n[a,i,m+l] -# daccu[0:4] = daccu[0:4] + een_rescaled_e_deriv_e_t[k,j,0:4,i,k] * \ +# daccu[0:4] = daccu[0:4] + een_rescaled_e_gl_t[k,j,0:4,i,k] * \ # een_rescaled_n[a,i,m] -# daccu[0:4] = daccu[0:4] + een_rescaled_e_deriv_e_t[k,j,0:4,i,k] * \ +# daccu[0:4] = daccu[0:4] + een_rescaled_e_gl_t[k,j,0:4,i,k] * \ # een_rescaled_n[a,i,m] accu2 = accu2 + accu * een_rescaled_n[a,j,m+l] # factor_een = factor_een + accu2 * cn @@ -9862,20 +9863,20 @@ print("factor_een:",factor_een) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_champ_provided(context)); -double factor_een_deriv_e[4][walk_num][elec_num]; -rc = qmckl_get_jastrow_champ_factor_een_deriv_e(context, &(factor_een_deriv_e[0][0][0]),4*walk_num*elec_num); +double factor_een_gl[4][walk_num][elec_num]; +rc = qmckl_get_jastrow_champ_factor_een_gl(context, &(factor_een_gl[0][0][0]),4*walk_num*elec_num); -printf("%20.15e\n", factor_een_deriv_e[0][0][0]); -assert(fabs(factor_een_deriv_e[0][0][0] - (-5.481671107220383e-04)) < 1e-12); +printf("%20.15e\n", factor_een_gl[0][0][0]); +assert(fabs(factor_een_gl[0][0][0] - (-5.481671107220383e-04)) < 1e-12); -printf("%20.15e\n", factor_een_deriv_e[1][0][1]); -assert(fabs(factor_een_deriv_e[1][0][1] - (-5.402107832095666e-02)) < 1e-12); +printf("%20.15e\n", factor_een_gl[1][0][1]); +assert(fabs(factor_een_gl[1][0][1] - (-5.402107832095666e-02)) < 1e-12); -printf("%20.15e\n", factor_een_deriv_e[2][0][2]); -assert(fabs(factor_een_deriv_e[2][0][2] - (-1.648945927082279e-01)) < 1e-12); +printf("%20.15e\n", factor_een_gl[2][0][2]); +assert(fabs(factor_een_gl[2][0][2] - (-1.648945927082279e-01)) < 1e-12); -printf("%20.15e\n", factor_een_deriv_e[3][0][3]); -assert(fabs(factor_een_deriv_e[3][0][3] - (-1.269746119491287e+00)) < 1e-12); +printf("%20.15e\n", factor_een_gl[3][0][3]); +assert(fabs(factor_een_gl[3][0][3] - (-1.269746119491287e+00)) < 1e-12); #+end_src ** Total Jastrow @@ -10328,13 +10329,13 @@ qmckl_exit_code qmckl_provide_jastrow_champ_gl(qmckl_context context) rc = qmckl_provide_jastrow_champ_value(context); if (rc != QMCKL_SUCCESS) return rc; - rc = qmckl_provide_jastrow_champ_factor_ee_deriv_e(context); + rc = qmckl_provide_jastrow_champ_factor_ee_gl(context); if (rc != QMCKL_SUCCESS) return rc; - rc = qmckl_provide_jastrow_champ_factor_en_deriv_e(context); + rc = qmckl_provide_jastrow_champ_factor_en_gl(context); if (rc != QMCKL_SUCCESS) return rc; - rc = qmckl_provide_jastrow_champ_factor_een_deriv_e(context); + rc = qmckl_provide_jastrow_champ_factor_een_gl(context); if (rc != QMCKL_SUCCESS) return rc; /* Compute if necessary */ @@ -10372,9 +10373,9 @@ qmckl_exit_code qmckl_provide_jastrow_champ_gl(qmckl_context context) ctx->electron.walker.num, ctx->electron.num, ctx->jastrow_champ.value, - ctx->jastrow_champ.factor_ee_deriv_e, - ctx->jastrow_champ.factor_en_deriv_e, - ctx->jastrow_champ.factor_een_deriv_e, + ctx->jastrow_champ.factor_ee_gl, + ctx->jastrow_champ.factor_en_gl, + ctx->jastrow_champ.factor_een_gl, ctx->jastrow_champ.gl); ctx->jastrow_champ.gl_date = ctx->date; @@ -10600,17 +10601,17 @@ printf("Total Jastrow derivatives\n"); assert(qmckl_jastrow_champ_provided(context)); rc = qmckl_check(context, - qmckl_get_jastrow_champ_factor_ee_deriv_e(context, &(factor_ee_deriv_e[0][0][0]), walk_num*elec_num*4) + qmckl_get_jastrow_champ_factor_ee_gl(context, &(factor_ee_gl[0][0][0]), walk_num*elec_num*4) ); assert(rc == QMCKL_SUCCESS); rc = qmckl_check(context, - qmckl_get_jastrow_champ_factor_en_deriv_e(context, &(factor_en_deriv_e[0][0][0]), walk_num*elec_num*4) + qmckl_get_jastrow_champ_factor_en_gl(context, &(factor_en_gl[0][0][0]), walk_num*elec_num*4) ); assert(rc == QMCKL_SUCCESS); rc = qmckl_check(context, - qmckl_get_jastrow_champ_factor_een_deriv_e(context, &(factor_een_deriv_e[0][0][0]), walk_num*elec_num*4) + qmckl_get_jastrow_champ_factor_een_gl(context, &(factor_een_gl[0][0][0]), walk_num*elec_num*4) ); assert(rc == QMCKL_SUCCESS); @@ -10630,7 +10631,7 @@ for (int64_t k=0 ; k< walk_num ; ++k) { for (int64_t m=0 ; m<4; ++m) { for (int64_t e=0 ; e