mirror of https://gitlab.com/scemama/qmcchem.git
377 lines
12 KiB
Fortran
377 lines
12 KiB
Fortran
! Providers of *_pdmc_block_walk
|
|
!==============================
|
|
BEGIN_SHELL [ /usr/bin/env python2 ]
|
|
from properties import *
|
|
|
|
t = """
|
|
BEGIN_PROVIDER [ $T, $X_pdmc_block_walk $D1 ]
|
|
&BEGIN_PROVIDER [ $T, $X_pdmc_block_walk_kahan $D2 ]
|
|
&BEGIN_PROVIDER [ $T, $X_2_pdmc_block_walk $D1 ]
|
|
&BEGIN_PROVIDER [ $T, $X_2_pdmc_block_walk_kahan $D2 ]
|
|
!&BEGIN_PROVIDER [ $T, $X_vmc_pdmc_block_walk $D1 ]
|
|
!&BEGIN_PROVIDER [ $T, $X_vmc_pdmc_block_walk_kahan $D2 ]
|
|
!&BEGIN_PROVIDER [ $T, $X_2_vmc_pdmc_block_walk $D1 ]
|
|
!&BEGIN_PROVIDER [ $T, $X_2_vmc_pdmc_block_walk_kahan $D2 ]
|
|
implicit none
|
|
BEGIN_DOC
|
|
! PDMC averages of $X. Computed in E_loc_pdmc_block_walk
|
|
END_DOC
|
|
$X_pdmc_block_walk = 0.d0
|
|
$X_pdmc_block_walk_kahan = 0.d0
|
|
$X_2_pdmc_block_walk = 0.d0
|
|
$X_2_pdmc_block_walk_kahan = 0.d0
|
|
! $X_vmc_pdmc_block_walk = 0.d0
|
|
! $X_vmc_pdmc_block_walk_kahan = 0.d0
|
|
! $X_2_vmc_pdmc_block_walk = 0.d0
|
|
! $X_2_vmc_pdmc_block_walk_kahan = 0.d0
|
|
END_PROVIDER
|
|
|
|
BEGIN_PROVIDER [ $T, $X_pdmc_trajectory $D3 ]
|
|
implicit none
|
|
BEGIN_DOC
|
|
! Value of $X along the PDMC trajectory
|
|
END_DOC
|
|
$X_pdmc_trajectory = 1.d0
|
|
END_PROVIDER
|
|
|
|
"""
|
|
for p in properties:
|
|
if p[1] != 'e_loc':
|
|
if p[2] == "":
|
|
D1 = ""
|
|
D2 = ", (3)"
|
|
D3 = ", (0:pdmc_n_projection_steps)"
|
|
else:
|
|
D1 = ", ("+p[2][1:-1]+")"
|
|
D2 = ", ("+p[2][1:-1]+",3)"
|
|
D3 = ", ("+p[2][1:-1]+",0:pdmc_n_projection_steps)"
|
|
print t.replace("$X",p[1]).replace("$T",p[0]).replace("$D1",D1).replace("$D2",D2).replace("$D3",D3)
|
|
|
|
END_SHELL
|
|
|
|
BEGIN_PROVIDER [ double precision, E_loc_pdmc_trajectory, (0:pdmc_n_projection_steps) ]
|
|
E_loc_pdmc_trajectory = -huge(1.d0)
|
|
END_PROVIDER
|
|
|
|
|
|
BEGIN_PROVIDER [ double precision, E_loc_pdmc_block_walk ]
|
|
&BEGIN_PROVIDER [ double precision, E_loc_2_pdmc_block_walk ]
|
|
&BEGIN_PROVIDER [ double precision, E_loc_pdmc_block_walk_kahan , (3) ]
|
|
&BEGIN_PROVIDER [ double precision, E_loc_2_pdmc_block_walk_kahan, (3) ]
|
|
!&BEGIN_PROVIDER [ double precision, E_loc_vmc_pdmc_block_walk ]
|
|
!&BEGIN_PROVIDER [ double precision, E_loc_2_vmc_pdmc_block_walk ]
|
|
!&BEGIN_PROVIDER [ double precision, E_loc_vmc_pdmc_block_walk_kahan , (3) ]
|
|
!&BEGIN_PROVIDER [ double precision, E_loc_2_vmc_pdmc_block_walk_kahan, (3) ]
|
|
implicit none
|
|
include '../types.F'
|
|
BEGIN_DOC
|
|
! Properties averaged over the block using the PDMC method
|
|
END_DOC
|
|
|
|
integer :: i,j,l
|
|
double precision :: E_loc_save(4)
|
|
!DIR$ ATTRIBUTES ALIGN : $IRP_ALIGN :: E_loc_save
|
|
|
|
calc_pdmc_norm = .True.
|
|
calc_pdmc_norm_nocusp = .True.
|
|
|
|
PROVIDE time_step
|
|
|
|
BEGIN_SHELL [ /usr/bin/env python2 ]
|
|
from properties import *
|
|
t = """
|
|
if (calc_$X) then
|
|
$X_pdmc_block_walk = 0.d0
|
|
$X_pdmc_block_walk_kahan = 0.d0
|
|
$X_2_pdmc_block_walk = 0.d0
|
|
$X_2_pdmc_block_walk_kahan = 0.d0
|
|
! $X_vmc_pdmc_block_walk = 0.d0
|
|
! $X_vmc_pdmc_block_walk_kahan = 0.d0
|
|
! $X_2_vmc_pdmc_block_walk = 0.d0
|
|
! $X_2_vmc_pdmc_block_walk_kahan = 0.d0
|
|
$X_min = huge(1.)
|
|
$X_max =-huge(1.)
|
|
endif
|
|
"""
|
|
for p in properties:
|
|
print t.replace("$X",p[1])
|
|
END_SHELL
|
|
|
|
block_weight = 0.d0
|
|
|
|
! CPU time at the beginning of the block
|
|
! --------------------------------------
|
|
|
|
integer*8 :: cpu0, cpu1, cpu2, count_rate, count_max
|
|
call system_clock(cpu0, count_rate, count_max)
|
|
cpu2 = cpu0
|
|
|
|
|
|
|
|
integer :: istep, istep_t_2
|
|
logical :: loop, first_loop
|
|
first_loop = .True.
|
|
loop = .True.
|
|
|
|
do l=1,3
|
|
do i=1,elec_num+1
|
|
elec_coord(i,l) = elec_coord_full(i,l,1)
|
|
enddo
|
|
enddo
|
|
TOUCH elec_coord
|
|
E_loc_save = E_loc
|
|
|
|
do while (loop)
|
|
|
|
! istep_t_2 = pdmc_n_projection_steps/2
|
|
istep_t_2 = -1
|
|
! istep_t_2 = 0
|
|
|
|
do istep = 0, pdmc_n_projection_steps
|
|
|
|
istep_t_2 = istep_t_2+1
|
|
if (istep_t_2 > pdmc_n_projection_steps) then
|
|
istep_t_2 = 0
|
|
endif
|
|
|
|
! Brownian step
|
|
! -------------
|
|
|
|
double precision :: p,q
|
|
real :: delta_x
|
|
logical :: accepted
|
|
|
|
E_loc_save(4) = E_loc_save(3)
|
|
E_loc_save(3) = E_loc_save(2)
|
|
E_loc_save(2) = E_loc_save(1)
|
|
E_loc_save(1) = E_loc
|
|
call brownian_step(p,q,accepted,delta_x)
|
|
elec_coord(elec_num+1,1) += p*time_step
|
|
elec_coord(elec_num+1,2) = E_loc
|
|
elec_coord(elec_num+1,3) = 1.
|
|
|
|
psi_nocusp_weight_pdmc_trajectory(istep) = psi_nocusp_weight
|
|
|
|
! PDMC weight
|
|
! -----------
|
|
|
|
double precision :: delta, w0, wt, w, w_prod
|
|
|
|
! if ( psi_value * psi_value_save >= 0.d0 ) then
|
|
|
|
!2 delta = (E_loc+E_loc_save(1))*0.5d0
|
|
!3 delta = (5.d0 * E_loc + 8.d0 * E_loc_save(1) - E_loc_save(2))/12.d0
|
|
delta = (9.d0*E_loc+19.d0*E_loc_save(1)-5.d0*E_loc_save(2)+E_loc_save(3))/24.d0
|
|
!5 delta = -((-251.d0*E_loc)-646.d0*E_loc_save(1)+264.d0*E_loc_save(2)-&
|
|
!5 106.d0*E_loc_save(3)+19.d0*E_loc_save(4))/720.d0
|
|
|
|
delta = (delta - E_ref)*p
|
|
if (delta >= 0.d0) then
|
|
pdmc_w = dexp(-dtime_step*delta)
|
|
else
|
|
pdmc_w = 2.d0 - dexp(dtime_step*delta)
|
|
endif
|
|
pdmc_w_pdmc_trajectory(istep) = 1.d0
|
|
w_prod = product(pdmc_w_pdmc_trajectory)
|
|
pdmc_w_pdmc_trajectory(istep) = pdmc_w
|
|
|
|
! Observables
|
|
! -----------
|
|
|
|
double precision :: x, x2
|
|
integer :: jstep
|
|
block_weight += 1.d0
|
|
|
|
BEGIN_SHELL [ /usr/bin/env python2 ]
|
|
from properties import *
|
|
t = """
|
|
|
|
if (calc_$X) then
|
|
|
|
if ($nocusp) then
|
|
wt = psi_nocusp_weight_pdmc_trajectory(istep)
|
|
if (istep /= pdmc_n_projection_steps) then
|
|
jstep = istep + 1
|
|
else
|
|
jstep = 0
|
|
endif
|
|
w0 = psi_nocusp_weight_pdmc_trajectory(jstep)
|
|
else
|
|
w0 = 1.d0
|
|
wt = 1.d0
|
|
endif
|
|
|
|
$X_pdmc_trajectory($D3 istep) = $X
|
|
|
|
|
|
! Kahan's summation algorithm to compute these sums reducing the rounding error:
|
|
! $X_pdmc_block_walk $D1 += x
|
|
! $X_2_pdmc_block_walk $D1 += x_2
|
|
! see http://en.wikipedia.org/wiki/Kahan_summation_algorithm
|
|
|
|
! PDMC observables
|
|
|
|
$X_pdmc_block_walk_kahan($D2 3) = $X_pdmc_trajectory($D3 istep_t_2) * w0 * wt * w_prod - $X_pdmc_block_walk_kahan($D2 1)
|
|
$X_pdmc_block_walk_kahan($D2 2) = $X_pdmc_block_walk $D1 + $X_pdmc_block_walk_kahan($D2 3)
|
|
$X_pdmc_block_walk_kahan($D2 1) = ($X_pdmc_block_walk_kahan($D2 2) - $X_pdmc_block_walk $D1 ) &
|
|
- $X_pdmc_block_walk_kahan($D2 3)
|
|
$X_pdmc_block_walk $D1 = $X_pdmc_block_walk_kahan($D2 2)
|
|
|
|
|
|
$X_2_pdmc_block_walk_kahan($D2 3) = ($X_pdmc_trajectory($D3 istep_t_2) * w0 * wt * w_prod)**2 - $X_2_pdmc_block_walk_kahan($D2 1)
|
|
$X_2_pdmc_block_walk_kahan($D2 2) = $X_2_pdmc_block_walk $D1 + $X_2_pdmc_block_walk_kahan($D2 3)
|
|
$X_2_pdmc_block_walk_kahan($D2 1) = ($X_2_pdmc_block_walk_kahan($D2 2) - $X_2_pdmc_block_walk $D1 ) &
|
|
- $X_2_pdmc_block_walk_kahan($D2 3)
|
|
$X_2_pdmc_block_walk $D1 = $X_2_pdmc_block_walk_kahan($D2 2)
|
|
|
|
|
|
! ! VMC observables
|
|
!
|
|
! $X_vmc_pdmc_block_walk_kahan($D2 3) = $X_pdmc_trajectory($D3 istep_t_2) * wt * wt - $X_vmc_pdmc_block_walk_kahan($D2 1)
|
|
! $X_vmc_pdmc_block_walk_kahan($D2 2) = $X_vmc_pdmc_block_walk $D1 + $X_vmc_pdmc_block_walk_kahan($D2 3)
|
|
! $X_vmc_pdmc_block_walk_kahan($D2 1) = ($X_vmc_pdmc_block_walk_kahan($D2 2) - $X_vmc_pdmc_block_walk $D1 ) &
|
|
! - $X_vmc_pdmc_block_walk_kahan($D2 3)
|
|
! $X_vmc_pdmc_block_walk $D1 = $X_vmc_pdmc_block_walk_kahan($D2 2)
|
|
!
|
|
!
|
|
! $X_2_vmc_pdmc_block_walk_kahan($D2 3) = $X_pdmc_trajectory($D3 istep_t_2)**2 * wt * wt - $X_2_vmc_pdmc_block_walk_kahan($D2 1)
|
|
! $X_2_vmc_pdmc_block_walk_kahan($D2 2) = $X_2_vmc_pdmc_block_walk $D1 + $X_2_vmc_pdmc_block_walk_kahan($D2 3)
|
|
! $X_2_vmc_pdmc_block_walk_kahan($D2 1) = ($X_2_vmc_pdmc_block_walk_kahan($D2 2) - $X_2_vmc_pdmc_block_walk $D1 ) &
|
|
! - $X_2_vmc_pdmc_block_walk_kahan($D2 3)
|
|
! $X_2_vmc_pdmc_block_walk $D1 = $X_2_vmc_pdmc_block_walk_kahan($D2 2)
|
|
endif
|
|
"""
|
|
for p in properties:
|
|
if "vmc_zv" not in p[1]:
|
|
if p[2] == "":
|
|
D1 = ""
|
|
D2 = ""
|
|
D3 = ""
|
|
else:
|
|
D1 = "("+":"*(p[2].count(',')+1)+")"
|
|
D2 = ":"*(p[2].count(',')+1)+","
|
|
D3 = ":"*(p[2].count(',')+1)+","
|
|
if 'nocusp' in p[1]:
|
|
nocusp = '.True.'
|
|
else:
|
|
nocusp = '.False.'
|
|
print t.replace("$X",p[1]).replace("$D1",D1).replace("$D2",D2).replace("$D3",D3).replace("$nocusp",nocusp)
|
|
|
|
END_SHELL
|
|
|
|
BEGIN_SHELL [ /usr/bin/env python2 ]
|
|
from properties import *
|
|
t = """
|
|
|
|
if (calc_$X) then
|
|
|
|
if ($nocusp) then
|
|
wt = psi_nocusp_weight_pdmc_trajectory(istep_t_2)
|
|
else
|
|
wt = 1.d0
|
|
endif
|
|
|
|
$X_pdmc_trajectory($D3 istep) = $X
|
|
|
|
|
|
! Kahan's summation algorithm to compute these sums reducing the rounding error:
|
|
! $X_pdmc_block_walk $D1 += x
|
|
! $X_2_pdmc_block_walk $D1 += x_2
|
|
! see http://en.wikipedia.org/wiki/Kahan_summation_algorithm
|
|
|
|
! PDMC observables
|
|
|
|
$X_pdmc_block_walk_kahan($D2 3) = $X_pdmc_trajectory($D3 istep_t_2) * wt * wt - $X_pdmc_block_walk_kahan($D2 1)
|
|
$X_pdmc_block_walk_kahan($D2 2) = $X_pdmc_block_walk $D1 + $X_pdmc_block_walk_kahan($D2 3)
|
|
$X_pdmc_block_walk_kahan($D2 1) = ($X_pdmc_block_walk_kahan($D2 2) - $X_pdmc_block_walk $D1 ) &
|
|
- $X_pdmc_block_walk_kahan($D2 3)
|
|
$X_pdmc_block_walk $D1 = $X_pdmc_block_walk_kahan($D2 2)
|
|
|
|
|
|
$X_2_pdmc_block_walk_kahan($D2 3) = ($X_pdmc_trajectory($D3 istep_t_2) * wt * wt )**2 - $X_2_pdmc_block_walk_kahan($D2 1)
|
|
$X_2_pdmc_block_walk_kahan($D2 2) = $X_2_pdmc_block_walk $D1 + $X_2_pdmc_block_walk_kahan($D2 3)
|
|
$X_2_pdmc_block_walk_kahan($D2 1) = ($X_2_pdmc_block_walk_kahan($D2 2) - $X_2_pdmc_block_walk $D1 ) &
|
|
- $X_2_pdmc_block_walk_kahan($D2 3)
|
|
$X_2_pdmc_block_walk $D1 = $X_2_pdmc_block_walk_kahan($D2 2)
|
|
|
|
|
|
endif
|
|
"""
|
|
for p in properties:
|
|
if "vmc_zv" in p[1]:
|
|
if p[2] == "":
|
|
D1 = ""
|
|
D2 = ""
|
|
D3 = ""
|
|
else:
|
|
D1 = "("+":"*(p[2].count(',')+1)+")"
|
|
D2 = ":"*(p[2].count(',')+1)+","
|
|
D3 = ":"*(p[2].count(',')+1)+","
|
|
if 'nocusp' in p[1]:
|
|
nocusp = '.True.'
|
|
else:
|
|
nocusp = '.False.'
|
|
print t.replace("$X",p[1]).replace("$D1",D1).replace("$D2",D2).replace("$D3",D3).replace("$nocusp",nocusp)
|
|
|
|
END_SHELL
|
|
|
|
end do ! istep
|
|
|
|
|
|
call system_clock(cpu1, count_rate, count_max)
|
|
if (cpu1 < cpu0) then
|
|
cpu1 = cpu1+cpu0
|
|
endif
|
|
loop = dble(cpu1-cpu0)/dble(count_rate) < block_time
|
|
if (cpu1-cpu2 > count_rate) then
|
|
integer :: do_run
|
|
call get_running(do_run)
|
|
loop = loop.and.(do_run == t_Running)
|
|
cpu2 = cpu1
|
|
endif
|
|
|
|
enddo ! while (loop)
|
|
|
|
do l=1,3
|
|
do i=1,elec_num+1
|
|
elec_coord_full(i,l,1) = elec_coord(i,l)
|
|
enddo
|
|
enddo
|
|
|
|
|
|
double precision :: factor
|
|
factor = 1.d0/block_weight
|
|
|
|
BEGIN_SHELL [ /usr/bin/env python2 ]
|
|
from properties import *
|
|
t = """
|
|
if (calc_$X) then
|
|
$X_pdmc_block_walk *= factor
|
|
$X_2_pdmc_block_walk *= factor
|
|
! $X_vmc_pdmc_block_walk *= factor
|
|
! $X_2_vmc_pdmc_block_walk *= factor
|
|
endif
|
|
"""
|
|
for p in properties:
|
|
# if p[1] in [ "pdmc_norm", "e_loc"]:
|
|
print t.replace("$X",p[1])
|
|
END_SHELL
|
|
|
|
SOFT_TOUCH elec_coord_full block_weight
|
|
|
|
END_PROVIDER
|
|
|
|
|
|
|
|
BEGIN_PROVIDER [ integer, pdmc_n_projection_steps ]
|
|
implicit none
|
|
BEGIN_DOC
|
|
! Number of projection steps for PDMC
|
|
END_DOC
|
|
real :: pdmc_projection_time
|
|
pdmc_projection_time = 1.
|
|
call get_simulation_srmc_projection_time(pdmc_projection_time)
|
|
pdmc_n_projection_steps = int( pdmc_projection_time/time_step) + 1
|
|
END_PROVIDER
|
|
|