TREX/qmckl
1
0
Fork 0
mirror of https://github.com/TREX-CoE/qmckl.git synced 2025-04-30 04:15:00 +02:00
Code Issues Projects Releases Wiki Activity

Fixing single-e for multiple walkers

Browse Source
This commit is contained in:
Anthony Scemama 2024-12-14 22:28:09 +01:00
parent e465c2c554
commit 0f041bd42b
2 changed files with 279 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
org/qmckl_electron.org
View File

@ -1153,24 +1153,31 @@ qmckl_check(context, rc);
*** Get
#+begin_src c :comments org :tangle (eval h_func) :noweb yes
qmckl_exit_code qmckl_get_electron_en_distance(qmckl_context context, double* distance);
qmckl_exit_code
qmckl_get_electron_en_distance(qmckl_context context,
double* const distance,
const int64_t size_max);
#+end_src
#+begin_src f90 :tangle (eval fh_func) :comments org :exports none
interface
integer(c_int32_t) function qmckl_get_electron_en_distance(context, distance) &
integer(c_int32_t) function qmckl_get_electron_en_distance(context, distance, size_max) &
bind(C)
use, intrinsic :: iso_c_binding
import
implicit none
integer (c_int64_t) , intent(in) , value :: context
real (c_double ) , intent(out) :: distance(*)
integer (c_int64_t) , intent(in) :: size_max
end function
end interface
#+end_src
#+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
qmckl_exit_code qmckl_get_electron_en_distance(qmckl_context context, double* distance)
qmckl_exit_code
qmckl_get_electron_en_distance(qmckl_context context,
double* const distance,
const int64_t size_max)
{
if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
@ -1185,7 +1192,20 @@ qmckl_exit_code qmckl_get_electron_en_distance(qmckl_context context, double* di
qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
assert (ctx != NULL);
if (distance == NULL) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_2,
"qmckl_get_electron_en_distance",
"distance is a null pointer");
}
size_t sze = ctx->point.num * ctx->nucleus.num;
if (size_max < sze) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_3,
"qmckl_get_electron_en_distance",
"size_max < num*nucl_num");
}
memcpy(distance, ctx->electron.en_distance, sze * sizeof(double));
return QMCKL_SUCCESS;
@ -1405,7 +1425,7 @@ assert(qmckl_nucleus_provided(context));
double en_distance[walk_num][elec_num][nucl_num];
rc = qmckl_get_electron_en_distance(context, &(en_distance[0][0][0]));
rc = qmckl_get_electron_en_distance(context, &(en_distance[0][0][0]), walk_num * elec_num * nucl_num);
qmckl_check(context, rc);
// (e,n,w) in Fortran notation

396
org/qmckl_jastrow_champ_single.org
View File

