mirror of
https://github.com/TREX-CoE/qmc-lttc.git
synced 2024-12-21 11:53:58 +01:00
Working on VMC
This commit is contained in:
parent
277e243545
commit
b6d70add67
278
QMC.org
278
QMC.org
@ -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.
|
||||
|
||||
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
import numpy as np
|
||||
from hydrogen import e_loc, psi
|
||||
|
||||
interval = np.linspace(-5,5,num=50)
|
||||
delta = (interval[1]-interval[0])**3
|
||||
interval = np.linspace(-5,5,num=50)
|
||||
delta = (interval[1]-interval[0])**3
|
||||
|
||||
r = np.array([0.,0.,0.])
|
||||
r = np.array([0.,0.,0.])
|
||||
|
||||
for a in [0.1, 0.2, 0.5, 0.9, 1., 1.5, 2.]:
|
||||
for a in [0.1, 0.2, 0.5, 0.9, 1., 1.5, 2.]:
|
||||
E = 0.
|
||||
norm = 0.
|
||||
for x in interval:
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
from hydrogen import *
|
||||
from qmc_stats import *
|
||||
|
||||
def MonteCarlo(a, nmax):
|
||||
def MonteCarlo(a, nmax):
|
||||
E = 0.
|
||||
N = 0.
|
||||
for istep in range(nmax):
|
||||
@ -12,8 +12,8 @@ from qmc_stats import *
|
||||
E += w * e_loc(a,r)
|
||||
return E/N
|
||||
|
||||
a = 0.9
|
||||
nmax = 100000
|
||||
X = [MonteCarlo(a,nmax) for i in range(30)]
|
||||
E, deltaE = ave_error(X)
|
||||
print(f"E = {E} +/- {deltaE}")
|
||||
a = 0.9
|
||||
nmax = 100000
|
||||
X = [MonteCarlo(a,nmax) for i in range(30)]
|
||||
E, deltaE = ave_error(X)
|
||||
print(f"E = {E} +/- {deltaE}")
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user