From fdf6b905bb129cfdd1a74e5265933e7647c68fc4 Mon Sep 17 00:00:00 2001 From: Anthony Scemama Date: Thu, 30 Mar 2023 12:34:17 +0200 Subject: [PATCH] Working on Jastrow --- org/qmckl_distance.org | 2 +- org/qmckl_jastrow.org | 3741 ++++++++++++++++++++-------------------- 2 files changed, 1857 insertions(+), 1886 deletions(-) diff --git a/org/qmckl_distance.org b/org/qmckl_distance.org index c435733..ecb9601 100644 --- a/org/qmckl_distance.org +++ b/org/qmckl_distance.org @@ -875,7 +875,7 @@ end function test_qmckl_dist pairs of points in two sets, one point within each set: \[ - C_{ij} = \left( 1 - \exp \left(-\kappa C_{ij} \right) \right)/\kappa + C_{ij} = \frac{ 1 - e^{-\kappa r_{ij}}}{\kappa} \] If the input array is normal (~'N'~), the xyz coordinates are in diff --git a/org/qmckl_jastrow.org b/org/qmckl_jastrow.org index 8739f44..0276438 100644 --- a/org/qmckl_jastrow.org +++ b/org/qmckl_jastrow.org @@ -20,8 +20,8 @@ \[ J_{\text{eN}}(\mathbf{r},\mathbf{R}) = \sum_{\alpha=1}^{N_\text{nucl}} \sum_{i=1}^{N_\text{elec}} - \frac{a_{1\,\alpha}\, f_\alpha(R_{i\,\alpha})}{1+a_{2\,\alpha}\, f_\alpha(R_{i\alpha})} + - \sum_{p=2}^{N_\text{ord}^a} a_{p+1\,\alpha}\, [f_\alpha(R_{i\alpha})]^p - J_{eN}^{\infty \alpha} + \frac{a_{1\,\alpha}\, f_\alpha(R_{i\alpha})}{1+a_{2\,\alpha}\, f_\alpha(R_{i\alpha})} + + \sum_{p=2}^{N_\text{ord}^a} a_{p+1\,\alpha}\, [f_\alpha(R_{i\alpha})]^p - J_{\text{eN}}^{\infty \alpha} \] $J_{\text{ee}}$ contains electron-electron terms: @@ -53,7 +53,7 @@ \[ f_\alpha(r) = \frac{1-e^{-\kappa_\alpha\, r}}{\kappa_\alpha} \text{ and } - g_\alpha(r) = e^{-\kappa_\alpha\, r}. + g_\alpha(r) = e^{-\kappa_\alpha\, r} = 1-\kappa_\alpha f_\alpha(r). \] The terms $J_{\text{ee}}^\infty$ and $J_{\text{eN}}^\infty$ are shifts to ensure that @@ -85,6 +85,7 @@ #include #include "n2.h" +#include "qmckl_jastrow_private_func.h" int main() { qmckl_context context; @@ -1072,6 +1073,7 @@ qmckl_exit_code qmckl_get_jastrow_b_vector (qmckl_context context, dou qmckl_exit_code qmckl_get_jastrow_c_vector (qmckl_context context, double * const c_vector, const int64_t size_max); qmckl_exit_code qmckl_get_jastrow_rescale_factor_ee (const qmckl_context context, double* const rescale_factor_ee); qmckl_exit_code qmckl_get_jastrow_rescale_factor_en (const qmckl_context context, double* const rescale_factor_en, const int64_t size_max); +qmckl_exit_code qmckl_get_jastrow_dim_c_vector (qmckl_context context, int64_t* const dim_c_vector); #+end_src @@ -1431,6 +1433,21 @@ qmckl_get_jastrow_rescale_factor_en (const qmckl_context context, return QMCKL_SUCCESS; } + +qmckl_exit_code qmckl_get_jastrow_dim_c_vector(qmckl_context context, int64_t* const dim_c_vector) +{ + if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { + return QMCKL_NULL_CONTEXT; + } + + qmckl_context_struct* const ctx = (qmckl_context_struct*) context; + assert (ctx != NULL); + + ,*dim_c_vector = ctx->jastrow.dim_c_vector; + + return QMCKL_SUCCESS; +} + #+end_src **** Fortran interface @@ -1651,27 +1668,29 @@ assert(qmckl_nucleus_provided(context)); compute. If it is the case, then the data is recomputed and the current date is stored. -** Asymptotic component for \(J_\text{ee}\) + +** Electron-electron component +*** Asymptotic component - Calculate the asymptotic component ~asymp_jasb~ to be substracted from the - electron-electron jastrow factor \(J_{\text{ee}}\). Two values are - computed. The first one is for antiparallel spin pairs, and the - second one for parallel spin pairs. + Calculate the asymptotic component ~asymp_jasb~ to be substracted from the + electron-electron jastrow factor \(J_{\text{ee}}\). Two values are + computed. The first one is for antiparallel spin pairs, and the + second one for parallel spin pairs. - \[ - J_{\text{ee}}^{\infty} = \frac{\frac{1}{2}(1+\delta^{\uparrow \downarrow})\,b_1 \kappa_\text{ee}^{-1}}{1 + b_2\, - \kappa_\text{ee}^{-1}} + \sum_{p=2}^{N_\text{ord}^b} b_{p+1}\, \kappa_\text{ee}^{-p} - \] + \[ + J_{\text{ee}}^{\infty} = \frac{\frac{1}{2}(1+\delta^{\uparrow \downarrow})\,b_1 \kappa_\text{ee}^{-1}}{1 + b_2\, + \kappa_\text{ee}^{-1}} + \sum_{p=2}^{N_\text{ord}^b} b_{p+1}\, \kappa_\text{ee}^{-p} + \] -*** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes +**** Get + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_asymp_jasb(qmckl_context context, double* const asymp_jasb, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_asymp_jasb(qmckl_context context, double* const asymp_jasb, @@ -1706,11 +1725,11 @@ qmckl_get_jastrow_asymp_jasb(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -**** Fortran interface +***** Fortran interface -#+begin_src f90 :tangle (eval fh_func) :comments org + #+begin_src f90 :tangle (eval fh_func) :comments org interface integer(qmckl_exit_code) function qmckl_get_jastrow_asymp_jasb(context, & asymp_jasb, size_max) bind(C) @@ -1722,14 +1741,14 @@ interface double precision, intent(out) :: asymp_jasb(size_max) end function qmckl_get_jastrow_asymp_jasb end interface -#+end_src + #+end_src -*** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +**** Provide :noexport: + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_asymp_jasb(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_asymp_jasb(qmckl_context context) { @@ -1785,27 +1804,27 @@ qmckl_exit_code qmckl_provide_jastrow_asymp_jasb(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_jastrow_asymp_jasb - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_jastrow_asymp_jasb + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_asymp_jasb_args - | Variable | Type | In/Out | Description | - |---------------------+----------------------+--------+-------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~bord_num~ | ~int64_t~ | in | Order of the polynomial | - | ~b_vector~ | ~double[bord_num+1]~ | in | Values of b | - | ~rescale_factor_ee~ | ~double~ | in | Electron coordinates | - | ~asymp_jasb~ | ~double[2]~ | out | Asymptotic value | + #+NAME: qmckl_asymp_jasb_args + | Variable | Type | In/Out | Description | + |---------------------+----------------------+--------+-------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~bord_num~ | ~int64_t~ | in | Order of the polynomial | + | ~b_vector~ | ~double[bord_num+1]~ | in | Values of b | + | ~rescale_factor_ee~ | ~double~ | in | Electron coordinates | + | ~asymp_jasb~ | ~double[2]~ | out | Asymptotic value | -# #+CALL: generate_c_interface(table=qmckl_asymp_jasb_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_interface(table=qmckl_asymp_jasb_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_jastrow_asymp_jasb_doc & (context, bord_num, b_vector, rescale_factor_ee, asymp_jasb) & bind(C) result(info) @@ -1824,9 +1843,9 @@ qmckl_exit_code qmckl_provide_jastrow_asymp_jasb(qmckl_context context) (context, bord_num, b_vector, rescale_factor_ee, asymp_jasb) end function qmckl_compute_jastrow_asymp_jasb_doc - #+end_src + #+end_src - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_jastrow_asymp_jasb_doc_f(context, bord_num, b_vector, rescale_factor_ee, asymp_jasb) & result(info) use qmckl @@ -1865,26 +1884,26 @@ integer function qmckl_compute_jastrow_asymp_jasb_doc_f(context, bord_num, b_vec end do end function qmckl_compute_jastrow_asymp_jasb_doc_f - #+end_src + #+end_src -#+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_jastrow_asymp_jasb_doc (const qmckl_context context, const int64_t bord_num, const double* b_vector, const double rescale_factor_ee, double* const asymp_jasb ); -#+end_src + #+end_src -#+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_jastrow_asymp_jasb_hpc (const qmckl_context context, const int64_t bord_num, const double* b_vector, const double rescale_factor_ee, double* const asymp_jasb ); -#+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_jastrow_asymp_jasb_hpc (const qmckl_context context, const int64_t bord_num, @@ -1916,18 +1935,18 @@ qmckl_compute_jastrow_asymp_jasb_hpc (const qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -#+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_jastrow_asymp_jasb (const qmckl_context context, const int64_t bord_num, const double* b_vector, const double rescale_factor_ee, double* const asymp_jasb ); -#+end_src + #+end_src -#+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_jastrow_asymp_jasb ( const qmckl_context context, const int64_t bord_num, @@ -1943,10 +1962,10 @@ qmckl_exit_code qmckl_compute_jastrow_asymp_jasb ( bord_num, b_vector, rescale_factor_ee, asymp_jasb); #endif } -#+end_src -*** Test - #+name: asymp_jasb - #+begin_src python :results output :exports none :noweb yes + #+end_src +**** Test + #+name: asymp_jasb + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -1963,14 +1982,14 @@ for i in range(2): print("asym_one : ", asym_one) print("asymp_jasb[0] : ", asymp_jasb[0]) print("asymp_jasb[1] : ", asymp_jasb[1]) - #+end_src + #+end_src - #+RESULTS: asymp_jasb - : asym_one : 0.43340325572525706 - : asymp_jasb[0] : 0.5323750557252571 - : asymp_jasb[1] : 0.31567342786262853 + #+RESULTS: asymp_jasb + : asym_one : 0.43340325572525706 + : asymp_jasb[0] : 0.5323750557252571 + : asymp_jasb[1] : 0.31567342786262853 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) assert(qmckl_electron_provided(context)); int64_t type_nucl_num = n2_type_nucl_num; @@ -2057,32 +2076,32 @@ rc = qmckl_get_jastrow_asymp_jasb(context, asymp_jasb,2); assert(fabs(asymp_jasb[0]-0.5323750557252571) < 1.e-12); assert(fabs(asymp_jasb[1]-0.31567342786262853) < 1.e-12); - #+end_src + #+end_src -** Electron-electron component \(f_\text{ee}\) +*** Electron-electron component - Calculate the electron-electron jastrow component ~factor_ee~ using the ~asymp_jasb~ - component and the electron-electron rescaled distances ~ee_distance_rescaled~. + Calculate the electron-electron jastrow component ~factor_ee~ using the ~asymp_jasb~ + component and the electron-electron rescaled distances ~ee_distance_rescaled~. - \[ - f_\text{ee} = \sum_{i,j> @@ -2497,16 +2516,16 @@ for i in range(0,elec_num): - asymp_jasb[ipar] + pow_ser print("factor_ee :",factor_ee) - #+end_src + #+end_src - #+RESULTS: - : asym_one : 0.43340325572525706 - : asymp_jasb[0] : 0.5323750557252571 - : asymp_jasb[1] : 0.31567342786262853 - : factor_ee : -4.282760865958113 + #+RESULTS: + : asym_one : 0.43340325572525706 + : asymp_jasb[0] : 0.5323750557252571 + : asymp_jasb[1] : 0.31567342786262853 + : factor_ee : -4.282760865958113 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_provided(context)); @@ -2519,30 +2538,30 @@ rc = qmckl_check(context, printf("%e\n%e\n\n",factor_ee[0],-4.282760865958113 ); assert(fabs(factor_ee[0]+4.282760865958113) < 1.e-12); - #+end_src + #+end_src -** Electron-electron component derivative \(f'_{ee}\) +*** 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~. - There are four components, the gradient which has 3 components in the \(x, y, z\) - directions and the laplacian as the last component. + The derivative of ~factor_ee~ is computed using the ~ee_distance_rescaled~ and + the electron-electron rescaled distances derivatives ~ee_distance_rescaled_deriv_e~. + There are four components, the gradient which has 3 components in the \(x, y, z\) + directions and the laplacian as the last component. - \[ \nabla_i f_\text{ee} = \frac{1}{2}\sum_{j} -\left[\frac{\delta_{ij}^{\uparrow\downarrow} B_0\, \nabla_i -C_{ij}}{(1 - B_1\, C_{ij})^2} + \sum^{n_\text{ord}}_{k=2} -B_k\, k\, C_{ij}^{k-1} \nabla C_{ij} \right] \] + \[ \nabla_i f_\text{ee} = \frac{1}{2}\sum_{j} + \left[\frac{\delta_{ij}^{\uparrow\downarrow} B_0\, \nabla_i + C_{ij}}{(1 - B_1\, C_{ij})^2} + \sum^{n_\text{ord}}_{k=2} + B_k\, k\, C_{ij}^{k-1} \nabla C_{ij} \right] \] -# TODO Formula for Laplacian -*** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes + # TODO Formula for Laplacian +**** Get + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_factor_ee_deriv_e(qmckl_context context, double* const factor_ee_deriv_e, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_factor_ee_deriv_e(qmckl_context context, double* const factor_ee_deriv_e, @@ -2572,14 +2591,14 @@ qmckl_get_jastrow_factor_ee_deriv_e(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +**** Provide :noexport: + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_factor_ee_deriv_e(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_factor_ee_deriv_e(qmckl_context context) { @@ -2659,29 +2678,29 @@ qmckl_exit_code qmckl_provide_jastrow_factor_ee_deriv_e(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_factor_ee_deriv_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_factor_ee_deriv_e + :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_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 | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_ee_deriv_e_doc_f( & context, walk_num, elec_num, up_num, bord_num, & b_vector, ee_distance_rescaled, ee_distance_rescaled_deriv_e, & @@ -2782,9 +2801,9 @@ integer function qmckl_compute_factor_ee_deriv_e_doc_f( & end do end function qmckl_compute_factor_ee_deriv_e_doc_f - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_factor_ee_deriv_e_hpc( const qmckl_context context, const int64_t walk_num, @@ -2894,12 +2913,12 @@ qmckl_exit_code qmckl_compute_factor_ee_deriv_e_hpc( return QMCKL_SUCCESS; } - #+end_src + #+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_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_ee_deriv_e ( const qmckl_context context, const int64_t walk_num, @@ -2910,13 +2929,13 @@ qmckl_exit_code qmckl_compute_factor_ee_deriv_e_hpc( const double* ee_distance_rescaled, const double* ee_distance_rescaled_deriv_e, double* const factor_ee_deriv_e ); - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_ee_deriv_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_factor_ee_deriv_e_doc") + #+CALL: generate_c_interface(table=qmckl_factor_ee_deriv_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_factor_ee_deriv_e_doc") - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_ee_deriv_e_doc & (context, & walk_num, & @@ -2955,9 +2974,9 @@ integer(c_int32_t) function qmckl_compute_factor_ee_deriv_e_doc & factor_ee_deriv_e) end function qmckl_compute_factor_ee_deriv_e_doc - #+end_src + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_factor_ee_deriv_e_hpc ( const qmckl_context context, const int64_t walk_num, @@ -2969,9 +2988,9 @@ integer(c_int32_t) function qmckl_compute_factor_ee_deriv_e_doc & const double* ee_distance_rescaled_deriv_e, double* const factor_ee_deriv_e ); - #+end_src + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_factor_ee_deriv_e_doc ( const qmckl_context context, const int64_t walk_num, @@ -2982,10 +3001,10 @@ integer(c_int32_t) function qmckl_compute_factor_ee_deriv_e_doc & const double* ee_distance_rescaled, const double* ee_distance_rescaled_deriv_e, double* const factor_ee_deriv_e ); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_factor_ee_deriv_e ( const qmckl_context context, const int64_t walk_num, @@ -3003,13 +3022,13 @@ integer(c_int32_t) function qmckl_compute_factor_ee_deriv_e_doc & return qmckl_compute_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 ); #endif } - #+end_src + #+end_src -*** Test - #+begin_src python :results output :exports none :noweb yes +**** Test + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -3100,19 +3119,19 @@ 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]) - #+end_src + #+end_src - #+RESULTS: - : asym_one : 0.43340325572525706 - : asymp_jasb[0] : 0.5323750557252571 - : asymp_jasb[1] : 0.31567342786262853 - : 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 + #+RESULTS: + : asym_one : 0.43340325572525706 + : asymp_jasb[0] : 0.5323750557252571 + : asymp_jasb[1] : 0.31567342786262853 + : 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 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_provided(context)); @@ -3125,27 +3144,527 @@ assert(fabs(factor_ee_deriv_e[0][0][0]-0.16364894652107934) < 1.e-12); assert(fabs(factor_ee_deriv_e[0][1][0]+0.6927548119830084 ) < 1.e-12); assert(fabs(factor_ee_deriv_e[0][2][0]-0.073267755223968 ) < 1.e-12); assert(fabs(factor_ee_deriv_e[0][3][0]-1.5111672803213185 ) < 1.e-12); + #+end_src + +*** Electron-electron rescaled distances + + ~ee_distance_rescaled~ stores the matrix of the rescaled distances between all + pairs of electrons: + + \[ + C_{ij} = \frac{ 1 - e^{-\kappa r_{ij}}}{\kappa} + \] + + where \(r_{ij}\) is the matrix of electron-electron distances. + +**** Get + + #+begin_src c :comments org :tangle (eval h_func) :noweb yes +qmckl_exit_code qmckl_get_jastrow_ee_distance_rescaled(qmckl_context context, double* const distance_rescaled); #+end_src -** Asymptotic component for \(J_{eN}\) + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none +qmckl_exit_code qmckl_get_jastrow_ee_distance_rescaled(qmckl_context context, double* const distance_rescaled) +{ + if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { + return QMCKL_NULL_CONTEXT; + } - Calculate the asymptotic component ~asymp_jasa~ to be substracted from the final - electron-nucleus jastrow factor \(J_{\text{eN}}\). The asymptotic component is calculated - via the ~a_vector~ and the electron-nucleus rescale factors ~rescale_factor_en~. + qmckl_exit_code rc; - \[ - J_{\text{en}}^{\infty \alpha} = \frac{a_1 \kappa_\alpha^{-1}}{1 + a_2 \kappa_\alpha^{-1}} - \] + rc = qmckl_provide_ee_distance_rescaled(context); + if (rc != QMCKL_SUCCESS) return rc; -*** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes + qmckl_context_struct* const ctx = (qmckl_context_struct*) context; + assert (ctx != NULL); + + size_t sze = ctx->electron.num * ctx->electron.num * ctx->electron.walker.num; + memcpy(distance_rescaled, ctx->jastrow.ee_distance_rescaled, sze * sizeof(double)); + + return QMCKL_SUCCESS; +} + #+end_src + +**** Provide :noexport: + + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +qmckl_exit_code qmckl_provide_ee_distance_rescaled(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(qmckl_context context) +{ + + if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { + return QMCKL_NULL_CONTEXT; + } + + qmckl_context_struct* const ctx = (qmckl_context_struct*) context; + assert (ctx != NULL); + + + /* Compute if necessary */ + if (ctx->electron.walker.point.date > ctx->jastrow.ee_distance_rescaled_date) { + + if (ctx->electron.walker.num > ctx->electron.walker_old.num) { + if (ctx->jastrow.ee_distance_rescaled != NULL) { + qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.ee_distance_rescaled); + if (rc != QMCKL_SUCCESS) { + return qmckl_failwith( context, rc, + "qmckl_provide_ee_distance_rescaled", + "Unable to free ctx->jastrow.ee_distance_rescaled"); + } + ctx->jastrow.ee_distance_rescaled = NULL; + } + } + + /* Allocate array */ + if (ctx->jastrow.ee_distance_rescaled == NULL) { + + qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; + mem_info.size = ctx->electron.num * ctx->electron.num * + ctx->electron.walker.num * sizeof(double); + double* ee_distance_rescaled = (double*) qmckl_malloc(context, mem_info); + + if (ee_distance_rescaled == NULL) { + return qmckl_failwith( context, + QMCKL_ALLOCATION_FAILED, + "qmckl_provide_ee_distance_rescaled", + NULL); + } + ctx->jastrow.ee_distance_rescaled = ee_distance_rescaled; + } + + qmckl_exit_code rc = + qmckl_compute_ee_distance_rescaled(context, + ctx->electron.num, + ctx->jastrow.rescale_factor_ee, + ctx->electron.walker.num, + ctx->electron.walker.point.coord.data, + ctx->jastrow.ee_distance_rescaled); + if (rc != QMCKL_SUCCESS) { + return rc; + } + + ctx->jastrow.ee_distance_rescaled_date = ctx->date; + } + + return QMCKL_SUCCESS; +} + #+end_src + +**** Compute + :PROPERTIES: + :Name: qmckl_compute_ee_distance_rescaled + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: + + #+NAME: qmckl_ee_distance_rescaled_args + | Variable | Type | In/Out | Description | + |---------------------+----------------------------------------+--------+--------------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~elec_num~ | ~int64_t~ | in | Number of electrons | + | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | + | ~walk_num~ | ~int64_t~ | in | Number of walkers | + | ~coord~ | ~double[3][walk_num][elec_num]~ | in | Electron coordinates | + | ~ee_distance~ | ~double[walk_num][elec_num][elec_num]~ | out | Electron-electron rescaled distances | + + #+begin_src f90 :comments org :tangle (eval f) :noweb yes +integer function qmckl_compute_ee_distance_rescaled_f(context, elec_num, rescale_factor_ee, walk_num, & + coord, ee_distance_rescaled) & + result(info) + use qmckl + implicit none + integer(qmckl_context), intent(in) :: context + integer*8 , intent(in) :: 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(elec_num,elec_num,walk_num) + + integer*8 :: k + + info = QMCKL_SUCCESS + + if (context == QMCKL_NULL_CONTEXT) then + info = QMCKL_INVALID_CONTEXT + return + endif + + if (elec_num <= 0) then + info = QMCKL_INVALID_ARG_2 + return + endif + + if (walk_num <= 0) then + info = QMCKL_INVALID_ARG_3 + return + endif + + do k=1,walk_num + info = qmckl_distance_rescaled(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(1,1,k), elec_num, rescale_factor_ee) + if (info /= QMCKL_SUCCESS) then + exit + endif + end do + +end function qmckl_compute_ee_distance_rescaled_f + #+end_src + + #+begin_src c :tangle (eval h_private_func) :comments org :exports none +qmckl_exit_code qmckl_compute_ee_distance_rescaled ( + const qmckl_context context, + const int64_t elec_num, + const double rescale_factor_ee, + const int64_t walk_num, + const double* coord, + double* const ee_distance_rescaled ); + #+end_src + + #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_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 & + (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled) & + bind(C) result(info) + + use, intrinsic :: iso_c_binding + implicit none + + integer (c_int64_t) , intent(in) , value :: context + integer (c_int64_t) , intent(in) , value :: elec_num + real (c_double ) , intent(in) , value :: rescale_factor_ee + integer (c_int64_t) , intent(in) , value :: walk_num + real (c_double ) , intent(in) :: coord(elec_num,3,walk_num) + real (c_double ) , intent(out) :: ee_distance_rescaled(elec_num,elec_num,walk_num) + + integer(c_int32_t), external :: qmckl_compute_ee_distance_rescaled_f + info = qmckl_compute_ee_distance_rescaled_f & + (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled) + + end function qmckl_compute_ee_distance_rescaled + #+end_src + +**** Test + + #+begin_src python :results output :exports none +import numpy as np + +kappa = 1.0 + +elec_1_w1 = np.array( [-0.250655104764153, 0.503070975550133 , -0.166554344502303]) +elec_2_w1 = np.array( [-0.587812193472177, -0.128751981129274 , 0.187773606533075]) +elec_5_w1 = np.array( [-0.127732483187947, -0.138975497694196 , -8.669850480215846E-002]) +elec_6_w1 = np.array( [-0.232271834949124, -1.059321673434182E-002 , -0.504862241464867]) + +print ( "[0][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-elec_1_w1)) )/kappa ) +print ( "[0][1] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-elec_2_w1)) )/kappa ) +print ( "[1][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_2_w1-elec_1_w1)) )/kappa ) +print ( "[5][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-elec_5_w1)) )/kappa ) +print ( "[5][6] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-elec_6_w1)) )/kappa ) +print ( "[6][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_6_w1-elec_5_w1)) )/kappa ) + #+end_src + + #+RESULTS: + : [0][0] : 0.0 + : [0][1] : 0.5502278003524018 + : [1][0] : 0.5502278003524018 + : [5][5] : 0.0 + : [5][6] : 0.3622098222364193 + : [6][5] : 0.3622098222364193 + + #+begin_src c :tangle (eval c_test) +assert(qmckl_electron_provided(context)); + + +double ee_distance_rescaled[walk_num * elec_num * elec_num]; +rc = qmckl_get_jastrow_ee_distance_rescaled(context, ee_distance_rescaled); + +// (e1,e2,w) +// (0,0,0) == 0. +assert(ee_distance_rescaled[0] == 0.); + +// (1,0,0) == (0,1,0) +assert(ee_distance_rescaled[1] == ee_distance_rescaled[elec_num]); + +// value of (1,0,0) +assert(fabs(ee_distance_rescaled[1]-0.5502278003524018) < 1.e-12); + +// (0,0,1) == 0. +assert(ee_distance_rescaled[5*elec_num + 5] == 0.); + +// (1,0,1) == (0,1,1) +assert(ee_distance_rescaled[5*elec_num+6] == ee_distance_rescaled[6*elec_num+5]); + +// value of (1,0,1) +assert(fabs(ee_distance_rescaled[5*elec_num+6]-0.3622098222364193) < 1.e-12); + + #+end_src + +*** Electron-electron rescaled distance gradients and Laplacian with respect to electron coordinates + + 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 + 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_ee_distance_rescaled_deriv_e(qmckl_context context, double* const distance_rescaled_deriv_e); + #+end_src + + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none +qmckl_exit_code qmckl_get_jastrow_ee_distance_rescaled_deriv_e(qmckl_context context, double* const distance_rescaled_deriv_e) +{ + if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { + return QMCKL_NULL_CONTEXT; + } + + qmckl_exit_code rc; + + rc = qmckl_provide_ee_distance_rescaled_deriv_e(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.ee_distance_rescaled_deriv_e, sze * sizeof(double)); + + return QMCKL_SUCCESS; +} + #+end_src + +**** 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); + #+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) +{ + + if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { + return QMCKL_NULL_CONTEXT; + } + + qmckl_context_struct* const ctx = (qmckl_context_struct*) context; + assert (ctx != NULL); + + + /* Compute if necessary */ + if (ctx->electron.walker.point.date > ctx->jastrow.ee_distance_rescaled_deriv_e_date) { + + if (ctx->electron.walker.num > ctx->electron.walker_old.num) { + if (ctx->jastrow.ee_distance_rescaled_deriv_e != NULL) { + qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.ee_distance_rescaled_deriv_e); + if (rc != QMCKL_SUCCESS) { + return qmckl_failwith( context, rc, + "qmckl_provide_ee_distance_rescaled_deriv_e", + "Unable to free ctx->jastrow.ee_distance_rescaled_deriv_e"); + } + ctx->jastrow.ee_distance_rescaled_deriv_e = NULL; + } + } + + /* Allocate array */ + if (ctx->jastrow.ee_distance_rescaled_deriv_e == 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); + + if (ee_distance_rescaled_deriv_e == NULL) { + return qmckl_failwith( context, + QMCKL_ALLOCATION_FAILED, + "qmckl_provide_ee_distance_rescaled_deriv_e", + NULL); + } + ctx->jastrow.ee_distance_rescaled_deriv_e = ee_distance_rescaled_deriv_e; + } + + qmckl_exit_code rc = + qmckl_compute_ee_distance_rescaled_deriv_e(context, + ctx->electron.num, + ctx->jastrow.rescale_factor_ee, + ctx->electron.walker.num, + ctx->electron.walker.point.coord.data, + ctx->jastrow.ee_distance_rescaled_deriv_e); + if (rc != QMCKL_SUCCESS) { + return rc; + } + + ctx->jastrow.ee_distance_rescaled_date = ctx->date; + } + + return QMCKL_SUCCESS; +} + #+end_src + +**** Compute + :PROPERTIES: + :Name: qmckl_compute_ee_distance_rescaled_deriv_e + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: + + #+NAME: qmckl_ee_distance_rescaled_deriv_e_args + | Variable | Type | In/Out | Description | + |-----------------------+-------------------------------------------+--------+-------------------------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~elec_num~ | ~int64_t~ | in | Number of electrons | + | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | + | ~walk_num~ | ~int64_t~ | in | Number of walkers | + | ~coord~ | ~double[3][walk_num][elec_num]~ | in | Electron coordinates | + | ~ee_distance_deriv_e~ | ~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) & + result(info) + use qmckl + implicit none + integer(qmckl_context), intent(in) :: context + integer*8 , intent(in) :: 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) + + integer*8 :: k + + info = QMCKL_SUCCESS + + if (context == QMCKL_NULL_CONTEXT) then + info = QMCKL_INVALID_CONTEXT + return + endif + + if (elec_num <= 0) then + info = QMCKL_INVALID_ARG_2 + return + endif + + if (walk_num <= 0) then + info = QMCKL_INVALID_ARG_3 + return + endif + + do k=1,walk_num + info = qmckl_distance_rescaled_deriv_e(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) + if (info /= QMCKL_SUCCESS) then + exit + endif + end do + +end function qmckl_compute_ee_distance_rescaled_deriv_e_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 ( + 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 ); + #+end_src + + #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_deriv_e_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) & + bind(C) result(info) + + use, intrinsic :: iso_c_binding + implicit none + + integer (c_int64_t) , intent(in) , value :: context + integer (c_int64_t) , intent(in) , value :: elec_num + real (c_double ) , intent(in) , value :: rescale_factor_ee + integer (c_int64_t) , intent(in) , value :: walk_num + real (c_double ) , intent(in) :: coord(elec_num,3,walk_num) + real (c_double ) , intent(out) :: ee_distance_rescaled_deriv_e(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) + + end function qmckl_compute_ee_distance_rescaled_deriv_e + #+end_src + +**** Test + + #+begin_src python :results output :exports none +import numpy as np + +# TODO + #+end_src + + #+begin_src c :tangle (eval c_test) +assert(qmckl_electron_provided(context)); + + +double ee_distance_rescaled_deriv_e[4 * walk_num * elec_num * elec_num]; +rc = qmckl_get_jastrow_ee_distance_rescaled_deriv_e(context, ee_distance_rescaled_deriv_e); + +// TODO: Get exact values +//// (e1,e2,w) +//// (0,0,0) == 0. +//assert(ee_distance[0] == 0.); +// +//// (1,0,0) == (0,1,0) +//assert(ee_distance[1] == ee_distance[elec_num]); +// +//// value of (1,0,0) +//assert(fabs(ee_distance[1]-7.152322512964209) < 1.e-12); +// +//// (0,0,1) == 0. +//assert(ee_distance[elec_num*elec_num] == 0.); +// +//// (1,0,1) == (0,1,1) +//assert(ee_distance[elec_num*elec_num+1] == ee_distance[elec_num*elec_num+elec_num]); +// +//// value of (1,0,1) +//assert(fabs(ee_distance[elec_num*elec_num+1]-6.5517646321055665) < 1.e-12); + + #+end_src + +** Electron-nucleus component +*** Asymptotic component for + + Calculate the asymptotic component ~asymp_jasa~ to be substracted from the final + electron-nucleus jastrow factor \(J_{\text{eN}}\). The asymptotic component is calculated + via the ~a_vector~ and the electron-nucleus rescale factors ~rescale_factor_en~. + + \[ + J_{\text{en}}^{\infty \alpha} = \frac{a_1 \kappa_\alpha^{-1}}{1 + a_2 \kappa_\alpha^{-1}} + \] + +**** Get + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_asymp_jasa(qmckl_context context, double* const asymp_jasa, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_asymp_jasa(qmckl_context context, double* const asymp_jasa, @@ -3180,11 +3699,11 @@ qmckl_get_jastrow_asymp_jasa(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -**** Fortran interface +***** Fortran interface -#+begin_src f90 :tangle (eval fh_func) :comments org + #+begin_src f90 :tangle (eval fh_func) :comments org interface integer(qmckl_exit_code) function qmckl_get_jastrow_asymp_jasa(context, & asymp_jasa, size_max) bind(C) @@ -3196,14 +3715,14 @@ interface double precision, intent(out) :: asymp_jasa(size_max) end function qmckl_get_jastrow_asymp_jasa end interface -#+end_src + #+end_src -*** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +**** Provide :noexport: + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_asymp_jasa(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_asymp_jasa(qmckl_context context) { @@ -3260,26 +3779,26 @@ qmckl_exit_code qmckl_provide_jastrow_asymp_jasa(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_jastrow_asymp_jasa - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_jastrow_asymp_jasa + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_asymp_jasa_args - | Variable | Type | In/Out | Description | - |---------------------+-------------------------------------+--------+----------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~aord_num~ | ~int64_t~ | in | Order of the polynomial | - | ~type_nucl_num~ | ~int64_t~ | in | Number of nucleus types | - | ~a_vector~ | ~double[type_nucl_num][aord_num+1]~ | in | Values of a | - | ~rescale_factor_en~ | ~double[type_nucl_num]~ | in | Electron nucleus distances | - | ~asymp_jasa~ | ~double[type_nucl_num]~ | out | Asymptotic value | + #+NAME: qmckl_asymp_jasa_args + | Variable | Type | In/Out | Description | + |---------------------+-------------------------------------+--------+----------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~aord_num~ | ~int64_t~ | in | Order of the polynomial | + | ~type_nucl_num~ | ~int64_t~ | in | Number of nucleus types | + | ~a_vector~ | ~double[type_nucl_num][aord_num+1]~ | in | Values of a | + | ~rescale_factor_en~ | ~double[type_nucl_num]~ | in | Electron nucleus distances | + | ~asymp_jasa~ | ~double[type_nucl_num]~ | out | Asymptotic value | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_jastrow_asymp_jasa_f(context, aord_num, type_nucl_num, a_vector, & rescale_factor_en, asymp_jasa) & result(info) @@ -3323,12 +3842,12 @@ integer function qmckl_compute_jastrow_asymp_jasa_f(context, aord_num, type_nucl end do end function qmckl_compute_jastrow_asymp_jasa_f - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_asymp_jasa_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_asymp_jasa_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_jastrow_asymp_jasa & (context, aord_num, type_nucl_num, a_vector, rescale_factor_en, asymp_jasa) & bind(C) result(info) @@ -3348,9 +3867,9 @@ end function qmckl_compute_jastrow_asymp_jasa_f (context, aord_num, type_nucl_num, a_vector, rescale_factor_en, asymp_jasa) end function qmckl_compute_jastrow_asymp_jasa - #+end_src + #+end_src -#+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes /* qmckl_exit_code qmckl_compute_jastrow_asymp_jasa ( const qmckl_context context, @@ -3382,12 +3901,12 @@ qmckl_exit_code qmckl_compute_jastrow_asymp_jasa ( return QMCKL_SUCCESS; } */ -#+end_src + #+end_src - #+CALL: generate_c_header(table=qmckl_asymp_jasa_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_header(table=qmckl_asymp_jasa_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src c :tangle (eval h_func) :comments org + #+RESULTS: + #+begin_src c :tangle (eval h_func) :comments org qmckl_exit_code qmckl_compute_jastrow_asymp_jasa ( const qmckl_context context, const int64_t aord_num, @@ -3395,11 +3914,11 @@ qmckl_exit_code qmckl_compute_jastrow_asymp_jasa ( const double* a_vector, const double* rescale_factor_en, double* const asymp_jasa ); - #+end_src + #+end_src -*** Test - #+name: asymp_jasa - #+begin_src python :results output :exports none :noweb yes +**** Test + #+name: asymp_jasa + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -3411,12 +3930,12 @@ for p in range(1,aord_num): asymp_jasa += a_vector[p + 1] * x print("asymp_jasa[i] : ", asymp_jasa) - #+end_src + #+end_src - #+RESULTS: asymp_jasa - : asymp_jasa[i] : [-0.548554] + #+RESULTS: asymp_jasa + : asymp_jasa[i] : [-0.548554] - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) double asymp_jasa[2]; rc = qmckl_get_jastrow_asymp_jasa(context, asymp_jasa, type_nucl_num); @@ -3424,27 +3943,27 @@ rc = qmckl_get_jastrow_asymp_jasa(context, asymp_jasa, type_nucl_num); printf("%e %e\n", asymp_jasa[0], -0.548554); assert(fabs(-0.548554 - asymp_jasa[0]) < 1.e-12); - #+end_src + #+end_src -** Electron-nucleus component \(f_{en}\) +*** Electron-nucleus component - Calculate the electron-electron jastrow component ~factor_en~ using the ~a_vector~ - coeffecients and the electron-nucleus rescaled distances ~en_distance_rescaled~. + Calculate the electron-electron jastrow component ~factor_en~ using the ~a_vector~ + coeffecients and the electron-nucleus rescaled distances ~en_distance_rescaled~. - \[ -f_{en} = \sum_{i,j> @@ -3855,14 +4374,14 @@ for a in range(0,nucl_num): factor_en -= asymp_jasa[type_nucl_vector[a]-1] print("factor_en :",factor_en) - #+end_src + #+end_src - #+RESULTS: - : asymp_jasa[i] : [-0.548554] - : factor_en : 5.1052574308112755 + #+RESULTS: + : asymp_jasa[i] : [-0.548554] + : factor_en : 5.1052574308112755 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_provided(context)); @@ -3872,24 +4391,24 @@ rc = qmckl_get_jastrow_factor_en(context, factor_en,walk_num); // calculate factor_en assert(fabs(5.1052574308112755 - factor_en[0]) < 1.e-12); - #+end_src + #+end_src -** Electron-nucleus component derivative \(f'_{en}\) - Calculate the electron-electron jastrow component ~factor_en_deriv_e~ derivative - with respect to the electron coordinates using the ~en_distance_rescaled~ and - ~en_distance_rescaled_deriv_e~ which are already calculated previously. +*** Derivative + Calculate the electron-electron jastrow component ~factor_en_deriv_e~ derivative + with respect to the electron coordinates using the ~en_distance_rescaled~ and + ~en_distance_rescaled_deriv_e~ which are already calculated previously. - TODO: write equations. + TODO: write equations. -*** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes +**** Get + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_factor_en_deriv_e(qmckl_context context, double* const factor_en_deriv_e, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_factor_en_deriv_e(qmckl_context context, double* const factor_en_deriv_e, @@ -3918,14 +4437,14 @@ qmckl_get_jastrow_factor_en_deriv_e(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +**** Provide :noexport: + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_factor_en_deriv_e(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_factor_en_deriv_e(qmckl_context context) { @@ -4007,31 +4526,31 @@ qmckl_exit_code qmckl_provide_jastrow_factor_en_deriv_e(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_factor_en_deriv_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_factor_en_deriv_e + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_en_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 | - | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | - | ~type_nucl_num~ | ~int64_t~ | in | Number of unique nuclei | - | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | IDs of unique nucleii | - | ~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 | + #+NAME: qmckl_factor_en_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 | + | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | + | ~type_nucl_num~ | ~int64_t~ | in | Number of unique nuclei | + | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | IDs of unique nucleii | + | ~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 | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_en_deriv_e_f( & context, walk_num, elec_num, nucl_num, type_nucl_num, & type_nucl_vector, aord_num, a_vector, & @@ -4131,11 +4650,11 @@ integer function qmckl_compute_factor_en_deriv_e_f( & end do end function qmckl_compute_factor_en_deriv_e_f - #+end_src + #+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_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_en_deriv_e ( const qmckl_context context, const int64_t walk_num, @@ -4148,13 +4667,13 @@ end function qmckl_compute_factor_en_deriv_e_f const double* en_distance_rescaled, const double* en_distance_rescaled_deriv_e, double* const factor_en_deriv_e ); - #+end_src + #+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_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_en_deriv_e & (context, & walk_num, & @@ -4199,10 +4718,10 @@ end function qmckl_compute_factor_en_deriv_e_f factor_en_deriv_e) end function qmckl_compute_factor_en_deriv_e - #+end_src + #+end_src -*** Test - #+begin_src python :results output :exports none :noweb yes +**** Test + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -4287,16 +4806,16 @@ 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]) - #+end_src + #+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 + #+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 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_provided(context)); @@ -4310,55 +4829,57 @@ 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); + #+end_src + +*** Electron-nucleus rescaled distances + + ~en_distance_rescaled~ stores the matrix of the rescaled distances between + electrons and nuclei. + + \[ + C_{i\alpha} = \frac{ 1 - e^{-\kappa_\alpha R_{i\alpha}}}{\kappa_\alpha} + \] + + where \(R_{i\alpha}\) is the matrix of electron-nucleus distances. + +**** Get + + #+begin_src c :comments org :tangle (eval h_func) :noweb yes +qmckl_exit_code qmckl_get_electron_en_distance_rescaled(qmckl_context context, double* distance_rescaled); #+end_src -** Electron-electron rescaled distances - ~ee_distance_rescaled~ stores the matrix of the rescaled distances between all - pairs of electrons: - - \[ - C_{ij} = \left( 1 - \exp{-\kappa C_{ij}}\right)/\kappa - \] - - where \(C_{ij}\) is the matrix of electron-electron distances. - -*** Get - - #+begin_src c :comments org :tangle (eval h_func) :noweb yes -qmckl_exit_code qmckl_get_jastrow_ee_distance_rescaled(qmckl_context context, double* const distance_rescaled); - #+end_src - - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_get_jastrow_ee_distance_rescaled(qmckl_context context, double* const distance_rescaled) + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none +qmckl_exit_code qmckl_get_electron_en_distance_rescaled(qmckl_context context, double* distance_rescaled) { + if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { return QMCKL_NULL_CONTEXT; } qmckl_exit_code rc; - rc = qmckl_provide_ee_distance_rescaled(context); + rc = qmckl_provide_en_distance_rescaled(context); if (rc != QMCKL_SUCCESS) return rc; qmckl_context_struct* const ctx = (qmckl_context_struct*) context; assert (ctx != NULL); - size_t sze = ctx->electron.num * ctx->electron.num * ctx->electron.walker.num; - memcpy(distance_rescaled, ctx->jastrow.ee_distance_rescaled, sze * sizeof(double)); + size_t sze = ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num; + memcpy(distance_rescaled, ctx->jastrow.en_distance_rescaled, sze * sizeof(double)); return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: +**** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_ee_distance_rescaled(qmckl_context context); - #+end_src + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +qmckl_exit_code qmckl_provide_en_distance_rescaled(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(qmckl_context context) + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none +qmckl_exit_code qmckl_provide_en_distance_rescaled(qmckl_context context) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -4368,88 +4889,105 @@ qmckl_exit_code qmckl_provide_ee_distance_rescaled(qmckl_context context) qmckl_context_struct* const ctx = (qmckl_context_struct*) context; assert (ctx != NULL); + if (!(ctx->nucleus.provided)) { + return QMCKL_NOT_PROVIDED; + } /* Compute if necessary */ - if (ctx->electron.walker.point.date > ctx->jastrow.ee_distance_rescaled_date) { + if (ctx->electron.walker.point.date > ctx->jastrow.en_distance_rescaled_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow.ee_distance_rescaled != NULL) { - qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.ee_distance_rescaled); + if (ctx->jastrow.en_distance_rescaled != NULL) { + qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.en_distance_rescaled); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_ee_distance_rescaled", - "Unable to free ctx->jastrow.ee_distance_rescaled"); + "qmckl_provide_en_distance_rescaled", + "Unable to free ctx->jastrow.en_distance_rescaled"); } - ctx->jastrow.ee_distance_rescaled = NULL; + ctx->jastrow.en_distance_rescaled = NULL; } } /* Allocate array */ - if (ctx->jastrow.ee_distance_rescaled == NULL) { + if (ctx->jastrow.en_distance_rescaled == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; - mem_info.size = ctx->electron.num * ctx->electron.num * + mem_info.size = ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num * sizeof(double); - double* ee_distance_rescaled = (double*) qmckl_malloc(context, mem_info); + double* en_distance_rescaled = (double*) qmckl_malloc(context, mem_info); - if (ee_distance_rescaled == NULL) { + if (en_distance_rescaled == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_ee_distance_rescaled", + "qmckl_provide_en_distance_rescaled", NULL); } - ctx->jastrow.ee_distance_rescaled = ee_distance_rescaled; + ctx->jastrow.en_distance_rescaled = en_distance_rescaled; } qmckl_exit_code rc = - qmckl_compute_ee_distance_rescaled(context, + qmckl_compute_en_distance_rescaled(context, ctx->electron.num, - ctx->jastrow.rescale_factor_ee, + ctx->nucleus.num, + ctx->jastrow.type_nucl_num, + ctx->jastrow.type_nucl_vector, + ctx->jastrow.rescale_factor_en, ctx->electron.walker.num, ctx->electron.walker.point.coord.data, - ctx->jastrow.ee_distance_rescaled); + ctx->nucleus.coord.data, + ctx->jastrow.en_distance_rescaled); if (rc != QMCKL_SUCCESS) { return rc; } - ctx->jastrow.ee_distance_rescaled_date = ctx->date; + ctx->jastrow.en_distance_rescaled_date = ctx->date; } return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_ee_distance_rescaled - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_en_distance_rescaled + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_ee_distance_rescaled_args - | Variable | Type | In/Out | Description | - |---------------------+----------------------------------------+--------+--------------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~elec_num~ | ~int64_t~ | in | Number of electrons | - | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | - | ~walk_num~ | ~int64_t~ | in | Number of walkers | - | ~coord~ | ~double[3][walk_num][elec_num]~ | in | Electron coordinates | - | ~ee_distance~ | ~double[walk_num][elec_num][elec_num]~ | out | Electron-electron rescaled distances | + #+NAME: qmckl_en_distance_rescaled_args + | Variable | Type | In/Out | Description | + |------------------------+----------------------------------------+--------+-----------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~elec_num~ | ~int64_t~ | in | Number of electrons | + | ~nucl_num~ | ~int64_t~ | in | Number of nuclei | + | ~type_nucl_num~ | ~int64_t~ | in | Number of types of nuclei | + | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Number of types of nuclei | + | ~rescale_factor_en~ | ~double[type_nucl_num]~ | in | The factor for rescaled distances | + | ~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~ | ~double[walk_num][nucl_num][elec_num]~ | out | Electron-nucleus distances | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes -integer function qmckl_compute_ee_distance_rescaled_f(context, elec_num, rescale_factor_ee, walk_num, & - coord, ee_distance_rescaled) & + #+begin_src f90 :comments org :tangle (eval f) :noweb yes +integer function qmckl_compute_en_distance_rescaled_f(context, elec_num, nucl_num, type_nucl_num, & + type_nucl_vector, rescale_factor_en, walk_num, elec_coord, & + nucl_coord, en_distance_rescaled) & result(info) use qmckl implicit none integer(qmckl_context), intent(in) :: context integer*8 , intent(in) :: elec_num - double precision , intent(in) :: rescale_factor_ee + integer*8 , intent(in) :: nucl_num + integer*8 , intent(in) :: type_nucl_num + integer*8 , intent(in) :: type_nucl_vector(nucl_num) + double precision , intent(in) :: rescale_factor_en(type_nucl_num) integer*8 , intent(in) :: walk_num - double precision , intent(in) :: coord(elec_num,walk_num,3) - double precision , intent(out) :: ee_distance_rescaled(elec_num,elec_num,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(elec_num,nucl_num,walk_num) - integer*8 :: k + integer*8 :: i, k + double precision :: coord(3) info = QMCKL_SUCCESS @@ -4463,40 +5001,60 @@ integer function qmckl_compute_ee_distance_rescaled_f(context, elec_num, rescale return endif - if (walk_num <= 0) then + if (nucl_num <= 0) then info = QMCKL_INVALID_ARG_3 return endif - do k=1,walk_num - info = qmckl_distance_rescaled(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(1,1,k), elec_num, rescale_factor_ee) - if (info /= QMCKL_SUCCESS) then - exit - endif + if (walk_num <= 0) then + info = QMCKL_INVALID_ARG_5 + return + endif + + do i=1, nucl_num + coord(1:3) = nucl_coord(i,1:3) + do k=1,walk_num + info = qmckl_distance_rescaled(context, 'T', 'T', elec_num, 1_8, & + elec_coord(1,k,1), elec_num*walk_num, coord, 1_8, & + en_distance_rescaled(1,i,k), elec_num, rescale_factor_en(type_nucl_vector(i))) + if (info /= QMCKL_SUCCESS) then + return + endif + end do end do -end function qmckl_compute_ee_distance_rescaled_f - #+end_src +end function qmckl_compute_en_distance_rescaled_f + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org :exports none -qmckl_exit_code qmckl_compute_ee_distance_rescaled ( + #+begin_src c :tangle (eval h_private_func) :comments org :exports none +qmckl_exit_code qmckl_compute_en_distance_rescaled ( const qmckl_context context, const int64_t elec_num, - const double rescale_factor_ee, + const int64_t nucl_num, + const int64_t type_nucl_num, + int64_t* const type_nucl_vector, + const double* rescale_factor_en, const int64_t walk_num, - const double* coord, - double* const ee_distance_rescaled ); - #+end_src + const double* elec_coord, + const double* nucl_coord, + double* const en_distance_rescaled ); + #+end_src - #+CALL: generate_c_interface(table=qmckl_ee_distance_rescaled_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_en_distance_rescaled_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 & - (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled) & + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none + integer(c_int32_t) function qmckl_compute_en_distance_rescaled & + (context, & + elec_num, & + nucl_num, & + type_nucl_num, & + type_nucl_vector, & + rescale_factor_en, & + walk_num, & + elec_coord, & + nucl_coord, & + en_distance_rescaled) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -4504,21 +5062,34 @@ qmckl_exit_code qmckl_compute_ee_distance_rescaled ( integer (c_int64_t) , intent(in) , value :: context integer (c_int64_t) , intent(in) , value :: elec_num - real (c_double ) , intent(in) , value :: rescale_factor_ee + integer (c_int64_t) , intent(in) , value :: nucl_num + integer (c_int64_t) , intent(in) , value :: type_nucl_num + integer (c_int64_t) , intent(in) :: type_nucl_vector(nucl_num) + real (c_double ) , intent(in) :: rescale_factor_en(type_nucl_num) integer (c_int64_t) , intent(in) , value :: walk_num - real (c_double ) , intent(in) :: coord(elec_num,3,walk_num) - real (c_double ) , intent(out) :: ee_distance_rescaled(elec_num,elec_num,walk_num) + 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(elec_num,nucl_num,walk_num) - integer(c_int32_t), external :: qmckl_compute_ee_distance_rescaled_f - info = qmckl_compute_ee_distance_rescaled_f & - (context, elec_num, rescale_factor_ee, walk_num, coord, ee_distance_rescaled) + integer(c_int32_t), external :: qmckl_compute_en_distance_rescaled_f + info = qmckl_compute_en_distance_rescaled_f & + (context, & + elec_num, & + nucl_num, & + type_nucl_num, & + type_nucl_vector, & + rescale_factor_en, & + walk_num, & + elec_coord, & + nucl_coord, & + en_distance_rescaled) - end function qmckl_compute_ee_distance_rescaled - #+end_src + end function qmckl_compute_en_distance_rescaled + #+end_src -*** Test +**** Test - #+begin_src python :results output :exports none + #+begin_src python :results output :exports none import numpy as np kappa = 1.0 @@ -4527,96 +5098,105 @@ elec_1_w1 = np.array( [-0.250655104764153, 0.503070975550133 , -0.1665543 elec_2_w1 = np.array( [-0.587812193472177, -0.128751981129274 , 0.187773606533075]) elec_5_w1 = np.array( [-0.127732483187947, -0.138975497694196 , -8.669850480215846E-002]) elec_6_w1 = np.array( [-0.232271834949124, -1.059321673434182E-002 , -0.504862241464867]) +nucl_1 = np.array( [ 0., 0., 0. ]) +nucl_2 = np.array( [ 0., 0., 2.059801 ]) -print ( "[0][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-elec_1_w1)) )/kappa ) -print ( "[0][1] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-elec_2_w1)) )/kappa ) -print ( "[1][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_2_w1-elec_1_w1)) )/kappa ) -print ( "[5][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-elec_5_w1)) )/kappa ) -print ( "[5][6] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-elec_6_w1)) )/kappa ) -print ( "[6][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_6_w1-elec_5_w1)) )/kappa ) - #+end_src - - #+RESULTS: - : [0][0] : 0.0 - : [0][1] : 0.5502278003524018 - : [1][0] : 0.5502278003524018 - : [5][5] : 0.0 - : [5][6] : 0.3622098222364193 - : [6][5] : 0.3622098222364193 - - #+begin_src c :tangle (eval c_test) -assert(qmckl_electron_provided(context)); - - -double ee_distance_rescaled[walk_num * elec_num * elec_num]; -rc = qmckl_get_jastrow_ee_distance_rescaled(context, ee_distance_rescaled); - -// (e1,e2,w) -// (0,0,0) == 0. -assert(ee_distance_rescaled[0] == 0.); - -// (1,0,0) == (0,1,0) -assert(ee_distance_rescaled[1] == ee_distance_rescaled[elec_num]); - -// value of (1,0,0) -assert(fabs(ee_distance_rescaled[1]-0.5502278003524018) < 1.e-12); - -// (0,0,1) == 0. -assert(ee_distance_rescaled[5*elec_num + 5] == 0.); - -// (1,0,1) == (0,1,1) -assert(ee_distance_rescaled[5*elec_num+6] == ee_distance_rescaled[6*elec_num+5]); - -// value of (1,0,1) -assert(fabs(ee_distance_rescaled[5*elec_num+6]-0.3622098222364193) < 1.e-12); +print ( "[0][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-nucl_1)) )/kappa ) +print ( "[1][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-nucl_2)) )/kappa ) +print ( "[0][1] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_2_w1-nucl_1)) )/kappa ) +print ( "[0][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-nucl_1)) )/kappa ) +print ( "[1][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-nucl_2)) )/kappa ) +print ( "[0][6] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_6_w1-nucl_1)) )/kappa ) #+end_src -** Electron-electron rescaled distance gradients and Laplacian with respect to electron coords + #+RESULTS: + : [0][0] : 0.4435709484118112 + : [1][0] : 0.8993601506374442 + : [0][1] : 0.46760219699910477 + : [0][5] : 0.1875631834682101 + : [1][5] : 0.8840716589810682 + : [0][6] : 0.42640469987268914 - The rescaled distances which is given as $R = (1 - \exp{-\kappa r})/\kappa$ - needs to be perturbed with respect to the electorn coordinates. - This data is stored in the ~ee_distance_rescaled_deriv_e~ tensor. The - The first three elements of this three index tensor ~[4][num][num]~ gives the - derivatives in the x, y, and z directions $dx, dy, dz$ and the last index - gives the Laplacian $\partial x^2 + \partial y^2 + \partial z^2$. + #+begin_src c :tangle (eval c_test) -*** Get +assert(qmckl_electron_provided(context)); +assert(qmckl_nucleus_provided(context)); - #+begin_src c :comments org :tangle (eval h_func) :noweb yes -qmckl_exit_code qmckl_get_jastrow_ee_distance_rescaled_deriv_e(qmckl_context context, double* const distance_rescaled_deriv_e); - #+end_src +double en_distance_rescaled[walk_num][nucl_num][elec_num]; - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_get_jastrow_ee_distance_rescaled_deriv_e(qmckl_context context, double* const distance_rescaled_deriv_e) +rc = qmckl_check(context, + qmckl_get_electron_en_distance_rescaled(context, &(en_distance_rescaled[0][0][0])) + ); +assert (rc == QMCKL_SUCCESS); + +// (e,n,w) in Fortran notation +// (1,1,1) +assert(fabs(en_distance_rescaled[0][0][0] - 0.4435709484118112) < 1.e-12); + +// (1,2,1) +assert(fabs(en_distance_rescaled[0][1][0] - 0.8993601506374442) < 1.e-12); + +// (2,1,1) +assert(fabs(en_distance_rescaled[0][0][1] - 0.46760219699910477) < 1.e-12); + +// (1,1,2) +assert(fabs(en_distance_rescaled[0][0][5] - 0.1875631834682101) < 1.e-12); + +// (1,2,2) +assert(fabs(en_distance_rescaled[0][1][5] - 0.8840716589810682) < 1.e-12); + +// (2,1,2) +assert(fabs(en_distance_rescaled[0][0][6] - 0.42640469987268914) < 1.e-12); + + #+end_src + +*** Electron-electron rescaled distance gradients and Laplacian with respect to electron coordinates + + 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 + 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); + #+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) { + if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { return QMCKL_NULL_CONTEXT; } qmckl_exit_code rc; - rc = qmckl_provide_ee_distance_rescaled_deriv_e(context); + rc = qmckl_provide_en_distance_rescaled_deriv_e(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.ee_distance_rescaled_deriv_e, sze * sizeof(double)); + size_t sze = 4 * ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num; + memcpy(distance_rescaled_deriv_e, ctx->jastrow.en_distance_rescaled_deriv_e, sze * sizeof(double)); return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: +**** 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); - #+end_src + #+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); + #+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) + #+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) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -4626,88 +5206,105 @@ qmckl_exit_code qmckl_provide_ee_distance_rescaled_deriv_e(qmckl_context context qmckl_context_struct* const ctx = (qmckl_context_struct*) context; assert (ctx != NULL); + if (!(ctx->nucleus.provided)) { + return QMCKL_NOT_PROVIDED; + } /* Compute if necessary */ - if (ctx->electron.walker.point.date > ctx->jastrow.ee_distance_rescaled_deriv_e_date) { + if (ctx->electron.walker.point.date > ctx->jastrow.en_distance_rescaled_deriv_e_date) { if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow.ee_distance_rescaled_deriv_e != NULL) { - qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.ee_distance_rescaled_deriv_e); + if (ctx->jastrow.en_distance_rescaled_deriv_e != NULL) { + qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.en_distance_rescaled_deriv_e); if (rc != QMCKL_SUCCESS) { return qmckl_failwith( context, rc, - "qmckl_provide_ee_distance_rescaled_deriv_e", - "Unable to free ctx->jastrow.ee_distance_rescaled_deriv_e"); + "qmckl_provide_en_distance_rescaled_deriv_e", + "Unable to free ctx->jastrow.en_distance_rescaled_deriv_e"); } - ctx->jastrow.ee_distance_rescaled_deriv_e = NULL; + ctx->jastrow.en_distance_rescaled_deriv_e = NULL; } } /* Allocate array */ - if (ctx->jastrow.ee_distance_rescaled_deriv_e == NULL) { + if (ctx->jastrow.en_distance_rescaled_deriv_e == NULL) { qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; - mem_info.size = 4 * ctx->electron.num * ctx->electron.num * + mem_info.size = 4 * ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num * sizeof(double); - double* ee_distance_rescaled_deriv_e = (double*) qmckl_malloc(context, mem_info); + double* en_distance_rescaled_deriv_e = (double*) qmckl_malloc(context, mem_info); - if (ee_distance_rescaled_deriv_e == NULL) { + if (en_distance_rescaled_deriv_e == NULL) { return qmckl_failwith( context, QMCKL_ALLOCATION_FAILED, - "qmckl_provide_ee_distance_rescaled_deriv_e", + "qmckl_provide_en_distance_rescaled_deriv_e", NULL); } - ctx->jastrow.ee_distance_rescaled_deriv_e = ee_distance_rescaled_deriv_e; + ctx->jastrow.en_distance_rescaled_deriv_e = en_distance_rescaled_deriv_e; } qmckl_exit_code rc = - qmckl_compute_ee_distance_rescaled_deriv_e(context, + qmckl_compute_en_distance_rescaled_deriv_e(context, ctx->electron.num, - ctx->jastrow.rescale_factor_ee, + ctx->nucleus.num, + ctx->jastrow.type_nucl_num, + ctx->jastrow.type_nucl_vector, + ctx->jastrow.rescale_factor_en, ctx->electron.walker.num, ctx->electron.walker.point.coord.data, - ctx->jastrow.ee_distance_rescaled_deriv_e); + ctx->nucleus.coord.data, + ctx->jastrow.en_distance_rescaled_deriv_e); if (rc != QMCKL_SUCCESS) { return rc; } - ctx->jastrow.ee_distance_rescaled_date = ctx->date; + ctx->jastrow.en_distance_rescaled_deriv_e_date = ctx->date; } return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_ee_distance_rescaled_deriv_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_en_distance_rescaled_deriv_e + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_ee_distance_rescaled_deriv_e_args - | Variable | Type | In/Out | Description | - |-----------------------+-------------------------------------------+--------+-------------------------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~elec_num~ | ~int64_t~ | in | Number of electrons | - | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | - | ~walk_num~ | ~int64_t~ | in | Number of walkers | - | ~coord~ | ~double[3][walk_num][elec_num]~ | in | Electron coordinates | - | ~ee_distance_deriv_e~ | ~double[walk_num][4][elec_num][elec_num]~ | out | Electron-electron rescaled distance derivatives | + #+NAME: qmckl_en_distance_rescaled_deriv_e_args + | Variable | Type | In/Out | Description | + |--------------------------------+-------------------------------------------+--------+---------------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~elec_num~ | ~int64_t~ | in | Number of electrons | + | ~nucl_num~ | ~int64_t~ | in | Number of nuclei | + | ~type_nucl_num~ | ~int64_t~ | in | Number of nucleus types | + | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Array of nucleus types | + | ~rescale_factor_en~ | ~double[nucl_num]~ | in | The factors for rescaled distances | + | ~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 | - #+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) & + #+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, & + type_nucl_num, type_nucl_vector, rescale_factor_en, walk_num, elec_coord, & + nucl_coord, en_distance_rescaled_deriv_e) & result(info) use qmckl implicit none integer(qmckl_context), intent(in) :: context integer*8 , intent(in) :: elec_num - double precision , intent(in) :: rescale_factor_ee + integer*8 , intent(in) :: nucl_num + integer*8 , intent(in) :: type_nucl_num + integer*8 , intent(in) :: type_nucl_vector(nucl_num) + double precision , intent(in) :: rescale_factor_en(nucl_num) 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(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) - integer*8 :: k + integer*8 :: i, k + double precision :: coord(3) info = QMCKL_SUCCESS @@ -4721,40 +5318,60 @@ integer function qmckl_compute_ee_distance_rescaled_deriv_e_f(context, elec_num, return endif - if (walk_num <= 0) then + if (nucl_num <= 0) then info = QMCKL_INVALID_ARG_3 return endif - do k=1,walk_num - info = qmckl_distance_rescaled_deriv_e(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) - if (info /= QMCKL_SUCCESS) then - exit - endif + if (walk_num <= 0) then + info = QMCKL_INVALID_ARG_5 + return + endif + + 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, & + 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))) + if (info /= QMCKL_SUCCESS) then + return + endif + end do end do -end function qmckl_compute_ee_distance_rescaled_deriv_e_f - #+end_src +end function qmckl_compute_en_distance_rescaled_deriv_e_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 ( + #+begin_src c :tangle (eval h_private_func) :comments org :exports none +qmckl_exit_code qmckl_compute_en_distance_rescaled_deriv_e ( const qmckl_context context, const int64_t elec_num, - const double rescale_factor_ee, + const int64_t nucl_num, + const int64_t type_nucl_num, + int64_t* const type_nucl_vector, + const double* rescale_factor_en, const int64_t walk_num, - const double* coord, - double* const ee_distance_rescaled_deriv_e ); - #+end_src + const double* elec_coord, + const double* nucl_coord, + double* const en_distance_rescaled_deriv_e ); + #+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_en_distance_rescaled_deriv_e_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) & + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none + integer(c_int32_t) function qmckl_compute_en_distance_rescaled_deriv_e & + (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) & bind(C) result(info) use, intrinsic :: iso_c_binding @@ -4762,76 +5379,97 @@ qmckl_exit_code qmckl_compute_ee_distance_rescaled_deriv_e ( integer (c_int64_t) , intent(in) , value :: context integer (c_int64_t) , intent(in) , value :: elec_num - real (c_double ) , intent(in) , value :: rescale_factor_ee + integer (c_int64_t) , intent(in) , value :: nucl_num + integer (c_int64_t) , intent(in) , value :: type_nucl_num + integer (c_int64_t) , intent(in) :: type_nucl_vector(nucl_num) + real (c_double ) , intent(in) :: rescale_factor_en(nucl_num) integer (c_int64_t) , intent(in) , value :: walk_num - real (c_double ) , intent(in) :: 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(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) - 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_en_distance_rescaled_deriv_e_f + info = qmckl_compute_en_distance_rescaled_deriv_e_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) - end function qmckl_compute_ee_distance_rescaled_deriv_e - #+end_src + end function qmckl_compute_en_distance_rescaled_deriv_e + #+end_src -*** Test +**** Test - #+begin_src python :results output :exports none + #+begin_src python :results output :exports none import numpy as np # TODO - #+end_src - - #+begin_src c :tangle (eval c_test) -assert(qmckl_electron_provided(context)); - - -double ee_distance_rescaled_deriv_e[4 * walk_num * elec_num * elec_num]; -rc = qmckl_get_jastrow_ee_distance_rescaled_deriv_e(context, ee_distance_rescaled_deriv_e); - -// TODO: Get exact values -//// (e1,e2,w) -//// (0,0,0) == 0. -//assert(ee_distance[0] == 0.); -// -//// (1,0,0) == (0,1,0) -//assert(ee_distance[1] == ee_distance[elec_num]); -// -//// value of (1,0,0) -//assert(fabs(ee_distance[1]-7.152322512964209) < 1.e-12); -// -//// (0,0,1) == 0. -//assert(ee_distance[elec_num*elec_num] == 0.); -// -//// (1,0,1) == (0,1,1) -//assert(ee_distance[elec_num*elec_num+1] == ee_distance[elec_num*elec_num+elec_num]); -// -//// value of (1,0,1) -//assert(fabs(ee_distance[elec_num*elec_num+1]-6.5517646321055665) < 1.e-12); - #+end_src -** Electron-electron-nucleus rescaled distances for each order - ~een_rescaled_e~ stores the table of the rescaled distances between all - pairs of electrons and raised to the power \(p\) defined by ~cord_num~: + #+begin_src c :tangle (eval c_test) - \[ - C_{ij,p} = \left( 1 - \exp{-\kappa C_{ij}} \right)^p - \] +assert(qmckl_electron_provided(context)); - where \(C_{ij}\) is the matrix of electron-electron distances. +assert(qmckl_nucleus_provided(context)); -*** Get +double en_distance_rescaled_deriv_e[walk_num][4][nucl_num][elec_num]; - #+begin_src c :comments org :tangle (eval h_func) :noweb yes +rc = qmckl_check(context, + qmckl_get_electron_en_distance_rescaled_deriv_e(context, &(en_distance_rescaled_deriv_e[0][0][0][0])) + ); +assert (rc == QMCKL_SUCCESS); + +// TODO: check exact values +//// (e,n,w) in Fortran notation +//// (1,1,1) +//assert(fabs(en_distance_rescaled[0][0][0] - 7.546738741619978) < 1.e-12); +// +//// (1,2,1) +//assert(fabs(en_distance_rescaled[0][1][0] - 8.77102435246984) < 1.e-12); +// +//// (2,1,1) +//assert(fabs(en_distance_rescaled[0][0][1] - 3.698922010513608) < 1.e-12); +// +//// (1,1,2) +//assert(fabs(en_distance_rescaled[1][0][0] - 5.824059436060509) < 1.e-12); +// +//// (1,2,2) +//assert(fabs(en_distance_rescaled[1][1][0] - 7.080482110317645) < 1.e-12); +// +//// (2,1,2) +//assert(fabs(en_distance_rescaled[1][0][1] - 3.1804527583077356) < 1.e-12); + + #+end_src + +** Electron-electron-nucleus component +*** Electron-electron rescaled distances in $J_\text{eeN}$ + + ~een_rescaled_e~ stores the table of the rescaled distances between all + pairs of electrons and raised to the power \(p\) defined by ~cord_num~: + + \[ + C_{ij,p} = \left[ \exp\left(-\kappa_\text{e}\, r_{ij}\right) \right]^p + \] + + where \(r_{ij}\) is the matrix of electron-electron distances. + +**** Get + + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_een_rescaled_e(qmckl_context context, double* const distance_rescaled, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_een_rescaled_e(qmckl_context context, double* const distance_rescaled, @@ -4860,15 +5498,15 @@ qmckl_get_jastrow_een_rescaled_e(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: +**** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_een_rescaled_e(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_een_rescaled_e(qmckl_context context) { @@ -4931,27 +5569,27 @@ qmckl_exit_code qmckl_provide_een_rescaled_e(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_een_rescaled_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_een_rescaled_e + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_een_rescaled_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 | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | - | ~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]~ | out | Electron-electron rescaled distances | + #+NAME: qmckl_factor_een_rescaled_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 | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | + | ~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]~ | out | Electron-electron rescaled distances | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_een_rescaled_e_doc_f( & context, walk_num, elec_num, cord_num, rescale_factor_ee, & ee_distance, een_rescaled_e) & @@ -5011,7 +5649,7 @@ integer function qmckl_compute_een_rescaled_e_doc_f( & do l = 2, cord_num do k = 1, elec_num * (elec_num - 1)/2 - een_rescaled_e_ij(k, l + 1) = een_rescaled_e_ij(k, l + 1 - 1) * een_rescaled_e_ij(k, 2) + een_rescaled_e_ij(k, l + 1) = een_rescaled_e_ij(k, l) * een_rescaled_e_ij(k, 2) end do end do @@ -5039,11 +5677,11 @@ integer function qmckl_compute_een_rescaled_e_doc_f( & end do end function qmckl_compute_een_rescaled_e_doc_f - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_een_rescaled_e ( const qmckl_context context, const int64_t walk_num, @@ -5052,12 +5690,12 @@ end function qmckl_compute_een_rescaled_e_doc_f const double rescale_factor_ee, const double* ee_distance, double* const een_rescaled_e ); - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_rescaled_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_een_rescaled_e_doc") + #+CALL: generate_c_interface(table=qmckl_factor_een_rescaled_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_een_rescaled_e_doc") - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_een_rescaled_e_doc & (context, walk_num, elec_num, cord_num, rescale_factor_ee, & ee_distance, een_rescaled_e) & @@ -5079,9 +5717,9 @@ end function qmckl_compute_een_rescaled_e_doc_f (context, walk_num, elec_num, cord_num, rescale_factor_ee, ee_distance, een_rescaled_e) end function qmckl_compute_een_rescaled_e_doc - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_een_rescaled_e_hpc ( const qmckl_context context, const int64_t walk_num, @@ -5202,11 +5840,11 @@ qmckl_exit_code qmckl_compute_een_rescaled_e_hpc ( return QMCKL_SUCCESS; } - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_een_rescaled_e_doc") + # #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_e_args,rettyp=get_value("CRetType"),fname="qmckl_compute_een_rescaled_e_doc") - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_een_rescaled_e ( const qmckl_context context, const int64_t walk_num, @@ -5215,9 +5853,9 @@ qmckl_exit_code qmckl_compute_een_rescaled_e_hpc ( const double rescale_factor_ee, const double* ee_distance, double* const een_rescaled_e ); - #+end_src + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_een_rescaled_e_doc ( const qmckl_context context, const int64_t walk_num, @@ -5226,9 +5864,9 @@ qmckl_exit_code qmckl_compute_een_rescaled_e_hpc ( const double rescale_factor_ee, const double* ee_distance, double* const een_rescaled_e ); - #+end_src + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_een_rescaled_e_hpc ( const qmckl_context context, const int64_t walk_num, @@ -5237,9 +5875,9 @@ qmckl_exit_code qmckl_compute_een_rescaled_e_hpc ( const double rescale_factor_ee, const double* ee_distance, double* const een_rescaled_e ); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_een_rescaled_e ( const qmckl_context context, const int64_t walk_num, @@ -5255,12 +5893,11 @@ qmckl_exit_code qmckl_compute_een_rescaled_e_hpc ( return qmckl_compute_een_rescaled_e_doc(context, walk_num, elec_num, cord_num, rescale_factor_ee, ee_distance, een_rescaled_e); #endif } - #+end_src + #+end_src +**** Test -*** Test - - #+begin_src python :results output :exports none :noweb yes + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -5308,17 +5945,17 @@ print(" een_rescaled_e[0, 4, 1] = ",een_rescaled_e[0, 4, 1]) print(" een_rescaled_e[1, 3, 2] = ",een_rescaled_e[1, 3, 2]) print(" een_rescaled_e[1, 4, 2] = ",een_rescaled_e[1, 4, 2]) print(" een_rescaled_e[1, 5, 2] = ",een_rescaled_e[1, 5, 2]) - #+end_src + #+end_src - #+RESULTS: - : een_rescaled_e[0, 2, 1] = 0.08084493981483197 - : een_rescaled_e[0, 3, 1] = 0.1066745707571846 - : een_rescaled_e[0, 4, 1] = 0.017542731694647366 - : een_rescaled_e[1, 3, 2] = 0.02214680362033448 - : een_rescaled_e[1, 4, 2] = 0.0005700154999202759 - : een_rescaled_e[1, 5, 2] = 0.3424402276009091 + #+RESULTS: + : een_rescaled_e[0, 2, 1] = 0.08084493981483197 + : een_rescaled_e[0, 3, 1] = 0.1066745707571846 + : een_rescaled_e[0, 4, 1] = 0.017542731694647366 + : een_rescaled_e[1, 3, 2] = 0.02214680362033448 + : een_rescaled_e[1, 4, 2] = 0.0005700154999202759 + : een_rescaled_e[1, 5, 2] = 0.3424402276009091 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) assert(qmckl_electron_provided(context)); @@ -5332,28 +5969,29 @@ assert(fabs(een_rescaled_e[0][1][0][4]-0.01754273169464735) < 1.e-12); assert(fabs(een_rescaled_e[0][2][1][3]-0.02214680362033448) < 1.e-12); assert(fabs(een_rescaled_e[0][2][1][4]-0.0005700154999202759) < 1.e-12); assert(fabs(een_rescaled_e[0][2][1][5]-0.3424402276009091) < 1.e-12); - #+end_src + #+end_src -** Electron-electron-nucleus rescaled distances for each order and derivatives +*** Electron-electron rescaled distances derivatives in $J_\text{eeN}$ + + ~een_rescaled_e_deriv_e~ 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. - ~een_rescaled_e_deriv_e~ 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. + \[ \frac{\partial}{\partial x} \left[ {g_\text{e}(r)}\right]^p = + -\frac{x}{r} \kappa_\text{e}\, p\,\left[ {g_\text{e}(r)}\right]^p \] + \[ \Delta \left[ {g_\text{e}(r)}\right]^p = \frac{2}{r} \kappa_\text{e}\, p\,\left[ {g_\text{e}(r)}\right]^p \right] + \left(\frac{\partial}{\partial x}\left[ {g_\text{e}(r)}\right]^p \right)^2 + \left(\frac{\partial}{\partial y}\left[ {g_\text{e}(r)}\right]^p \right)^2 + \left(\frac{\partial}{\partial z}\left[ {g_\text{e}(r)}\right]^p \right)^2 \] - TODO: write formulae +**** Get - -*** Get - - #+begin_src c :comments org :tangle (eval h_func) :noweb yes + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_een_rescaled_e_deriv_e(qmckl_context context, double* const distance_rescaled, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_een_rescaled_e_deriv_e(qmckl_context context, double* const distance_rescaled, @@ -5382,15 +6020,15 @@ qmckl_get_jastrow_een_rescaled_e_deriv_e(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: +**** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+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); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+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) { @@ -5455,29 +6093,29 @@ qmckl_exit_code qmckl_provide_een_rescaled_e_deriv_e(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_factor_een_rescaled_e_deriv_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_factor_een_rescaled_e_deriv_e + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_een_rescaled_e_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 | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | - | ~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 | + #+NAME: qmckl_factor_een_rescaled_e_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 | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~rescale_factor_ee~ | ~double~ | in | Factor to rescale ee distances | + | ~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 | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_een_rescaled_e_deriv_e_f( & context, walk_num, elec_num, cord_num, rescale_factor_ee, & coord_ee, ee_distance, een_rescaled_e, een_rescaled_e_deriv_e) & @@ -5564,11 +6202,11 @@ integer function qmckl_compute_factor_een_rescaled_e_deriv_e_f( & end do end function qmckl_compute_factor_een_rescaled_e_deriv_e_f - #+end_src + #+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_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_een_rescaled_e_deriv_e ( const qmckl_context context, const int64_t walk_num, @@ -5579,13 +6217,13 @@ end function qmckl_compute_factor_een_rescaled_e_deriv_e_f const double* ee_distance, const double* een_rescaled_e, double* const een_rescaled_e_deriv_e ); - #+end_src + #+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_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_een_rescaled_e_deriv_e & (context, & walk_num, & @@ -5624,11 +6262,11 @@ end function qmckl_compute_factor_een_rescaled_e_deriv_e_f een_rescaled_e_deriv_e) end function qmckl_compute_factor_een_rescaled_e_deriv_e - #+end_src + #+end_src -*** Test -#+name: een_e_deriv_e - #+begin_src python :results output :exports none :noweb yes +**** Test + #+name: een_e_deriv_e + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -5697,17 +6335,17 @@ for l in range(0,cord_num+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]) - #+end_src + #+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_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 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) double een_rescaled_e_deriv_e[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_een_rescaled_e_deriv_e(context, @@ -5720,646 +6358,29 @@ assert(fabs(een_rescaled_e_deriv_e[0][1][0][0][4] + 0.00441398875758468 ) < 1. 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); - #+end_src + #+end_src -** Electron-nucleus rescaled distances +*** Electron-nucleus rescaled distances in $J_\text{eeN}$ - ~en_distance_rescaled~ stores the matrix of the rescaled distances between - electrons and nuclei. + ~een_rescaled_n~ stores the table of the rescaled distances between + electrons and nuclei raised to the power \(p\) defined by ~cord_num~: - \[ - C_{ij} = \left( 1 - \exp{-\kappa C_{ij}}\right)/\kappa - \] + \[ + C_{i\alpha,p} = \left[ \exp\left(-\kappa_\alpha\, R_{i\alpha}\right) \right]^p + \] - where \(C_{ij}\) is the matrix of electron-nucleus distances. + where \(R_{i\alpha}\) is the matrix of electron-nucleus distances. -*** Get +**** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes -qmckl_exit_code qmckl_get_electron_en_distance_rescaled(qmckl_context context, double* distance_rescaled); - #+end_src - - - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_get_electron_en_distance_rescaled(qmckl_context context, double* distance_rescaled) -{ - - if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { - return QMCKL_NULL_CONTEXT; - } - - qmckl_exit_code rc; - - rc = qmckl_provide_en_distance_rescaled(context); - if (rc != QMCKL_SUCCESS) return rc; - - qmckl_context_struct* const ctx = (qmckl_context_struct*) context; - assert (ctx != NULL); - - size_t sze = ctx->electron.num * ctx->nucleus.num * ctx->electron.walker.num; - memcpy(distance_rescaled, ctx->jastrow.en_distance_rescaled, sze * sizeof(double)); - - return QMCKL_SUCCESS; -} - #+end_src - -*** Provide :noexport: - - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none -qmckl_exit_code qmckl_provide_en_distance_rescaled(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(qmckl_context context) -{ - - if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { - return QMCKL_NULL_CONTEXT; - } - - qmckl_context_struct* const ctx = (qmckl_context_struct*) context; - assert (ctx != NULL); - - if (!(ctx->nucleus.provided)) { - return QMCKL_NOT_PROVIDED; - } - - /* Compute if necessary */ - if (ctx->electron.walker.point.date > ctx->jastrow.en_distance_rescaled_date) { - - if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow.en_distance_rescaled != NULL) { - qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.en_distance_rescaled); - if (rc != QMCKL_SUCCESS) { - return qmckl_failwith( context, rc, - "qmckl_provide_en_distance_rescaled", - "Unable to free ctx->jastrow.en_distance_rescaled"); - } - ctx->jastrow.en_distance_rescaled = NULL; - } - } - - /* Allocate array */ - if (ctx->jastrow.en_distance_rescaled == NULL) { - - qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero; - mem_info.size = ctx->electron.num * ctx->nucleus.num * - ctx->electron.walker.num * sizeof(double); - double* en_distance_rescaled = (double*) qmckl_malloc(context, mem_info); - - if (en_distance_rescaled == NULL) { - return qmckl_failwith( context, - QMCKL_ALLOCATION_FAILED, - "qmckl_provide_en_distance_rescaled", - NULL); - } - ctx->jastrow.en_distance_rescaled = en_distance_rescaled; - } - - qmckl_exit_code rc = - qmckl_compute_en_distance_rescaled(context, - ctx->electron.num, - ctx->nucleus.num, - ctx->jastrow.type_nucl_num, - ctx->jastrow.type_nucl_vector, - ctx->jastrow.rescale_factor_en, - ctx->electron.walker.num, - ctx->electron.walker.point.coord.data, - ctx->nucleus.coord.data, - ctx->jastrow.en_distance_rescaled); - if (rc != QMCKL_SUCCESS) { - return rc; - } - - ctx->jastrow.en_distance_rescaled_date = ctx->date; - } - - return QMCKL_SUCCESS; -} - #+end_src - -*** Compute - :PROPERTIES: - :Name: qmckl_compute_en_distance_rescaled - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: - - #+NAME: qmckl_en_distance_rescaled_args - | Variable | Type | In/Out | Description | - |------------------------+----------------------------------------+--------+-----------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~elec_num~ | ~int64_t~ | in | Number of electrons | - | ~nucl_num~ | ~int64_t~ | in | Number of nuclei | - | ~type_nucl_num~ | ~int64_t~ | in | Number of types of nuclei | - | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Number of types of nuclei | - | ~rescale_factor_en~ | ~double[type_nucl_num]~ | in | The factor for rescaled distances | - | ~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~ | ~double[walk_num][nucl_num][elec_num]~ | out | Electron-nucleus distances | - - #+begin_src f90 :comments org :tangle (eval f) :noweb yes -integer function qmckl_compute_en_distance_rescaled_f(context, elec_num, nucl_num, type_nucl_num, & - type_nucl_vector, rescale_factor_en, walk_num, elec_coord, & - nucl_coord, en_distance_rescaled) & - result(info) - use qmckl - implicit none - integer(qmckl_context), intent(in) :: context - integer*8 , intent(in) :: elec_num - integer*8 , intent(in) :: nucl_num - integer*8 , intent(in) :: type_nucl_num - integer*8 , intent(in) :: type_nucl_vector(nucl_num) - double precision , intent(in) :: rescale_factor_en(type_nucl_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(elec_num,nucl_num,walk_num) - - integer*8 :: i, k - double precision :: coord(3) - - info = QMCKL_SUCCESS - - if (context == QMCKL_NULL_CONTEXT) then - info = QMCKL_INVALID_CONTEXT - return - endif - - if (elec_num <= 0) then - info = QMCKL_INVALID_ARG_2 - return - endif - - if (nucl_num <= 0) then - info = QMCKL_INVALID_ARG_3 - return - endif - - if (walk_num <= 0) then - info = QMCKL_INVALID_ARG_5 - return - endif - - do i=1, nucl_num - coord(1:3) = nucl_coord(i,1:3) - do k=1,walk_num - info = qmckl_distance_rescaled(context, 'T', 'T', elec_num, 1_8, & - elec_coord(1,k,1), elec_num*walk_num, coord, 1_8, & - en_distance_rescaled(1,i,k), elec_num, rescale_factor_en(type_nucl_vector(i))) - if (info /= QMCKL_SUCCESS) then - return - endif - end do - end do - -end function qmckl_compute_en_distance_rescaled_f - #+end_src - - #+begin_src c :tangle (eval h_private_func) :comments org :exports none -qmckl_exit_code qmckl_compute_en_distance_rescaled ( - const qmckl_context context, - const int64_t elec_num, - const int64_t nucl_num, - const int64_t type_nucl_num, - int64_t* const type_nucl_vector, - const double* rescale_factor_en, - const int64_t walk_num, - const double* elec_coord, - const double* nucl_coord, - double* const en_distance_rescaled ); - #+end_src - - #+CALL: generate_c_interface(table=qmckl_en_distance_rescaled_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 & - (context, & - elec_num, & - nucl_num, & - type_nucl_num, & - type_nucl_vector, & - rescale_factor_en, & - walk_num, & - elec_coord, & - nucl_coord, & - en_distance_rescaled) & - bind(C) result(info) - - use, intrinsic :: iso_c_binding - implicit none - - integer (c_int64_t) , intent(in) , value :: context - integer (c_int64_t) , intent(in) , value :: elec_num - integer (c_int64_t) , intent(in) , value :: nucl_num - integer (c_int64_t) , intent(in) , value :: type_nucl_num - integer (c_int64_t) , intent(in) :: type_nucl_vector(nucl_num) - real (c_double ) , intent(in) :: rescale_factor_en(type_nucl_num) - integer (c_int64_t) , intent(in) , value :: walk_num - real (c_double ) , intent(in) :: elec_coord(elec_num,walk_num,3) - real (c_double ) , intent(in) :: nucl_coord(elec_num,3) - real (c_double ) , intent(out) :: en_distance_rescaled(elec_num,nucl_num,walk_num) - - integer(c_int32_t), external :: qmckl_compute_en_distance_rescaled_f - info = qmckl_compute_en_distance_rescaled_f & - (context, & - elec_num, & - nucl_num, & - type_nucl_num, & - type_nucl_vector, & - rescale_factor_en, & - walk_num, & - elec_coord, & - nucl_coord, & - en_distance_rescaled) - - end function qmckl_compute_en_distance_rescaled - #+end_src - -*** Test - - #+begin_src python :results output :exports none -import numpy as np - -kappa = 1.0 - -elec_1_w1 = np.array( [-0.250655104764153, 0.503070975550133 , -0.166554344502303]) -elec_2_w1 = np.array( [-0.587812193472177, -0.128751981129274 , 0.187773606533075]) -elec_5_w1 = np.array( [-0.127732483187947, -0.138975497694196 , -8.669850480215846E-002]) -elec_6_w1 = np.array( [-0.232271834949124, -1.059321673434182E-002 , -0.504862241464867]) -nucl_1 = np.array( [ 0., 0., 0. ]) -nucl_2 = np.array( [ 0., 0., 2.059801 ]) - -print ( "[0][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-nucl_1)) )/kappa ) -print ( "[1][0] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_1_w1-nucl_2)) )/kappa ) -print ( "[0][1] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_2_w1-nucl_1)) )/kappa ) -print ( "[0][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-nucl_1)) )/kappa ) -print ( "[1][5] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_5_w1-nucl_2)) )/kappa ) -print ( "[0][6] : ", (1.0 - np.exp(-kappa * np.linalg.norm(elec_6_w1-nucl_1)) )/kappa ) - - #+end_src - - #+RESULTS: - : [0][0] : 0.4435709484118112 - : [1][0] : 0.8993601506374442 - : [0][1] : 0.46760219699910477 - : [0][5] : 0.1875631834682101 - : [1][5] : 0.8840716589810682 - : [0][6] : 0.42640469987268914 - - #+begin_src c :tangle (eval c_test) - -assert(qmckl_electron_provided(context)); -assert(qmckl_nucleus_provided(context)); - -double en_distance_rescaled[walk_num][nucl_num][elec_num]; - -rc = qmckl_check(context, - qmckl_get_electron_en_distance_rescaled(context, &(en_distance_rescaled[0][0][0])) - ); -assert (rc == QMCKL_SUCCESS); - -// (e,n,w) in Fortran notation -// (1,1,1) -assert(fabs(en_distance_rescaled[0][0][0] - 0.4435709484118112) < 1.e-12); - -// (1,2,1) -assert(fabs(en_distance_rescaled[0][1][0] - 0.8993601506374442) < 1.e-12); - -// (2,1,1) -assert(fabs(en_distance_rescaled[0][0][1] - 0.46760219699910477) < 1.e-12); - -// (1,1,2) -assert(fabs(en_distance_rescaled[0][0][5] - 0.1875631834682101) < 1.e-12); - -// (1,2,2) -assert(fabs(en_distance_rescaled[0][1][5] - 0.8840716589810682) < 1.e-12); - -// (2,1,2) -assert(fabs(en_distance_rescaled[0][0][6] - 0.42640469987268914) < 1.e-12); - - #+end_src - -** Electron-electron-nucleus rescaled distance gradients and laplacian with respect to electron coords - - The rescaled distances which is given as $R = (1 - \exp{-\kappa r})/\kappa$ - needs to be perturbed with respect to the nuclear coordinates. - This data is stored in the ~en_distance_rescaled_deriv_e~ tensor. The - The first three elements of this three index tensor ~[4][nucl_num][elec_num]~ gives the - derivatives in the x, y, and z directions $dx, dy, dz$ and the last index - gives the Laplacian $\partial x^2 + \partial y^2 + \partial z^2$. - -*** 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); - #+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) -{ - - if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { - return QMCKL_NULL_CONTEXT; - } - - qmckl_exit_code rc; - - rc = qmckl_provide_en_distance_rescaled_deriv_e(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.en_distance_rescaled_deriv_e, sze * sizeof(double)); - - return QMCKL_SUCCESS; -} - #+end_src - -*** 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); - #+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) -{ - - if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { - return QMCKL_NULL_CONTEXT; - } - - qmckl_context_struct* const ctx = (qmckl_context_struct*) context; - assert (ctx != NULL); - - if (!(ctx->nucleus.provided)) { - return QMCKL_NOT_PROVIDED; - } - - /* Compute if necessary */ - if (ctx->electron.walker.point.date > ctx->jastrow.en_distance_rescaled_deriv_e_date) { - - if (ctx->electron.walker.num > ctx->electron.walker_old.num) { - if (ctx->jastrow.en_distance_rescaled_deriv_e != NULL) { - qmckl_exit_code rc = qmckl_free(context, ctx->jastrow.en_distance_rescaled_deriv_e); - if (rc != QMCKL_SUCCESS) { - return qmckl_failwith( context, rc, - "qmckl_provide_en_distance_rescaled_deriv_e", - "Unable to free ctx->jastrow.en_distance_rescaled_deriv_e"); - } - ctx->jastrow.en_distance_rescaled_deriv_e = NULL; - } - } - - /* Allocate array */ - if (ctx->jastrow.en_distance_rescaled_deriv_e == 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); - - if (en_distance_rescaled_deriv_e == NULL) { - return qmckl_failwith( context, - QMCKL_ALLOCATION_FAILED, - "qmckl_provide_en_distance_rescaled_deriv_e", - NULL); - } - ctx->jastrow.en_distance_rescaled_deriv_e = en_distance_rescaled_deriv_e; - } - - qmckl_exit_code rc = - qmckl_compute_en_distance_rescaled_deriv_e(context, - ctx->electron.num, - ctx->nucleus.num, - ctx->jastrow.type_nucl_num, - ctx->jastrow.type_nucl_vector, - ctx->jastrow.rescale_factor_en, - ctx->electron.walker.num, - ctx->electron.walker.point.coord.data, - ctx->nucleus.coord.data, - ctx->jastrow.en_distance_rescaled_deriv_e); - if (rc != QMCKL_SUCCESS) { - return rc; - } - - ctx->jastrow.en_distance_rescaled_deriv_e_date = ctx->date; - } - - return QMCKL_SUCCESS; -} - #+end_src - -*** Compute - :PROPERTIES: - :Name: qmckl_compute_en_distance_rescaled_deriv_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: - - #+NAME: qmckl_en_distance_rescaled_deriv_e_args - | Variable | Type | In/Out | Description | - |--------------------------------+-------------------------------------------+--------+---------------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~elec_num~ | ~int64_t~ | in | Number of electrons | - | ~nucl_num~ | ~int64_t~ | in | Number of nuclei | - | ~type_nucl_num~ | ~int64_t~ | in | Number of nucleus types | - | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Array of nucleus types | - | ~rescale_factor_en~ | ~double[nucl_num]~ | in | The factors for rescaled distances | - | ~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 | - - #+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, & - type_nucl_num, type_nucl_vector, rescale_factor_en, walk_num, elec_coord, & - nucl_coord, en_distance_rescaled_deriv_e) & - result(info) - use qmckl - implicit none - integer(qmckl_context), intent(in) :: context - integer*8 , intent(in) :: elec_num - integer*8 , intent(in) :: nucl_num - integer*8 , intent(in) :: type_nucl_num - integer*8 , intent(in) :: type_nucl_vector(nucl_num) - double precision , intent(in) :: rescale_factor_en(nucl_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) - - integer*8 :: i, k - double precision :: coord(3) - - info = QMCKL_SUCCESS - - if (context == QMCKL_NULL_CONTEXT) then - info = QMCKL_INVALID_CONTEXT - return - endif - - if (elec_num <= 0) then - info = QMCKL_INVALID_ARG_2 - return - endif - - if (nucl_num <= 0) then - info = QMCKL_INVALID_ARG_3 - return - endif - - if (walk_num <= 0) then - info = QMCKL_INVALID_ARG_5 - return - endif - - 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, & - 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))) - if (info /= QMCKL_SUCCESS) then - return - endif - end do - end do - -end function qmckl_compute_en_distance_rescaled_deriv_e_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 ( - const qmckl_context context, - const int64_t elec_num, - const int64_t nucl_num, - const int64_t type_nucl_num, - int64_t* const type_nucl_vector, - const double* rescale_factor_en, - const int64_t walk_num, - const double* elec_coord, - const double* nucl_coord, - double* const en_distance_rescaled_deriv_e ); - #+end_src - - #+CALL: generate_c_interface(table=qmckl_en_distance_rescaled_deriv_e_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 & - (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) & - bind(C) result(info) - - use, intrinsic :: iso_c_binding - implicit none - - integer (c_int64_t) , intent(in) , value :: context - integer (c_int64_t) , intent(in) , value :: elec_num - integer (c_int64_t) , intent(in) , value :: nucl_num - integer (c_int64_t) , intent(in) , value :: type_nucl_num - integer (c_int64_t) , intent(in) :: type_nucl_vector(nucl_num) - real (c_double ) , intent(in) :: rescale_factor_en(nucl_num) - integer (c_int64_t) , intent(in) , value :: walk_num - real (c_double ) , intent(in) :: elec_coord(elec_num,walk_num,3) - real (c_double ) , intent(in) :: nucl_coord(elec_num,3) - real (c_double ) , intent(out) :: en_distance_rescaled_deriv_e(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 & - (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) - - end function qmckl_compute_en_distance_rescaled_deriv_e - #+end_src - -*** Test - - #+begin_src python :results output :exports none -import numpy as np - -# TODO - #+end_src - - - #+begin_src c :tangle (eval c_test) - -assert(qmckl_electron_provided(context)); - -assert(qmckl_nucleus_provided(context)); - -double en_distance_rescaled_deriv_e[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])) - ); -assert (rc == QMCKL_SUCCESS); - -// TODO: check exact values -//// (e,n,w) in Fortran notation -//// (1,1,1) -//assert(fabs(en_distance_rescaled[0][0][0] - 7.546738741619978) < 1.e-12); -// -//// (1,2,1) -//assert(fabs(en_distance_rescaled[0][1][0] - 8.77102435246984) < 1.e-12); -// -//// (2,1,1) -//assert(fabs(en_distance_rescaled[0][0][1] - 3.698922010513608) < 1.e-12); -// -//// (1,1,2) -//assert(fabs(en_distance_rescaled[1][0][0] - 5.824059436060509) < 1.e-12); -// -//// (1,2,2) -//assert(fabs(en_distance_rescaled[1][1][0] - 7.080482110317645) < 1.e-12); -// -//// (2,1,2) -//assert(fabs(en_distance_rescaled[1][0][1] - 3.1804527583077356) < 1.e-12); - - #+end_src - -** Electron-electron-nucleus rescaled distances for each order - - ~een_rescaled_n~ stores the table of the rescaled distances between - electrons and nucleii raised to the power \(p\) defined by ~cord_num~: - - \[ - C_{ia,p} = \left( 1 - \exp{-\kappa C_{ia}} \right)^p - \] - - where \(C_{ia}\) is the matrix of electron-nucleus distances. - -*** Get - - #+begin_src c :comments org :tangle (eval h_func) :noweb yes + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_een_rescaled_n(qmckl_context context, double* const distance_rescaled, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_een_rescaled_n(qmckl_context context, double* const distance_rescaled, @@ -6388,15 +6409,15 @@ qmckl_get_jastrow_een_rescaled_n(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: +**** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_een_rescaled_n(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_een_rescaled_n(qmckl_context context) { @@ -6462,30 +6483,30 @@ qmckl_exit_code qmckl_provide_een_rescaled_n(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_een_rescaled_n - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_een_rescaled_n + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_een_rescaled_n_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 | - | ~nucl_num~ | ~int64_t~ | in | Number of atoms | - | ~type_nucl_num~ | ~int64_t~ | in | Number of atom types | - | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Types of atoms | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~rescale_factor_en~ | ~double[nucl_num]~ | in | Factor to rescale ee distances | - | ~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]~ | out | Electron-nucleus rescaled distances | + #+NAME: qmckl_factor_een_rescaled_n_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 | + | ~nucl_num~ | ~int64_t~ | in | Number of atoms | + | ~type_nucl_num~ | ~int64_t~ | in | Number of atom types | + | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Types of atoms | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~rescale_factor_en~ | ~double[nucl_num]~ | in | Factor to rescale ee distances | + | ~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]~ | out | Electron-nucleus rescaled distances | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_een_rescaled_n_f( & context, walk_num, elec_num, nucl_num, & type_nucl_num, type_nucl_vector, cord_num, rescale_factor_en, & @@ -6557,9 +6578,9 @@ integer function qmckl_compute_een_rescaled_n_f( & end do end function qmckl_compute_een_rescaled_n_f - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes /* qmckl_exit_code qmckl_compute_een_rescaled_n ( const qmckl_context context, @@ -6623,12 +6644,12 @@ qmckl_exit_code qmckl_compute_een_rescaled_n ( return QMCKL_SUCCESS; } */ - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_rescaled_n_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_factor_een_rescaled_n_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_een_rescaled_n & (context, & walk_num, & @@ -6670,11 +6691,11 @@ qmckl_exit_code qmckl_compute_een_rescaled_n ( een_rescaled_n) end function qmckl_compute_een_rescaled_n - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_n_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_een_rescaled_n_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_een_rescaled_n ( const qmckl_context context, const int64_t walk_num, @@ -6686,11 +6707,11 @@ qmckl_exit_code qmckl_compute_een_rescaled_n ( const double* rescale_factor_en, const double* en_distance, double* const een_rescaled_n ); - #+end_src + #+end_src -*** Test +**** Test - #+begin_src python :results output :exports none :noweb yes + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -6722,17 +6743,17 @@ print(" een_rescaled_n[0, 4, 1] = ",een_rescaled_n[0, 4, 1]) print(" een_rescaled_n[1, 3, 2] = ",een_rescaled_n[1, 3, 2]) print(" een_rescaled_n[1, 4, 2] = ",een_rescaled_n[1, 4, 2]) print(" een_rescaled_n[1, 5, 2] = ",een_rescaled_n[1, 5, 2]) - #+end_src + #+end_src - #+RESULTS: - : een_rescaled_n[0, 2, 1] = 0.10612983920006765 - : een_rescaled_n[0, 3, 1] = 0.135652809635553 - : een_rescaled_n[0, 4, 1] = 0.023391817607642338 - : een_rescaled_n[1, 3, 2] = 0.880957224822116 - : een_rescaled_n[1, 4, 2] = 0.027185942659395074 - : een_rescaled_n[1, 5, 2] = 0.01343938025140174 + #+RESULTS: + : een_rescaled_n[0, 2, 1] = 0.10612983920006765 + : een_rescaled_n[0, 3, 1] = 0.135652809635553 + : een_rescaled_n[0, 4, 1] = 0.023391817607642338 + : een_rescaled_n[1, 3, 2] = 0.880957224822116 + : een_rescaled_n[1, 4, 2] = 0.027185942659395074 + : een_rescaled_n[1, 5, 2] = 0.01343938025140174 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) assert(qmckl_electron_provided(context)); double een_rescaled_n[walk_num][(cord_num + 1)][nucl_num][elec_num]; @@ -6746,24 +6767,34 @@ assert(fabs(een_rescaled_n[0][1][0][4]-0.023391817607642338) < 1.e-12); assert(fabs(een_rescaled_n[0][2][1][3]-0.880957224822116) < 1.e-12); assert(fabs(een_rescaled_n[0][2][1][4]-0.027185942659395074) < 1.e-12); assert(fabs(een_rescaled_n[0][2][1][5]-0.01343938025140174) < 1.e-12); - #+end_src + #+end_src -** Electron-nucleus rescaled distances for each order and derivatives +*** Electron-nucleus rescaled distances derivatives in $J_\text{eeN}$ - ~een_rescaled_n_deriv_e~ stores the table of the rescaled distances between - electrons and nucleii raised to the power \(p\) defined by ~cord_num~: + ~een_rescaled_n_deriv_e~ 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. + \[ \frac{\partial}{\partial x} \left[ {g_\alpha(R_{i\alpha})}\right]^p = + -\frac{x}{R_{i\alpha}} \kappa_\alpha\, p\,\left[ {g_\alpha(R_{i\alpha})}\right]^p \] + \[ \Delta \left[ {g_\alpha(R_{i\alpha})}\right]^p = \frac{2}{R_{i\alpha}} + \kappa_\alpha\, p\,\left[ {g_\alpha(R_{i\alpha})}\right]^p \right] + + \left(\frac{\partial}{\partial x}\left[ {g_\alpha(R_{i\alpha})}\right]^p + \right)^2 + \left(\frac{\partial}{\partial y}\left[ + {g_\alpha(R_{i\alpha})}\right]^p \right)^2 + \left(\frac{\partial}{\partial + z}\left[ {g_\alpha(R_{i\alpha})}\right]^p \right)^2 \] -*** Get +**** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_een_rescaled_n_deriv_e(qmckl_context context, double* const distance_rescaled, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_een_rescaled_n_deriv_e(qmckl_context context, double* const distance_rescaled, @@ -6792,15 +6823,15 @@ qmckl_get_jastrow_een_rescaled_n_deriv_e(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: +**** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+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); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+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) { @@ -6873,33 +6904,33 @@ qmckl_exit_code qmckl_provide_een_rescaled_n_deriv_e(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_factor_een_rescaled_n_deriv_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_factor_een_rescaled_n_deriv_e + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_compute_factor_een_rescaled_n_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 | - | ~nucl_num~ | ~int64_t~ | in | Number of atoms | - | ~type_nucl_num~ | ~int64_t~ | in | Number of atom types | - | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Types of atoms | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~rescale_factor_en~ | ~double[nucl_num]~ | in | Factor to rescale ee distances | - | ~coord_ee~ | ~double[walk_num][3][elec_num]~ | in | Electron coordinates | - | ~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 | + #+NAME: qmckl_compute_factor_een_rescaled_n_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 | + | ~nucl_num~ | ~int64_t~ | in | Number of atoms | + | ~type_nucl_num~ | ~int64_t~ | in | Number of atom types | + | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | Types of atoms | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~rescale_factor_en~ | ~double[nucl_num]~ | in | Factor to rescale ee distances | + | ~coord_ee~ | ~double[walk_num][3][elec_num]~ | in | Electron coordinates | + | ~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 | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_een_rescaled_n_deriv_e_f( & context, walk_num, elec_num, nucl_num, type_nucl_num, type_nucl_vector, & cord_num, rescale_factor_en, & @@ -6996,11 +7027,11 @@ integer function qmckl_compute_factor_een_rescaled_n_deriv_e_f( & end do end function qmckl_compute_factor_een_rescaled_n_deriv_e_f - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_compute_factor_een_rescaled_n_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_compute_factor_een_rescaled_n_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_een_rescaled_n_deriv_e ( const qmckl_context context, const int64_t walk_num, @@ -7015,12 +7046,12 @@ end function qmckl_compute_factor_een_rescaled_n_deriv_e_f const double* en_distance, const double* een_rescaled_n, double* const een_rescaled_n_deriv_e ); - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_compute_factor_een_rescaled_n_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_compute_factor_een_rescaled_n_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_een_rescaled_n_deriv_e & (context, & walk_num, & @@ -7071,11 +7102,11 @@ end function qmckl_compute_factor_een_rescaled_n_deriv_e_f een_rescaled_n_deriv_e) end function qmckl_compute_factor_een_rescaled_n_deriv_e - #+end_src + #+end_src -*** Test +**** Test - #+begin_src python :results output :exports none :noweb yes + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -7130,17 +7161,17 @@ 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]) - #+end_src + #+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 + #+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 - #+begin_src c :tangle (eval c_test) + #+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]; @@ -7155,79 +7186,22 @@ assert(fabs(een_rescaled_n_deriv_e[0][2][1][0][3]-0.1362654644223866 ) < 1.e 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); - #+end_src + #+end_src -** Prepare for electron-electron-nucleus Jastrow \(f_{een}\) +*** Temporary arrays for electron-electron-nucleus Jastrow $f_{een}$ - 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~. + 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~. -*** Get +**** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes -qmckl_exit_code qmckl_get_jastrow_dim_c_vector(qmckl_context context, int64_t* const dim_c_vector); -qmckl_exit_code qmckl_get_jastrow_c_vector_full(qmckl_context context, double* const c_vector_full); -qmckl_exit_code qmckl_get_jastrow_lkpm_combined_index(qmckl_context context, int64_t* const lkpm_combined_index); + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_tmp_c(qmckl_context context, double* const tmp_c); qmckl_exit_code qmckl_get_jastrow_dtmp_c(qmckl_context context, double* const dtmp_c); - #+end_src - - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none -qmckl_exit_code qmckl_get_jastrow_dim_c_vector(qmckl_context context, int64_t* const dim_c_vector) -{ - if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { - return QMCKL_NULL_CONTEXT; - } - - qmckl_context_struct* const ctx = (qmckl_context_struct*) context; - assert (ctx != NULL); - - *dim_c_vector = ctx->jastrow.dim_c_vector; - - return QMCKL_SUCCESS; -} - -qmckl_exit_code qmckl_get_jastrow_c_vector_full(qmckl_context context, double* const c_vector_full) -{ - if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { - return QMCKL_NULL_CONTEXT; - } - - qmckl_exit_code rc; - - rc = qmckl_provide_jastrow_c_vector_full(context); - if (rc != QMCKL_SUCCESS) return rc; - - qmckl_context_struct* const ctx = (qmckl_context_struct*) context; - assert (ctx != NULL); - - size_t sze = ctx->jastrow.dim_c_vector * ctx->nucleus.num; - memcpy(c_vector_full, ctx->jastrow.c_vector_full, sze * sizeof(double)); - - return QMCKL_SUCCESS; -} - -qmckl_exit_code qmckl_get_jastrow_lkpm_combined_index(qmckl_context context, int64_t* const lkpm_combined_index) -{ - if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { - return QMCKL_NULL_CONTEXT; - } - - qmckl_exit_code rc; - - rc = qmckl_provide_jastrow_c_vector_full(context); - if (rc != QMCKL_SUCCESS) return rc; - - qmckl_context_struct* const ctx = (qmckl_context_struct*) context; - assert (ctx != NULL); - - size_t sze = ctx->jastrow.dim_c_vector * 4; - memcpy(lkpm_combined_index, ctx->jastrow.lkpm_combined_index, sze * sizeof(double)); - - return QMCKL_SUCCESS; -} + #+end_src + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_tmp_c(qmckl_context context, double* const tmp_c) { if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) { @@ -7275,18 +7249,18 @@ qmckl_exit_code qmckl_get_jastrow_dtmp_c(qmckl_context context, double* const dt return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: +**** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_c_vector_full(qmckl_context context); qmckl_exit_code qmckl_provide_lkpm_combined_index(qmckl_context context); qmckl_exit_code qmckl_provide_tmp_c(qmckl_context context); qmckl_exit_code qmckl_provide_dtmp_c(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_jastrow_c_vector_full(qmckl_context context) { @@ -7498,23 +7472,23 @@ qmckl_exit_code qmckl_provide_dtmp_c(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute dim_c_vector - :PROPERTIES: - :Name: qmckl_compute_dim_c_vector - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute dim_c_vector + :PROPERTIES: + :Name: qmckl_compute_dim_c_vector + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_dim_c_vector_args - | Variable | Type | In/Out | Description | - |-----------------+-----------------+--------+-----------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~dim_c_vector~ | ~int64_t~ | out | dimension of c_vector_full table | + #+NAME: qmckl_factor_dim_c_vector_args + | Variable | Type | In/Out | Description | + |-----------------+-----------------+--------+-----------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~dim_c_vector~ | ~int64_t~ | out | dimension of c_vector_full table | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_dim_c_vector_f( & context, cord_num, dim_c_vector) & result(info) @@ -7555,9 +7529,9 @@ integer function qmckl_compute_dim_c_vector_f( & end do end function qmckl_compute_dim_c_vector_f - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_dim_c_vector ( const qmckl_context context, const int64_t cord_num, @@ -7592,36 +7566,36 @@ qmckl_exit_code qmckl_compute_dim_c_vector ( return QMCKL_SUCCESS; } - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_dim_c_vector_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_dim_c_vector_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_dim_c_vector ( const qmckl_context context, const int64_t cord_num, int64_t* const dim_c_vector ); - #+end_src + #+end_src -*** Compute c_vector_full - :PROPERTIES: - :Name: qmckl_compute_c_vector_full - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute c_vector_full + :PROPERTIES: + :Name: qmckl_compute_c_vector_full + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_c_vector_full_args - | Variable | Type | In/Out | Description | - |--------------------+----------------------------------------+--------+------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~nucl_num~ | ~int64_t~ | in | Number of atoms | - | ~dim_c_vector~ | ~int64_t~ | in | dimension of cord full table | - | ~type_nucl_num~ | ~int64_t~ | in | dimension of cord full table | - | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | dimension of cord full table | - | ~c_vector~ | ~double[dim_c_vector][type_nucl_num]~ | in | dimension of cord full table | - | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | out | Full list of coefficients | + #+NAME: qmckl_factor_c_vector_full_args + | Variable | Type | In/Out | Description | + |--------------------+----------------------------------------+--------+------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~nucl_num~ | ~int64_t~ | in | Number of atoms | + | ~dim_c_vector~ | ~int64_t~ | in | dimension of cord full table | + | ~type_nucl_num~ | ~int64_t~ | in | dimension of cord full table | + | ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | dimension of cord full table | + | ~c_vector~ | ~double[dim_c_vector][type_nucl_num]~ | in | dimension of cord full table | + | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | out | Full list of coefficients | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_c_vector_full_doc_f( & context, nucl_num, dim_c_vector, type_nucl_num, & type_nucl_vector, c_vector, c_vector_full) & @@ -7666,12 +7640,12 @@ integer function qmckl_compute_c_vector_full_doc_f( & end do end function qmckl_compute_c_vector_full_doc_f - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_c_vector_full_args,rettyp=get_value("CRetType"),fname="qmckl_compute_c_vector_full_doc") + #+CALL: generate_c_interface(table=qmckl_factor_c_vector_full_args,rettyp=get_value("CRetType"),fname="qmckl_compute_c_vector_full_doc") - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_c_vector_full_doc & (context, nucl_num, dim_c_vector, type_nucl_num, type_nucl_vector, c_vector, c_vector_full) & bind(C) result(info) @@ -7692,9 +7666,9 @@ end function qmckl_compute_c_vector_full_doc_f (context, nucl_num, dim_c_vector, type_nucl_num, type_nucl_vector, c_vector, c_vector_full) end function qmckl_compute_c_vector_full_doc - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_c_vector_full_hpc ( const qmckl_context context, const int64_t nucl_num, @@ -7728,12 +7702,12 @@ qmckl_exit_code qmckl_compute_c_vector_full_hpc ( return QMCKL_SUCCESS; } - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_c_vector_full_args,rettyp=get_value("CRetType"),fname="qmckl_compute_c_vector_full_doc") + # #+CALL: generate_c_header(table=qmckl_factor_c_vector_full_args,rettyp=get_value("CRetType"),fname="qmckl_compute_c_vector_full_doc") - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_c_vector_full ( const qmckl_context context, const int64_t nucl_num, @@ -7742,9 +7716,9 @@ qmckl_exit_code qmckl_compute_c_vector_full_hpc ( const int64_t* type_nucl_vector, const double* c_vector, double* const c_vector_full ); - #+end_src + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_c_vector_full_doc ( const qmckl_context context, const int64_t nucl_num, @@ -7753,9 +7727,9 @@ qmckl_exit_code qmckl_compute_c_vector_full_hpc ( const int64_t* type_nucl_vector, const double* c_vector, double* const c_vector_full ); - #+end_src + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_c_vector_full_hpc ( const qmckl_context context, const int64_t nucl_num, @@ -7764,9 +7738,9 @@ qmckl_exit_code qmckl_compute_c_vector_full_hpc ( const int64_t* type_nucl_vector, const double* c_vector, double* const c_vector_full ); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_c_vector_full ( const qmckl_context context, const int64_t nucl_num, @@ -7782,25 +7756,24 @@ qmckl_exit_code qmckl_compute_c_vector_full ( return qmckl_compute_c_vector_full_doc(context, nucl_num, dim_c_vector, type_nucl_num, type_nucl_vector, c_vector, c_vector_full); #endif } - #+end_src + #+end_src +**** Compute lkpm_combined_index + :PROPERTIES: + :Name: qmckl_compute_lkpm_combined_index + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: -*** Compute lkpm_combined_index - :PROPERTIES: - :Name: qmckl_compute_lkpm_combined_index - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: + #+NAME: qmckl_factor_lkpm_combined_index_args + | Variable | Type | In/Out | Description | + |-----------------------+-----------------------------+--------+-------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~dim_c_vector~ | ~int64_t~ | in | dimension of cord full table | + | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | out | Full list of combined indices | - #+NAME: qmckl_factor_lkpm_combined_index_args - | Variable | Type | In/Out | Description | - |-----------------------+-----------------------------+--------+-------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~dim_c_vector~ | ~int64_t~ | in | dimension of cord full table | - | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | out | Full list of combined indices | - - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_lkpm_combined_index_f( & context, cord_num, dim_c_vector, lkpm_combined_index) & result(info) @@ -7852,9 +7825,9 @@ integer function qmckl_compute_lkpm_combined_index_f( & end do end function qmckl_compute_lkpm_combined_index_f - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_lkpm_combined_index ( const qmckl_context context, const int64_t cord_num, @@ -7899,39 +7872,38 @@ qmckl_exit_code qmckl_compute_lkpm_combined_index ( return QMCKL_SUCCESS; } - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_lkpm_combined_index_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_lkpm_combined_index_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_lkpm_combined_index ( const qmckl_context context, const int64_t cord_num, const int64_t dim_c_vector, int64_t* const lkpm_combined_index ); - #+end_src + #+end_src +**** Compute tmp_c + :PROPERTIES: + :Name: qmckl_compute_tmp_c + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: -*** Compute tmp_c - :PROPERTIES: - :Name: qmckl_compute_tmp_c - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: + #+NAME: qmckl_factor_tmp_c_args + | Variable | Type | In/Out | Description | + |------------------+------------------------------------------------------------------+--------+-----------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~elec_num~ | ~int64_t~ | in | Number of electrons | + | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | + | ~walk_num~ | ~int64_t~ | in | Number of walkers | + | ~een_rescaled_e~ | ~double[walk_num][0:cord_num][elec_num][elec_num]~ | in | Electron-electron rescaled factor | + | ~een_rescaled_n~ | ~double[walk_num][0:cord_num][nucl_num][elec_num]~ | in | Electron-nucleus rescaled factor | + | ~tmp_c~ | ~double[walk_num][0:cord_num-1][0:cord_num][nucl_num][elec_num]~ | out | vector of non-zero coefficients | - #+NAME: qmckl_factor_tmp_c_args - | Variable | Type | In/Out | Description | - |------------------+------------------------------------------------------------------+--------+-----------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~elec_num~ | ~int64_t~ | in | Number of electrons | - | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | - | ~walk_num~ | ~int64_t~ | in | Number of walkers | - | ~een_rescaled_e~ | ~double[walk_num][0:cord_num][elec_num][elec_num]~ | in | Electron-electron rescaled factor | - | ~een_rescaled_n~ | ~double[walk_num][0:cord_num][nucl_num][elec_num]~ | in | Electron-nucleus rescaled factor | - | ~tmp_c~ | ~double[walk_num][0:cord_num-1][0:cord_num][nucl_num][elec_num]~ | out | vector of non-zero coefficients | - - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_tmp_c (const qmckl_context context, const int64_t cord_num, const int64_t elec_num, @@ -7947,11 +7919,11 @@ qmckl_exit_code qmckl_compute_tmp_c (const qmckl_context context, return qmckl_compute_tmp_c_doc(context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e, een_rescaled_n, tmp_c); #endif } - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c") + # #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c") - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_tmp_c ( const qmckl_context context, const int64_t cord_num, @@ -7961,9 +7933,9 @@ qmckl_exit_code qmckl_compute_tmp_c (const qmckl_context context, const double* een_rescaled_e, const double* een_rescaled_n, double* const tmp_c ); - #+end_src + #+end_src - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_tmp_c_doc_f( & context, cord_num, elec_num, nucl_num, & walk_num, een_rescaled_e, een_rescaled_n, tmp_c) & @@ -8029,9 +8001,9 @@ integer function qmckl_compute_tmp_c_doc_f( & end do end function qmckl_compute_tmp_c_doc_f - #+end_src + #+end_src - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_tmp_c_doc ( const qmckl_context context, const int64_t cord_num, @@ -8041,12 +8013,12 @@ qmckl_exit_code qmckl_compute_tmp_c_doc ( const double* een_rescaled_e, const double* een_rescaled_n, double* const tmp_c ); - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_tmp_c_args,rettyp=get_value("FRetType"),fname="qmckl_compute_tmp_c_doc") + #+CALL: generate_c_interface(table=qmckl_factor_tmp_c_args,rettyp=get_value("FRetType"),fname="qmckl_compute_tmp_c_doc") -#+RESULTS: -#+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_tmp_c_doc & (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e, een_rescaled_n, tmp_c) & bind(C) result(info) @@ -8068,11 +8040,11 @@ integer(c_int32_t) function qmckl_compute_tmp_c_doc & (context, cord_num, elec_num, nucl_num, walk_num, een_rescaled_e, een_rescaled_n, tmp_c) end function qmckl_compute_tmp_c_doc -#+end_src + #+end_src -**** CPU :noexport: +***** CPU :noexport: - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_tmp_c_hpc ( const qmckl_context context, const int64_t cord_num, @@ -8136,14 +8108,14 @@ qmckl_exit_code qmckl_compute_tmp_c_hpc ( return info; } - #+end_src + #+end_src - #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c") + #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c") - #+RESULTS: - #+begin_src c :tangle (eval h_func) :comments org + #+RESULTS: + #+begin_src c :tangle (eval h_func) :comments org qmckl_exit_code qmckl_compute_tmp_c ( const qmckl_context context, const int64_t cord_num, @@ -8153,12 +8125,12 @@ qmckl_exit_code qmckl_compute_tmp_c ( const double* een_rescaled_e, const double* een_rescaled_n, double* const tmp_c ); - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c_doc") + # #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c_doc") - #+RESULTS: - #+begin_src c :tangle (eval h_private_func) :comments org + #+RESULTS: + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_tmp_c_doc ( const qmckl_context context, const int64_t cord_num, @@ -8168,13 +8140,13 @@ qmckl_exit_code qmckl_compute_tmp_c_doc ( const double* een_rescaled_e, const double* een_rescaled_n, double* const tmp_c ); - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c_hpc") + # #+CALL: generate_c_header(table=qmckl_factor_tmp_c_args,rettyp=get_value("CRetType"),fname="qmckl_compute_tmp_c_hpc") - #+RESULTS: + #+RESULTS: - #+begin_src c :tangle (eval h_private_func) :comments org + #+begin_src c :tangle (eval h_private_func) :comments org qmckl_exit_code qmckl_compute_tmp_c_hpc (const qmckl_context context, const int64_t cord_num, const int64_t elec_num, @@ -8183,29 +8155,29 @@ qmckl_exit_code qmckl_compute_tmp_c_hpc (const qmckl_context context, const double* een_rescaled_e, const double* een_rescaled_n, double* const tmp_c ); - #+end_src + #+end_src -*** Compute dtmp_c - :PROPERTIES: - :Name: qmckl_compute_dtmp_c - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute dtmp_c + :PROPERTIES: + :Name: qmckl_compute_dtmp_c + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_dtmp_c_args - | Variable | Type | In/Out | Description | - |--------------------------+------------------------------------------------------------------+--------+-----------------------------------------------| - | ~context~ | ~qmckl_context~ | in | Global state | - | ~cord_num~ | ~int64_t~ | in | Order of polynomials | - | ~elec_num~ | ~int64_t~ | in | Number of electrons | - | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | - | ~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_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 | + #+NAME: qmckl_factor_dtmp_c_args + | Variable | Type | In/Out | Description | + |--------------------------+------------------------------------------------------------------+--------+-----------------------------------------------| + | ~context~ | ~qmckl_context~ | in | Global state | + | ~cord_num~ | ~int64_t~ | in | Order of polynomials | + | ~elec_num~ | ~int64_t~ | in | Number of electrons | + | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | + | ~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_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 | - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_dtmp_c (const qmckl_context context, const int64_t cord_num, @@ -8215,9 +8187,9 @@ qmckl_compute_dtmp_c (const qmckl_context context, const double* een_rescaled_e_deriv_e, const double* een_rescaled_n, double* const dtmp_c ); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_dtmp_c (const qmckl_context context, const int64_t cord_num, @@ -8236,9 +8208,9 @@ qmckl_compute_dtmp_c (const qmckl_context context, een_rescaled_n, dtmp_c ); #endif } - #+end_src + #+end_src - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+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) & @@ -8304,12 +8276,12 @@ integer function qmckl_compute_dtmp_c_doc_f( & end do end function qmckl_compute_dtmp_c_doc_f - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_dtmp_c_args,rettyp=get_value("FRetType"),fname="qmckl_compute_dtmp_c_doc") + #+CALL: generate_c_interface(table=qmckl_factor_dtmp_c_args,rettyp=get_value("FRetType"),fname="qmckl_compute_dtmp_c_doc") -#+RESULTS: -#+begin_src f90 :tangle (eval f) :comments org :exports none + #+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) & bind(C) result(info) @@ -8331,9 +8303,9 @@ 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) end function qmckl_compute_dtmp_c_doc -#+end_src + #+end_src - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_dtmp_c_doc ( const qmckl_context context, const int64_t cord_num, @@ -8343,11 +8315,11 @@ qmckl_exit_code qmckl_compute_dtmp_c_doc ( const double* een_rescaled_e_deriv_e, const double* een_rescaled_n, double* const dtmp_c ); - #+end_src + #+end_src -**** CPU :noexport: +***** CPU :noexport: - #+begin_src c :comments org :tangle (eval c) :noweb yes + #+begin_src c :comments org :tangle (eval c) :noweb yes qmckl_exit_code qmckl_compute_dtmp_c_hpc (const qmckl_context context, const int64_t cord_num, @@ -8412,9 +8384,9 @@ qmckl_compute_dtmp_c_hpc (const qmckl_context context, return info; } - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_dtmp_c_hpc ( const qmckl_context context, const int64_t cord_num, @@ -8424,12 +8396,12 @@ qmckl_exit_code qmckl_compute_dtmp_c_hpc ( const double* een_rescaled_e_deriv_e, const double* een_rescaled_n, double* const dtmp_c ); - #+end_src + #+end_src -*** Test +**** Test - #+name: helper_funcs - #+begin_src python :results output :exports none :noweb yes + #+name: helper_funcs + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -8492,11 +8464,11 @@ for l in range(0,cord_num+1): een_rescaled_e[j,j,l] = 0.0 lkpm_of_cindex = np.array(lkpm_combined_index).T - #+end_src + #+end_src - #+RESULTS: helper_funcs + #+RESULTS: helper_funcs - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) assert(qmckl_electron_provided(context)); double tmp_c[walk_num][cord_num][cord_num+1][nucl_num][elec_num]; @@ -8510,24 +8482,24 @@ assert(fabs(tmp_c[0][0][1][0][0] - 2.7083473948352403) < 1e-12); printf("%e\n%e\n", dtmp_c[0][1][0][0][0][0],0.237440520852232); assert(fabs(dtmp_c[0][1][0][0][0][0] - 0.237440520852232) < 1e-12); - #+end_src + #+end_src + +*** Electron-electron-nucleus Jastrow $f_{een}$ -** Electron-electron-nucleus Jastrow \(f_{een}\) + Calculate the electron-electron-nuclear three-body jastrow component ~factor_een~ + using the above prepared tables. - Calculate the electron-electron-nuclear three-body jastrow component ~factor_een~ - using the above prepared tables. + TODO: write equations. - TODO: write equations. - -*** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes +**** Get + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_factor_een(qmckl_context context, double* const factor_een, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_factor_een(qmckl_context context, double* const factor_een, @@ -8556,11 +8528,11 @@ qmckl_get_jastrow_factor_een(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -**** Fortran interface +***** Fortran interface -#+begin_src f90 :tangle (eval fh_func) :comments org + #+begin_src f90 :tangle (eval fh_func) :comments org interface integer(qmckl_exit_code) function qmckl_get_jastrow_factor_een (context, & factor_een, size_max) bind(C) @@ -8572,14 +8544,14 @@ interface double precision, intent(out) :: factor_een(size_max) end function qmckl_get_jastrow_factor_een end interface -#+end_src + #+end_src -*** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +**** Provide :noexport: + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_factor_een(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_factor_een(qmckl_context context) { @@ -8663,31 +8635,31 @@ qmckl_exit_code qmckl_provide_factor_een(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute naive - :PROPERTIES: - :Name: qmckl_compute_factor_een_naive - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute naive + :PROPERTIES: + :Name: qmckl_compute_factor_een_naive + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_een_naive_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 | - | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | - | ~cord_num~ | ~int64_t~ | in | order of polynomials | - | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | - | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | - | ~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 | - | ~factor_een~ | ~double[walk_num]~ | out | Electron-nucleus jastrow | + #+NAME: qmckl_factor_een_naive_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 | + | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | + | ~cord_num~ | ~int64_t~ | in | order of polynomials | + | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | + | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | + | ~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 | + | ~factor_een~ | ~double[walk_num]~ | out | Electron-nucleus jastrow | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_een_naive_f( & context, walk_num, elec_num, nucl_num, cord_num,& dim_c_vector, c_vector_full, lkpm_combined_index, & @@ -8763,11 +8735,11 @@ integer function qmckl_compute_factor_een_naive_f( & end do end function qmckl_compute_factor_een_naive_f - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_een_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_een_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_een_naive ( const qmckl_context context, const int64_t walk_num, @@ -8780,12 +8752,12 @@ end function qmckl_compute_factor_een_naive_f const double* een_rescaled_e, const double* een_rescaled_n, double* const factor_een ); - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_factor_een_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_een_naive & (context, & walk_num, & @@ -8830,31 +8802,31 @@ end function qmckl_compute_factor_een_naive_f factor_een) end function qmckl_compute_factor_een_naive - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_factor_een - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_factor_een + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_een_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 | - | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | - | ~cord_num~ | ~int64_t~ | in | order of polynomials | - | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | - | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | - | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | in | combined indices | - | ~tmp_c~ | ~double[walk_num][0:cord_num-1][0:cord_num][nucl_num][elec_num]~ | vector of non-zero coefficients | | - | ~een_rescaled_n~ | ~double[walk_num][0:cord_num][nucl_num][elec_num]~ | in | Electron-nucleus rescaled factor | - | ~factor_een~ | ~double[walk_num]~ | out | Electron-nucleus jastrow | + #+NAME: qmckl_factor_een_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 | + | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | + | ~cord_num~ | ~int64_t~ | in | order of polynomials | + | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | + | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | + | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | in | combined indices | + | ~tmp_c~ | ~double[walk_num][0:cord_num-1][0:cord_num][nucl_num][elec_num]~ | vector of non-zero coefficients | | + | ~een_rescaled_n~ | ~double[walk_num][0:cord_num][nucl_num][elec_num]~ | in | Electron-nucleus rescaled factor | + | ~factor_een~ | ~double[walk_num]~ | out | Electron-nucleus jastrow | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_een_f( & context, walk_num, elec_num, nucl_num, cord_num, & dim_c_vector, c_vector_full, lkpm_combined_index, & @@ -8923,11 +8895,11 @@ integer function qmckl_compute_factor_een_f( & end do end function qmckl_compute_factor_een_f - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_een_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_een_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_een ( const qmckl_context context, const int64_t walk_num, @@ -8940,12 +8912,12 @@ end function qmckl_compute_factor_een_f const double* een_rescaled_e, const double* een_rescaled_n, double* const factor_een ); - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_factor_een_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_een & (context, & walk_num, & @@ -8990,10 +8962,10 @@ end function qmckl_compute_factor_een_f factor_een) end function qmckl_compute_factor_een - #+end_src + #+end_src -*** Test - #+begin_src python :results output :exports none :noweb yes +**** Test + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -9022,13 +8994,13 @@ for n in range(0, dim_c_vector): factor_een = factor_een + accu2 * cn print("factor_een:",factor_een) - #+end_src + #+end_src - #+RESULTS: - : factor_een: -0.37407972141304213 + #+RESULTS: + : factor_een: -0.37407972141304213 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_provided(context)); @@ -9036,24 +9008,24 @@ double factor_een[walk_num]; rc = qmckl_get_jastrow_factor_een(context, &(factor_een[0]),walk_num); assert(fabs(factor_een[0] + 0.37407972141304213) < 1e-12); - #+end_src + #+end_src -** Electron-electron-nucleus Jastrow \(f_{een}\) derivative +*** Electron-electron-nucleus Jastrow $f_{een}$ derivative - Calculate the electron-electron-nuclear three-body jastrow component ~factor_een_deriv_e~ - using the above prepared tables. + Calculate the electron-electron-nuclear three-body jastrow component ~factor_een_deriv_e~ + using the above prepared tables. - TODO: write equations. + TODO: write equations. -*** Get - #+begin_src c :comments org :tangle (eval h_func) :noweb yes +**** Get + #+begin_src c :comments org :tangle (eval h_func) :noweb yes qmckl_exit_code qmckl_get_jastrow_factor_een_deriv_e(qmckl_context context, double* const factor_een_deriv_e, const int64_t size_max); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_get_jastrow_factor_een_deriv_e(qmckl_context context, double* const factor_een_deriv_e, @@ -9082,14 +9054,14 @@ qmckl_get_jastrow_factor_een_deriv_e(qmckl_context context, return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Provide :noexport: - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none +**** Provide :noexport: + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_provide_factor_een_deriv_e(qmckl_context context); - #+end_src + #+end_src - #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none qmckl_exit_code qmckl_provide_factor_een_deriv_e(qmckl_context context) { @@ -9187,33 +9159,33 @@ qmckl_exit_code qmckl_provide_factor_een_deriv_e(qmckl_context context) return QMCKL_SUCCESS; } - #+end_src + #+end_src -*** Compute Naive - :PROPERTIES: - :Name: qmckl_compute_factor_een_deriv_e_naive - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute Naive + :PROPERTIES: + :Name: qmckl_compute_factor_een_deriv_e_naive + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_een_deriv_e_naive_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 | - | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | - | ~cord_num~ | ~int64_t~ | in | order of polynomials | - | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | - | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | - | ~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 | + #+NAME: qmckl_factor_een_deriv_e_naive_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 | + | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | + | ~cord_num~ | ~int64_t~ | in | order of polynomials | + | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | + | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | + | ~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 | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_een_deriv_e_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, & @@ -9308,11 +9280,11 @@ integer function qmckl_compute_factor_een_deriv_e_naive_f( & end do end function qmckl_compute_factor_een_deriv_e_naive_f - #+end_src + #+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_deriv_e_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_een_deriv_e_naive ( const qmckl_context context, const int64_t walk_num, @@ -9327,13 +9299,13 @@ end function qmckl_compute_factor_een_deriv_e_naive_f const double* een_rescaled_e_deriv_e, const double* een_rescaled_n_deriv_e, double* const factor_een_deriv_e ); - #+end_src + #+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_deriv_e_naive_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_een_deriv_e_naive & (context, & walk_num, & @@ -9384,34 +9356,34 @@ end function qmckl_compute_factor_een_deriv_e_naive_f factor_een_deriv_e) end function qmckl_compute_factor_een_deriv_e_naive - #+end_src + #+end_src -*** Compute - :PROPERTIES: - :Name: qmckl_compute_factor_een_deriv_e - :CRetType: qmckl_exit_code - :FRetType: qmckl_exit_code - :END: +**** Compute + :PROPERTIES: + :Name: qmckl_compute_factor_een_deriv_e + :CRetType: qmckl_exit_code + :FRetType: qmckl_exit_code + :END: - #+NAME: qmckl_factor_een_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 | - | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | - | ~cord_num~ | ~int64_t~ | in | order of polynomials | - | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | - | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | - | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | in | combined indices | - | ~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 | + #+NAME: qmckl_factor_een_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 | + | ~nucl_num~ | ~int64_t~ | in | Number of nucleii | + | ~cord_num~ | ~int64_t~ | in | order of polynomials | + | ~dim_c_vector~ | ~int64_t~ | in | dimension of full coefficient vector | + | ~c_vector_full~ | ~double[dim_c_vector][nucl_num]~ | in | full coefficient vector | + | ~lkpm_combined_index~ | ~int64_t[4][dim_c_vector]~ | in | combined indices | + | ~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 | - #+begin_src f90 :comments org :tangle (eval f) :noweb yes + #+begin_src f90 :comments org :tangle (eval f) :noweb yes integer function qmckl_compute_factor_een_deriv_e_f( & context, walk_num, elec_num, nucl_num, & cord_num, dim_c_vector, c_vector_full, lkpm_combined_index, & @@ -9499,11 +9471,11 @@ integer function qmckl_compute_factor_een_deriv_e_f( & end do end function qmckl_compute_factor_een_deriv_e_f - #+end_src + #+end_src -# #+CALL: generate_c_header(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + # #+CALL: generate_c_header(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none + #+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none qmckl_exit_code qmckl_compute_factor_een_deriv_e ( const qmckl_context context, const int64_t walk_num, @@ -9518,13 +9490,13 @@ end function qmckl_compute_factor_een_deriv_e_f const double* een_rescaled_n, const double* een_rescaled_n_deriv_e, double* const factor_een_deriv_e ); - #+end_src + #+end_src - #+CALL: generate_c_interface(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) + #+CALL: generate_c_interface(table=qmckl_factor_een_deriv_e_args,rettyp=get_value("CRetType"),fname=get_value("Name")) - #+RESULTS: - #+begin_src f90 :tangle (eval f) :comments org :exports none + #+RESULTS: + #+begin_src f90 :tangle (eval f) :comments org :exports none integer(c_int32_t) function qmckl_compute_factor_een_deriv_e & (context, & walk_num, & @@ -9575,10 +9547,10 @@ end function qmckl_compute_factor_een_deriv_e_f factor_een_deriv_e) end function qmckl_compute_factor_een_deriv_e - #+end_src + #+end_src -*** Test - #+begin_src python :results output :exports none :noweb yes +**** Test + #+begin_src python :results output :exports none :noweb yes import numpy as np <> @@ -9622,14 +9594,14 @@ for n in range(0, dim_c_vector): print("factor_een:",factor_een) - #+end_src + #+end_src - #+RESULTS: - : (6, 10, 4, 10) - : factor_een: 0.0 + #+RESULTS: + : (6, 10, 4, 10) + : factor_een: 0.0 - #+begin_src c :tangle (eval c_test) + #+begin_src c :tangle (eval c_test) /* Check if Jastrow is properly initialized */ assert(qmckl_jastrow_provided(context)); @@ -9637,11 +9609,10 @@ double factor_een_deriv_e[4][walk_num][elec_num]; rc = qmckl_get_jastrow_factor_een_deriv_e(context, &(factor_een_deriv_e[0][0][0]),4*walk_num*elec_num); assert(fabs(factor_een_deriv_e[0][0][0] + 0.0005481671107226865) < 1e-12); - #+end_src - + #+end_src ** TODO Jastrow VGL functions - + * End of files :noexport: #+begin_src c :tangle (eval h_private_type)