@ -6,7 +6,7 @@
* Introduction
Single-electron move version of the Jastrow factor functions.
* Headers :noexport:
#+begin_src elisp :noexport :results none
(org-babel-lob-ingest "../tools/lib.org")
@ -41,7 +41,7 @@ int main() {
qmckl_context context;
context = qmckl_context_create();
#+end_src
#+begin_src c :tangle (eval c)
#ifdef HAVE_CONFIG_H
#include "config.h"
@ -323,7 +323,7 @@ double coords[walk_num][elec_num][3];
The dimension of ~coord~ is
- [walk_num][3] if ~transp~ is ~'N'~
- [3][walk_num] if ~transp~ is ~'T'~
#+begin_src c :comments org :tangle (eval h_func)
qmckl_exit_code qmckl_set_single_point (qmckl_context context,
const char transp,
@ -334,7 +334,7 @@ qmckl_exit_code qmckl_set_single_point (qmckl_context context,
The Fortran function shifts the ~num~ by 1 because of 1-based
indexing.
#+begin_src c :comments org :tangle (eval h_private_func)
qmckl_exit_code qmckl_set_single_point_f (qmckl_context context,
const char transp,
@ -343,7 +343,7 @@ qmckl_exit_code qmckl_set_single_point_f (qmckl_context context,
const int64_t size_max);
#+end_src
#+begin_src c :comments org :tangle (eval c) :noweb yes
qmckl_exit_code
@ -461,25 +461,31 @@ end interface
** Get
#+begin_src c :comments org :tangle (eval h_func) :noweb yes
qmckl_exit_code qmckl_get_single_electron_ee_distance(qmckl_context context, double* const distance);
qmckl_exit_code qmckl_get_single_electron_ee_distance(qmckl_context context,
double* const distance,
const int64_t size_max);
#+end_src
#+begin_src f90 :tangle (eval fh_func) :comments org :exports none
interface
integer(qmckl_exit_code) function qmckl_get_single_electron_ee_distance(context, distance) &
integer(qmckl_exit_code) function qmckl_get_single_electron_ee_distance(context, distance, size_max) &
bind(C)
use, intrinsic :: iso_c_binding
import
implicit none
integer (c_int64_t) , intent(in) , value :: context
real (c_double ) , intent(out) :: distance(*)
integer (c_int64_t) , intent(in) , value :: size_max
end function
end interface
#+end_src
#+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
qmckl_exit_code qmckl_get_single_electron_ee_distance(qmckl_context context, double* const distance)
qmckl_exit_code
qmckl_get_single_electron_ee_distance(qmckl_context context,
double* const distance,
const int64_t size_max)
{
if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
return QMCKL_NULL_CONTEXT;
@ -493,7 +499,20 @@ qmckl_exit_code qmckl_get_single_electron_ee_distance(qmckl_context context, dou
qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
assert (ctx != NULL);
if (distance == NULL) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_2,
"qmckl_get_single_electron_ee_distance",
"distance is a NULL pointer");
}
size_t sze = ctx->electron.num * ctx->electron.walker.num;
if (size_max < sze) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_3,
"qmckl_get_single_electron_ee_distance",
"Array too small. Expected ctx->electron.num * ctx->electron.walker.num");
}
memcpy(distance, ctx->single_point.single_ee_distance, sze * sizeof(double));
return QMCKL_SUCCESS;
@ -654,29 +673,31 @@ qmckl_exit_code qmckl_compute_single_ee_distance (
assert(qmckl_jastrow_champ_provided(context));
rc = qmckl_check(context,
rc = qmckl_check(context,
qmckl_set_electron_coord(context, 'N', walk_num, elec_coord, walk_num*elec_num*3)
);
assert(rc == QMCKL_SUCCESS);
double ee_distance[walk_num][elec_num][elec_num];
rc = qmckl_check(context,
rc = qmckl_check(context,
qmckl_get_electron_ee_distance(context, &ee_distance[0][0][0], walk_num*elec_num*elec_num)
);
rc = qmckl_check(context,
rc = qmckl_check(context,
qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3)
);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_check(context,
qmckl_set_single_point(context, 'N', 2, new_coords, 3)
rc = qmckl_check(context,
qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num)
);
assert (rc == QMCKL_SUCCESS);
double single_ee_distance[walk_num][elec_num];
rc = qmckl_check(context,
qmckl_get_single_electron_ee_distance(context, &single_ee_distance[0][0])
rc = qmckl_check(context,
qmckl_get_single_electron_ee_distance(context,
&single_ee_distance[0][0],
walk_num*elec_num)
);
assert (rc == QMCKL_SUCCESS);
@ -684,12 +705,12 @@ coords[0][2][0] = new_coords[0];
coords[0][2][1] = new_coords[1];
coords[0][2][2] = new_coords[2];
rc = qmckl_check(context,
rc = qmckl_check(context,
qmckl_set_electron_coord(context, 'N', walk_num, &coords[0][0][0], walk_num*elec_num*3)
);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_check(context,
rc = qmckl_check(context,
qmckl_get_electron_ee_distance(context, &ee_distance[0][0][0], walk_num*elec_num*elec_num)
);
assert (rc == QMCKL_SUCCESS);
@ -990,7 +1011,7 @@ rc = qmckl_get_jastrow_champ_een_rescaled_e(context, &rescaled_een_ee_distance[
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double single_rescaled_een_ee_distance[walk_num][cord_num+1][elec_num];
@ -1024,26 +1045,33 @@ for (int nw = 0; nw < walk_num; nw++){
Electron-nucleus distance between the single electron and all
nuclei for all walkers.
Dimension is ~[walk_num][nucl_num]~.
#+begin_src c :comments org :tangle (eval h_func) :noweb yes
qmckl_exit_code qmckl_get_single_electron_en_distance(qmckl_context context, double* distance);
qmckl_exit_code
qmckl_get_single_electron_en_distance(qmckl_context context,
double* distance,
const int64_t size_max);
#+end_src
#+begin_src f90 :tangle (eval fh_func) :comments org :exports none
interface
integer(qmckl_exit_code) function qmckl_get_single_electron_en_distance(context, distance) &
integer(qmckl_exit_code) function qmckl_get_single_electron_en_distance(context, distance, size_max) &
bind(C)
use, intrinsic :: iso_c_binding
import
implicit none
integer (c_int64_t) , intent(in) , value :: context
real (c_double ) , intent(out) :: distance(*)
integer (c_int64_t) , intent(in) , value :: size_max
end function
end interface
#+end_src
#+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
qmckl_exit_code qmckl_get_single_electron_en_distance(qmckl_context context, double* distance)
qmckl_exit_code
qmckl_get_single_electron_en_distance(qmckl_context context,
double* distance,
const int64_t size_max)
{
if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
@ -1058,7 +1086,20 @@ qmckl_exit_code qmckl_get_single_electron_en_distance(qmckl_context context, dou
qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
assert (ctx != NULL);
if (distance == NULL) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_2,
"qmckl_get_single_electron_en_distance",
"distance is a NULL pointer");
}
size_t sze = ctx->nucleus.num * ctx->electron.walker.num;
if (size_max < sze) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_3,
"qmckl_get_single_electron_en_distance",
"Array too small. Expected ctx->nucleus.num * ctx->electron.walker.num");
}
memcpy(distance, ctx->single_point.single_en_distance, sze * sizeof(double));
return QMCKL_SUCCESS;
@ -1214,17 +1255,20 @@ assert(qmckl_jastrow_champ_provided(context));
rc = qmckl_set_electron_coord(context, 'N', walk_num, elec_coord, walk_num*elec_num*3);
assert(rc == QMCKL_SUCCESS);
double en_distance[elec_num][nucl_num];
rc = qmckl_get_electron_en_distance(context, &en_distance[0][0]);
double en_distance[walk_num][elec_num][nucl_num];
rc = qmckl_get_electron_en_distance(context,
&en_distance[0][0][0],
walk_num*elec_num*nucl_num);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double single_en_distance[nucl_num];
rc = qmckl_get_single_electron_en_distance(context, &single_en_distance[0]);
double single_en_distance[walk_num][nucl_num];
rc = qmckl_get_single_electron_en_distance(context,
&(single_en_distance[0][0]), nucl_num);
assert (rc == QMCKL_SUCCESS);
coords[0][2][0] = new_coords[0];
@ -1234,11 +1278,15 @@ coords[0][2][2] = new_coords[2];
rc = qmckl_set_electron_coord(context, 'N', walk_num, &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_en_distance(context, &en_distance[0][0]);
rc = qmckl_get_electron_en_distance(context,
&en_distance[0][0][0], walk_num*elec_num*nucl_num);
assert (rc == QMCKL_SUCCESS);
for (int a = 0; a < nucl_num; a++){
assert(fabs((en_distance[2][a]-single_en_distance[a])) < 1.e-12);
for (int nw = 0 ; nw < walk_num ; nw++) {
for (int a = 0; a < nucl_num; a++){
assert(fabs((en_distance[nw][2][a]-single_en_distance[nw][a])) < 1.e-12);
}
}
#+end_src
@ -1492,7 +1540,7 @@ rc = qmckl_get_jastrow_champ_een_rescaled_n(context, &rescaled_een_en_distance[
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double single_rescaled_een_en_distance[walk_num][cord_num+1][nucl_num];
@ -1683,7 +1731,7 @@ integer function qmckl_compute_jastrow_champ_delta_p_doc( &
double precision :: dn, dn2
integer*8 :: LDA, LDB, LDC
num = num_in + 1
num = num_in + 1
info = QMCKL_SUCCESS
@ -1698,7 +1746,7 @@ integer function qmckl_compute_jastrow_champ_delta_p_doc( &
do nw=1, walk_num
do i=0, cord_num-1
do i=0, cord_num-1
een_rescaled_delta_e(:) = een_rescaled_single_e(:,i,nw) - een_rescaled_e(:,num,i,nw)
@ -1775,7 +1823,7 @@ qmckl_compute_jastrow_champ_delta_p (const qmckl_context context,
#else
return qmckl_compute_jastrow_champ_delta_p_doc
#endif
(context, num, walk_num, elec_num, nucl_num, cord_num,
(context, num, walk_num, elec_num, nucl_num, cord_num,
een_rescaled_n, een_rescaled_e, een_rescaled_single_n, een_rescaled_single_e, delta_p );
}
@ -1801,7 +1849,7 @@ rc = qmckl_get_jastrow_champ_tmp_c(context,
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_p[walk_num][cord_num][cord_num+1][nucl_num][elec_num];
@ -2065,7 +2113,7 @@ integer function qmckl_compute_jastrow_champ_factor_single_een_doc( &
accu = 0.0d0
do j = 1, elec_num
accu = accu + een_rescaled_n(j,a,m,nw) * delta_p(j,a,m+l,k,nw)
accu = accu + een_rescaled_n(j,a,m,nw) * delta_p(j,a,m+l,k,nw)
end do
accu = accu + een_rescaled_delta_n(a,m) * (tmp_c(num,a,m+l,k,nw) + delta_p(num,a,m+l,k,nw))
delta_een(nw) = delta_een(nw) + accu * cn
@ -2168,7 +2216,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_een[walk_num];
@ -2431,7 +2479,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double single_ee_rescaled[walk_num][elec_num];
@ -2595,7 +2643,7 @@ qmckl_exit_code qmckl_provide_en_rescaled_single(qmckl_context context)
| ~single_en_distance~ | ~double[walk_num][nucl_num]~ | in | Electron coordinates |
| ~en_rescaled_single~ | ~double[walk_num][nucl_num]~ | out | Electron-electron rescaled distances |
#+begin_src f90 :comments org :tangle (eval f) :noweb yes
function qmckl_compute_en_rescaled_single_doc(context, &
nucl_num, type_nucl_num, type_nucl_vector, rescale_factor_en, &
@ -2707,7 +2755,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double single_en_rescaled[walk_num][nucl_num];
@ -3064,7 +3112,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_ee[walk_num];
@ -3327,7 +3375,7 @@ function qmckl_compute_jastrow_champ_single_en_doc( &
x = en_distance_rescaled(num, a, nw)
y = en_rescaled_single(a, nw)
delta_en(nw) = delta_en(nw) - a_vector(1, type_nucl_vector(a)+1) * x / (1.0d0 + a_vector(2, type_nucl_vector(a)+1) * x)
delta_en(nw) = delta_en(nw) - a_vector(1, type_nucl_vector(a)+1) * x / (1.0d0 + a_vector(2, type_nucl_vector(a)+1) * x)
delta_en(nw) = delta_en(nw) + a_vector(1, type_nucl_vector(a)+1) * y / (1.0d0 + a_vector(2, type_nucl_vector(a)+1) * y)
do p = 2, aord_num
@ -3419,7 +3467,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_en[walk_num];
@ -3712,7 +3760,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double een_rescaled_single_n_gl[walk_num][cord_num+1][nucl_num][4];
@ -3734,7 +3782,7 @@ for (int l = 0; l < cord_num+1; l++) {
for (int a = 0; a < nucl_num; a++) {
for (int m = 0; m < 4; m++) {
assert(fabs(een_rescaled_en_gl[nw][l][a][m][2] - een_rescaled_single_n_gl[nw][l][a][m]) < 1.e-12);
}
}
}
@ -4054,7 +4102,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double een_rescaled_single_e_gl[walk_num][cord_num+1][elec_num][4];
@ -4087,7 +4135,7 @@ for (int l = 0; l < cord_num+1; l++) {
// assert(fabs(een_rescaled_ee_gl[nw][l][2][m][i] + een_rescaled_single_e_gl[nw][l][m][i]) < 1.e-12);
//}
assert(fabs(een_rescaled_ee_gl[nw][l][i][m][2] - een_rescaled_single_e_gl[nw][l][i][m]) < 1.e-12);
}
}
}
@ -4313,7 +4361,7 @@ integer(qmckl_exit_code) function qmckl_compute_jastrow_champ_delta_p_gl_doc( &
fk(1:3) = -1.d0
fk(4) = 1.d0
do nw=1, walk_num
do m=0, cord_num-1
do k = 1, 4
@ -4406,8 +4454,8 @@ qmckl_compute_jastrow_champ_delta_p_gl (const qmckl_context context,
#else
return qmckl_compute_jastrow_champ_delta_p_gl_doc
#endif
(context, num, walk_num, elec_num, nucl_num, cord_num,
een_rescaled_n, een_rescaled_e, een_rescaled_single_n, een_rescaled_single_e,
(context, num, walk_num, elec_num, nucl_num, cord_num,
een_rescaled_n, een_rescaled_e, een_rescaled_single_n, een_rescaled_single_e,
een_rescaled_n_gl, een_rescaled_e_gl, een_rescaled_single_n_gl, een_rescaled_single_e_gl, delta_p_gl);
}
@ -4433,7 +4481,7 @@ rc = qmckl_get_jastrow_champ_dtmp_c(context,
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_p_gl[walk_num][cord_num][cord_num+1][4][nucl_num][elec_num];
@ -4504,6 +4552,13 @@ qmckl_get_jastrow_champ_single_een_gl(qmckl_context context,
qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
assert (ctx != NULL);
if (delta_een_gl == NULL) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_2,
"qmckl_get_jastrow_champ_single_een_gl",
"Array is NULL.");
}
int64_t sze = 4 * ctx->electron.num * ctx->electron.walker.num;
if (size_max < sze) {
return qmckl_failwith( context,
@ -4672,7 +4727,7 @@ integer(qmckl_exit_code) function qmckl_compute_jastrow_champ_factor_single_een_
real(c_double) , intent(in) :: een_rescaled_single_n(nucl_num, 0:cord_num, walk_num)
real(c_double) , intent(in) :: een_rescaled_n_gl(elec_num, 4, nucl_num, 0:cord_num, walk_num)
real(c_double) , intent(in) :: een_rescaled_single_n_gl(4, nucl_num, 0:cord_num, walk_num)
real(c_double) , intent(out) :: delta_een_gl(elec_num, 4, walk_num)
real(c_double) , intent(out) :: delta_een_gl(elec_num, 4, walk_num)
integer*8 :: i, a, j, l, k, p, m, n, nw, kk, num
double precision :: accu, accu2, cn
@ -4848,7 +4903,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_een_gl[walk_num][4][elec_num];
@ -4873,7 +4928,7 @@ for (int nw = 0; nw < walk_num; nw++) {
//printf("een_gl_[%d][%d][%d] = %f\n", nw, m,i, een_gl_new[nw][m][i]-een_gl_old[nw][m][i]);
assert(fabs((een_gl_new[nw][m][i]- een_gl_old[nw][m][i]) - delta_een_gl[nw][m][i]) < 1.e-12);
}
}
}
@ -4885,11 +4940,15 @@ for (int nw = 0; nw < walk_num; nw++) {
** Get
#+begin_src c :comments org :tangle (eval h_func) :noweb yes
qmckl_exit_code qmckl_get_ee_rescaled_single_gl(qmckl_context context, double* const distance_rescaled_gl);
qmckl_exit_code qmckl_get_ee_rescaled_single_gl(qmckl_context context,
double* const distance_rescaled_gl,
const int64_t size_max);
#+end_src
#+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
qmckl_exit_code qmckl_get_ee_rescaled_single_gl(qmckl_context context, double* const distance_rescaled_gl)
qmckl_exit_code qmckl_get_ee_rescaled_single_gl(qmckl_context context,
double* const distance_rescaled_gl,
const int64_t size_max)
{
if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
return QMCKL_NULL_CONTEXT;
@ -4903,7 +4962,20 @@ qmckl_exit_code qmckl_get_ee_rescaled_single_gl(qmckl_context context, double* c
qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
assert (ctx != NULL);
if (distance_rescaled_gl == NULL) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_2,
"qmckl_get_ee_rescaled_single_gl",
"Array is NULL");
}
size_t sze = 4 * ctx->electron.num * ctx->electron.walker.num;
if (size_max < sze) {
return qmckl_failwith( context,
QMCKL_INVALID_ARG_3,
"qmckl_get_ee_rescaled_single_gl",
"Array too small. Expected 4 * ctx->electron.num * ctx->electron.walker.num");
}
memcpy(distance_rescaled_gl, ctx->single_point.ee_rescaled_single_gl, sze * sizeof(double));
return QMCKL_SUCCESS;
@ -5059,16 +5131,16 @@ function qmckl_compute_ee_rescaled_single_gl_doc(context, num_in, &
do i = 1, elec_num
kappa_l = -1 * rescale_factor_ee
ee_rescaled_single_gl(1, i, nw) = elel_dist_gl(1, i)
ee_rescaled_single_gl(2, i, nw) = elel_dist_gl(2, i)
ee_rescaled_single_gl(2, i, nw) = elel_dist_gl(2, i)
ee_rescaled_single_gl(3, i, nw) = elel_dist_gl(3, i)
ee_rescaled_single_gl(4, i, nw) = elel_dist_gl(4, i)
ee_rescaled_single_gl(4, i, nw) = elel_dist_gl(4, i)
ee_rescaled_single_gl(4, i, nw) = ee_rescaled_single_gl(4, i, nw) + kappa_l
ee_rescaled_single_gl(1, i, nw) = ee_rescaled_single_gl(1, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
ee_rescaled_single_gl(2, i, nw) = ee_rescaled_single_gl(2, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
ee_rescaled_single_gl(3, i, nw) = ee_rescaled_single_gl(3, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
ee_rescaled_single_gl(4, i, nw) = ee_rescaled_single_gl(4, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
ee_rescaled_single_gl(1, i, nw) = ee_rescaled_single_gl(1, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
ee_rescaled_single_gl(2, i, nw) = ee_rescaled_single_gl(2, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
ee_rescaled_single_gl(3, i, nw) = ee_rescaled_single_gl(3, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
ee_rescaled_single_gl(4, i, nw) = ee_rescaled_single_gl(4, i, nw) * dexp(kappa_l * single_ee_distance(i,nw))
end do
ee_rescaled_single_gl(1, num, nw) = 0.0d0
@ -5149,11 +5221,13 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double single_ee_rescaled_gl[walk_num][elec_num][4];
rc = qmckl_get_ee_rescaled_single_gl(context, &single_ee_rescaled_gl[0][0][0]);
rc = qmckl_get_ee_rescaled_single_gl(context,
&single_ee_rescaled_gl[0][0][0],
walk_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
coords[0][2][0] = new_coords[0];
@ -5174,7 +5248,7 @@ for (int nw = 0; nw < walk_num; nw++) {
//printf("%f\n", ee_rescaled_gl[nw][2][i][m]);
//printf("%f\n", single_ee_rescaled_gl[nw][i][m]);
assert(fabs(ee_rescaled_gl[nw][2][i][m] - single_ee_rescaled_gl[nw][i][m]) < 1.e-12);
}
}
}
@ -5186,11 +5260,15 @@ for (int nw = 0; nw < walk_num; nw++) {
** Get
#+begin_src c :comments org :tangle (eval h_func) :noweb yes
qmckl_exit_code qmckl_get_en_rescaled_single_gl(qmckl_context context, double* distance_rescaled_gl);
qmckl_exit_code qmckl_get_en_rescaled_single_gl(qmckl_context context,
double* distance_rescaled_gl,
const int64_t size_max);
#+end_src
#+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
qmckl_exit_code qmckl_get_en_rescaled_single_gl(qmckl_context context, double* distance_rescaled_gl)
qmckl_exit_code qmckl_get_en_rescaled_single_gl(qmckl_context context,
double* distance_rescaled_gl,
const int64_t size_max)
{
if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
@ -5371,10 +5449,10 @@ integer function qmckl_compute_en_rescaled_single_gl_doc_f(context, nucl_num, &
en_rescaled_single_gl(4, a, nw) = en_rescaled_single_gl(4, a, nw) + kappa_l
en_rescaled_single_gl(1, a, nw) = en_rescaled_single_gl(1, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
en_rescaled_single_gl(2, a, nw) = en_rescaled_single_gl(2, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
en_rescaled_single_gl(3, a, nw) = en_rescaled_single_gl(3, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
en_rescaled_single_gl(4, a, nw) = en_rescaled_single_gl(4, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
en_rescaled_single_gl(1, a, nw) = en_rescaled_single_gl(1, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
en_rescaled_single_gl(2, a, nw) = en_rescaled_single_gl(2, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
en_rescaled_single_gl(3, a, nw) = en_rescaled_single_gl(3, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
en_rescaled_single_gl(4, a, nw) = en_rescaled_single_gl(4, a, nw) * dexp(kappa_l * single_en_distance(a,nw))
end do
end do
@ -5498,11 +5576,13 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double single_en_rescaled_gl[walk_num][nucl_num][4];
rc = qmckl_get_en_rescaled_single_gl(context, &single_en_rescaled_gl[0][0][0]);
rc = qmckl_get_en_rescaled_single_gl(context,
&single_en_rescaled_gl[0][0][0],
walk_num*nucl_num*4);
assert (rc == QMCKL_SUCCESS);
coords[0][2][0] = new_coords[0];
@ -5520,7 +5600,7 @@ for (int nw = 0; nw < walk_num; nw++) {
for (int a = 0; a < nucl_num; a++) {
for (int m = 0; m < 4; m++) {
assert(fabs(en_rescaled_gl[nw][a][2][m] - single_en_rescaled_gl[nw][a][m]) < 1.e-12);
}
}
}
@ -5850,7 +5930,7 @@ function qmckl_compute_jastrow_champ_single_ee_gl_doc( &
kf = kf + 1.d0
end do
end do
end do
@ -5943,7 +6023,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_ee_gl[walk_num][elec_num][4];
@ -5967,7 +6047,7 @@ for (int nw = 0; nw < walk_num; nw++) {
//printf("%f\n",(ee_gl_new[nw][m][i] - ee_gl_old[nw][m][i]));
//printf("%f\n",delta_ee_gl[nw][i][m]);
assert(fabs((ee_gl_new[nw][m][i] - ee_gl_old[nw][m][i]) - delta_ee_gl[nw][i][m]) < 1.e-12);
}
}
}
@ -6029,7 +6109,7 @@ interface
end function qmckl_get_jastrow_champ_single_en_gl
end interface
#+end_src
** Provide :noexport:
#+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none
qmckl_exit_code qmckl_provide_jastrow_champ_single_en_gl(qmckl_context context);
@ -6364,7 +6444,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
double delta_en_gl[walk_num][elec_num][4];
@ -6386,7 +6466,7 @@ for (int nw = 0; nw < walk_num; nw++) {
for (int i = 0; i < elec_num; i++) {
for (int m = 0; m < 4; m++) {
assert(fabs((en_gl_new[nw][m][i] - en_gl_old[nw][m][i]) - delta_en_gl[nw][i][m]) < 1.e-12);
}
}
}
@ -6436,27 +6516,27 @@ qmckl_get_jastrow_champ_single_accept(qmckl_context context)
for (int nw = 0; nw < ctx->electron.walker.num; nw++) {
for (int l = 0; l <= ctx->jastrow_champ.cord_num; l++){
for (int a = 0; a < ctx->nucleus.num; a++){
ctx->jastrow_champ.een_rescaled_n[nw*(ctx->jastrow_champ.cord_num+1)*ctx->nucleus.num*ctx->electron.num
ctx->jastrow_champ.een_rescaled_n[nw*(ctx->jastrow_champ.cord_num+1)*ctx->nucleus.num*ctx->electron.num
+ l*ctx->nucleus.num*ctx->electron.num
+ a*ctx->electron.num
+ ctx->single_point.num] =
+ ctx->single_point.num] =
ctx->single_point.een_rescaled_single_n[nw*(ctx->jastrow_champ.cord_num+1)*ctx->nucleus.num
+ l*ctx->nucleus.num
+ a];
}
for (int i = 0; i < ctx->electron.num; i++) {
ctx->jastrow_champ.een_rescaled_e[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*ctx->electron.num
+ l*ctx->electron.num*ctx->electron.num
+ i*ctx->electron.num
+ ctx->single_point.num] =
ctx->jastrow_champ.een_rescaled_e[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*ctx->electron.num
+ l*ctx->electron.num*ctx->electron.num
+ i*ctx->electron.num
+ ctx->single_point.num] =
ctx->single_point.een_rescaled_single_e[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num
+ l*ctx->electron.num
+ i];
ctx->jastrow_champ.een_rescaled_e[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*ctx->electron.num
+ l*ctx->electron.num*ctx->electron.num
+ ctx->single_point.num*ctx->electron.num
+ i] =
ctx->jastrow_champ.een_rescaled_e[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*ctx->electron.num
+ l*ctx->electron.num*ctx->electron.num
+ ctx->single_point.num*ctx->electron.num
+ i] =
ctx->single_point.een_rescaled_single_e[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num
+ l*ctx->electron.num
+ i];
@ -6481,20 +6561,20 @@ qmckl_get_jastrow_champ_single_accept(qmckl_context context)
+ i];
for (int k = 0; k < 4; k++){
ctx->jastrow_champ.ee_distance_rescaled_gl[nw*ctx->electron.num*ctx->electron.num*4
+ i*ctx->electron.num*4
+ ctx->single_point.num*4
+ k] =
ctx->single_point.ee_rescaled_single_gl[nw*ctx->electron.num*4
+ i*4
ctx->jastrow_champ.ee_distance_rescaled_gl[nw*ctx->electron.num*ctx->electron.num*4
+ i*ctx->electron.num*4
+ ctx->single_point.num*4
+ k] =
ctx->single_point.ee_rescaled_single_gl[nw*ctx->electron.num*4
+ i*4
+ k];
ctx->jastrow_champ.ee_distance_rescaled_gl[nw*ctx->electron.num*ctx->electron.num*4
+ ctx->single_point.num*ctx->electron.num*4
+ i*4
+ k] =
ctx->single_point.ee_rescaled_single_gl[nw*ctx->electron.num*4
+ i*4
ctx->jastrow_champ.ee_distance_rescaled_gl[nw*ctx->electron.num*ctx->electron.num*4
+ ctx->single_point.num*ctx->electron.num*4
+ i*4
+ k] =
ctx->single_point.ee_rescaled_single_gl[nw*ctx->electron.num*4
+ i*4
+ k];
}
}
@ -6503,15 +6583,15 @@ qmckl_get_jastrow_champ_single_accept(qmckl_context context)
for (int l = 0; l <= ctx->jastrow_champ.cord_num; l++){
for (int i = 0; i < ctx->electron.num; i++) {
for (int k = 0; k < 4; k++){
ctx->jastrow_champ.een_rescaled_e_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*4*ctx->electron.num
+ l*ctx->electron.num*4*ctx->electron.num
+ i*4*ctx->electron.num
+ k*ctx->electron.num
+ ctx->single_point.num] =
ctx->jastrow_champ.een_rescaled_e_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*4*ctx->electron.num
+ l*ctx->electron.num*4*ctx->electron.num
+ i*4*ctx->electron.num
+ k*ctx->electron.num
+ ctx->single_point.num] =
ctx->single_point.een_rescaled_single_e_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*4
+ l*ctx->electron.num*4
+ i*4 + k];
ctx->jastrow_champ.een_rescaled_e_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*4*ctx->electron.num + l*ctx->electron.num*4*ctx->electron.num + ctx->single_point.num*4*ctx->electron.num + k*ctx->electron.num + i] = ctx->single_point.een_rescaled_single_e_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*4+ l*ctx->electron.num*4 + i*4 + k];
+ l*ctx->electron.num*4
+ i*4 + k];
ctx->jastrow_champ.een_rescaled_e_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*4*ctx->electron.num + l*ctx->electron.num*4*ctx->electron.num + ctx->single_point.num*4*ctx->electron.num + k*ctx->electron.num + i] = ctx->single_point.een_rescaled_single_e_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->electron.num*4+ l*ctx->electron.num*4 + i*4 + k];
}
}
}
@ -6528,7 +6608,7 @@ qmckl_get_jastrow_champ_single_accept(qmckl_context context)
ctx->jastrow_champ.en_distance_rescaled_gl[nw*ctx->nucleus.num*4*ctx->electron.num
+ a*ctx->electron.num*4
+ ctx->single_point.num*4
+ k] =
+ k] =
ctx->single_point.en_rescaled_single_gl[nw*ctx->nucleus.num*4
+ a*4
+ k];
@ -6537,7 +6617,7 @@ qmckl_get_jastrow_champ_single_accept(qmckl_context context)
+ l*ctx->nucleus.num*4*ctx->electron.num
+ a*4*ctx->electron.num
+ k*ctx->electron.num
+ ctx->single_point.num] =
+ ctx->single_point.num] =
ctx->single_point.een_rescaled_single_n_gl[nw*(ctx->jastrow_champ.cord_num+1)*ctx->nucleus.num*4
+ l*ctx->nucleus.num*4
+ a*4
@ -6588,20 +6668,20 @@ qmckl_get_jastrow_champ_single_accept(qmckl_context context)
for (int k = 0; k < 4; k++){
ctx->jastrow_champ.factor_ee_gl[nw*4*ctx->electron.num
+ k*ctx->electron.num
+ i] =
+ i] =
ctx->jastrow_champ.factor_ee_gl[nw*4*ctx->electron.num
+ k*ctx->electron.num
+ i] +
+ i] +
ctx->single_point.delta_ee_gl[nw*4*ctx->electron.num
+ i*4
+ k];
ctx->jastrow_champ.factor_en_gl[nw*4*ctx->electron.num
+ k*ctx->electron.num
+ i] =
+ i] =
ctx->jastrow_champ.factor_en_gl[nw*4*ctx->electron.num
+ k*ctx->electron.num
+ i] +
+ i] +
ctx->single_point.delta_en_gl[nw*4*ctx->electron.num
+ i*4
+ k];
@ -6638,7 +6718,7 @@ qmckl_get_jastrow_champ_single_accept(qmckl_context context)
// TODO iets met de normale unrescaled afstanden
return QMCKL_SUCCESS;
}
#+end_src
@ -6686,10 +6766,14 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_tmp_c(context, &p_old[0][0][0][0][0]);
rc = qmckl_get_jastrow_champ_tmp_c(context,
&p_old[0][0][0][0][0],
walk_num*cord_num*(cord_num+1)*nucl_num*elec_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_dtmp_c(context, &p_gl_old[0][0][0][0][0][0]);
rc = qmckl_get_jastrow_champ_dtmp_c(context,
&p_gl_old[0][0][0][0][0][0],
walk_num*cord_num*(cord_num+1)*nucl_num*elec_num);
assert (rc == QMCKL_SUCCESS);
@ -6699,7 +6783,7 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_coord(context, 'N', &coords[0][0][0], walk_num*elec_num*3);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3);
rc = qmckl_set_single_point(context, 'N', 2, new_coords, 3*walk_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_single_en(context, &delta_en[0], walk_num);
@ -6746,14 +6830,24 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_delta_p_gl(context, &delta_p_gl[0][0][0][0][0][0], 4*walk_num*cord_num*(cord_num+1)*nucl_num*elec_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_ee_rescaled_single_gl(context, &single_ee_rescaled_gl[0][0][0]);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_en_rescaled_single_gl(context, &single_en_rescaled_gl[0][0][0]);
rc = qmckl_get_ee_rescaled_single_gl(context,
&single_ee_rescaled_gl[0][0][0],
walk_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_single_electron_ee_distance(context, &single_ee_distance[0][0]);
rc = qmckl_get_en_rescaled_single_gl(context,
&single_en_rescaled_gl[0][0][0],
walk_num*nucl_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_single_electron_en_distance(context, &single_en_distance[0]);
rc = qmckl_get_single_electron_ee_distance(context,
&single_ee_distance[0][0],
walk_num*elec_num*elec_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_single_electron_en_distance(context,
&(single_en_distance[0][0]),
walk_num*nucl_num*elec_num);
assert (rc == QMCKL_SUCCESS);
// ----------------------------
@ -6792,32 +6886,52 @@ assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_een_rescaled_n(context, &rescaled_een_en_distance[0][0][0][0], walk_num*(cord_num+1)*elec_num*nucl_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_tmp_c(context, &p_new[0][0][0][0][0]);
rc = qmckl_get_jastrow_champ_tmp_c(context,
&p_new[0][0][0][0][0],
walk_num*cord_num*(cord_num+1)*nucl_num*elec_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_ee_distance_rescaled(context, &ee_rescaled[0][0][0]);
rc = qmckl_get_jastrow_champ_ee_distance_rescaled(context,
&ee_rescaled[0][0][0],
walk_num*elec_num*elec_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_en_distance_rescaled(context, &en_rescaled[0][0][0]);
rc = qmckl_get_jastrow_champ_en_distance_rescaled(context,
&en_rescaled[0][0][0],
walk_num*(cord_num+1)*nucl_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_een_rescaled_n_gl(context, &een_rescaled_en_gl[0][0][0][0][0], walk_num*(cord_num+1)*nucl_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_een_rescaled_e_gl(context, &een_rescaled_ee_gl[0][0][0][0][0], walk_num*(cord_num+1)*elec_num*elec_num*4);
rc = qmckl_get_jastrow_champ_een_rescaled_n_gl(context,
&een_rescaled_en_gl[0][0][0][0][0],
walk_num*(cord_num+1)*nucl_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_dtmp_c(context, &p_gl_new[0][0][0][0][0][0]);
rc = qmckl_get_jastrow_champ_een_rescaled_e_gl(context,
&een_rescaled_ee_gl[0][0][0][0][0],
walk_num*(cord_num+1)*elec_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_jastrow_champ_ee_distance_rescaled_gl(context, &ee_rescaled_gl[0][0][0][0]);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_en_distance_rescaled_gl(context, &en_rescaled_gl[0][0][0][0]);
rc = qmckl_get_jastrow_champ_dtmp_c(context,
&p_gl_new[0][0][0][0][0][0],
walk_num*cord_num*(cord_num+1)*nucl_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_ee_distance(context, &ee_distance[0][0][0]);
rc = qmckl_get_jastrow_champ_ee_distance_rescaled_gl(context,
&ee_rescaled_gl[0][0][0][0],
walk_num*elec_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_en_distance(context, &en_distance[0][0]);
rc = qmckl_get_jastrow_champ_en_distance_rescaled_gl(context,
&en_rescaled_gl[0][0][0][0],
walk_num*nucl_num*elec_num*4);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_ee_distance(context,
&ee_distance[0][0][0], walk_num*elec_num*elec_num);
assert (rc == QMCKL_SUCCESS);
rc = qmckl_get_electron_en_distance(context,
&en_distance[0][0][0], walk_num*nucl_num*elec_num);
assert (rc == QMCKL_SUCCESS);
@ -6888,7 +7002,7 @@ for (int l = 0; l < cord_num+1; l++) {
for (int a = 0; a < nucl_num; a++) {
for (int m = 0; m < 4; m++) {
assert(fabs(een_rescaled_en_gl[nw][l][a][m][2] - een_rescaled_single_n_gl[nw][l][a][m]) < 1.e-12);
}
}
}
@ -6901,7 +7015,7 @@ for (int l = 0; l < cord_num+1; l++) {
//printf("een_rescaled_ee_gl[nw][l][i][m][2] %i %i %i %f \n", l, m ,i, een_rescaled_ee_gl[nw][l][i][m][2]);
//printf("een_rescaled_single_e_gl[nw][l][i][m] %i %i %i %f\n", l, m, i,een_rescaled_single_e_gl[nw][l][i][m]);
assert(fabs(een_rescaled_ee_gl[nw][l][i][m][2] - een_rescaled_single_e_gl[nw][l][i][m]) < 1.e-12);
}
}
}
@ -6930,7 +7044,7 @@ for (int nw = 0; nw < walk_num; nw++) {
//printf("%f\n", ee_rescaled_gl[nw][2][i][m]);
//printf("%f\n", single_ee_rescaled_gl[nw][i][m]);
assert(fabs(ee_rescaled_gl[nw][2][i][m] - single_ee_rescaled_gl[nw][i][m]) < 1.e-12);
}
}
}
@ -6939,7 +7053,7 @@ for (int nw = 0; nw < walk_num; nw++) {
for (int a = 0; a < nucl_num; a++) {
for (int m = 0; m < 4; m++) {
assert(fabs(en_rescaled_gl[nw][a][2][m] - single_en_rescaled_gl[nw][a][m]) < 1.e-12);
}
}
}