mirror of
https://github.com/TREX-CoE/qmckl.git
synced 2025-04-30 04:15:00 +02:00
Merge branch 'master' of github.com:EmielSlootman/qmckl
This commit is contained in:
commit
9c59d9f0cb
@ -83,6 +83,8 @@ typedef struct qmckl_forces_struct{
|
||||
uint64_t forces_jastrow_en_date;
|
||||
double * restrict forces_jastrow_en_g;
|
||||
uint64_t forces_jastrow_en_g_date;
|
||||
double * restrict forces_jastrow_en_l;
|
||||
uint64_t forces_jastrow_en_l_date;
|
||||
} qmckl_forces_struct;
|
||||
#+end_src
|
||||
|
||||
@ -754,8 +756,8 @@ rc = qmckl_finite_difference_deriv_n(context, delta_x, &qmckl_get_jastrow_champ_
|
||||
for (int nw = 0; nw < walk_num; nw++){
|
||||
for (int a = 0; a < nucl_num; a++) {
|
||||
for (int k = 0; k < 3; k++){
|
||||
printf("%.10f\t", finite_difference_force_en[nw][a][k]);
|
||||
printf("%.10f\n", forces_jastrow_en[nw][a][k]);
|
||||
//printf("%.10f\t", finite_difference_force_en[nw][a][k]);
|
||||
//printf("%.10f\n", forces_jastrow_en[nw][a][k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -769,6 +771,8 @@ for (int nw = 0; nw < walk_num; nw++){
|
||||
printf("OK\n");
|
||||
|
||||
#+end_src
|
||||
|
||||
|
||||
* Force of en jastrow gradient
|
||||
|
||||
** Get
|
||||
@ -1142,7 +1146,7 @@ qmckl_compute_forces_jastrow_en_g (const qmckl_context context,
|
||||
** Test
|
||||
|
||||
#+begin_src c :tangle (eval c_test)
|
||||
printf("Forces Jastrow en GL\n");
|
||||
printf("Forces Jastrow en G\n");
|
||||
|
||||
/* Check if Jastrow is properly initialized */
|
||||
assert(qmckl_jastrow_champ_provided(context));
|
||||
@ -1162,8 +1166,8 @@ for (int nw = 0; nw < walk_num; nw++){
|
||||
for (int k = 0; k < 3; k++){
|
||||
for (int i = 0; i < elec_num; i++){
|
||||
for (int l = 1; l < 3; l++){
|
||||
printf("finite_difference_force_en_g[%i][%i][%i][%i][%i] %+3.10f \n", nw,a,k,l,i,finite_difference_force_en_g[nw][a][k][l][i]);
|
||||
printf("forces_jastrow_en_g [%i][%i][%i][%i][%i] %+3.10f\n", nw,a,k,i,l,forces_jastrow_en_g[nw][a][k][i][l]);
|
||||
//printf("finite_difference_force_en_g[%i][%i][%i][%i][%i] %+3.10f \n", nw,a,k,l,i,finite_difference_force_en_g[nw][a][k][l][i]);
|
||||
//printf("forces_jastrow_en_g [%i][%i][%i][%i][%i] %+3.10f\n", nw,a,k,i,l,forces_jastrow_en_g[nw][a][k][i][l]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1184,6 +1188,425 @@ printf("OK\n");
|
||||
|
||||
#+end_src
|
||||
|
||||
* Force of en jastrow laplacien
|
||||
|
||||
** Get
|
||||
|
||||
|
||||
#+begin_src c :comments org :tangle (eval h_func) :noweb yes
|
||||
qmckl_exit_code
|
||||
qmckl_get_forces_jastrow_en_l(qmckl_context context,
|
||||
double* const forces_jastrow_en_l,
|
||||
const int64_t size_max);
|
||||
#+end_src
|
||||
|
||||
#+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
|
||||
qmckl_exit_code
|
||||
qmckl_get_forces_jastrow_en_l(qmckl_context context,
|
||||
double* const forces_jastrow_en_l,
|
||||
const int64_t size_max)
|
||||
{
|
||||
if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
|
||||
return QMCKL_NULL_CONTEXT;
|
||||
}
|
||||
|
||||
qmckl_exit_code rc;
|
||||
|
||||
rc = qmckl_provide_forces_jastrow_en_l(context);
|
||||
if (rc != QMCKL_SUCCESS) return rc;
|
||||
|
||||
qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
|
||||
assert (ctx != NULL);
|
||||
|
||||
int64_t sze = 3 * ctx->nucleus.num * ctx->electron.walker.num;
|
||||
if (size_max < sze) {
|
||||
return qmckl_failwith( context,
|
||||
QMCKL_INVALID_ARG_3,
|
||||
"qmckl_get_forces_jastrow_en_l",
|
||||
"Array too small. Expected 3*nucl_num*walk_num");
|
||||
}
|
||||
|
||||
memcpy(forces_jastrow_en_l, ctx->forces.forces_jastrow_en_l, sze * sizeof(double));
|
||||
|
||||
return QMCKL_SUCCESS;
|
||||
}
|
||||
#+end_src
|
||||
|
||||
|
||||
#+begin_src f90 :tangle (eval fh_func) :comments org
|
||||
interface
|
||||
integer(qmckl_exit_code) function qmckl_get_forces_jastrow_en_l (context, &
|
||||
forces_jastrow_en_l, size_max) bind(C)
|
||||
use, intrinsic :: iso_c_binding
|
||||
import
|
||||
implicit none
|
||||
integer (qmckl_context) , intent(in), value :: context
|
||||
integer(c_int64_t), intent(in), value :: size_max
|
||||
real(c_double), intent(out) :: forces_jastrow_en_l(size_max)
|
||||
end function qmckl_get_forces_jastrow_en_l
|
||||
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_forces_jastrow_en_l(qmckl_context context);
|
||||
#+end_src
|
||||
|
||||
#+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
|
||||
qmckl_exit_code qmckl_provide_forces_jastrow_en_l(qmckl_context context)
|
||||
{
|
||||
|
||||
qmckl_exit_code rc;
|
||||
|
||||
if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
|
||||
return qmckl_failwith( context,
|
||||
QMCKL_INVALID_CONTEXT,
|
||||
"qmckl_provide_forces_jastrow_en_l",
|
||||
NULL);
|
||||
}
|
||||
|
||||
qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
|
||||
assert (ctx != NULL);
|
||||
|
||||
if (!ctx->jastrow_champ.provided) {
|
||||
return qmckl_failwith( context,
|
||||
QMCKL_NOT_PROVIDED,
|
||||
"qmckl_provide_forces_jastrow_en_l",
|
||||
NULL);
|
||||
}
|
||||
|
||||
|
||||
/* Check if en rescaled distance is provided */
|
||||
rc = qmckl_provide_en_distance_rescaled(context);
|
||||
if(rc != QMCKL_SUCCESS) return rc;
|
||||
|
||||
/* Check if en rescaled distance derivatives is provided */
|
||||
rc = qmckl_provide_en_distance_rescaled_gl(context);
|
||||
if(rc != QMCKL_SUCCESS) return rc;
|
||||
|
||||
rc = qmckl_provide_en_distance(context);
|
||||
if(rc != QMCKL_SUCCESS) return rc;
|
||||
|
||||
|
||||
/* Compute if necessary */
|
||||
if (ctx->date > ctx->forces.forces_jastrow_en_l_date) {
|
||||
|
||||
if (ctx->electron.walker.num > ctx->electron.walker_old.num) {
|
||||
if (ctx->forces.forces_jastrow_en_l != NULL) {
|
||||
rc = qmckl_free(context, ctx->forces.forces_jastrow_en_l);
|
||||
if (rc != QMCKL_SUCCESS) {
|
||||
return qmckl_failwith( context, rc,
|
||||
"qmckl_provide_forces_jastrow_en_l",
|
||||
"Unable to free ctx->forces.forces_jastrow_en_l");
|
||||
}
|
||||
ctx->forces.forces_jastrow_en_l = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Allocate array */
|
||||
if (ctx->forces.forces_jastrow_en_l == NULL) {
|
||||
|
||||
qmckl_memory_info_struct mem_info = qmckl_memory_info_struct_zero;
|
||||
mem_info.size = ctx->electron.walker.num * 3 * ctx->nucleus.num * sizeof(double);
|
||||
double* forces_jastrow_en_l = (double*) qmckl_malloc(context, mem_info);
|
||||
|
||||
if (forces_jastrow_en_l == NULL) {
|
||||
return qmckl_failwith( context,
|
||||
QMCKL_ALLOCATION_FAILED,
|
||||
"qmckl_provide_forces_jastrow_en_l",
|
||||
NULL);
|
||||
}
|
||||
ctx->forces.forces_jastrow_en_l = forces_jastrow_en_l;
|
||||
}
|
||||
|
||||
rc = qmckl_compute_forces_jastrow_en_l(context,
|
||||
ctx->electron.walker.num,
|
||||
ctx->electron.num,
|
||||
ctx->nucleus.num,
|
||||
ctx->jastrow_champ.type_nucl_num,
|
||||
ctx->jastrow_champ.type_nucl_vector,
|
||||
ctx->jastrow_champ.aord_num,
|
||||
ctx->jastrow_champ.a_vector,
|
||||
ctx->jastrow_champ.rescale_factor_en,
|
||||
ctx->electron.en_distance,
|
||||
ctx->jastrow_champ.en_distance_rescaled,
|
||||
ctx->jastrow_champ.en_distance_rescaled_gl,
|
||||
ctx->forces.forces_jastrow_en_l);
|
||||
if (rc != QMCKL_SUCCESS) {
|
||||
return rc;
|
||||
}
|
||||
|
||||
ctx->forces.forces_jastrow_en_l_date = ctx->date;
|
||||
}
|
||||
|
||||
return QMCKL_SUCCESS;
|
||||
}
|
||||
#+end_src
|
||||
|
||||
** Compute
|
||||
|
||||
:PROPERTIES:
|
||||
:Name: qmckl_compute_forces_jastrow_en_l
|
||||
:CRetType: qmckl_exit_code
|
||||
:FRetType: qmckl_exit_code
|
||||
:END:
|
||||
|
||||
#+NAME: qmckl_forces_jastrow_en_l_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 nuclei |
|
||||
| ~type_nucl_num~ | ~int64_t~ | in | Number of unique nuclei |
|
||||
| ~type_nucl_vector~ | ~int64_t[nucl_num]~ | in | IDs of unique nuclei |
|
||||
| ~aord_num~ | ~int64_t~ | in | Number of coefficients |
|
||||
| ~a_vector~ | ~double[type_nucl_num][aord_num+1]~ | in | List of coefficients |
|
||||
| ~rescale_factor_en~ | ~double[type_nucl_num]~ | in | Rescale factor for electron-nucleus |
|
||||
| ~en_distance~ | ~double[elec_num][nucl_num]~ | in | Electron-nucleus distances |
|
||||
| ~en_distance_rescaled~ | ~double[walk_num][nucl_num][elec_num]~ | in | Electron-nucleus distances |
|
||||
| ~en_distance_rescaled_gl~ | ~double[walk_num][nucl_num][elec_num][4]~ | in | Electron-nucleus distance derivatives |
|
||||
| ~forces_jastrow_en_l~ | ~double[walk_num][nucl_num][3]~ | out | Electron-nucleus forces |
|
||||
|
||||
#+begin_src f90 :comments org :tangle (eval f) :noweb yes
|
||||
function qmckl_compute_forces_jastrow_en_l_doc( &
|
||||
context, walk_num, elec_num, nucl_num, type_nucl_num, &
|
||||
type_nucl_vector, aord_num, a_vector, rescale_factor_en, en_distance, &
|
||||
en_distance_rescaled, en_distance_rescaled_gl, forces_jastrow_en_l) &
|
||||
bind(C) result(info)
|
||||
use qmckl
|
||||
implicit none
|
||||
|
||||
integer (qmckl_context), intent(in), value :: context
|
||||
integer (c_int64_t) , intent(in) , value :: walk_num
|
||||
integer (c_int64_t) , intent(in) , value :: elec_num
|
||||
integer (c_int64_t) , intent(in) , value :: nucl_num
|
||||
integer (c_int64_t) , intent(in) , value :: type_nucl_num
|
||||
integer (c_int64_t) , intent(in) :: type_nucl_vector(nucl_num)
|
||||
integer (c_int64_t) , intent(in) , value :: aord_num
|
||||
real (c_double ) , intent(in) :: a_vector(aord_num+1,type_nucl_num)
|
||||
real (c_double ) , intent(in) :: rescale_factor_en(type_nucl_num)
|
||||
real (c_double ) , intent(in) :: en_distance(nucl_num, elec_num)
|
||||
real (c_double ) , intent(in) :: en_distance_rescaled(elec_num,nucl_num,walk_num)
|
||||
real (c_double ) , intent(in) :: en_distance_rescaled_gl(4, elec_num,nucl_num,walk_num)
|
||||
real (c_double ) , intent(out) :: forces_jastrow_en_l(3,nucl_num,walk_num)
|
||||
integer(qmckl_exit_code) :: info
|
||||
|
||||
integer*8 :: i, a, k, nw, ii, m,l
|
||||
double precision :: x, x1, kf
|
||||
double precision :: denom, invdenom, invdenom2, f, f2, expk, invdist
|
||||
double precision :: dx(3)
|
||||
|
||||
info = QMCKL_SUCCESS
|
||||
|
||||
if (context == QMCKL_NULL_CONTEXT) then
|
||||
info = QMCKL_INVALID_CONTEXT
|
||||
return
|
||||
endif
|
||||
|
||||
if (walk_num <= 0) then
|
||||
info = QMCKL_INVALID_ARG_2
|
||||
return
|
||||
endif
|
||||
|
||||
if (elec_num <= 0) then
|
||||
info = QMCKL_INVALID_ARG_3
|
||||
return
|
||||
endif
|
||||
|
||||
if (nucl_num <= 0) then
|
||||
info = QMCKL_INVALID_ARG_4
|
||||
return
|
||||
endif
|
||||
|
||||
if (aord_num < 0) then
|
||||
info = QMCKL_INVALID_ARG_7
|
||||
return
|
||||
endif
|
||||
|
||||
do nw =1, walk_num
|
||||
forces_jastrow_en_l(:,:,nw) = 0.0d0
|
||||
do a = 1, nucl_num
|
||||
do i = 1, elec_num
|
||||
expk = dexp(rescale_factor_en(type_nucl_vector(a)+1) * en_distance(a,i))
|
||||
invdist = 1.d0 / en_distance(a,i)
|
||||
x = en_distance_rescaled(i,a,nw)
|
||||
if(abs(x) < 1.d-12) continue
|
||||
denom = 1.0d0 + a_vector(2, type_nucl_vector(a)+1) * x
|
||||
invdenom = 1.0d0 / denom
|
||||
invdenom2 = invdenom*invdenom
|
||||
f = a_vector(1, type_nucl_vector(a)+1) * invdenom2
|
||||
|
||||
do m = 1, 4
|
||||
dx(m) = en_distance_rescaled_gl(m,i,a,nw)
|
||||
end do
|
||||
|
||||
!do m = 1, 3
|
||||
! do l = 1,3
|
||||
! if (m == l) then
|
||||
! forces_jastrow_en_g(l,a,nw) = forces_jastrow_en_g(l,a,nw) - f * invdist / expk
|
||||
! end if
|
||||
|
||||
! forces_jastrow_en_g(l,a,nw) = forces_jastrow_en_g(l,a,nw) + f * dx(m) * dx(l) * invdist * expk
|
||||
! forces_jastrow_en_g(l,a,nw) = forces_jastrow_en_g(l,a,nw) + 2.d0 * f * invdenom * &
|
||||
! a_vector(2, type_nucl_vector(a)+1) * dx(m) * dx(l)
|
||||
! end do
|
||||
!end do
|
||||
|
||||
|
||||
kf = 2.d0
|
||||
x1 = x
|
||||
x = 1.d0
|
||||
do k=2, aord_num
|
||||
f = a_vector(k+1,type_nucl_vector(a)+1) * kf * x
|
||||
do m = 1, 3
|
||||
forces_jastrow_en_l(m,a,nw) = forces_jastrow_en_l(m,a,nw) &
|
||||
- f * dx(m) * dx(4) * (kf-1.d0) &
|
||||
- f / x1 * (kf-1.d0) * (kf-2.d0) * dx(m) /expk /expk &
|
||||
+ f * x1 * rescale_factor_en(type_nucl_vector(a)+1) * dx(m) * dx(4) * expk &
|
||||
+ f * x1 * 2 * dx(m) * invdist * invdist &
|
||||
+ 2 * f * (kf-1.d0) * dx(m) * rescale_factor_en(type_nucl_vector(a)+1) / expk
|
||||
end do
|
||||
x = x*x1
|
||||
kf = kf + 1.d0
|
||||
end do
|
||||
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
|
||||
|
||||
|
||||
end function qmckl_compute_forces_jastrow_en_l_doc
|
||||
#+end_src
|
||||
|
||||
# #+CALL: generate_c_header(table=qmckl_factor_en_gl_args,rettyp=get_value("CRetType"),fname=get_value("Name"))
|
||||
|
||||
#+begin_src c :comments org :tangle (eval h_private_func) :noweb yes :exports none
|
||||
qmckl_exit_code qmckl_compute_forces_jastrow_en_l_doc (
|
||||
const qmckl_context context,
|
||||
const int64_t walk_num,
|
||||
const int64_t elec_num,
|
||||
const int64_t nucl_num,
|
||||
const int64_t type_nucl_num,
|
||||
const int64_t* type_nucl_vector,
|
||||
const int64_t aord_num,
|
||||
const double* a_vector,
|
||||
const double* rescale_factor_en,
|
||||
const double* en_distance,
|
||||
const double* en_distance_rescaled,
|
||||
const double* en_distance_rescaled_gl,
|
||||
double* const forces_jastrow_en_l );
|
||||
|
||||
qmckl_exit_code qmckl_compute_forces_jastrow_en_l (
|
||||
const qmckl_context context,
|
||||
const int64_t walk_num,
|
||||
const int64_t elec_num,
|
||||
const int64_t nucl_num,
|
||||
const int64_t type_nucl_num,
|
||||
const int64_t* type_nucl_vector,
|
||||
const int64_t aord_num,
|
||||
const double* a_vector,
|
||||
const double* rescale_factor_en,
|
||||
const double* en_distance,
|
||||
const double* en_distance_rescaled,
|
||||
const double* en_distance_rescaled_gl,
|
||||
double* const forces_jastrow_en_l );
|
||||
|
||||
qmckl_exit_code qmckl_compute_forces_jastrow_en_l (
|
||||
const qmckl_context context,
|
||||
const int64_t walk_num,
|
||||
const int64_t elec_num,
|
||||
const int64_t nucl_num,
|
||||
const int64_t type_nucl_num,
|
||||
const int64_t* type_nucl_vector,
|
||||
const int64_t aord_num,
|
||||
const double* a_vector,
|
||||
const double* rescale_factor_en,
|
||||
const double* en_distance,
|
||||
const double* en_distance_rescaled,
|
||||
const double* en_distance_rescaled_gl,
|
||||
double* const forces_jastrow_en_l );
|
||||
#+end_src
|
||||
|
||||
|
||||
#+begin_src c :tangle (eval c) :comments org :exports none
|
||||
qmckl_exit_code
|
||||
qmckl_compute_forces_jastrow_en_l (const qmckl_context context,
|
||||
const int64_t walk_num,
|
||||
const int64_t elec_num,
|
||||
const int64_t nucl_num,
|
||||
const int64_t type_nucl_num,
|
||||
const int64_t* type_nucl_vector,
|
||||
const int64_t aord_num,
|
||||
const double* a_vector,
|
||||
const double* rescale_factor_en,
|
||||
const double* en_distance,
|
||||
const double* en_distance_rescaled,
|
||||
const double* en_distance_rescaled_gl,
|
||||
double* const forces_jastrow_en_l )
|
||||
{
|
||||
#ifdef HAVE_HPC
|
||||
return qmckl_compute_forces_jastrow_en_l_doc
|
||||
#else
|
||||
return qmckl_compute_forces_jastrow_en_l_doc
|
||||
#endif
|
||||
(context, walk_num, elec_num, nucl_num, type_nucl_num, type_nucl_vector, aord_num,
|
||||
a_vector, rescale_factor_en, en_distance, en_distance_rescaled, en_distance_rescaled_gl, forces_jastrow_en_l);
|
||||
}
|
||||
#+end_src
|
||||
|
||||
** Test
|
||||
|
||||
#+begin_src c :tangle (eval c_test)
|
||||
printf("Forces Jastrow en L\n");
|
||||
|
||||
/* Check if Jastrow is properly initialized */
|
||||
assert(qmckl_jastrow_champ_provided(context));
|
||||
|
||||
rc = qmckl_set_nucleus_coord(context, 'T', &(nucl_coord[0]), 3*nucl_num);
|
||||
assert(rc == QMCKL_SUCCESS);
|
||||
|
||||
double forces_jastrow_en_l[walk_num][nucl_num][3];
|
||||
rc = qmckl_get_forces_jastrow_en_l(context, &forces_jastrow_en_l[0][0][0], 3*nucl_num*walk_num);
|
||||
assert(rc == QMCKL_SUCCESS);
|
||||
|
||||
double finite_difference_force_en_l[walk_num][nucl_num][3][4][elec_num];
|
||||
rc = qmckl_finite_difference_deriv_n(context, delta_x, &qmckl_get_jastrow_champ_factor_en_gl, &finite_difference_force_en_l[0][0][0][0][0], 4*elec_num);
|
||||
|
||||
|
||||
double finite_difference_force_en_l_sum[walk_num][nucl_num][3];
|
||||
for (int nw = 0; nw < walk_num; nw++){
|
||||
for (int a = 0; a < nucl_num; a++) {
|
||||
for (int k = 0; k < 3; k++){
|
||||
finite_difference_force_en_l_sum[nw][a][k] = 0;
|
||||
for (int i = 0; i < elec_num; i++){
|
||||
finite_difference_force_en_l_sum[nw][a][k] = finite_difference_force_en_l_sum[nw][a][k] + finite_difference_force_en_l[nw][a][k][3][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int nw = 0; nw < walk_num; nw++){
|
||||
for (int a = 0; a < nucl_num; a++) {
|
||||
for (int k = 0; k < 3; k++){
|
||||
//printf("finite_difference_force_en_l_sum[%i][%i][%i] %+3.10f \n", nw,a,k,finite_difference_force_en_l_sum[nw][a][k]);
|
||||
//printf("forces_jastrow_en_l [%i][%i][%i] %+3.10f\n", nw,a,k,forces_jastrow_en_l[nw][a][k]);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int nw = 0; nw < walk_num; nw++){
|
||||
for (int a = 0; a < nucl_num; a++) {
|
||||
for (int k = 0; k < 3; k++){
|
||||
assert(fabs(finite_difference_force_en_l_sum[nw][a][k] - forces_jastrow_en_l[nw][a][k]) < 1.e-8);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("OK\n");
|
||||
|
||||
#+end_src
|
||||
|
||||
|
||||
|
||||
* End of files :noexport:
|
||||
|
||||
@ -6630,10 +6630,8 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_e_gl_f( &
|
||||
een_rescaled_e_gl(i, 3, j, l, nw) = kappa_l * elec_dist_gl(i, 3, j)
|
||||
een_rescaled_e_gl(i, 4, j, l, nw) = kappa_l * elec_dist_gl(i, 4, j)
|
||||
|
||||
een_rescaled_e_gl(i, 4, j, l, nw) = een_rescaled_e_gl(i, 4, j, l, nw) &
|
||||
+ een_rescaled_e_gl(i, 1, j, l, nw) * een_rescaled_e_gl(i, 1, j, l, nw) &
|
||||
+ een_rescaled_e_gl(i, 2, j, l, nw) * een_rescaled_e_gl(i, 2, j, l, nw) &
|
||||
+ een_rescaled_e_gl(i, 3, j, l, nw) * een_rescaled_e_gl(i, 3, j, l, nw)
|
||||
een_rescaled_e_gl(i, 4, j, l, nw) = een_rescaled_e_gl(i, 4, j, l, nw) + &
|
||||
kappa_l * kappa_l
|
||||
|
||||
een_rescaled_e_gl(i,1,j,l,nw) = een_rescaled_e_gl(i,1,j,l,nw) * een_rescaled_e(i,j,l,nw)
|
||||
een_rescaled_e_gl(i,2,j,l,nw) = een_rescaled_e_gl(i,2,j,l,nw) * een_rescaled_e(i,j,l,nw)
|
||||
@ -7603,10 +7601,8 @@ integer function qmckl_compute_jastrow_champ_factor_een_rescaled_n_gl_f( &
|
||||
een_rescaled_n_gl(i, 3, a, l, nw) = kappa_l * elnuc_dist_gl(i, 3, a)
|
||||
een_rescaled_n_gl(i, 4, a, l, nw) = kappa_l * elnuc_dist_gl(i, 4, a)
|
||||
|
||||
een_rescaled_n_gl(i, 4, a, l, nw) = een_rescaled_n_gl(i, 4, a, l, nw) &
|
||||
+ een_rescaled_n_gl(i, 1, a, l, nw) * een_rescaled_n_gl(i, 1, a, l, nw) &
|
||||
+ een_rescaled_n_gl(i, 2, a, l, nw) * een_rescaled_n_gl(i, 2, a, l, nw) &
|
||||
+ een_rescaled_n_gl(i, 3, a, l, nw) * een_rescaled_n_gl(i, 3, a, l, nw)
|
||||
een_rescaled_n_gl(i, 4, a, l, nw) = een_rescaled_n_gl(i, 4, a, l, nw) + &
|
||||
kappa_l * kappa_l
|
||||
|
||||
een_rescaled_n_gl(i, 1, a, l, nw) = een_rescaled_n_gl(i, 1, a, l, nw) * &
|
||||
een_rescaled_n(i, a, l, nw)
|
||||
|
||||
@ -3626,12 +3626,7 @@ integer function qmckl_compute_een_rescaled_single_n_gl( &
|
||||
een_rescaled_single_n_gl(1, a, l, nw) = kappa_l * elnuc_dist_gl(1, a)
|
||||
een_rescaled_single_n_gl(2, a, l, nw) = kappa_l * elnuc_dist_gl(2, a)
|
||||
een_rescaled_single_n_gl(3, a, l, nw) = kappa_l * elnuc_dist_gl(3, a)
|
||||
een_rescaled_single_n_gl(4, a, l, nw) = kappa_l * elnuc_dist_gl(4, a)
|
||||
|
||||
een_rescaled_single_n_gl(4, a, l, nw) = een_rescaled_single_n_gl(4, a, l, nw) &
|
||||
+ een_rescaled_single_n_gl(1, a, l, nw) * een_rescaled_single_n_gl(1, a, l, nw) &
|
||||
+ een_rescaled_single_n_gl(2, a, l, nw) * een_rescaled_single_n_gl(2, a, l, nw) &
|
||||
+ een_rescaled_single_n_gl(3, a, l, nw) * een_rescaled_single_n_gl(3, a, l, nw)
|
||||
een_rescaled_single_n_gl(4, a, l, nw) = kappa_l * (elnuc_dist_gl(4, a) + kappa_l)
|
||||
|
||||
een_rescaled_single_n_gl(1, a, l, nw) = een_rescaled_single_n_gl(1, a, l, nw) * &
|
||||
een_rescaled_single_n(a, l, nw)
|
||||
@ -3928,12 +3923,7 @@ integer function qmckl_compute_een_rescaled_single_e_gl_doc( &
|
||||
een_rescaled_single_e_gl(1, i, l, nw) = kappa_l * elec_dist_gl(1, i)
|
||||
een_rescaled_single_e_gl(2, i, l, nw) = kappa_l * elec_dist_gl(2, i)
|
||||
een_rescaled_single_e_gl(3, i, l, nw) = kappa_l * elec_dist_gl(3, i)
|
||||
een_rescaled_single_e_gl(4, i, l, nw) = kappa_l * elec_dist_gl(4, i)
|
||||
|
||||
een_rescaled_single_e_gl(4, i, l, nw) = een_rescaled_single_e_gl(4, i, l, nw) &
|
||||
+ een_rescaled_single_e_gl(1, i, l, nw) * een_rescaled_single_e_gl(1, i, l, nw) &
|
||||
+ een_rescaled_single_e_gl(2, i, l, nw) * een_rescaled_single_e_gl(2, i, l, nw) &
|
||||
+ een_rescaled_single_e_gl(3, i, l, nw) * een_rescaled_single_e_gl(3, i, l, nw)
|
||||
een_rescaled_single_e_gl(4, i, l, nw) = kappa_l * (elec_dist_gl(4, i) + kappa_l)
|
||||
|
||||
een_rescaled_single_e_gl(1,i,l,nw) = een_rescaled_single_e_gl(1,i,l,nw) * een_rescaled_single_e(i,l,nw)
|
||||
een_rescaled_single_e_gl(2,i,l,nw) = een_rescaled_single_e_gl(2,i,l,nw) * een_rescaled_single_e(i,l,nw)
|
||||
@ -5200,10 +5190,7 @@ function qmckl_compute_ee_rescaled_single_gl_doc(context, num_in, &
|
||||
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) = ee_rescaled_single_gl(4, i, nw) &
|
||||
+ ee_rescaled_single_gl(1, i, nw) * ee_rescaled_single_gl(1, i, nw) * kappa_l &
|
||||
+ ee_rescaled_single_gl(2, i, nw) * ee_rescaled_single_gl(2, i, nw) * kappa_l &
|
||||
+ ee_rescaled_single_gl(3, i, nw) * ee_rescaled_single_gl(3, i, nw) * kappa_l
|
||||
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))
|
||||
@ -5507,10 +5494,7 @@ integer function qmckl_compute_en_rescaled_single_gl_doc_f(context, nucl_num, &
|
||||
en_rescaled_single_gl(3, a, nw) = elnuc_dist_gl(3, a)
|
||||
en_rescaled_single_gl(4, a, nw) = elnuc_dist_gl(4, a)
|
||||
|
||||
en_rescaled_single_gl(4, a, nw) = en_rescaled_single_gl(4, a, nw) &
|
||||
+ en_rescaled_single_gl(1, a, nw) * en_rescaled_single_gl(1, a, nw) * kappa_l &
|
||||
+ en_rescaled_single_gl(2, a, nw) * en_rescaled_single_gl(2, a, nw) * kappa_l &
|
||||
+ en_rescaled_single_gl(3, a, nw) * en_rescaled_single_gl(3, a, nw) * kappa_l
|
||||
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))
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user