TREX/qmc-lttc
1
0
Fork 0
mirror of https://github.com/TREX-CoE/qmc-lttc.git synced 2024-12-21 11:53:58 +01:00
Code Issues Projects Releases Wiki Activity

Working on VMC

Browse Source
This commit is contained in:
Anthony Scemama 2021-01-12 01:01:52 +01:00
parent 277e243545
commit b6d70add67
9 changed files with 453 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

278
QMC.org
View File

@ -90,9 +90,14 @@
:header-args:python: :tangle hydrogen.py
:header-args:f90: :tangle hydrogen.f90
:END:
*** Write a function which computes the potential at $\mathbf{r}$
*** Exercise 1
#+begin_exercise
Write a function which computes the potential at $\mathbf{r}$.
The function accepts a 3-dimensional vector =r= as input arguments
and returns the potential.
#+end_exercise
$\mathbf{r}=\left( \begin{array}{c} x \\ y\\ z\end{array} \right)$, so
$$
@ -117,9 +122,12 @@ double precision function potential(r)
end function potential
#+END_SRC
*** Write a function which computes the wave function at $\mathbf{r}$
*** Exercise 2
#+begin_exercise
Write a function which computes the wave function at $\mathbf{r}$.
The function accepts a scalar =a= and a 3-dimensional vector =r= as
input arguments, and returns a scalar.
#+end_exercise
*Python*
@ -137,9 +145,12 @@ double precision function psi(a, r)
end function psi
#+END_SRC
*** Write a function which computes the local kinetic energy at $\mathbf{r}$
*** Exercise 3
#+begin_exercise
Write a function which computes the local kinetic energy at $\mathbf{r}$.
The function accepts =a= and =r= as input arguments and returns the
local kinetic energy.
#+end_exercise
The local kinetic energy is defined as $$-\frac{1}{2}\frac{\Delta \Psi}{\Psi}.$$
@ -187,9 +198,12 @@ double precision function kinetic(a,r)
end function kinetic
#+END_SRC
*** Write a function which computes the local energy at $\mathbf{r}$
*** Exercise 4
#+begin_exercise
Write a function which computes the local energy at $\mathbf{r}$.
The function accepts =x,y,z= as input arguments and returns the
local energy.
#+end_exercise
$$
E_L(\mathbf{r}) = -\frac{1}{2} \frac{\Delta \Psi}{\Psi} (\mathbf{r}) + V(\mathbf{r})
@ -218,8 +232,12 @@ end function e_loc
:header-args:f90: :tangle plot_hydrogen.f90
:END:
*** Exercise
#+begin_exercise
For multiple values of $a$ (0.1, 0.2, 0.5, 1., 1.5, 2.), plot the
local energy along the $x$ axis.
#+end_exercise
*Python*
#+BEGIN_SRC python :results none
@ -310,7 +328,7 @@ plot './data' index 0 using 1:2 with lines title 'a=0.1', \
#+RESULTS:
[[file:plot.png]]
** Compute numerically the expectation value of the energy
** Numerical estimation of the energy
:PROPERTIES:
:header-args:python: :tangle energy_hydrogen.py
:header-args:f90: :tangle energy_hydrogen.f90
@ -327,16 +345,20 @@ plot './data' index 0 using 1:2 with lines title 'a=0.1', \
w_i = \left[\Psi(\mathbf{r}_i)\right]^2 \delta \mathbf{r}
$$
In this section, we will compute a numerical estimate of the
energy in a grid of $50\times50\times50$ points in the range
$(-5,-5,-5) \le \mathbf{r} \le (5,5,5)$.
#+begin_note
The energy is biased because:
- The volume elements are not infinitely small (discretization error)
- The energy is evaluated only inside the box (incompleteness of the space)
#+end_note
*** Exercise
#+begin_exercise
Compute a numerical estimate of the energy in a grid of
$50\times50\times50$ points in the range $(-5,-5,-5) \le
\mathbf{r} \le (5,5,5)$.
#+end_exercise
*Python*
#+BEGIN_SRC python :results none
import numpy as np
@ -431,7 +453,7 @@ gfortran hydrogen.f90 energy_hydrogen.f90 -o energy_hydrogen
: a = 1.5000000000000000 E = -0.39242967082602065
: a = 2.0000000000000000 E = -8.0869806678448772E-002
** Compute the variance of the local energy
** Variance of the local energy
:PROPERTIES:
:header-args:python: :tangle variance_hydrogen.py
:header-args:f90: :tangle variance_hydrogen.f90
@ -450,8 +472,13 @@ gfortran hydrogen.f90 energy_hydrogen.f90 -o energy_hydrogen
$\hat{H}$) the variance is zero, so the variance of the local
energy can be used as a measure of the quality of a wave function.
*** Exercise
#+begin_exercise
Compute a numerical estimate of the variance of the local energy
in a grid of $50\times50\times50$ points in the range $(-5,-5,-5) \le \mathbf{r} \le (5,5,5)$.
in a grid of $50\times50\times50$ points in the range
$(-5,-5,-5)
\le \mathbf{r} \le (5,5,5)$ for different values of $a$.
#+end_exercise
*Python*
#+begin_src python :results none
@ -617,8 +644,11 @@ gfortran hydrogen.f90 variance_hydrogen.f90 -o variance_hydrogen
E \pm \delta E, \text{ where } \delta E = \frac{\sigma}{\sqrt{M}}
$$
*** Exercise
#+begin_exercise
Write a function returning the average and statistical error of an
input array.
#+end_exercise
*Python*
#+BEGIN_SRC python :results none
@ -656,23 +686,35 @@ end subroutine ave_error
:header-args:f90: :tangle qmc_uniform.f90
:END:
In this section we write a function to perform a Monte Carlo
calculation of the average energy.
We will now do our first Monte Carlo calculation to compute the
energy of the hydrogen atom.
At every Monte Carlo step:
- Draw 3 uniform random numbers in the interval $(-5,-5,-5) \le
- Draw a random point $\mathbf{r}_i$ in the box $(-5,-5,-5) \le
(x,y,z) \le (5,5,5)$
- Compute $\Psi^2 \times E_L$ at this point and accumulate the
result in E
- Compute $\Psi^2$ at this point and accumulate the result in N
- Compute $[\Psi(\mathbf{r}_i)]^2$ and accumulate the result in a
variable =normalization=
- Compute $[\Psi(\mathbf{r}_i)]^2 \times E_L(\mathbf{r}_i)$, and accumulate the
result in a variable =energy=
Once all the steps have been computed, return the average energy
computed on the Monte Carlo calculation.
One Monte Carlo run will consist of $N$ Monte Carlo steps. Once all the
steps have been computed, the run returns the average energy
$\bar{E}_k$ over the $N$ steps of the run.
In the main program, write a loop to perform 30 Monte Carlo runs,
and compute the average energy and the associated statistical error.
To compute the statistical error, perform $M$ runs. The final
estimate of the energy will be the average over the $\bar{E}_k$,
and the variance of the $\bar{E}_k$ will be used to compute the
statistical error.
Compute the energy of the wave function with $a=0.9$.
*** Exercise
#+begin_exercise
Parameterize the wave function with $a=0.9$. Perform 30
independent Monte Carlo runs, each with 100 000 Monte Carlo
steps. Store the final energies of each run and use this array to
compute the average energy and the associated error bar.
#+end_exercise
*Python*
#+BEGIN_SRC python :results output
@ -773,6 +815,9 @@ gfortran hydrogen.f90 qmc_stats.f90 qmc_uniform.f90 -o qmc_uniform
z_2 &=& \sqrt{-2 \ln u_1} \sin(2 \pi u_2)
\end{eqnarray*}
Here is a Fortran implementation returning a Gaussian-distributed
n-dimensional vector $\mathbf{z}$;
*Fortran*
#+BEGIN_SRC f90 :tangle qmc_stats.f90
subroutine random_gauss(z,n)
@ -805,14 +850,16 @@ end subroutine random_gauss
#+END_SRC
Now the equation for the energy is changed into
Now the sampling probability can be inserted into the equation of the energy:
\[
E = \frac{\int P(\mathbf{r}) \frac{\left[\Psi(\mathbf{r})\right]^2}{P(\mathbf{r})}\, \frac{\hat{H} \Psi(\mathbf{r})}{\Psi(\mathbf{r})}\,d\mathbf{r}}{\int P(\mathbf{r}) \frac{\left[\Psi(\mathbf{r}) \right]^2}{P(\mathbf{r})} d\mathbf{r}}
\]
with
with the Gaussian probability
\[
P(\mathbf{r}) = \frac{1}{(2 \pi)^{3/2}}\exp\left( -\frac{\mathbf{r}^2}{2} \right)
P(\mathbf{r}) = \frac{1}{(2 \pi)^{3/2}}\exp\left( -\frac{\mathbf{r}^2}{2} \right).
\]
As the coordinates are drawn with probability $P(\mathbf{r})$, the
@ -823,6 +870,15 @@ end subroutine random_gauss
w_i = \frac{\left[\Psi(\mathbf{r}_i)\right]^2}{P(\mathbf{r}_i)} \delta \mathbf{r}
$$
*** Exercise
#+begin_exercise
Modify the exercise of the previous section to sample with
Gaussian-distributed random numbers. Can you see an reduction in
the statistical error?
#+end_exercise
*Python*
#+BEGIN_SRC python :results output
from hydrogen import *
@ -933,6 +989,9 @@ gfortran hydrogen.f90 qmc_stats.f90 qmc_gaussian.f90 -o qmc_gaussian
E \approx \frac{1}{M}\sum_{i=1}^M E_L(\mathbf{r}_i)
$$
*** Importance sampling
To generate the probability density $\Psi^2$, we consider a
diffusion process characterized by a time-dependent density
$[\Psi(\mathbf{r},t)]^2$, which obeys the Fokker-Planck equation:
@ -994,27 +1053,41 @@ gfortran hydrogen.f90 qmc_stats.f90 qmc_gaussian.f90 -o qmc_gaussian
\Psi(\mathbf{r})}{\Psi(\mathbf{r})} = 2 \nabla \left( \log \Psi(\mathbf{r}) \right)
\]
following drifted diffusion scheme:
In statistical mechanics, Fokker-Planck trajectories are generated
by a Langevin equation:
\[
\mathbf{r}_{n+1} = \mathbf{r}_{n} + \tau \frac{\nabla
\Psi(\mathbf{r})}{\Psi(\mathbf{r})} + \eta \sqrt{\tau}
\frac{\partial \mathbf{r}(t)}{\partial t} = 2D \frac{\nabla
\Psi(\mathbf{r}(t))}{\Psi} + \eta
\]
where $\eta$ is a normally-distributed Gaussian random number.
where $\eta$ is a normally-distributed fluctuating random force.
Discretizing this differential equation gives the following drifted
diffusion scheme:
First, write a function to compute the drift vector $\frac{\nabla \Psi(\mathbf{r})}{\Psi(\mathbf{r})}$.
\[
\mathbf{r}_{n+1} = \mathbf{r}_{n} + \tau\, 2D \frac{\nabla
\Psi(\mathbf{r})}{\Psi(\mathbf{r})} + \chi
\]
where $\chi$ is a Gaussian random variable with zero mean and
variance $\tau\,2D$.
**** Exercise 1
#+begin_exercise
Write a function to compute the drift vector $\frac{\nabla \Psi(\mathbf{r})}{\Psi(\mathbf{r})}$.
#+end_exercise
*Python*
#+BEGIN_SRC python
#+BEGIN_SRC python :tangle hydrogen.py
def drift(a,r):
ar_inv = -a/np.sqrt(np.dot(r,r))
return r * ar_inv
#+END_SRC
*Fortran*
#+BEGIN_SRC f90
#+BEGIN_SRC f90 :tangle hydrogen.f90
subroutine drift(a,r,b)
implicit none
double precision, intent(in) :: a, r(3)
@ -1025,15 +1098,149 @@ subroutine drift(a,r,b)
end subroutine drift
#+END_SRC
**** TODO Exercise 2
Now we can write the Monte Carlo sampling:
#+begin_exercise
Sample $\Psi^2$ approximately using the drifted diffusion scheme,
with a diffusion constant $D=1/2$. You can use a time step of
0.001 a.u.
#+end_exercise
*Python*
#+BEGIN_SRC python :results output :tangle vmc.py
from hydrogen import *
from qmc_stats import *
def MonteCarlo(a,tau,nmax):
E = 0.
N = 0.
sq_tau = np.sqrt(tau)
r_old = np.random.normal(loc=0., scale=1.0, size=(3))
d_old = drift(a,r_old)
d2_old = np.dot(d_old,d_old)
psi_old = psi(a,r_old)
for istep in range(nmax):
chi = np.random.normal(loc=0., scale=1.0, size=(3))
r_new = r_old + tau * d_old + sq_tau * chi
N += 1.
E += e_loc(a,r_new)
r_old = r_new
return E/N
a = 0.9
nmax = 100000
tau = 0.001
X = [MonteCarlo(a,tau,nmax) for i in range(30)]
E, deltaE = ave_error(X)
print(f"E = {E} +/- {deltaE}")
#+END_SRC
#+RESULTS:
: E = -0.4112049153828464 +/- 0.00027934927432953063
*Fortran*
#+BEGIN_SRC f90
subroutine variational_montecarlo(a,nmax,energy)
implicit none
double precision, intent(in) :: a
integer , intent(in) :: nmax
double precision, intent(out) :: energy
integer*8 :: istep
double precision :: norm, r(3), w
double precision, external :: e_loc, psi, gaussian
energy = 0.d0
norm = 0.d0
do istep = 1,nmax
call random_gauss(r,3)
w = psi(a,r)
w = w*w / gaussian(r)
norm = norm + w
energy = energy + w * e_loc(a,r)
end do
energy = energy / norm
end subroutine variational_montecarlo
program qmc
implicit none
double precision, parameter :: a = 0.9
integer , parameter :: nmax = 100000
integer , parameter :: nruns = 30
integer :: irun
double precision :: X(nruns)
double precision :: ave, err
do irun=1,nruns
call gaussian_montecarlo(a,nmax,X(irun))
enddo
call ave_error(X,nruns,ave,err)
print *, 'E = ', ave, '+/-', err
end program qmc
#+END_SRC
#+begin_src sh :results output :exports both
gfortran hydrogen.f90 qmc_stats.f90 vmc.f90 -o vmc
./vmc
#+end_src
*** Metropolis algorithm
Discretizing the differential equation to generate the desired
probability density will suffer from a discretization error
leading to biases in the averages. The [[https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm][Metropolis-Hastings
sampling algorithm]] removes exactly the discretization errors, so
large time steps can be employed.
After the new position $\mathbf{r}_{n+1}$ has been computed, an
additional accept/reject step is performed. The acceptance
probability $A$ is chosen so that it is consistent with the
probability of leaving $\mathbf{r}_n$ and the probability of
entering $\mathbf{r}_{n+1}$:
\[ A(\mathbf{r}_{n} \rightarrow \mathbf{r}_{n+1}) = \min \left( 1,
\frac{g(\mathbf{r}_{n+1} \rightarrow \mathbf{r}_{n}) P(\mathbf{r}_{n+1})}
{g(\mathbf{r}_{n} \rightarrow \mathbf{r}_{n+1}) P(\mathbf{r}_{n})}
\right)
\]
In our Hydrogen atom example, $P$ is $\Psi^2$ and $g$ is a
solution of the discretized Fokker-Planck equation:
\begin{eqnarray*}
P(r_{n}) &=& \Psi^2(\mathbf{r}_n) \\
g(\mathbf{r}_{n} \rightarrow \mathbf{r}_{n+1}) & = &
\frac{1}{(4\pi\,D\,\tau)^{3/2}} \exp \left[ - \frac{\left(
\mathbf{r}_{n+1} - \mathbf{r}_{n} - 2D \frac{\nabla
\Psi(\mathbf{r}_n)}{\Psi(\mathbf{r}_n)} \right)^2}{4D\,\tau} \right]
\end{eqnarray*}
The accept/reject step is the following:
- Compute $A(\mathbf{r}_{n} \rightarrow \mathbf{r}_{n+1})$.
- Draw a uniform random number $u$
- if $u \le A(\mathbf{r}_{n} \rightarrow \mathbf{r}_{n+1})$, accept
the move
- if $u>A(\mathbf{r}_{n} \rightarrow \mathbf{r}_{n+1})$, reject
the move: set $\mathbf{r}_{n+1} = \mathbf{r}_{n}$, but *don't
remove the sample from the average!*
**** TODO Exercise
#+begin_exercise
Modify the previous program to introduce the accept/reject step.
You should recover the unbiased result.
#+end_exercise
*Python*
#+BEGIN_SRC python
def MonteCarlo(a,tau,nmax):
E = 0.
N = 0.
sq_tau = sqrt(tau)
sq_tau = np.sqrt(tau)
r_old = np.random.normal(loc=0., scale=1.0, size=(3))
d_old = drift(a,r_old)
d2_old = np.dot(d_old,d_old)
@ -1119,7 +1326,7 @@ gfortran hydrogen.f90 qmc_stats.f90 vmc.f90 -o vmc
#+end_src
* Diffusion Monte Carlo
* TODO Diffusion Monte Carlo
We will now consider the H_2 molecule in a minimal basis composed of the
$1s$ orbitals of the hydrogen atoms:
@ -1133,3 +1340,4 @@ gfortran hydrogen.f90 qmc_stats.f90 vmc.f90 -o vmc
the nuclei.

1
energy_hydrogen.f90
View File

@ -26,7 +26,6 @@ program energy_hydrogen
r(3) = x(l)
w = psi(a(j),r)
w = w * w * delta
energy = energy + w * e_loc(a(j), r)
norm = norm + w
end do

9
hydrogen.f90
View File

@ -23,3 +23,12 @@ double precision function e_loc(a,r)
double precision, external :: kinetic, potential
e_loc = kinetic(a,r) + potential(r)
end function e_loc
subroutine drift(a,r,b)
implicit none
double precision, intent(in) :: a, r(3)
double precision, intent(out) :: b(3)
double precision :: ar_inv
ar_inv = -a / dsqrt(r(1)*r(1) + r(2)*r(2) + r(3)*r(3))
b(:) = r(:) * ar_inv
end subroutine drift

4
hydrogen.py
View File

@ -11,3 +11,7 @@ def kinetic(a,r):
def e_loc(a,r):
return kinetic(a,r) + potential(r)
def drift(a,r):
ar_inv = -a/np.sqrt(np.dot(r,r))
return r * ar_inv

2
variance_hydrogen.f90
View File

@ -26,7 +26,6 @@ program variance_hydrogen
r(3) = x(l)
w = psi(a(j),r)
w = w * w * delta
energy = energy + w * e_loc(a(j), r)
norm = norm + w
end do
@ -44,7 +43,6 @@ program variance_hydrogen
r(3) = x(l)
w = psi(a(j),r)
w = w * w * delta
s2 = s2 + w * ( e_loc(a(j), r) - energy )**2
norm = norm + w
end do

4
worg.css
View File

@ -306,6 +306,10 @@
/* font-lock-warning-face */
background-color: #e3e3f7;
}
.exercise {
/* font-lock-warning-face */
background-color: #e3f7e3;
}
.note {
/* font-lock-warning-face */
background-color: #f7f7d9;