diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml
new file mode 100644
index 00000000..65635939
--- /dev/null
+++ b/.github/workflows/draft-pdf.yml
@@ -0,0 +1,23 @@
+on: [push]
+
+jobs:
+  paper:
+    runs-on: ubuntu-latest
+    name: Paper Draft
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Build draft PDF
+        uses: openjournals/openjournals-draft-action@master
+        with:
+          journal: joss
+          # This should be the path to the paper within your repo.
+          paper-path: paper/paper.md
+      - name: Upload
+        uses: actions/upload-artifact@v1
+        with:
+          name: paper
+          # This is the output path where Pandoc will write the compiled
+          # PDF. Note, this should be the same directory as the input
+          # paper.md
+          path: paper/paper.pdf
\ No newline at end of file
diff --git a/bin/qmctorch b/bin/qmctorch
index 843c9e9f..15c440e7 100755
--- a/bin/qmctorch
+++ b/bin/qmctorch
@@ -3,7 +3,7 @@ import os
 import argparse
 
 
-dist_solvers = ['SolverSlaterJastrowHorovod']
+dist_solvers = ['SolverMPI']
 
 
 def check_file(fname):
diff --git a/docs/conf.py b/docs/conf.py
index 78d95391..f9cac9b1 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -105,7 +105,8 @@
     'sphinx.ext.mathjax',
     'sphinx.ext.ifconfig',
     'sphinx.ext.napoleon',
-    'sphinx.ext.viewcode'
+    'sphinx.ext.viewcode',
+    'nbsphinx'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -139,7 +140,7 @@
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -165,7 +166,7 @@
 #     html_theme = 'classic'
 
 html_theme = 'sphinx_rtd_theme'
-html_logo = "qmctorch_white.png"
+html_logo = "./pics/qmctorch_white.png"
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -261,3 +262,4 @@
 
 autoclass_content = 'init'
 autodoc_member_order = 'bysource'
+nbsphinx_allow_errors = True
\ No newline at end of file
diff --git a/example/backflow/backflow.py b/docs/example/backflow/backflow.py
similarity index 100%
rename from example/backflow/backflow.py
rename to docs/example/backflow/backflow.py
diff --git a/docs/example/colab/google_collab.ipynb b/docs/example/colab/google_collab.ipynb
new file mode 100644
index 00000000..56027427
--- /dev/null
+++ b/docs/example/colab/google_collab.ipynb
@@ -0,0 +1 @@
+{"cells":[{"attachments":{},"cell_type":"markdown","metadata":{"colab_type":"text","id":"PA9WOB4zJfCu"},"source":["# Installation on Google Collab\n","To install `QMCTorch` copy the code from one of the 3 text cells below in a code cell and run that cell. "]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"6KLOhN_dGQ11"},"source":["## Install QMCTorch from Pypi Package manager\n","\n","```\n","! pip install qmctorch\n","```\n","\n"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"Eb9wI3eOGfz1"},"source":["## Install QMCTorch from GitHub\n","```\n","from google.colab import drive\n","drive.mount('/content/gdrive')\n","% cd gdrive/My Drive/\n","! git clone https://github.com/NLESC-JCER/QMCTorch\n","% cd QMCTorch\n","! pip install -e .\n","% cd ../\n","```"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"_VNw5sAeHC7M"},"source":["## Pull latest code from Github\n","```\n","from google.colab import drive\n","drive.mount('/content/gdrive')\n","% cd gdrive/My Drive/QMCTorch\n","! git pull origin master\n","! pip install -e .\n","% cd ../\n","```"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":671},"colab_type":"code","executionInfo":{"elapsed":9770,"status":"ok","timestamp":1588617088336,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"},"user_tz":-120},"id":"khGd1-ewHZWF","outputId":"674fbe9e-7817-4e11-cc91-cd508bda8107","vscode":{"languageId":"python"}},"outputs":[],"source":["# from google.colab import drive\n","# drive.mount('/content/gdrive')\n","# % cd gdrive/My Drive/QMCTorch\n","# ! git pull origin master\n","# ! pip install -e .\n","# % cd .."]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"MGNu_L-OJ-7u"},"source":["# Using QMCTorch"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":52},"colab_type":"code","executionInfo":{"elapsed":11632,"status":"ok","timestamp":1588617090211,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"},"user_tz":-120},"id":"p7qEQTV2HB4h","outputId":"52c2bbce-3775-442c-95de-d18bd432c2e3","vscode":{"languageId":"python"}},"outputs":[],"source":["import torch\n","from torch import optim\n","from qmctorch.scf import Molecule\n","from qmctorch.wavefunction import SlaterJastrow\n","from qmctorch.solver import Solver\n","from qmctorch.sampler import Metropolis\n","from qmctorch.utils import set_torch_double_precision\n","from qmctorch.utils import plot_energy, plot_data"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"x-s06JyaHUdN","vscode":{"languageId":"python"}},"outputs":[],"source":["use_gpu = torch.cuda.is_available()\n","set_torch_double_precision()"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":52},"colab_type":"code","executionInfo":{"elapsed":11608,"status":"ok","timestamp":1588617090213,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"},"user_tz":-120},"id":"7HO4cNaAID-F","outputId":"a1f652aa-9bcb-4e9b-c038-833b29da2eae","vscode":{"languageId":"python"}},"outputs":[],"source":["mol = Molecule(atom='H 0 0 0.69; H 0 0 -0.69', unit='bohr', \\\n","               calculator='pyscf', basis='sto-3g')"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"hFZg-XanIOeY","vscode":{"languageId":"python"}},"outputs":[],"source":["wf = SlaterJastrow(mol, configs='cas(2,2)', cuda=use_gpu)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"Mqlk1N3tIVXN","vscode":{"languageId":"python"}},"outputs":[],"source":["sampler = Metropolis(nwalkers=2000, nstep=2000, step_size=0.2, \\\n","                     ntherm=-1, ndecor=100, nelec=wf.nelec, \\\n","                     init=mol.domain('atomic'), \\\n","                     move={'type':'all-elec', 'proba':'normal'},\n","                     cuda=use_gpu)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"5-I7abLxI5qG","vscode":{"languageId":"python"}},"outputs":[],"source":["lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},\n","           {'params': wf.ao.parameters(), 'lr': 1E-6},\n","           {'params': wf.mo.parameters(), 'lr': 1E-3},\n","           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n","opt = optim.Adam(lr_dict, lr=1E-3)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"xgXSp8JwJIr9","vscode":{"languageId":"python"}},"outputs":[],"source":["scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"g6TE--nNJL1H","vscode":{"languageId":"python"}},"outputs":[],"source":["solver = Solver(wf=wf, sampler=sampler,\n","                       optimizer=opt, scheduler=scheduler)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":87},"colab_type":"code","executionInfo":{"elapsed":26805,"status":"ok","timestamp":1588617105475,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"},"user_tz":-120},"id":"Y5MPLiv2JTCy","outputId":"ef067f86-11b3-48e0-9dac-dc8ff5784905","vscode":{"languageId":"python"}},"outputs":[],"source":["# obs = solver.single_point()"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"yfx4g1Luz9Z-","vscode":{"languageId":"python"}},"outputs":[],"source":["# solver.configure(freeze=['ao', 'mo'], loss='energy', grad='manual')\n","# solver.track_observable(['local_energy'])\n","\n","# solver.configure_resampling(mode='update',\n","#                             resample_every=1,\n","#                             nstep_update=50)\n","# solver.ortho_mo = False"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"colab_type":"code","executionInfo":{"elapsed":52595,"status":"ok","timestamp":1588617131289,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"},"user_tz":-120},"id":"VtrVSk620A1A","outputId":"32ad9904-40e5-4efa-bcee-27145e04cfd4","vscode":{"languageId":"python"}},"outputs":[],"source":["# obs = solver.run(50)"]}],"metadata":{"accelerator":"GPU","colab":{"authorship_tag":"ABX9TyMr6DKmNBGlyg+0pzpuupgz","name":"qmctorch.ipynb","provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"}},"nbformat":4,"nbformat_minor":0}
diff --git a/docs/example/example_gpu.rst b/docs/example/example_gpu.rst
deleted file mode 100644
index 2c9d5eec..00000000
--- a/docs/example/example_gpu.rst
+++ /dev/null
@@ -1,4 +0,0 @@
-GPU support
-==============================================
-
-.. literalinclude:: ../../example/gpu/h2.py
\ No newline at end of file
diff --git a/docs/example/example_horovod.rst b/docs/example/example_horovod.rst
deleted file mode 100644
index 9f0853cf..00000000
--- a/docs/example/example_horovod.rst
+++ /dev/null
@@ -1,4 +0,0 @@
-Multi-GPU support
-==============================================
-
-.. literalinclude:: ../../example/horovod/h2.py
\ No newline at end of file
diff --git a/docs/example/example_opt.rst b/docs/example/example_opt.rst
deleted file mode 100644
index d21ab59d..00000000
--- a/docs/example/example_opt.rst
+++ /dev/null
@@ -1,4 +0,0 @@
-Wave function optimization
-==============================================
-
-.. literalinclude:: ../../example/optimization/h2.py
\ No newline at end of file
diff --git a/docs/example/example_sp.rst b/docs/example/example_sp.rst
deleted file mode 100644
index 4dd20904..00000000
--- a/docs/example/example_sp.rst
+++ /dev/null
@@ -1,4 +0,0 @@
-Single point calculation
-==============================================
-
-.. literalinclude:: ../../example/single_point/h2o_sampling.py
\ No newline at end of file
diff --git a/example/gpu/h2.py b/docs/example/gpu/h2.py
similarity index 95%
rename from example/gpu/h2.py
rename to docs/example/gpu/h2.py
index 1ded350d..ead8d048 100644
--- a/example/gpu/h2.py
+++ b/docs/example/gpu/h2.py
@@ -2,7 +2,7 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.utils import (plot_energy, plot_data)
@@ -45,7 +45,7 @@
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # QMC solver
-solver = SolverSlaterJastrow(wf=wf, sampler=sampler,
+solver = Solver(wf=wf, sampler=sampler,
                              optimizer=opt, scheduler=None)
 
 # perform a single point calculation
diff --git a/example/horovod/h2.py b/docs/example/horovod/h2.py
similarity index 91%
rename from example/horovod/h2.py
rename to docs/example/horovod/h2.py
index 2b5ccb1b..69eba976 100644
--- a/example/horovod/h2.py
+++ b/docs/example/horovod/h2.py
@@ -4,7 +4,7 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.solver import SolverSlaterJastrowHorovod
+from qmctorch.solver import SolverMPI
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.utils import (plot_energy, plot_data)
@@ -15,7 +15,8 @@
 # bond dissociation energy 4.478 eV -> 0.16 hartree
 
 hvd.init()
-if torch.cuda.is_available():
+use_cuda = torch.cuda.is_available()
+if use_cuda:
     torch.cuda.set_device(hvd.rank())
 
 set_torch_double_precision()
@@ -29,14 +30,15 @@
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
                    configs='cas(2,2)',
-                   cuda=False)
+                   cuda=use_cuda)
 
 # sampler
 sampler = Metropolis(nwalkers=200,
                      nstep=200, step_size=0.2,
                      ntherm=-1, ndecor=100,
                      nelec=wf.nelec, init=mol.domain('atomic'),
-                     move={'type': 'all-elec', 'proba': 'normal'})
+                     move={'type': 'all-elec', 'proba': 'normal'},
+                     cuda=use_cuda)
 
 
 # optimizer
@@ -50,7 +52,7 @@
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # QMC solver
-solver = SolverSlaterJastrowHorovod(wf=wf, sampler=sampler,
+solver = SolverMPI(wf=wf, sampler=sampler,
                                     optimizer=opt, scheduler=scheduler,
                                     rank=hvd.rank())
 
diff --git a/example/optimization/h2.py b/docs/example/optimization/h2.py
similarity index 61%
rename from example/optimization/h2.py
rename to docs/example/optimization/h2.py
index e6dfc44b..7ff7e7da 100644
--- a/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -3,8 +3,8 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.solver import SolverSlaterJastrow
-from qmctorch.sampler import Metropolis, Hamiltonian
+from qmctorch.solver import Solver
+from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.utils import (plot_energy, plot_data)
 
@@ -26,43 +26,43 @@
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
                    configs='single_double(2,2)',
-                   jastrow_kernel=PadeJastrowKernel)
+                   jastrow_kernel=PadeJastrowKernel).gto2sto()
 
 # sampler
-sampler = Hamiltonian(nwalkers=100, nstep=100, nelec=wf.nelec,
-                      step_size=0.1, L=30,
-                      ntherm=-1, ndecor=10,
-                      init=mol.domain('atomic'))
-
+sampler = Metropolis(nwalkers=5000,
+                     nstep=200, step_size=0.2,
+                     ntherm=-1, ndecor=100,
+                     nelec=wf.nelec, init=mol.domain('atomic'),
+                     move={'type': 'all-elec', 'proba': 'normal'})
 
 # optimizer
-lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},
            {'params': wf.ao.parameters(), 'lr': 1E-6},
-           {'params': wf.mo.parameters(), 'lr': 1E-3},
+           {'params': wf.mo.parameters(), 'lr': 2E-3},
            {'params': wf.fc.parameters(), 'lr': 2E-3}]
 opt = optim.Adam(lr_dict, lr=1E-3)
 
 # scheduler
-scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
+scheduler = optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.90)
 
 # QMC solver
-solver = SolverSlaterJastrow(wf=wf, sampler=sampler,
+solver = Solver(wf=wf, sampler=sampler,
                              optimizer=opt, scheduler=None)
 
 # perform a single point calculation
 obs = solver.single_point()
 
 # configure the solver
-solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
-                 loss='energy', grad='auto',
+solver.configure(track=['local_energy', 'parameters'], freeze=['ao'],
+                 loss='energy', grad='manual',
                  ortho_mo=False, clip_loss=False,
                  resampling={'mode': 'update',
                              'resample_every': 1,
-                             'nstep_update': 50})
+                             'nstep_update': 25})
 
 # optimize the wave function
-obs = solver.run(250)
+obs = solver.run(50)
 
 # plot
 plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-plot_data(solver.observable, obsname='jastrow.weight')
+plot_data(solver.observable, obsname='jastrow.jastrow_kernel.weight')
diff --git a/docs/example/scf/scf.py b/docs/example/scf/scf.py
new file mode 100644
index 00000000..a609f866
--- /dev/null
+++ b/docs/example/scf/scf.py
@@ -0,0 +1,23 @@
+from qmctorch.scf import Molecule
+
+# Select the SCF calculator
+calc = ['pyscf',            # pyscf  
+        'adf',          # adf 2019 
+        'adf2019'               # adf 2020+
+    ][1]
+
+# select an appropriate basis
+basis = {
+    'pyscf'  : 'sto-6g',
+    'adf'    : 'VB1',
+    'adf2019': 'dz'
+}[calc]
+
+# do the scf calculation
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+            calculator=calc,
+            basis=basis,
+            unit='bohr')
+
+
+
diff --git a/example/single_point/h2o_sampling.py b/docs/example/single_point/h2o_sampling.py
similarity index 84%
rename from example/single_point/h2o_sampling.py
rename to docs/example/single_point/h2o_sampling.py
index 46a1cdeb..35b56d58 100644
--- a/example/single_point/h2o_sampling.py
+++ b/docs/example/single_point/h2o_sampling.py
@@ -1,7 +1,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.utils import plot_walkers_traj
 
 # define the molecule
@@ -16,10 +16,10 @@
 sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,
                      nelec=wf.nelec, ndim=wf.ndim,
                      init=mol.domain('atomic'),
-                     move={'type': 'one-elec', 'proba': 'normal'})
+                     move={'type': 'all-elec', 'proba': 'normal'})
 
 # solver
-solver = SolverSlaterJastrow(wf=wf, sampler=sampler)
+solver = Solver(wf=wf, sampler=sampler)
 
 # single point
 obs = solver.single_point()
diff --git a/example/single_point/water.xyz b/docs/example/single_point/water.xyz
similarity index 100%
rename from example/single_point/water.xyz
rename to docs/example/single_point/water.xyz
diff --git a/docs/index.rst b/docs/index.rst
index bbcc06b6..496b8ea3 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -10,35 +10,30 @@ Quantum Monte Carlo with Pytorch
    :maxdepth: 1
    :caption: QMCTorch
 
-   intro
-   qmc
-   qmctorch/molecule
-   qmctorch/wavefunction
-   qmctorch/sampler
-   qmctorch/optimizer
-   qmctorch/solver
+   rst/install
+   rst/qmc
+   rst/qmctorch
+   rst/hdf5
 
 .. toctree::
    :maxdepth: 1
    :caption: Tutorial
 
-   tutorial/tutorial_sampling_traj
-   tutorial/tutorial_correlation
-   tutorial/tutorial_wf_opt
-   tutorial/tutorial_jastrow
-   tutorial/tutorial_backflow
-   # tutorial/tutorial_geo_opt
-   tutorial/tutorial_gpus
-   tutorial/tutorial_hdf5
+   notebooks/molecule
+   notebooks/sampling
+   notebooks/wfopt 
+   notebooks/geoopt 
+   notebooks/gpu
 
 .. toctree::
    :maxdepth: 1
-   :caption: Examples
+   :caption: Advanced Tutorial
+
+   notebooks/correlation
+   notebooks/create_jastrow
+   notebooks/create_backflow
+   notebooks/horovod
 
-   example/example_sp
-   example/example_opt
-   example/example_gpu
-   example/example_horovod
 
 .. toctree::
    :maxdepth: 1
diff --git a/docs/notebooks/correlation.ipynb b/docs/notebooks/correlation.ipynb
new file mode 100644
index 00000000..ef68e3c8
--- /dev/null
+++ b/docs/notebooks/correlation.ipynb
@@ -0,0 +1,334 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Correlation and Blocking\n",
+    "\n",
+    "One important part of the sampling is to estimate the correlation between the different sampling points.\n",
+    "To this end let's import the following modules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.sampler import Metropolis\n",
+    "from qmctorch.solver import Solver\n",
+    "from qmctorch.utils import set_torch_double_precision\n",
+    "from qmctorch.utils import blocking, plot_blocking_energy\n",
+    "from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up the system\n",
+    "\n",
+    "Let's create a simple H2 molecule and a Slater Jastrow wave fuction to demonstrate the correlation properties of the sampling"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "set_torch_double_precision()\n",
+    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 2\n",
+      "INFO:QMCTorch|  Configurations      : ground_state\n",
+      "INFO:QMCTorch|  Number of confs     : 1\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 18\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "wf = SlaterJastrow(mol, configs='ground_state')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also define a simple Metropolis sampler:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 100\n",
+      "INFO:QMCTorch|  Number of steps     : 500\n",
+      "INFO:QMCTorch|  Step size           : 0.25\n",
+      "INFO:QMCTorch|  Thermalization steps: 0\n",
+      "INFO:QMCTorch|  Decorelation steps  : 1\n",
+      "INFO:QMCTorch|  Walkers init pos    : normal\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                    nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                    init=mol.domain('normal'),\n",
+    "                    ntherm=0, ndecor=1,\n",
+    "                    move={'type': 'all-elec', 'proba': 'normal'})"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "note that by setting `nthemr=0` and `ndecor=1`, we record all the walker positions along the trajectory. \n",
+    "\n",
+    "We can then define the solver:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n"
+     ]
+    }
+   ],
+   "source": [
+    "solver = Solver(wf=wf, sampler=sampler)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Correlation coefficient\n",
+    "\n",
+    "The simplest way to estimate the decorelation time is to compute the autocorrelation coefficient of the local energy. To this end we must first record the sampling trajectory, i.e. the values of the local energies along the path of the walkers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [00:46<00:00, 10.68it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|   Acceptance rate     : 62.55 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 10.68 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 46.83 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Sampling trajectory\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Energy  : 100%|██████████| 500/500 [01:43<00:00,  4.85it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "pos = solver.sampler(solver.wf.pdf)\n",
+    "obs = solver.sampling_traj(pos)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then plot the correlation coefficient with:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rho, tau = plot_correlation_coefficient(obs.local_energy)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On this picture is represented the autocorrelation coefficient of the local energy of all the walkers (transparent colorful line)\n",
+    "and the average of the autocorrelation coefficient (thick black line). This mean value is fitted with an exponential decay\n",
+    "to obtain the autocorrelation time that is here equal to 1.79 MCs.\n",
+    "\n",
+    "## Integrated autocorrelation time\n",
+    "\n",
+    "Another way to estimate the correlation time is to compute the integrated autocorrelation time. This can be done with"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_integrated_autocorrelation_time(obs.local_energy)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A conservative estimate of the correlation time can be obtain when the iac cross the dashed line, leading here to a value of about 20 steps.\n",
+    "\n",
+    "## Energy blocking\n",
+    "\n",
+    "It is also common practice to use blocking of the local energy values to reduce the variance. This can easily be done with"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "eb = plot_blocking_energy(obs.local_energy, block_size=100, walkers='mean')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That shows the raw and blocked values of the mean local energy values."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
new file mode 100644
index 00000000..cd993268
--- /dev/null
+++ b/docs/notebooks/create_backflow.ipynb
@@ -0,0 +1,168 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Creating your own Backflow transformation\n",
+    "\n",
+    "We present here how to create your own backflow transformation and use it in QMCTorch.\n",
+    "During the import you must import the base class of the backflow kernel. We aso create a H2 molecule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrowBackFlow\n",
+    "from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase\n",
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then use this base class to create a new backflow transformation kernel.\n",
+    "This is done in the same way one would create a new neural network layer in pytorch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torch import nn \n",
+    "class MyBackflow(BackFlowKernelBase):\n",
+    "    def __init__(self, mol, cuda, size=16):\n",
+    "        super().__init__(mol, cuda)\n",
+    "        self.fc1 = nn.Linear(1, size, bias=False)\n",
+    "        self.fc2 = nn.Linear(size, 1, bias=False)\n",
+    "    def forward(self, x):\n",
+    "        original_shape = x.shape\n",
+    "        x = x.reshape(-1,1)\n",
+    "        x = self.fc2(self.fc1(x))\n",
+    "        return x.reshape(*original_shape)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This backflow transformation consists of two fully connected layers. The calculation of the first and second derivative are then done via automatic differentiation\n",
+    "as implemented in the `BackFlowKernelBase` class. To use this new kernel in the `SlaterJastrowBackFlow` wave function ansatz we simply pass the class name as argument of the `backflow_kernel` keyword argument :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 2\n",
+      "INFO:QMCTorch|  Configurations      : ground_state\n",
+      "INFO:QMCTorch|  Number of confs     : 1\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 146\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "wf = SlaterJastrowBackFlow(mol, \n",
+    "                   backflow_kernel=MyBackflow,\n",
+    "                   backflow_kernel_kwargs={'size' : 64})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([[0.1134],\n",
+      "        [0.1509],\n",
+      "        [0.1096],\n",
+      "        [0.1093],\n",
+      "        [0.2632],\n",
+      "        [0.1523],\n",
+      "        [0.1253],\n",
+      "        [0.1424],\n",
+      "        [0.1324],\n",
+      "        [0.0665]], grad_fn=<MulBackward0>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "pos = torch.rand(10, wf.nelec*3)\n",
+    "print(wf(pos))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/create_jastrow.ipynb b/docs/notebooks/create_jastrow.ipynb
new file mode 100644
index 00000000..20216768
--- /dev/null
+++ b/docs/notebooks/create_jastrow.ipynb
@@ -0,0 +1,166 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Creating your own Jastrow Factor\n",
+    "\n",
+    "We present here how to create your own electron-electron Jastrow factor and use it in QMCTorch.\n",
+    "During the import you must import the base class of the electron-electron Jastrow. We aso create a H2 molecule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import JastrowKernelElectronElectronBase\n",
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then use this base class to create a new Jastrow Factor. This is done in the same way one would create\n",
+    "a new neural network layer in pytorch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torch import nn \n",
+    "class MyJastrow(JastrowKernelElectronElectronBase):\n",
+    "    def __init__(self, nup, ndown, cuda, size=16):\n",
+    "        super().__init__(nup, ndown, cuda)\n",
+    "        self.fc1 = nn.Linear(1, size, bias=False)\n",
+    "        self.fc2 = nn.Linear(size, 1, bias=False)\n",
+    "    def forward(self, x):\n",
+    "        nbatch, npair = x.shape\n",
+    "        x = x.reshape(-1,1)\n",
+    "        x = self.fc2(self.fc1(x))\n",
+    "        return x.reshape(nbatch, npair)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As seen above the prototype of the class constructor must be: \n",
+    "\n",
+    "`def __init__(self, nup, ndown, cuda, **kwargs)`\n",
+    "\n",
+    "The list of keyword argument can contain any pairs such as ``size=16``.\n",
+    "\n",
+    "\n",
+    "This Jastrow use two fully connected layers. The size of the hidden layer is here controlled by a keyword argument ``size`` whose defauilt value is 16\n",
+    "It is important to note that the calculation of the first and second derivative of the jastrow kernel wrt the electronic positions are then done via automatic differentiation\n",
+    "as implemented in the `JastrowKernelElectronElectronBase` class. Hence there is no need to derive and implement these derivatives. However it\n",
+    "is necessary that the ``forward`` function, which takes as input a ``torch.tensor`` of\n",
+    "dimension ``[Nbatch, Npair]`` first reshape this tensor to ``[Nbatch*Npair,1]``, then applies the transformation on this tensor and finally reshape\n",
+    "the output tensor to ``[Nbatch, Npair]``.\n",
+    "\n",
+    "To use this new Jastrow in the `SlaterJastrow` wave function ansatz we simply pass the class name as argument of the `jastrow_kernel` keyword argument. It is also\n",
+    "possible to specify the values of the keyword argument ``size`` with the ``jastrow_kernel_kwargs``. As seen below the pair of keyword argument and its value is passed as\n",
+    "a python dictionary :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : MyJastrow\n",
+      "INFO:QMCTorch|  Highest MO included : 2\n",
+      "INFO:QMCTorch|  Configurations      : ground_state\n",
+      "INFO:QMCTorch|  Number of confs     : 1\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 145\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "wf = SlaterJastrow(mol, jastrow_kernel=MyJastrow, jastrow_kernel_kwargs={'size' : 64})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/geoopt.ipynb b/docs/notebooks/geoopt.ipynb
new file mode 100644
index 00000000..eb7287e9
--- /dev/null
+++ b/docs/notebooks/geoopt.ipynb
@@ -0,0 +1,533 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Geometry Optimization\n",
+    "\n",
+    "We present here a complete example on how to use QMCTorch to optimize the geometry of a H2 molecule.\n",
+    "As previously the firs task is to import all the modules needed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  ____    __  ______________             _\n",
+      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
+      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
+      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
+     ]
+    }
+   ],
+   "source": [
+    "from torch import optim\n",
+    "from torch.optim import Adam\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.solver import Solver\n",
+    "from qmctorch.sampler import Metropolis\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.utils import plot_energy\n",
+    "from qmctorch.utils import set_torch_double_precision\n",
+    "set_torch_double_precision()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then define the molecule. We create a H2 molecule with a short atomic distance that we will then try to relax\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "mol = Molecule(atom = 'H 0. 0. -0.5; H 0. 0. 0.5', unit='bohr', \n",
+    "               calculator='pyscf', basis='sto-3g', redo_scf=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As for the wave function optimization example we need to define a wave function, a sampler an optimizer and a solver."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 2\n",
+      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
+      "INFO:QMCTorch|  Number of confs     : 4\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 21\n",
+      "INFO:QMCTorch|  Cuda support        : False\n",
+      "INFO:QMCTorch|  Fit GTOs to STOs  : \n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 2\n",
+      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
+      "INFO:QMCTorch|  Number of confs     : 4\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 17\n",
+      "INFO:QMCTorch|  Cuda support        : False\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 1000\n",
+      "INFO:QMCTorch|  Number of steps     : 200\n",
+      "INFO:QMCTorch|  Step size           : 0.5\n",
+      "INFO:QMCTorch|  Thermalization steps: -1\n",
+      "INFO:QMCTorch|  Decorelation steps  : 100\n",
+      "INFO:QMCTorch|  Walkers init pos    : normal\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
+   "source": [
+    "# wave function with only the ground state determinant\n",
+    "wf = SlaterJastrow(mol, configs='single_double(2,2)').gto2sto()\n",
+    "\n",
+    "# sampler\n",
+    "sampler = Metropolis(nwalkers=1000, nstep=200, step_size=0.5,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     ntherm=-1, ndecor=100,\n",
+    "                     init=mol.domain('normal'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})\n",
+    "# optimizer\n",
+    "opt = Adam(wf.parameters(), lr=0.005)\n",
+    "\n",
+    "# scheduler\n",
+    "scheduler = optim.lr_scheduler.StepLR(opt, step_size=20, gamma=0.75)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object Solver already exists in H2_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_9\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n",
+      "INFO:QMCTorch|  Optimizer           : Adam\n"
+     ]
+    }
+   ],
+   "source": [
+    "solver = Solver(wf=wf,\n",
+    "                       sampler=sampler,\n",
+    "                       optimizer=opt,\n",
+    "                       scheduler=None)\n",
+    "solver.configure(loss='energy', grad='auto', track=['local_energy','geometry'], freeze = ['ao'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that we must set `grad='auto'` to perform a geometry optimization. To optimize the geometry of the molecule we must use the `set_params_requires_grad` method of the solver. We here set all the wave function parameters and all the atomic positions as variational parameters, leading to a simultaneous optimization of the wave function and of the atomic coordinates. We can then run the optimization here using 50 epochs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Optimization\n",
+      "INFO:QMCTorch|  Task                :\n",
+      "INFO:QMCTorch|  Number Parameters   : 6\n",
+      "INFO:QMCTorch|  Number of epoch     : 50\n",
+      "INFO:QMCTorch|  Batch size          : 1000\n",
+      "INFO:QMCTorch|  Loss function       : energy\n",
+      "INFO:QMCTorch|  Clip Loss           : False\n",
+      "INFO:QMCTorch|  Gradients           : auto\n",
+      "INFO:QMCTorch|  Resampling mode     : update\n",
+      "INFO:QMCTorch|  Resampling every    : 1\n",
+      "INFO:QMCTorch|  Resampling steps    : 25\n",
+      "INFO:QMCTorch|  Output file         : H2_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch|  Checkpoint every    : None\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 0\n",
+      "INFO:QMCTorch|  energy   : -1.070846 +/- 0.012322\n",
+      "INFO:QMCTorch|  variance : 0.389654\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 1\n",
+      "INFO:QMCTorch|  energy   : -1.093524 +/- 0.012193\n",
+      "INFO:QMCTorch|  variance : 0.385562\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 2\n",
+      "INFO:QMCTorch|  energy   : -1.085855 +/- 0.011676\n",
+      "INFO:QMCTorch|  variance : 0.369217\n",
+      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 3\n",
+      "INFO:QMCTorch|  energy   : -1.095264 +/- 0.011571\n",
+      "INFO:QMCTorch|  variance : 0.365905\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 4\n",
+      "INFO:QMCTorch|  energy   : -1.078411 +/- 0.010946\n",
+      "INFO:QMCTorch|  variance : 0.346155\n",
+      "INFO:QMCTorch|  epoch done in 0.34 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 5\n",
+      "INFO:QMCTorch|  energy   : -1.073701 +/- 0.011750\n",
+      "INFO:QMCTorch|  variance : 0.371554\n",
+      "INFO:QMCTorch|  epoch done in 0.35 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 6\n",
+      "INFO:QMCTorch|  energy   : -1.083239 +/- 0.011441\n",
+      "INFO:QMCTorch|  variance : 0.361785\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 7\n",
+      "INFO:QMCTorch|  energy   : -1.091864 +/- 0.011191\n",
+      "INFO:QMCTorch|  variance : 0.353902\n",
+      "INFO:QMCTorch|  epoch done in 0.13 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 8\n",
+      "INFO:QMCTorch|  energy   : -1.112321 +/- 0.010893\n",
+      "INFO:QMCTorch|  variance : 0.344459\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 9\n",
+      "INFO:QMCTorch|  energy   : -1.101314 +/- 0.011203\n",
+      "INFO:QMCTorch|  variance : 0.354284\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 10\n",
+      "INFO:QMCTorch|  energy   : -1.095483 +/- 0.011385\n",
+      "INFO:QMCTorch|  variance : 0.360013\n",
+      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 11\n",
+      "INFO:QMCTorch|  energy   : -1.120974 +/- 0.010508\n",
+      "INFO:QMCTorch|  variance : 0.332293\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 12\n",
+      "INFO:QMCTorch|  energy   : -1.116147 +/- 0.010295\n",
+      "INFO:QMCTorch|  variance : 0.325555\n",
+      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 13\n",
+      "INFO:QMCTorch|  energy   : -1.090706 +/- 0.011097\n",
+      "INFO:QMCTorch|  variance : 0.350910\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 14\n",
+      "INFO:QMCTorch|  energy   : -1.106975 +/- 0.010232\n",
+      "INFO:QMCTorch|  variance : 0.323554\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 15\n",
+      "INFO:QMCTorch|  energy   : -1.114616 +/- 0.010598\n",
+      "INFO:QMCTorch|  variance : 0.335125\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 16\n",
+      "INFO:QMCTorch|  energy   : -1.120063 +/- 0.009871\n",
+      "INFO:QMCTorch|  variance : 0.312143\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 17\n",
+      "INFO:QMCTorch|  energy   : -1.126814 +/- 0.010350\n",
+      "INFO:QMCTorch|  variance : 0.327289\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 18\n",
+      "INFO:QMCTorch|  energy   : -1.110957 +/- 0.009913\n",
+      "INFO:QMCTorch|  variance : 0.313466\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 19\n",
+      "INFO:QMCTorch|  energy   : -1.135297 +/- 0.009999\n",
+      "INFO:QMCTorch|  variance : 0.316206\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 20\n",
+      "INFO:QMCTorch|  energy   : -1.126248 +/- 0.010025\n",
+      "INFO:QMCTorch|  variance : 0.317012\n",
+      "INFO:QMCTorch|  epoch done in 0.13 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 21\n",
+      "INFO:QMCTorch|  energy   : -1.119559 +/- 0.010067\n",
+      "INFO:QMCTorch|  variance : 0.318341\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 22\n",
+      "INFO:QMCTorch|  energy   : -1.114980 +/- 0.009557\n",
+      "INFO:QMCTorch|  variance : 0.302212\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 23\n",
+      "INFO:QMCTorch|  energy   : -1.122430 +/- 0.010054\n",
+      "INFO:QMCTorch|  variance : 0.317943\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 24\n",
+      "INFO:QMCTorch|  energy   : -1.122087 +/- 0.009651\n",
+      "INFO:QMCTorch|  variance : 0.305191\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 25\n",
+      "INFO:QMCTorch|  energy   : -1.133653 +/- 0.009697\n",
+      "INFO:QMCTorch|  variance : 0.306655\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 26\n",
+      "INFO:QMCTorch|  energy   : -1.153086 +/- 0.009464\n",
+      "INFO:QMCTorch|  variance : 0.299277\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 27\n",
+      "INFO:QMCTorch|  energy   : -1.137196 +/- 0.009235\n",
+      "INFO:QMCTorch|  variance : 0.292042\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 28\n",
+      "INFO:QMCTorch|  energy   : -1.134850 +/- 0.009741\n",
+      "INFO:QMCTorch|  variance : 0.308045\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 29\n",
+      "INFO:QMCTorch|  energy   : -1.137292 +/- 0.008938\n",
+      "INFO:QMCTorch|  variance : 0.282648\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 30\n",
+      "INFO:QMCTorch|  energy   : -1.129972 +/- 0.009542\n",
+      "INFO:QMCTorch|  variance : 0.301736\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 31\n",
+      "INFO:QMCTorch|  energy   : -1.129879 +/- 0.008805\n",
+      "INFO:QMCTorch|  variance : 0.278450\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 32\n",
+      "INFO:QMCTorch|  energy   : -1.120897 +/- 0.009573\n",
+      "INFO:QMCTorch|  variance : 0.302713\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 33\n",
+      "INFO:QMCTorch|  energy   : -1.126543 +/- 0.008883\n",
+      "INFO:QMCTorch|  variance : 0.280912\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 34\n",
+      "INFO:QMCTorch|  energy   : -1.125339 +/- 0.009391\n",
+      "INFO:QMCTorch|  variance : 0.296973\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 35\n",
+      "INFO:QMCTorch|  energy   : -1.132248 +/- 0.009047\n",
+      "INFO:QMCTorch|  variance : 0.286092\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 36\n",
+      "INFO:QMCTorch|  energy   : -1.143987 +/- 0.008693\n",
+      "INFO:QMCTorch|  variance : 0.274895\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 37\n",
+      "INFO:QMCTorch|  energy   : -1.143939 +/- 0.009039\n",
+      "INFO:QMCTorch|  variance : 0.285829\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 38\n",
+      "INFO:QMCTorch|  energy   : -1.132018 +/- 0.008930\n",
+      "INFO:QMCTorch|  variance : 0.282378\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 39\n",
+      "INFO:QMCTorch|  energy   : -1.135228 +/- 0.008902\n",
+      "INFO:QMCTorch|  variance : 0.281495\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 40\n",
+      "INFO:QMCTorch|  energy   : -1.146552 +/- 0.009092\n",
+      "INFO:QMCTorch|  variance : 0.287503\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 41\n",
+      "INFO:QMCTorch|  energy   : -1.141178 +/- 0.008888\n",
+      "INFO:QMCTorch|  variance : 0.281070\n",
+      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 42\n",
+      "INFO:QMCTorch|  energy   : -1.133022 +/- 0.009063\n",
+      "INFO:QMCTorch|  variance : 0.286591\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 43\n",
+      "INFO:QMCTorch|  energy   : -1.133298 +/- 0.008375\n",
+      "INFO:QMCTorch|  variance : 0.264828\n",
+      "INFO:QMCTorch|  epoch done in 0.23 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 44\n",
+      "INFO:QMCTorch|  energy   : -1.135157 +/- 0.008890\n",
+      "INFO:QMCTorch|  variance : 0.281116\n",
+      "INFO:QMCTorch|  epoch done in 0.38 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 45\n",
+      "INFO:QMCTorch|  energy   : -1.143128 +/- 0.008901\n",
+      "INFO:QMCTorch|  variance : 0.281471\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 46\n",
+      "INFO:QMCTorch|  energy   : -1.148810 +/- 0.008243\n",
+      "INFO:QMCTorch|  variance : 0.260676\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 47\n",
+      "INFO:QMCTorch|  energy   : -1.143023 +/- 0.008719\n",
+      "INFO:QMCTorch|  variance : 0.275712\n",
+      "INFO:QMCTorch|  epoch done in 0.28 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 48\n",
+      "INFO:QMCTorch|  energy   : -1.154847 +/- 0.008289\n",
+      "INFO:QMCTorch|  variance : 0.262111\n",
+      "INFO:QMCTorch|  epoch done in 0.33 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 49\n",
+      "INFO:QMCTorch|  energy   : -1.140911 +/- 0.008209\n",
+      "INFO:QMCTorch|  variance : 0.259583\n",
+      "INFO:QMCTorch|  epoch done in 0.24 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object wf_opt already exists in H2_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to wf_opt_5\n",
+      "INFO:QMCTorch|\n"
+     ]
+    }
+   ],
+   "source": [
+    "solver.set_params_requires_grad(wf_params=False, geo_params=True)\n",
+    "obs = solver.run(50)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.save_traj('h2_traj.xyz', obs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGwCAYAAAC5ACFFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACbG0lEQVR4nOzdd3xc1Zn4/8+5U9R7lyVZ7r0bjI0Bg41NCS1geogDgcCGZBf4fjfht7vJht0sIZvN5ksaKRBDgBB6x9hgY7Bxt+VuWbYlS1bvXaOZuef3x7VkC0ujNqPm5/166WVrdO+dM0eamWfOec5zlNZaI4QQQgghOmUMdgOEEEIIIYYyCZaEEEIIIXyQYEkIIYQQwgcJloQQQgghfJBgSQghhBDCBwmWhBBCCCF8kGBJCCGEEMIH+2A3YCQwTZOioiIiIiJQSg12c4QQQgjRA1pr6uvrSU1NxTC6Hj+SYMkPioqKSE9PH+xmCCGEEKIPCgoKSEtL6/LnEiz5QUREBGB1dmRkpN+u63a7Wbt2LcuXL8fhcPjtuuJc0tcDQ/p5YEg/Dwzp54ERyH6uq6sjPT29/X28KxIs+UHb1FtkZKTfg6XQ0FAiIyPliRhg0tcDQ/p5YEg/Dwzp54ExEP3cXQqNJHgLIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvhgH+wGiO6V1JnY7KbPY+LDFU6b712ThRBCCNF7EiwNAy/ucWMq3eXPDQVLxtlZOFp+nUIIIYS/ybvrMJEY3vWoUXmD5lCplwUZNgwlo0tCCCGEP0mwNAzYFD6n2GJCoaxBU1KnSY2SYEkIIYTwJ0nwHgFC7NDigbxq33lNQgghhOg9CZZGAKUUIXY4VObFa3ad2ySEEEKI3pNgaYSIDlGU12tK6iVYEkIIIfxJgqURIlim4oQQQoiAkGBphFBKEeKAw6UyFSeEEEL4kwRLI0h0iKKsQVMsU3FCCCGE30iwNIIE28Hlgbwq72A3RQghhBgxJFgaQZRShDrhcJkpU3FCCCGEn0iwNMJEBSvKGzRFdRIsCSGEEP4gwdIIE+JQuLwyFSeEEEL4iwRLI1CoQ6bihBBCCH+RYGkEig5WlDfKVJwQQgjhDxIsjUDBDkWrB3JlKk4IIYToNwmWRqi2VXEer4wuCSGEEP0hwdIIFR2iqBjCU3Hrc9xsO+kZ7GYIIYQQ3ZJgaYQKtg/dqbh6l2ZvsZet+V5qW4ZmMCeEEEK0kWBpBAtzwpHyoTcVd7zSpLYFKps0ewpldEkIIcTQJsHSCBYVoqho0BQOoak4rTUHS7zYDWvV3u5TXqqazMFulhBCCNElCZZGsGC7wm0Oram4knpNQY1JTKgiJhRqWmD3qaHTPiGEEOKrJFga4UIdcGQIrYrLqfDS7IYwBxhKERuqyCryUt4go0tCCCGGJgmWRri2VXGnhsBUXKtHc7DUJMxpbfoLEB0M9S7YKaNLQgghhigJlka4ILvC7dVDYiour9qkvEETE6rab1NKERem2F/spbhORpeEEEIMPRIsnQfCghRHykzcgzwVl11mojU4barD7ZFB0OiGnQVetB78ETAhhBDibBIsnQeigxWVjZqT1YM3clPbrDla4SU6RJ3zM6UUCWGKg6VeTtVKsCSEEGJokWDpPBBkV5ga3j3oZuNxN3WDUAjyWKVJnQsigzv/ebgTmt2wvcAjo0tCCCGGlGETLFVVVXHXXXcRGRlJdHQ09913Hw0NDT7POX78ODfddBMJCQlERkZy6623Ulpa2uGYzMxMlFIdvn72s58F8qEMioxoBUrx6TEvq3e2si3fQ7N7YIIS83RtJafNWgHXGaUUiRGK7DKTk9USLAkhhBg6hk2wdNddd3Hw4EHWrVvH+++/z+eff84DDzzQ5fGNjY0sX74cpRTr169n8+bNtLa2ct1112GaHaejnnjiCYqLi9u/vve97wX64Qw4pRRxoYoxsYoWj+bDwx5e2NVKVpGX1gDnMhXVaQrrTGI7mYI7W7hT4fbCtnwPpowuCSGEGCLsg92Anjh8+DBr1qxhx44dzJ8/H4Bf//rXXHPNNfziF78gNTX1nHM2b95MXl4ee/bsITIyEoDnn3+emJgY1q9fz7Jly9qPjYiIIDk5eWAezCAzlCIpXOEJ1ZQ1aN454GZPocHC0TYmxBvYDN8BTV/kVHhpcUNIRPfHJoYrcipMTlSajI+3+b0tQgghRG8Ni2Bpy5YtREdHtwdKAMuWLcMwDLZt28ZNN910zjkulwulFEFBQe23BQcHYxgGmzZt6hAs/exnP+M//uM/yMjI4M477+SRRx7Bbu+6a1wuFy6Xq/37uro6ANxuN263u1+P9Wxt1zK0B0z/BjF2IDUc3F4orvHwRjWMjVNcMtZOUrj/BhxbPZpDRW6inBqlFXQzYBRqh0pTsy3PS1qEIyDBW2fa+tqfvz9xLunngSH9PDCknwdGIPu5p9ccFsFSSUkJiYmJHW6z2+3ExsZSUlLS6TkXXXQRYWFh/OAHP+C//uu/0Frzwx/+EK/XS3Fxcftx3//+95k7dy6xsbF8+eWXPP744xQXF/PLX/6yy/Y8+eST/OQnPznn9rVr1xIaGtrHR9m1CY0bodHvl22X0PafU7DrlP+vn9b2n7qeHR8NUAgfF/q/Ld1Zt27dwN/peUj6eWBIPw8M6eeBEYh+bmpq6tFxgxos/fCHP+Spp57yeczhw4f7dO2EhARee+01HnroIZ5++mkMw+COO+5g7ty5GMaZkZNHH320/f8zZ87E6XTyne98hyeffLLDqNTZHn/88Q7n1dXVkZ6ezvLly9un/PzB7Xazbt06csIuIyHS4bfrdsVrQn6NZn6awZUT7V0mY/fG+4daOVCqrQTzXjhVo0mPVqyc6cBuC/zoUltfX3nllTgcge/r85X088CQfh4Y0s8DI5D93DYz1J1BDZYee+wxVq1a5fOYsWPHkpycTFlZWYfbPR4PVVVVPnONli9fzvHjx6moqMButxMdHU1ycjJjx47t8pwFCxbg8XjIy8tj0qRJnR4TFBTUaSDlcDgC8oQxlR2MwD8RbQYkRGj2lGjSY23MSu1fzlBVk+Z4tZeoUAW9nE5LiNTk1WqO19iYnjxwuUuB+h2KjqSfB4b088CQfh4Ygejnnl5vUIOlhIQEEhISuj1u4cKF1NTUsGvXLubNmwfA+vXrMU2TBQsWdHt+fHx8+zllZWVcf/31XR6blZWFYRjnTPudL8KDFA2tmg3HPSRHKJIi+p6/dKzCS30rZIb1/twgu8JuaDbneRgTaxDmHJjcJSGEEOKrhkXpgClTpnDVVVdx//33s337djZv3szDDz/M7bff3r4SrrCwkMmTJ7N9+/b28/7yl7+wdetWjh8/zosvvsjKlSt55JFH2keMtmzZwq9+9Sv27t3LiRMneOmll3jkkUe4++67iYmJGZTHOhQkhSuqmzRrj3po6WMtJq+pOVDiJchHbaXuJEcoCms1Owo8fTpfCCGE8IdhkeAN8NJLL/Hwww+zdOlSDMPg5ptv5umnn27/udvtJjs7u0OyVnZ2No8//jhVVVVkZmbyL//yLzzyyCPtPw8KCuKVV17h3//933G5XIwZM4ZHHnmkQz7S+UgpRVo05FSYbMr1sHSCHdXLgOdUraa4XhMX2vcRIZuhiAmBHQVeJibYSI0cFrG9EEKIEWbYBEuxsbG8/PLLXf48MzPznG0yfvazn/msxj137ly2bt3qtzaOJE6bIj4MthV4GRVlMCWpd3lDOeVeWr0Q4ujf9FlMCORWwRcnPNwyc+BKCQghhBBt5KO66FJUsEIBnx7zUNnY8014m92aQ2UmkZ0vJuwVpRQpkYrscpODJYO3EbAQQojzlwRLwqeUSEV5g8knOR7cPdwW5XilSXWTJrqb7U16KsShcNhgU56HepdsgyKEEGJgSbAkfDKUIjXK4HCpydb8rhOt613WZrnvHXSz7qgbwwC7H6fMksIVJfWarSc950y3CiGEEIE0bHKWxOAJtiuiQuDLPC+pkQbj4mxoraltgZPVJscqvZysMqlzgVIQGaRIi/JvG2yGIi4Udhd6mZRgIyNGcpeEEEIMDAmWRI/EhiryazSf5HiobtIcrzQpqDFpcIFhWPlNGdEENAE7KhhqauDzEx5um+3AMQCVvYUQQggJlkSPjYpU5FVrimo92G0QHayIC+t7HaXeUkqREgHHKk32FZvMSxu4yt5CCCHOXxIsiR6zGYoxsaCg13WX/CXIrghxWJW9x8UZfksiF0IIIboiCd6iVwylBi1QapMYrqhotAImSfYWQggRaBIsiWHHUIrEcMW+Ii8nqiRYEkIIEVgSLIlhKSJI4Tbhi1wPrZ6BCZgKakxO1UphTCGEON9IsCSGrZRIRV6lyb5ib8Dvq6DG5I39bradlE19hRDifCPBkhi2nDaF0w4HSsyA5i5VNJp8cNhNcZ1Jcb3GawZ+JCu73MvOAgnMhBBiKJBgSQxrUSGK0gaT8sbABDANLs37hz0U12kyog0aWzXVzYEPlo6Wmewu9GJKArsQQgw6CZbEsBbmgKZWq5K4v7k8mg8PuzlRaZIerQh1QosbqpoCG8CYWnOqzqS6WVMZ4PsSQgjRPQmWxLCmlMJpg6Pl/p2K85pWtfKDpSajohQOm8JQCg0BD2BqmqG+RdPg0pTWS7AkhBCDTYIlMexFhSgKa02/jfhorfki18OOAi9JEYpg+5m6UjZFwAOYyiaTZo8VCBbVyeo7IYQYbBIsiWEvzAmNbsiv8U8Qs7vQZFOul5gQRZizYwHOEAcU1ZkBzSWqbNRoDeFBkFsV2PsSQgjRPQmWxLBnKIXDgJyK/pcQOFru5dMcN8F2Ot1KJcShaHBpalv6fVddKq7X2BSEOxU1krckhBCDToIlMSJEBivyq01q+7lS7ZNjXjwmxId1vqVLiAOa3VDVFJjpMa+pKao1CXGeuS/JWxJCiMElwZIYESKCoKEVTtb0LYipPB381LVoUiO73v/OZpxO8g5QqYKaZk1DqybUYSWUK5C8JSGEGGQSLIkRwVAKQ8Hxit4HFlprNuVaBSDTorrfKNhQUBagYKmiSdPitkaVAEKckrckhBCDTYIlMWJEBityq7w0uHoXWOTXaI5XWOcYvuMkAIIdUFQbmKrhlY0ajRX8geQtCSHEUCDBkhgxIoOgzgX5vZiK01qz+5QHVy9yw0MdiroWTZ2rD43sRnGdif2sZ6XkLQkhxOCTYEmMGDbDyvE5XtnzYOlUrSa73CQutAdDSqedSfL2bwDj8WqK63X7FBwgeUtCCDEESLAkRpSIYMXxSpNmd/eBjNaaPYVemj1WraaeshsKr/Z/Je/qZqtqd6jjK7WdJG9JCCEGlQRLYkSJCobaZt2jqbjies3hMi/xoYpucrrPoRRUNPh3tKeySdPisXKiziZ5S0IIMbgkWBIjiv300v7cHkzF7Sn00uS2yg70VrAdCv2c5F3R2JZkfm7VcMlbEkKIwSPBkhhxIoIgp8LE5ek6uCitNzlU6iUutPtSAZ0JdShqWjSNrf1paUdFdSaOTp6RkrckhBCDS4IlMeJEBSuqmzWnarsOLvYUemlwWSvo+sLfSd7utuRuZxeVwyVvSQghBo0ES2LEcdgUpraCi86UN5ocKPES08dRJQC7AW7Tf0neVU2aplZNqKPzn0vekhBCDB4JlsSIFOaEo+Umbu+5wcXeQi91LogO7vv11empsYpG/0yNVTRqXB4rF6ozkrckhBCDR4IlMSJFBSuqmjSFdR2Di6omk73FXmJC+j6q1CbY7r88orYRo67aJHlLQggxeCRYEiNSkF3h9mpOVnUszb232EttC0SH9P8+QhyKyibdo5pO3SmsNXHaurk/yVsSQohBIcGSGLFCnYrschOvaQUXNc2arEKT6GB1zvL8vmibGutvHlGrR1PaoAlx+G6T5C0JIcTgkGBJjFhRwYryRk3R6am4fcUeqps1MaH+ub7TBq3e/q+Iq2zSNPtI7m4jeUtCCDE4JFgSI1awHVo91sa6dS2a3YUmkcHnFn3sq7Yk78p+JnlXNmlcXgjqIrm7jeQtCSHE4Ojm5VmI4UspRbBDc6TMi9aa6iZNZqx/AqU2QXbOSSLvrbYVdT1JOD87b8lfQZ8QQgjfJFgSI1p0sKKsQdPgMgkP8t+oUpsQu6K8QePyaILsfbv2qVrdbXJ3m7PzlhLCJFgSQoiBINNwYkQLcUDL6UrbcaH+Dy6sPCLd57ylFremvMEktIvK3Z3fn+QtCSHEQJJgSYxoSiniwqwvm+H/YCnI3r8k78omTZObbpO720jekhBCDDyZhhMjXlRw4KarrDyjvi/nr2zUtHrp8TQcSN6SEEIMtGEzsvTTn/6URYsWERoaSnR0dI/O0Vrzox/9iJSUFEJCQli2bBk5OTkdjqmqquKuu+4iMjKS6Oho7rvvPhoaGgLwCMRI5bD1faSnvNFE0bPk7jbteUuNMhUnhBADYdgES62traxcuZKHHnqox+f8/Oc/5+mnn+aZZ55h27ZthIWFsWLFClpaWtqPueuuuzh48CDr1q3j/fff5/PPP+eBBx4IxEMQI1SIQ1HaoDvdh647p2p1tyUDzr0/K2+pRPKWhBBiQAybYOknP/kJjzzyCDNmzOjR8VprfvWrX/Gv//qv3HDDDcycOZMXXniBoqIi3n77bQAOHz7MmjVr+POf/8yCBQtYvHgxv/71r3nllVcoKioK4KMRI0moA5pbNdXNvQtemt2ayiaT0G4qd3+V5C0JIcTAGrE5S7m5uZSUlLBs2bL226KioliwYAFbtmzh9ttvZ8uWLURHRzN//vz2Y5YtW4ZhGGzbto2bbrqp02u7XC5cLlf793V1dQC43W7cbrffHkPbtQztAVNyUwLK9HT8txeCDGh1a8rrICao58lHpbUmLpfHKgHQy7gnzKE5WemlxaUDkrgeKG1/0/58nohzST8PDOnngRHIfu7pNUdssFRSUgJAUlJSh9uTkpLaf1ZSUkJiYmKHn9vtdmJjY9uP6cyTTz7JT37yk3NuX7t2LaGhftpL4ywTGjdCo98vKzoRXfpZn86LBY7tgGO9PG8qQFPv7y/69L8fr+n9uUPBunXrBrsJ5wXp54Eh/TwwAtHPTU09ewEe1GDphz/8IU899ZTPYw4fPszkyZMHqEU98/jjj/Poo4+2f19XV0d6ejrLly8nMjLSb/fjdrtZt24dOWGXkRDZw7Xlom9MD9Gln1GTtASM3j8tCms1ExMUN0xz9vicDcfcbM03GR3T+5EhU0NBjeaGaXamJvViKd0ga/ubvvLKK3E45G86UKSfB4b088AIZD+3zQx1Z1CDpccee4xVq1b5PGbs2LF9unZycjIApaWlpKSktN9eWlrK7Nmz248pKyvrcJ7H46Gqqqr9/M4EBQURFBR0zu0OhyMgTxhT2cGQJ+KAMPrW10FOk5JGhWGz92haTGtNYYNJkNMAo/epgwaglcmeYoOjlefmSikFba1IjzG4MH1oDSIH6rkiOpJ+HhjSzwMjEP3c0+sN6itoQkICCQkJAbn2mDFjSE5O5tNPP20Pjurq6ti2bVv7irqFCxdSU1PDrl27mDdvHgDr16/HNE0WLFgQkHaJkSnEoah3WUne8T3YhqTpdFXxkF4md58tIVxRVGfiK63c7YWCWs3kBBuRAaw3JYQQI9nQ+rjpQ35+PlVVVeTn5+P1esnKygJg/PjxhIeHAzB58mSefPJJbrrpJpRS/NM//RP/+Z//yYQJExgzZgz/9m//RmpqKjfeeCMAU6ZM4aqrruL+++/nmWeewe128/DDD3P77beTmpo6SI9UDEchDihvsAKg+LDuj69o1DS7ISq47/cZ5lSEdbNNiqk1eVWa7HIvFwyx0SUhhBguhs2r549+9COef/759u/nzJkDwIYNG1iyZAkA2dnZ1NbWth/zz//8zzQ2NvLAAw9QU1PD4sWLWbNmDcHBZ96hXnrpJR5++GGWLl2KYRjcfPPNPP300wPzoMSIYSiF7kUl78pGjccEhy2woz2GUgQ7NHsKvcxOtQX8/oQQYiQaNsHS6tWrWb16tc9jtO74RqWU4oknnuCJJ57o8pzY2FhefvllfzRRnOdsqucb3JY3DlyNpPgwRXGd5nilyeTE4ZMMLoQQQ8WwKUopxFAX4rAKRZrad8CktaagxiRkgPJBnadHk/YXe8/5QCGEEKJ7EiwJ4SchDkWDS1Pb4vu4hlaobdG9rtzdH3GhiuOVJsWyRYoQQvSaBEtC+Enbnm1VTb6n2CobNU2tDNjIEkCY02rboRLvwN2pEEKMEMMmZ0mIoc5mKEw0p2o0TpuJ2wseU5/+t+1LU94wMMndZ1NKERUMB0pNFozWRARJorcQQvSUBEtC+JHDgE15Hr7IBa+GthShs0MTDUScW9M04GJCIa9ak13mZb6UERBCiB6TV0wh/GhUlMLtBUOBzbCCJKWGxiiOoRTBdk1WkZdZUkZACCF6THKWhPAjQymC7AqHTWEoNWQCpTbxoYqiOs2JKv+WLnB7NRuOuXn/kFtW3AkhRhwJloQ4jzjtCo1/ywjUtWjeOehmw3Evh0q9lDdKsCSEGFkkWBLiPNNWRqDED2UEimpNXtvXyr5ik9RIRWMr5JTLijshxMgiwZIQ55lwJzS1wsHSvgc1WmsOlnh5dZ+bUzWa0TGKEIci1GmtuHN7ZXRJCDFySLAkxHlGKUVkMBwoMWlw9T6o8Xg1n5/w8M5BN81uK1CyG1ZuVmyIoqxBc7J64LZzEUKIQJNgSYjzUEyIorpJc6S8d0FNg0vz3iErPynMqUiNNDoksTvtCtOEw2WBDZbcXk1Ns4xeCSEGhgRLQpyHbIYi2AFZRR48PZwyK6k3eW2fmz1FJskRiuiQzlf6RYUojpZ7qW0JTDDT4LISyv+yw8XmXDcujwRNQojAkmBJiPNUXKiiuNZ3GQGtNaX1JtvyPby6183JarM9P6krUcFQ54JjFf4fXapsNHlzv5t9xSZuE9Ye9fLyHjfHK00pWSCECBgpSinEeSrIrjC1Zl+xlwnxZ6bTtNZUNGpyq0yyy02K6kwaW6395TJjuq8dZSiF06Y5UOJlzigDw0+1pgpqTD484qaoVpMRbdWycodoCmpMXt3byuxUG4sy7UQF9+7+tNZDrh6WEGJokWBJiPNYXJhVRqC0QWMzNCerTI6UnQmQnHaIDlYkhfeuEnlsqKKw1qSwVpMe3f9A5EiZlzXZHmpbNJmxqj0Ac9gUo2MUdS2aLSe9nKgyuSTTzrRkA5vR+f22uDUl9ZqiOpPcKhNTw1WT7CSEy0C7EKJzEiwJcR4Ld0JZA7x3yEN1k0mjG5wGRIcoEnsZIJ0t1KEo8ZgcLfeSHt33IERrza5TXj495sFrwujozke2IoMV4UFQUq95+6Cb7HKDS8faSYow8Hg1ZQ2aonpNfrWX/BpNvUvj9YLDDm4vvLbPzbVTHIyOkYBJCHEuCZaEOI8pZQVFZQ0mUcH9C5C+KjJYcajUZFGm9pnj1JW2EgWbT3oJcUByhO9AxlCK1EhFs1tzoMQkv6aVcfE2CmtNaps1Lg/YDQgPUiRHKJyn98YztaagRvPmfjdXTbIzJcnWp8crhBi5JFgS4jwXEaSICPJ/zk50iOJUjeZEpcm05N4FIM1uzbqjHnYXeokNVb3KQwpxKMbEQmWTZl+Rl1CHNS0YbO88EDSUIiMaiuutVXYNrZr5aTbJYxJCtJMxZyFEQNgNhVJwqLR3+9DVtWjePuBm1ykvSeG9C5TaKKWIDzMYHWOQEG4Q4vCdmK6UVTPKYYM12R42HOt5SQUhxMgnwZIQImBiQxW5VSYVPdxct6nVKnp5uMwkLUoR6hzY0Z34MIOoYMXnuV4+yvbQ4paASQghwZIQIoDCndDQCjk9qLnU6tF8eMRNdrlJerTCaR+cabCoYEVSuGJngZe3D7qpC1BxTSHE8CHBkhAiYJRShDnhQInX5+a6Hq/m46Me9hWbjIo8k3w9WEKdilFRVoL6G/vdlDfIXndCnM8kWBJCBFRsiKK0vuvNdU2t+ey4h12nvCRHKIL7sHIuEILsVg2nk9Umbx5wU9UkI0ydqWvRfJIj286IkU2CJSFEQDntCq+m0017tdZ8mefhy5Ne4kIVYQOco9Qdu2EFTIW1JmuOuCWHqRPZ5V52FnjJDvDmyUIMJgmWhBABFx2iOFrmpc7VMdjYU2iy8YSXiCBFZB9WvQ0EQynSow2yy03WH/PgNSVgauM1rW1tKho1uwplBaEYuSRYEkIEXFQw1LZAbuWZ0YfDpV7W5bhx2qxVc0OZ06ZIDFfsPOVlR4F3sJszZBTWaorqNBkxBgU1ukeJ/EIMRxIsCSECzlAKp92quQSQV2Xy0RE3pobEYbInW3iQlay+8YSHo+USMAEcrfDS6tFEBVs1tXad8srImxiRhserlBBi2IsNVRTXWW+kH2d7aHRDSsTQHlH6qvgwA48X1mZ7KDvPV8g1uzWHS00iTk+fJoQp8qqtzYmFGGkkWBJCDIgQO7ScXjFV3aJJi/JdVXuoSo1SVDRpPjziocF1/o6i5FaZVDVrYkKs32GIQ+E1rdGl3lRsF2I4kGBJCDEglFLEhlovOWmRCmMYBkpgTSmmRSlOVJp8knP+JjUfLvOisFYMtkkIVxyvNMmvOT/7RIxcEiwJIQZMZLD1rzHMX3kcNkVKpCKryMvmPM95N5JS1WRyotJsH1VqE+ZUtHphT2HvR5ea3Zo9hb6LlwoxWIb5S5YQQgyOUIciOkSxOc/LwdLzK08np8KkwQURQef+LD5MkV3upbi+50GP19SsO+rhw8NudhdK8rwYeiRYEkKIPooJURgK1h31cKp2eAVMtS2aL064ae1l5e222krBDjrNOQt3QmOrJquHQY/Wms15HnYXetHA5lwPpfXDqy/FyCfBkhBC9ENyhKLOpVmb7R6QKaTqZs2Ogv4Xx9xd6OGz4152nerdSM6pWk1JvT5nCq6NUoq4UIODpV7KG7sPeg6WmmzK9RIdYuWC1brgs+Pnby6YGJokWBJCiH5QSpESoSiq0xQEOLHZ7dWsy3bzaY6HE/1Yol/botlbZNLqhS9PeijpxUhOTrmXVq+1+q0rUcFQ74K9Rb4DsYIak7VHPRjKGqVTSpEaqThSZpJVLKNLYuiQYEkIIfopyK7wmJBTEdh8m+35Hg6VmTS5YWdB3wtAHizxUN2kGRunqHfBhmM9G8lpdmsOlZlEdpKrdDalrHyufUVeapo7v251s+bDI27qXZrks+ptBdsVIU7YlOvp0ciUEANBgiUhhPCDiCA4UmbSHKDNdnOrTDbneYkMtkZfjleafRpdamrV7C40CQuyyiCkRCqOlvdsJOdEpUl1kya6iym4s8WEQE0L7C/2nPOzZrfmo8NuimpN0jupt5UYpqhu1mw8LnvxiaFBgiUhhPCD6BBFTbPmRKX/R0PqXZp1R920eCA2xJoCM7U1umT2con+oTKT8kZN/On9+ILtihCHlVhd4WMkR2tt1VZSHWsrdcVQisgg2FNkdije6TU16495yC43SYsysHVyrbapzYMlJvtkOk4MARIsCSGEH9gNBQqy/bxvnNfUbDjm4VRtx6rniacLQPYmOHN5NLtOeQi20yFISQhXVDaZfH6i65GcyiZNbtW5tZV8iQ1VVDZqDp7eE1BrzdaTHnae8pIYoXDau75WiEMR7IAvcj1UNUnAJAaXBEtCCOEnMSFWZe/qLvJ0+mJvkUlWkZfkCNUhwAlxKLwadvRidCm7zKSkTpMQ1jFIsabjDA6WmF3WjDpe2XVtpa7YDEWo09oCpdmtOVxm8nmul8ggRbiz+6ArMdwKtmQ6Tgy2YRMs/fSnP2XRokWEhoYSHR3do3O01vzoRz8iJSWFkJAQli1bRk5OTodjMjMzUUp1+PrZz34WgEcghBjpIoKgvhW/TcUV15l8dsJDsMOqjv1VvRld8ng1uwo92G1WBfKvCnUo7Db44oSH2q8Ee15Ts99HbSVf4sMUZfWaTbke1h618pdiQ3t2DUMpkiMUB3wEcUIMhGETLLW2trJy5UoeeuihHp/z85//nKeffppnnnmGbdu2ERYWxooVK2hpaelw3BNPPEFxcXH71/e+9z1/N18IcR4wlMJpg0Ol/d9MtsVtVbWua9EkhnUeXIT2YnTpWKVJQc25o0pnS45QlDZoPs/tuIVLQa2mtE4T24spuDZ2QxHkgKwiL7UtmpSI3l0j1HkmiOtqZZ0QgTZsgqWf/OQnPPLII8yYMaNHx2ut+dWvfsW//uu/csMNNzBz5kxeeOEFioqKePvttzscGxERQXJycvtXWFhYAB6BEOJ8EBOiKKw1KenFdh9fpbXmi1wPxyvNDnlKnWkbXcr1sTLOa2p2nbKSs4N85AkZSpEUrthb5CW7/Mz1jpZ7aTUh2EdtJV8SwxVek05XvvVEWxD3xQlPrxPahfAH+2A3IFByc3MpKSlh2bJl7bdFRUWxYMECtmzZwu23395++89+9jP+4z/+g4yMDO68804eeeQR7Pauu8blcuFyudq/r6urA8DtduN2u/32GNquZWgPmMNzh/Zhw/R0/FcExnnQz6E2KG/V5JSZxIc4+nSN7DIvO/M9JIQoHArwMQMVaoMKr2bHSS9pEQ4MpdpfO9r+za0yOVnpJjFUgek7AT3cAXVNms+PeUkOc2AAR0rcRDl1n1+H7EBK+Olv+jCbZgDJYbC/yENmtJfJibY+tcPfvtrPIjAC2c89veaIDZZKSkoASEpK6nB7UlJS+88Avv/97zN37lxiY2P58ssvefzxxykuLuaXv/xll9d+8skn+clPfnLO7WvXriU0NNRPj+CMCY0bodHvlxWdiC79bLCbcF4Y6f0cA1QfhA8P9v0aU6HHz/togAJYU9Dx9nXr1rX/fxpAUy+u1wQbP7G+H932g9qenR8I0cAo4MROODF4zejU2f0sAicQ/dzU1LMnxaAGSz/84Q956qmnfB5z+PBhJk+eHLA2PProo+3/nzlzJk6nk+985zs8+eSTBAV1vuzj8ccf73BeXV0d6enpLF++nMjISL+1ze12s27dOnLCLiMhsm+fUEUPmR6iSz+jJmkJGCP2M8TgO0/6udUD5Y2alTMdZMb2PNvB7dW8f8jNoTKT0TEGPShn1K6gRjMhXnHjdAdej4d169Zx5ZVXUtZk4+973UQEKcKcPb9eXQs0uTVJ4YpTtZr06MEf3TZNyK/RLJ9kY37a4P/9tL1GX3nllTgcgX2Nzqnw8kmOl/lpBhekD/5jH0iB7Oe2maHuDGqPP/bYY6xatcrnMWPHju3TtZOTkwEoLS0lJSWl/fbS0lJmz57d5XkLFizA4/GQl5fHpEmTOj0mKCio00DK4XAE5AljKjsYEiwNCEP6ekCM8H52OqG1wSS31mBCUs8f57ZTbg5V2EiJtmN0smLNl7hwzbFqzal6OxmR1rl2u539pYpmr53k4N6lqEaGQk2NSX4dxIYpehW5BYhhQHCQyZ5ixew0u8/96fqrotHks2Me0mMMJifaiAru+r4C9dp/dlvWnzApaTT4Ml+REWcjLWrYpBz7TSD6uafXG9RgKSEhgYSEhIBce8yYMSQnJ/Ppp5+2B0d1dXVs27bN54q6rKwsDMMgMTExIO0SQpwf2rY/uWSM7tGb+rEKL5vzvEQFK4J9JGF3JdSpKGvU7CzwkDbVuq280aptFNfDpfpflRqpqGuB8F6MSAVafJiioEZzsNRkflpgcpcaXJoPDnvIqfCyv8Rkc56HaUk2piXbGBXZtyT1vmpxaz7O9lDeoJkQb5Bfo/kkx8NtsxwBDRZFR8MmNM3PzycrK4v8/Hy8Xi9ZWVlkZWXR0NDQfszkyZN56623AKsWyD/90z/xn//5n7z77rvs37+fe+65h9TUVG688UYAtmzZwq9+9Sv27t3LiRMneOmll3jkkUe4++67iYmJGYyHKYQYIaJDrP3NfK1Sa1PTbL0Bur09r0HUmcQwxbFKk5PV1oqxAyVeGlp1rwpJns1uKGJDBzY46I7dUATZYdcpDy6P/1fGuTyaj464OV5pkhljkBmrUCi+zPPw112tvJLl5lCpl9YA3PdXaW2VcbC2hlEYSjEq0ip8uukr5R1EYA2bic8f/ehHPP/88+3fz5kzB4ANGzawZMkSALKzs6mtPZOB+M///M80NjbywAMPUFNTw+LFi1mzZg3BwcGANZ32yiuv8O///u+4XC7GjBnDI4880iEfSQgh+sJuKBSa7DIvU5O6HgHxeDWf5LgpqtNkxvQvKGkbXcoq9BAEHCw1iQ1xDKlgxx8SwhSFtdao2exU/40ueU0raD1QYjIqSrUX74wNhZgQgyY35FSYHC03SY5UzEgMbKHM/cUm2/O9JISd2RrGYVPEh1m1tTJiDCYlDI2VgSPdsAmWVq9ezerVq30e89UoWynFE088wRNPPNHp8XPnzmXr1q3+aqIQQnQQFaw4UWVS06yJ7qKg49Z86805NVJ1uqlsbyWGKY5XaaZiJWlnxvX7kkOOw6Zw2Kwpx6lJBs5e5nd1RmvNpjwPOwu8JIafOxWqlJUgH+ZUuL2ayibNuqNeZgNHSr3MSPNvLk1Rncmnxzw4bBD5lXypqGBFfYu1IXFyuEFUL4qFljVYo1LTk21MlECrx4bNNJwQQgw3kcFQ57L2VevM8cozeUr+yj8JdSo85pn7H2mjSm0SwhWFdZrsMv+M7mQVmWw64SUqRBEe5LvPHDZFcoRBxumRwI+yrc2B/TUt1thq5SnVtVirETuTEqkoqdOsP+7u8b55R8u9vJrlZkeBl3cOuskq8l+bRzoJloQQIkAMpXAacLiT7U9qT+cptXr6l6fUmbbtUWL6sD3JcOG0KewKdp7y4vH27w3/aLmXT3LcOO2967O2gUC7AWuOuNmc1/8Nf72mNWKUW2WSFt11vpjNsPbN21dkklXkO2D0mpotJz28dcBNbYtmYoKB1vDhYTdbTkpV9J6QYEkIIQIoJlRx6ivbn3i8mnU5bgprNaOi/B/QBJ+eERoCq/0DKiFcUVBjklPR99GlwlqTNdlW0Opr3zxf4sKs0ahPc7ysP+bpV/C265SXPYVekiMU9m5+gaFORYgTPj/hoaS+8z5odmvWZHtYd9SD3YC0aMPa1ibCIMSh+CTHy/qc/rX5fCDBkhBCBFCoA5rd1pRbm235Hg76MU/pfBVkVyis0aW+jOhUNZm8f9hNdbMVtPZnyjImxFo5uDnPy0fZfVupl1dlsvGEh9DTuVE9kRimrNWURz3nrNCrbDR5c7+bbfle4sIU8WEd3/JjQxUxIYov8rx8dMRDi1sCpq70KVhqbJS9N4QQoieUUoQ64VCpicerOV5psjnPS4Qf85TOZ4nhirxqs8u8sK40tlq1lAprzT5v8PtVkcHWRsQ7C7y8e9BNY2vPg4/aZs3HR900uyG+F9OySinSohU5FSZfnjxTTiC3yuTVfW6OVpikRyvCuwi+IoMVyeGKnaesNje4JGDqTJ+CpaSkJO699142bdrk7/YIIcSIExOiKGvQHCg1+STHjcsLsSGD3aqRIdih0Nqavupp7k1Tq2bNETc5FSYZ0YZfR/dCnYrUKMX+EpO39rupbe66Ta1eTUm9ycESLx8ftaZl0/oQuDltiphQxdaTXk5Umew65eX1fa1UNFrlKLpbLRjqVIyKUhwotUaiqpoCWxJhOOpT6YAXX3yR1atXc8UVV5CZmcm9997bXvBRCCFER0F2hcfU7Mj3UFhrvYGN1FVqgyEh3CrUmFulGRfnu1/zq00+PeYmt0qTGnmmlpI/BdsV6dFWTaY39rdy3VQHUcGKyiar5EBlo0lRnaasQdPk1rg81nmj+jEtGxOiyHdpPjriobpZE2ynVyNmQXZFRjQcrzJ5fZ+b66Y6SImUTJ02fQqWbrzxRm688UbKy8v561//yurVq/m3f/s3VqxYwb333sv111+P3T5sSjgJIUTAWTWXNKNjJE/J30IdijKt2X3Kw9jYzotweryaHQVeNuV5aGqFjOjABEptnDZFRoy18e/fstyYppVs7fK2/RxCHFbOULDdPyUeRkVaxTpjQhUR3ZQ/6IzDphgdbW3K/MZ+NytnOkiKkIAJ+pngnZCQwKOPPsq+ffv45S9/ySeffMItt9xCamoqP/rRj2hqavJXO4UQYliLDVVMTJA8pUBJCFMcqzDJrzl32qst0fnjox4MBaNjAhsotbEbitExqj3xOjZUkRmjGBNrMCrKIDbU+nvw1yijzVBkxBh9CpQ6XkNR3qjZni91mNr0a/intLSU559/ntWrV3Py5EluueUW7rvvPk6dOsVTTz3F1q1bWbt2rb/aKoQQw5ohU28BE+a08sJ2n/KQEW2NLmltbbj72TEP5Y0mqVFGnzYp7g9DKRK6KCw5VBlKkRAGB0u9zEmzkRaA8hbDTZ+CpTfffJO//OUvfPzxx0ydOpV/+Id/4O677yY6Orr9mEWLFjFlyhR/tVMIIYTwKT5MkV1uUliniQmBjcc97C70YjMgM9aQYLUXwp1Q0Qg78r2Mmt630a+2YDUzxui2KvpQ16dg6Vvf+ha33347mzdv5oILLuj0mNTUVP7lX/6lX40TQggheircCeUNsOWktVXIyWpNYnjf8nfOd+r06NKRci8FNbb2rV16I6fC5KMjbi5It7FknH/3zhtofQqWiouLCQ0N9XlMSEgIP/7xj/vUKCGEEKK3lFLEh8G+Iq+VrBzTfRVs0bXwICt3aUeBh/TozhPnu9Ls1nx+wkNFo2Zvkcn8ND2sR5f6FCx5PB7q6urOuV0pRVBQEE6ns98NE/Dmhr2s23GKCucXhAd1vTt0SEgICxfMx2aTHaSFEOe3yGBFsN3AYRu5mwgPpMRwa2rzZLUmM7bn/bkt30NBjWZ8vMGpGs2hUi8XZgzfVfJ9anl0dLTPP8K0tDRWrVrFj3/8YwxDlh321evrs/hsVwFQ0O2xWmsuufiiwDdKCCGGOOcAJ3GPZGFORXmDZnu+h4wYR4/yvgprTXYUeIkOsQpihjg0e4q8zEq1ETRMfzd9CpZWr17Nv/zLv7Bq1SouvPBCALZv387zzz/Pv/7rv1JeXs4vfvELgoKC+P/+v//Prw0+n1wxfyK6pZ4axyhCnJ0HndXVNWTnHGP7zl0sXrRAPkkJIYTwq8RwRU6lSW6Vybg43zMYHq9m43EPja2QGWPdFh9m1X86Wm4yI2V4zoD0KVh6/vnn+Z//+R9uvfXW9tuuu+46ZsyYwR/+8Ac+/fRTMjIy+OlPfyrBUj98+4aFpDqqyQ5fSlJU51ObTc3NPPFf/01xSSmFRcWkjRr6VdSLS0rJOXac+fPmEBoiez4IIcRQFnq6LMP2fC+ZMb63h8kqNsmpMEmJPLOCzmFT2A3N7kIvU5P8u73MQOnTHNmXX37JnDlzzrl9zpw5bNmyBYDFixeTn5/fv9aJboWGhDBjmlWiYfvO3YPcGt+qa2p45bU3+eXTv+PdD9bw57/8FVdr62A3SwghRDeSIhTHK31vWFzVpPkyz0OIg3PqWcWHK/JrTE5U9X7fOY/XKoxZ1jB4e9b1KVhKT0/n2WefPef2Z599lvT0dAAqKyuJiYnpX+tEj1wwfy4Ae7L24Xa7B7k152pqbub9jz7mqf95mp27s9Ba43A4yC84xQsvvoLH4xnsJgohhPAhxKEwNewo8OI1z63qbWrNplxr9VtnRTiD7daGx1mFva8KnlVk7RFT3TR41cT7NA33i1/8gpUrV/LRRx+111nauXMnR44c4fXXXwdgx44d3Hbbbf5rqejS+LFjiImOprqmhgMHDzNn9szBbhIAbrebzVu28elnX9Dc3AzAuLGZXHvVcrTWPPPn1WTnHOPvr7/NHbd+XRYDCCHEEJYUrjhRZU2zTU7smHt0tNxkX7GXpAjVZRJ4XKg1OlVYp3tcFbyozmRLvpdx/W59//QpWLr++uvJzs7mD3/4A9nZ2QBcffXVvP3222RmZgLw0EMP+a2RwjfDMLhg3hzWfrqB7bt2D3qwZJomu/bs5eN166mprQUgOSmRa69azuRJE9rnsb951+0898JL7Nm7j/DwMK6/9ipJUBdCiCEq2KEAa0PiCfFnco+aWq2aSgoId3b9Gh7mhLJGqw5WWlT3H45bPZpPczw0uPz0APqh18GS2+3mqquu4plnnuHJJ58MRJtEH8yfN4d16z8j59gJqqqriR2kKdDiklJe/vvrFJeUAhAdFcWKK69g3pxZ54wcTZ40gdtvuYmXX32DLzZvISI8jCuWXDoYzRZCCNEDieGK3CqT7HKTqUnW6NLWkx4Ka3W3Vb6VUsSGwKFSLwsybMSF+Q6YtuR7OFZhkh6poMVvD6FPej3v4XA42LdvXyDaIvohNiaa8ePGALBj155BaYNpmrzy2psUl5QSEhzMtVcv5wePfZ8L5s3pcopt7pxZXH/tVQB8+PEnQz5JXQghzmfBdoWhYFu+F7dXU1BjsvOUl5jQnlVLjwqGOhccKPH6PC6v2mTbSatWk2MIVBvoU5LI3Xff3WmCtxhcF86zEr137NqDaQ78qoEDhw5TWFRMUFAQ//fR73H5pYtxOLrfD+jSxYu4/LLFALz25jscPHQk0E0VQgjRR4nhivxqkwMlJhuPe2h2Q3Rwz85VShEZDHuLTRpcnSdsN7s163PctHggZohUl+nzdifPPfccn3zyCfPmzSMsLKzDz3/5y1/6pXGid6ZPm0JIcDA1NbUcO5HLxPEDlxJnmiYfr1sPwKUXLyQyIqJX51+z4koaGhrZsWsPf/3bqzxw7z2MHZMZgJYKIYTojyC7VTdp60kPZQ26Q02lnogNUZys1hwu83JBescwRJ9eVXeyWpMeffq6g7cIrl2fRpYOHDjA3LlziYiI4OjRo+zZs6f9Kysry89NFD3lcDjak7t3DPB0Vtbe/ZSWlRMSEsKlixf2+nylFLfcdD1Tp0yygvEXXm7PexJCCDG0JEYo8ms1YU56vYWJzVCEOGB3oZdWT8dIKKfCZGeBl7gwhcM2dBb89GlkacOGDf5uh/CTC+fP5cut29l/8DBNzc0DUiHb6/Wy9lPrb2LJpRcT0sf7tNls3H37Sv70lxfIzcvnT8+9wHcfvI+42Fh/NlcIIUQ/OW2KifH0aK+4zrRvgVJhMj3ZSkqqd2k2HPfg1RAVPHQCJejjyFKbY8eO8fHHH7fX0OltoSnhf6NSU0hJTsLj8bAna/+A3OfO3VlUVFYRFhbG4oUL+nUtp9PJt+65i+SkROrq6/n9n/5CZVWVn1oqhBDCX/oaKIG1BYrNgN2nrCKXptZsPGGtqkuNHFqBEvQxWKqsrGTp0qVMnDiRa665huLiYgDuu+8+HnvsMb82UPSOUooL57clegd+Ks7j8bBu/WcALF1yCUFBQf2+ZmhICA/c+00SEuKpqanl93/8CxWVEjAJIcRIkhBmbYGSW2VyuNQkq9BLUrgaknvH9SlYeuSRR6ztKvLzCQ0Nbb/9tttuY82aNX5rnOibubNnYrPZOFVYRFFxSbfHa63Z8Pkm/vfXv+dEbl6v7mvbjt3U1NQSGRnBwgUX9LHF54qMjOChb3+LxIR4ampr+f2fnqOiotJv1xdCCDG4gh0Kr4adp7xsOO7BZkB40NALlKCPwdLatWt56qmnSEtL63D7hAkTOHnypF8aJvouLCyMaVMmA90nenu9Xt54+z0++GgthUXFPPf8SxQWFffoftxuN59u2AjAsssv61GZgN6IjIzgwfu/RWJiArW1dfz+T3+hXAImIYQYMeJDFccqTMobNMkRQzNQgj4GS42NjR1GlNpUVVX5ZRpG9N8F8+cAsCtrX5cb1bpaW1n917+xdftOlFIkJsTT4nLxx+deoLy8otv7+HLrdurq64mJjm6f+vO3yAhrhCkpMYHaujp+/6fnetQ2IYQQQ1+YE4LtkBrV9Z5yQ0GfgqVLLrmEF154of17pRSmafLzn/+cyy+/3G+NE303acJ4oiIjaWpq4uDh7HN+Xl/fwO//+ByHs49it9v55l23871/eIBRqSk0Njbyx+deaN/XrTMul4v1G78A4MqlS7Db+7SwskciIsJ58NvfIikpkbo6K+m7TAImIYQY9pRSJIQbBPey/MBA61Ow9POf/5w//vGPXH311bS2tvLP//zPTJ8+nc8//5ynnnrK320UfWAYBvPnzgZg+85dHX5WXl7Bb575E6cKiwgNDeXBb69qL2j57W99g/i4OKpravjTcy/Q2NjU6fU3fbmVxsYm4uPimDdnVqAfzumAaVX7Krln/vQXysrKA36/QgghRJ+CpenTp3P06FEWL17MDTfcQGNjI1//+tfZs2cP48YNXNVo4dsF86ypuKM5x6mpsUaJ8k7m8+tn/kxlVTVxsTF878Fvkzk6o/2ciPBwHrjvm0RFRlJaVs6zz7+Iy9Vxy+fm5mY++3wzACuWXY7NNjAb90SEWyNMKclJVlmBP/+F0hEYMJWUlvHr3/2Rw0eODnZThBBC0I86S1FRUfzLv/wLr776Kh9++CH/+Z//SUpKij/bJvopPj6OsWNGo7Vm554sDhw8zDN/Xk1TUxPpaaN4+KH7SUiIP+e82Jho7r/3HkJDQsgvOMXzL77SIe9p46YvaW5pITkpkVkzpw/kQyI8PIwHv72KlOQk6usbeOZPfxlxq+TWf/YFJwtO8dqb79Da2jrYzRFCiPNenxNNampq2L59O2VlZeds2nrPPff0u2HCPy6YN5cTuSfZ+PlmWlwutNZMmTyRu++4lSCns8vzkpMSuW/V3fzh2ec5euw4L7/6BnffvpLm5ma+2LQFgBVXXoFh9KuuaZ+EhYXx4Le/xR+eXU1RcQlr1q3n7jtWDng7AsHtdnPwsLWRcF19PZu+3MoVSy4d5FYJIcT5rU/B0nvvvcddd91FQ0MDkZGRHTbQU0pJsDSEzJwxjbff+5DmlhYALrpwPjddf22Pps5GZ6Sz6u7befb5l9i3/yBvhoQQFBSEq7WVUakpTJ86JdDN71JYWCi33XIT//vr37PvwEFq61YQFRk5aO3xlyPZObhcLgzDwDRNNmzcxEULLhiQbWuEEEJ0rk/DAo899hj33nsvDQ0N1NTUUF1d3f5VJVtTDClBTicLF8xHKcVVy5dy843X9SrHaOKE8dx5280opdi6fScbv7Byla5avrRXu0wHwqjUFMZkZmCaJlu37xzUtvhL1r4DACxedBEpyUk0t7Sw/rMvBrlVQghxfutTsFRYWMj3v//9TmstiaHn2quW88SPHmfZ5Zf1KcCZNWM6N994Xfv3maPTmTxxgj+b2GcXn96Lbuv2nV3Wk+ov0zT5fNOX/Oo3z3C8lxXOe8PlcnHoiFXmYe7smVy9YhlgrTz0VcZBCCFEYPUpWFqxYgU7d46MT/LnA6UUIcHB/brGRRfO5/prryI2Jobrr7160EeV2syYNpXIyAjq6xvYd+CQ369fUVHJ7//0HO9+sIZThUV8vG693++jzaEjR3G73cTFxjIqNYUpkyYyJjPD2n/v088Cdr9CCCF861OwdO211/J//+//5d///d954403ePfddzt8BcJPf/pTFi1aRGhoKNHR0T06580332T58uXExcWhlCIrK+ucY1paWvjud79LXFwc4eHh3HzzzZSWlvq38SPEpYsX8f/98yNkpKd1f/AAsdlsLLzQ2pNu85db/XZd0zTZ9OVW/ufp35Gbl4/zdDJ8bt5Jauvq/HY/Z9t7egpu9qzpKKVQSnHtVcsB2LFrjxTiFEKIQdKnYOn++++noKCAJ554gpUrV3LjjTe2f910003+biMAra2trFy5koceeqjH5zQ2NrJ48WKfhTIfeeQR3nvvPV577TU2btxIUVERX//61/3RZDFAFlw4D5vNxsmCUxScKuz39Sqrqnjmz6t5+70PcbvdjB83hv/zT99ldEY6Wmv27ff/CFZzSwuHs626SrNnzmi/PXN0BtOmTMY0TT5a+4nf71cIIUT3+rQa7qulAgbCT37yEwBWr17d43O+8Y1vAJCXl9fpz2tra3n22Wd5+eWXueKKKwD4y1/+wpQpU9i6dSsXXXRRv9osBkZkRASzZkxjd9Y+Nm/Zxu0r+xbsmlrz5badvL/mU1pbW3E4HHzt6hUsXDAfwzCYPXM6J/ML2Lt/P5dc7N+/jYOHjuD1eklMTCA5KbHDz65avpRDR7LZf+AQ+QWFZKSP8ut9CyGE8K1XwdI111zD3/72N6KiogD42c9+xoMPPtg+LVZZWckll1zCoUP+/+QdCLt27cLtdrNs2bL22yZPnkxGRgZbtmzpMlhyuVwdqlrXnZ6WcbvduN1uv7Wv7VqG9oA5NHKEhqqLL5rP7qx9ZO3bz9euuoLwsLBenV9VVcmz7xzm8CkrkXrsmNHc9vXriIuNAbxgepk5bRLvfvAReScLqK6qICY6ym/tz9q7D4DZM6aitAf0mZ+lJMYyb/YMdu7Zx4drPuY79949ZHLGes30dPxXBIb088CQfh4Yp/vX9Hr8+h4L9Ph6vQqWPv744w5Bwn/9139x6623tgdLHo+H7OxzN20dqkpKSnA6nefkQCUlJVFSUtLleU8++WT7SNfZ1q5dG5AVghMaN0Kj3y87okTZNJmJYeSVNbJv/etcM7/noy8H82v43UfZuNwmTrvBzQszuHxmMoZrFxSfOS4amJASydGiOo5ufocVc1P90vaGZjc5x44DcGlyLdHF5063rZxhJ2uv4tiJPIq2v8G0jGi/3PdgiS79bLCbcF6Qfh4Y0s8DI3fPp+Tu8e81m5o63//0q3oVLGmtfX7fWz/84Q+73Xj38OHDTJ48uV/342+PP/44jz76aPv3dXV1pKens3z5ciL9WBjR7Xazbt06csIuIyHS4bfrjlQXXZpI3uvvsv5wDQuu+QY2W/cpeRWVVfx+7Z9xuU3Gp0Rwy213Ep+QSFcp3NPnR3P03Y/YcrKVBdcu6+Ko3tm6YzdeU5OanETw1Ouo6eQYWwosvMjBF19u49Wd1fzjBTdjGMNwdMn0EF36GTVJS8Do8wYCojvSzwND+nlgnO7nMXOWMiUlyK+Xruvhgp1B/e0+9thjrFq1yucxY8eODdj9Jycn09raSk1NTYfRpdLSUpKTk7s8LygoiKCgc39hDocDh8P/QY2p7GBIsNSdWTNn8d5Hn1JTW8fB7GPMnD7N5/Gu1lZWv/QaLS0uRmek8X+uHUVDQqLPvp4xYwZvvbeGU4XFVFTXEx8X2+92791/GIDZs2b4vO9lVyxh+64sCotK2Hcou0Mi+LBjyN/0gJB+HhjSzwPCsNn9/h7b0+v1ajVc23Lmr97WVwkJCUyePNnnl9PH/mX9NW/ePBwOB59++mn7bdnZ2eTn57Nw4cKA3a8IDIfDwUUXzANg05fbfB6rtea1N96hpLSMiPBw7rnjFuw9GImKCA9nwjgrgN+7b3+/21xf38CxE7kA3W5KHBYWxpJLLgZgzdpP8Xq9/b5/IYQQ3ev1NNyqVavaR1VaWlp48MEHCTudTHt2PpO/5efnU1VVRX5+Pl6vt71m0vjx4wkPDwes5Ownn3yyvXxB2/FFRUUA7flUycnJJCcnExUVxX333cejjz5KbGwskZGRfO9732PhwoWyEm6YWnjRBWz4fBMncvMoLiklJTmp0+O+2LyFrH37MQyDb9x5K1GRET3OC5s1czpHjx0na98Bll5+Wb/au+/AQbTWpKeNIi62+1GqSxcvZPPWbVRUVrFt524WLbigX/cvhBCie70aWfrmN79JYmIiUVFRREVFcffdd5Oamtr+fWJiYsA20f3Rj37EnDlz+PGPf0xDQwNz5sxhzpw5HSqJZ2dnU3vWthDvvvsuc+bM4dprrwXg9ttvZ86cOTzzzDPtx/zv//4vX/va17j55pu59NJLSU5O5s033wzIYxCBFx0V1b7B7+YtnY8uHTuRy/sfrQXg+muvYuyYzF7dx4xpUzAMg+KSUsrKyvvV3ra94GZ3M6rUJigoiGWXLwFg3acbcLW29uv+hRBCdK9XI0t/+ctfAtWObq1evbrbGktfTThftWpVtzlRwcHB/Pa3v+W3v/1tP1sohoqLFy1g34GD7Nqzl2uuupLQkJD2n9XU1vLXl1/FNE3mzp7Vvrdcb4SGhjJxwjiOZOeQte8Ay5dd3qd21tTWkpt3ErD23+upiy6cx+ebvqSqupoPPlrLjdddg2H0qb6sEEKIHpBXWDHijM0cTUpyEm63mx07d7ff7vF4eP7FV2hsbCQ1JZlbbrquzzl3bcnVWfv293lV6L79BwEYk5lBdC9qNtntdq692toG5cut2/nbq28GbBNhIYQQEiyJEUgp1T5i9OXW7e0V599+70MKThUSEhLCN+++vV+LB6ZNnYzdbqesvILikr7tJbhnr5UgPmtG71e1zZoxjdtuuQnDMNizdx9/+ssLNDc396kdQgghfJNgSYxIc2fPJCQ4mMqqao5k57Btxy62bt+JUoq7brulR8nUvoQEBzN54gTgzAa4vVFZVU3BqUKUUsycMbVPbbhg3hy+vepugoKCOH4ij98882eqa2r6dC0hhBBdk2BJjEhOp5MLL5gLwIcfr+PNd94HYMWVVzB50gS/3EfbUv+sfQd6PRXXVnZg3NhMIiMi+tyGiRPG893v3EdkZASlZeX8+nd/orCouPsT/ayyqpo/PLu6PWFdCCFGEgmWxIi16KILUUpRUlqG1+tl2tTJXHHZJX67/tTJE3E4HFRWVfU6QDmzCq7/hSVTU5L5/kMPkJSUSF19Pb/7w7NkHz3W7+v2xrsffETOsRN88NHaQdloWwghAkmCJTFixcXGMmXyRAAS4uO4feXX/bpqLCgoiKmTJwFn8o96oqy8gqLiEgzDYMa0KX5pS3R0FA9/5z7GjR2Dq7WVZ59/kR27/LyJUhdO5OZx8NARAKprasg7mT8g9yuEEANFgiUxot3wtWtYvHAB9636BiHBwX6/flt9pL37ez4Vl3V6Cm7C+LHtBV39ISQkhPu/9Q3mzp6JaZr8/fW3WPvJhn7v4eiL1pr3PvwYsFbpAezO2hew+xNCiMEgwZIY0eJiY7jx+mv9sodbZyZPmkCQ00lNTS0n8wu6PV5r7dcpuK+y2+3cvvLrXLHEmm5c++kGVr/4N2rOKtbqT/sOHKTgVCFOp5Nbv34DAHv3Hxz0UgYlpWW8+c777D94aFDbIYQYGSRYEqIfHA4H06ZOBnq2Kq6ouISysnJsNhvT/TQF91WGYXDNiiv5+o3XYRgGBw8d4b9/+Wu+2LzVr/lEHo+HD9d8AsCSSy5m9qwZREZG0NzczJGjOX67n96oqq7mb6++yf/8v9/y5dbtPP/iK6z9NLCja0KIkU+CJSH6aVb7VNzBLoMRt9vN+s8+53d/fA6AyRMnBGRa8GyLFlzAI997iNEZ6bhaW3nn/Q95+nd/9NtquS3bdlJZVUVEeDiXXbIIwzCYM8saLRvoqbi6+nreevcDnvqfp9m1J6t9vz2AtZ9s4JXXpHCnEKLverXdiRDiXJMmjCckOJi6+npy804ybuyY9p+ZpknW3v18uPYTamqsqbBRqSlcd82KAWlbSnIS3/3OfWzdsYsP16zjVGER/++3f+CSiy9i+bIrCOpjYc7mlhbWrf8MgOXLLm/fXHvu7Fls/OJLDh3OprmlJeABYXNzM599vpnPN2/B7XYDVi7Y1cuvJCN9FFu37+TNd95n1569VNfUsOruOwgNDQ1om4QQI48ES0L0k91uZ/q0KezYtYesfQfag6XjJ3J578OPOVVYBEBUVCTXLF/GnNkzB3QvN8MwWLTgAqZPmcw773/E3v0H2PjFl+zdf5Cv3/C19hV9vbFh4xc0NTWRmBDPhfPntt+empJMUmICpWXl7D9wqMPP/Km1tZVNW7axYeOm9srl6WmjuOaqK5kwbmz7cRddOJ+Y6GheePnvnMg9ydO/+xPfXnU38fFxAWmXEGJkkmBJCD+YPXM6O3btYd+BQ1y8cAEfffwJBw9by+mDgoK4YsklXHrxQhwOx6C1MTIygm/ceSvzj8zmzXfep7qmhueef4mZ06dx4/XX9Lg4Zk1tLZ9v2gLAtVctx2aztf9MKcXc2TP5aO2n7M7aG5Bg6eix47zy2pvU1dUDkJSUyNXLlzJtyuRO9/qbNHE8Dz/4bZ59/kUqKit5+vd/4lvfuIMxmaP93jYhxMgkwZIQfjB+3FhCQ0NpbGzkF7/6DWCN6Cy4YB7Ll11ORHj4ILfwjCmTJ/J/xj7M2k828MXmLew7cJDckyf5xh23MnZMZrfnf7xuPR6PhzGZo5k65dxRqTmng6XjJ/Kora0jKirSL+02TZP1G7/g43Xr0VoTExPNVcuu6NFIXUpyEt//hwd47vmXOFVYxDN/Xs1tt9zE3Nkz/dK285XWmqy9+3E4HV0Gq0KMBBIsCeEHNpuNmdOnsnX7TgCmTpnEtVctJykxYZBb1rkgp5PrrlnB3Nkz+durb1BSWsYzf17N165eziUXL+zyTa+ouISdu7MA+NrVyzs9LjYmhjGZGeTm5bNn336WXHJxv9vb1NTE3159k8PZRwG4cP5cbrr+2l6N1EVGRPAPD9zLy6++wYGDh3n5769TWVnFsisuQ2uN2+2m1e22/m11t3/vcXtIG5VKWJjkOn3Vx+vW88mGjQBMmTSRm2+8jujoqEFulRD+J8GSEH5y9fJlhIaEMHHCOMaflTczlI1KTeF7//AAr7/5Lnv27uPdD9aQl1/ArTffSPDppO2zfbBmLVprZs6YxuiM9C6vO2f2LHLz8tm9Z2+/g6WCU4W88PLfqa6uwW638/Ubvtbn6T2n08k9d97GB2vWsfGLzXz8ifVm7/V6fZ6XkBDPP373O532yfnqkw0b2wMlm83G4eyj/PevfsO1Vy/nogvmDWhenhCBJn/NQvhJWFgo11x15bAJlNoEOZ3cedvN3HjdtdhsNvbtP8jTv/0DpWXlHY47euw42UePYbPZuGbFlT6vOWv6NGw2G0XFJZSUlvWpXVprtmzbwW+e+TPV1TXExcbwvYfu73celGEYXHfNCm6+8TpsNts5gZLD4SA0NJToqCgSE+IJDg6mvLyCN956T+o1nfbZF5tZs/ZTAL52zQqrREV6Gi6Xizfffo9n/rya8orKQW6lEP4jI0tCCJRSLF60gLRRKfz15VcpK6/g//32D9x6843Mnjkd0zT54KO1ACxccEG3FdHDwkKZPHECBw8fYU/WPq5esaxX7WltbeWNt99n154sAKZNncztt9xESEhInx5fZxYuuIDZM6fT4nLhdDhwOBzY7fZzRkRy807y+z/9hT179zF+3BgWXDDPb20YjjZv2cb7p7e4uerKK9pHDr/74LfZvGUbH378CSdy8/if//dbrrryCi65eGGHRQBCDEcSLAkh2mWOzuCfvvcgL/7tNY6fyOXFv73KyfwCUlOSKSwqJjgoiCuvuKxH15ozeyYHDx9hd9Y+Vlx5RY+nZcrLK3jh5b9TXFKKUoprVixjyaWLA5I8HBIS0m0ANiZzNFcvX8oHa9bx1rsfkJ42itSUZL+3ZTjYtmMXb737AQBLL7+UZVcsaf+ZYRhccvFCpk6ZzOtvvUPOsRO8/9FasvYd4LZbbiIlOQmwAuHKqmoqq6qoqKyisu2rqpqUlCRuvuE6IiKGzoIIIUCCJSHEV0SEh/PAvfewZt2nbNi4iS82b2n/2RVLLunx5r/TpkwiKCiI6poaTuYX9Gipfm7eSf68+kVcLhcR4eHcfcfKDkU+B8tll1zM8dw8jmTn8NeX/84/PvzgeZe/tGvPXl5/610ALl28iKuuXNrpcXGxMTxw7zfZsWsP736whlOFRfzvr39PRvooqqpr2ks+dKayqoqCgkLuues2nzlxQgw0yVkSQpzDZrNx7VXLWXX3He1BQVRUJJdcvLDH13A4HMyYPhWw3mi7k19wqj1QGpOZwSPfe2hIBEpgjZrcsfLrREVFUl5RyRtvvXte5S/t3X+AV157E601iy66kOuuWeFzpE8pxYXz5/J/H3mY6VOnYJomeScL2gOl4OBg0kalMnvmdJYuuZRbb76Re++5i8SEeGrr6vjdH59j245dA/XwhOiWjCwJIbo0fdoU/jHpQT7f9CXz587udVHNubNnsnPXHvbtP8iN112DvYuPZ4VFxfzpuRdwuVyMGzuGb6+6e1ALeHYmLCyMb9xxK7/743Ps2bufcWPHcNGF8we7WQF34NBhXnrldbTWXDh/Ljded02Pp0SjIiP55t23czw3j7q6euLjYomLjSU0NKTTa4wdM5pXXn+LAwcP89qb71BwqtD6u7HLW5UYXPIXKITwKSE+jptvvK5P544fO4bIiAjq6uvJPnqMaZPHnXNMaVk5f3zueZpbWsgcnc6999w55AKlNpmjM7h6xTI++Ggtb7/3IRnpacM2f8ntdtPQ2IjWGtPUaNO0/q815un/l5WV88rrb2GaJnNnz+SWm67vdUkApRTjezhCGBwczD133saGjV+wZt16tm7fSXFJKffcdRtRkf4pbipEX0iwJIQIGMMwmD1rBp9v+pJdWXvPCZYqKir5w59X09jYRNqoVO5b9Y32TXmHqssWL+LEiTwOZx/lhZf+zj99b/jlL2UfzeGlV16n6fS+et2ZOX0at91y04DUTjIMg6WXX0Zqagovv/I6J/ML+NVvnuGeO2+TLWrEoJGcJSFEQM2bMwuAQ4ezaW5pab+9uqaGZ55dTV19PclJidz/rXsICQ4erGb2mGEY3L7y60RHRVFROfzylzZv2cafV79IU3MzhmHgcDhwOp0EBwUREhJCWFgo4eFhREZEEBUVyUUXzufO224e8OX/UyZN5B+/+x2SkxKpr2/g93/6C5u3bB9WfS1GDhlZEkIEVGpKMomJCZSVlbP/4BFSUqG2rp5n/vQCNTW1JMTH8Z37Vg2r7UTCwkK5+46V7flLY8dksnDBBYPdLJ+8Xi/vfrCGzVu2ATB/7mxuuen6IZ0PFB8fx/ceup9X33iHvfsP8Na771NcUsLNN14X0H3o3G43zz3/EtU1NcyeOYN5c2eTEB8XsPsTQ9/QfZYIIUYEpRRzZ89kzdpP2bP3AAtj4vjD31+ksqqK2JgYvvPtVcOyrk7m6AyuWbGM9z9ayzvvf0RGehqjUlMGu1mdam5p4cWXXyU75xgA11x1JZcHqHaVvwUFBXH3HStJS0vlwzXr2Lp9J8lJSSxetCBg9/nehx+Tc/wEcGZbl9EZ6cyfO5vZM6f7tThqT7hcLl578x2O5hzHbrfjcNix2+3n/t/uIDw8jPS0UaSnjSIpMUG2nfETCZaEEAE3Z5YVLB07kct/V5dQVtVMVGQk3/n2KqKjhu/Gq5ddcjEn8k5y6HA2f3/9LR753kMBD0DapqF6ej+VVVU89/xLlJaV43A4uPO2m5kxbWogm+h3Sikuv3QxdpuNd97/iPc+XEPm6HTSRqX6/b4OHDzMl1u3A7B82eWczC/gaM5xTuYXcDK/gHfe/4hpUyYzf+5sJo4LfA5VU1MTz65+kZMFp3p8zpZtOwAr0Ewblcro9DQy0tNITx8lifJ9JMGSECLg4mJjyBydQd7JfIqqmokID+PBb68iLjZmsJvWL0opbrv5Rn768/+lqLiEnOMnmDj+3BV//aG1pqS0jOycY+TkHOdE3klCgoOZNHE8kyZOYOL4sYSGdj6FmZuXz+qXX6OxsYnIyAjuveeugAQYA2Xxoos4djyXg4eP8OLfXuWfvveQX5Pra2pq+fsbbwNWILx86eUA1NbVsSdrHzt3Z1FSWsbe/QfYu/8AEeFhLJ0Wy8XXaQIRItfV1/On516guKSUkJAQ7rrtFiIiwvF4PLg9HtxuNx6PB4+77XsP1TU15Bec4lRhES6Xi+Mncjl+Irf9mlFRkUyeOIHrrllB8DDIERwqJFgSQgyIeXNmkXcyn7AgOw/cezcJCfGD3SS/CAsL48L5c9n05VY2frHZL8FSbV0dOcdOcDTnODnHj1Nf39Dh5263mx279rBj1x6UUmSkpzFpwngmTRxPetooDGDLkXJWb9iO1+slbVQq3/rGnURFDe9RBaUUt91yI798+vdUVFbxxlvvcedtN/tlNM80TV5+9XWam5tJG5XK1cvPVCiPioxkyaWLueySiykqLmHnrj3s3ruf+oZG3t7WiDd2G5ddekm/23C2quoa/vjsaioqq4iICOeBe7/ZvmVMT3i9XkrLyik4VUh+wSnyC05RUlpGbW0d23bs4lRhEd/+1jeICB9+U+CDQYIlIcSAuHD+XLTpYW5EMcFJiYPdHL+65OKL2LxlG9lHj1FSWkZyHx6faZps+HwTu7P2UVpa1uFnDoeDsWNGM3H8OCaMH0dDYyPZR3M4cvQYpaVl7VNEaz/dQGhICKNSk8k5bo0mzJg+lTtWfh2n0+mXxzrYQkNDuev2W9o3N54wfiwXzp/b7+t+smEjJ3JPEuR0cvftKztNfFdKMSo1hVGpKXztmhVs/OILPvx4PR98/AkZGRl+K21QVlbOH557ntraOmJiovnOfau63bz6q2w2G6kpyaSmJLdv/uxyuTiem8ffX3+LwqJifvvMszxw3z3ExgzvEd6BIMGSEGJA2Gw2Fi2YT3TxJ9QMdmP8LC42lunTprD/wCE+3/Qlt958Y6+vsWPXHj76+BPgzJvyxAnjmDh+HJmjM8558544fhzXXWNNHWXnHOPI0Rxyco7T1NzcHigtvexiViy/csQl+Y7JHM2KK6/go48/4a13PyAjPa1PAWqbE7l5rPv0MwC+fuN1xPdg5ZvNZuPySxZRcWIv23Mq+evLr/LI9x7q92KFwqJi/vjcCzQ2NpKYEM8D933Tb3l9QUFBTJ08iYe/823+8NzzVFRW8ptn/swD936zX/13PpBgSQgh/OCyxYvYf+AQu7P2cfXyZb1603S1tvLxuvUAXH7ZYpZcsrjHpRSio6NYcME8FlwwD6/XS37BKXJychgfVMLYxVfACAuU2lx+6WKOH8/l6LHj/PVvr/KP//BAn0bPmpqaePnvb6C1Zt6c2e11wXpCKcU9l48jr0ZRVl7BS39/jQfu/Wafg9PcvJM8u/pFWlwuRqWmcP+37iE8vGcbV/dGQkI833vwfv743POUlpXz2z88y33fvIvM0Rl+v6+RYmQ+i4QQYoCNzkgnIz0Nj8fDl9u29+rcLzZ9SV19PbExMaxYdkWfa07ZbDbGZI5m+dLLmDtuZNcFMgyDO269mYiIcEpLy3jn/Y96fQ2tNa+++Q41tbXEx8Vx0w3X9voawU4b99x5C06nk2PHc1n7yYZeXwOsqup/fO4FWlwuxmSO5sH7vxWQQKlNVFQk3/3OfYxOT6O5uZk/PPs8R7JzAnZ//eH1ejEHuRipBEtCCOEHSikuu2QRAF9u3Y7b7e7RefUNDWzYuAmAq1csG9JFIoeaiIhw7rzVSvDetmMXe/bu79X5W7bt4MDBw9hsNu6+Y2WfV9YlJyZwy03XA1bu0+EjR3t1/p69+3nuhZdxu91MnjiB+7/1jQGpZh8aGsoD317FpInjrUKcL7zE7qx9Ab/f3vpkwxf895sHyS0s6/7gAJFgSQgh/GT61CnEREfT2NjErj17e3TOuk8/w9XaStqoVGbNmBbgFo48E8aPY+mSSwF4/a13qaio7NF5xSWlvPvBGgCuverKfpdUmDt7JosuuhCAl199g6rqmm7PqamtZfWLf+OlV17D6/Uyc8Y0Vn3jjgFNxg9yOvnWN+5kzqwZ1orAv7/Opi+3Dtj9d6esrJz1n39JTnE9JwvLB60dEiwJIYSf2Gw2Lrn4IgA+3/Qlpmn6PL68vIKt23cC8LWrl4+4ROyBcuXSJYzJHI3L5eLFV17D4/H4PL61tZUX//YqHo+HyRMnsHjRRX5px/XXXkV62iiam5v568t/77IdXq+Xzzd9yX//8tccOHgYwzC44rJLulyFF2h2u507br2ZxQutquhvv/cha9Z+2u3fb3eO5hzjy207+nwdrTWvv/0eXq+XGaOjueyCwSumKuO9QgjhRxfOn8vaTzZQVl5B9tFjTJk8sctjP1z7CaZpMmXSRMaPGzuArRxZbDYbd91+C798+vecKiziLy+8TEJCPFrr9ornZ/+/rLyc0rJyIiLCuW3lTX4LUu12O9+48zb+99e/p+BUIe9+sIav3/C1DsfkF5zi9bfepai4BLBy3W6+8TpSU5L90oa+MgyDG667hrCwMD7+ZD2fbNjIsRO53HrzjST2siZaU1MTb7/3EbuzrNHVhvoGli+7vNdt2rk7ixO5eTgcdu66bMygbs8jwZIQQvhRcHAwCy6cx8YvvmTjps1dBkt5J/PZf+AQSimuuerKAW7lyBMdFcXtK2/iuedfIjvnWPs+eF1RSlkJ4n4uyhgbE82dt97Ms8+/yJdbtzNmdAZzZs+kubmZDz/+hK3bd6K1JiQkhGuvupIL588dMiOKSimuXLqE6Ogo3n73A/JO5vPLp3/H8mWXc9niRdhstm6vcfDQEV5/+13q6xtQSqG1Zt36zxg3NpNxY8f0uC2NjY289+HHACy/4jLiI5v6/Lj8QYIlIYTws8WLLuKLzVs5djyXwqLiczbY1Vrz/kdrAbhg3pxeVWYWXZs6eRL33HUbpwqLUChQVgDw1f8rBaNGpfp9a5o2UyZPZNnll/HJho289ta7VhL/55vaK7HPmzOLr12zYshWz75g3hzGjR3DG2+9S3bOMT5cs459+w9y6803djkCZo0mfdieIJ6YEM9tt9zElu072blrDy///Q0e/f5DhIX1bIXfex+tpampiZTkJC69eAGU9W2Vob9IsCSEEH4WEx3NzOnTyNq3n883beGOW7/e4ecHDx0h72Q+DoeDFcuuGKRWjkwzp09j5vTBT5Rfvuxy8vLzOXY8tz2RPCEhnptv+NqwmHKNjYnm29/6Bjt3Z/Hu+x9xqrCIX/3mGZYuuZSll1/aIbfqwKHDvPHWe9Q3NJxeFXoxK5ZdjsPhIDkpkZP5BZSXV/DK629x7z13dTudduxELjtPb+Vz843X9WhEK9CGxthfD/z0pz9l0aJFhIaGEh0d3aNz3nzzTZYvX05cXBxKKbKyss45ZsmSJdanjbO+HnzwQf82Xghx3mkrI5C1bz+1dXXtt3u9Xj5YY40qXbp44bDfr010zjAM7rp9JTHR0djtdlYsu4LHvv8PwyJQaqOU4oJ5c/i/j3yP6dOmYJom69Z/xq9+8wz5BYU0Njbx0iuvs/qvf6O+oYHEhHgefvDbfO3q5TgcDsCqGt6WuH74yNFuV9p5PB7eePs9AC66cP6QKZQ5bEaWWltbWblyJQsXLuTZZ5/t0TmNjY0sXryYW2+9lfvvv7/L4+6//36eeOKJ9u+72sFbCCF6Kj1tFGMyR5Obd5LNW7ZxzQorL2nbzt2UV1QSFhbK5ZcuHuRWikCKCA/n//zTdzFNk5CQkMFuTp9FRkbwzbtuZ9+Bg7z5zgeUlJbx69//kZDgYJqam1FKseTSi1m+9PL2IOlso1JTuO6aFbz17ge8/9FaxmSO7rJUw4aNmygvryAiPJxrViwL9EPrsWETLP3kJz8BYPXq1T0+5xvf+AYAeXl5Po8LDQ0lOXlwVyIIIUaeyxYvIjfvJFu27WTp5ZehtWbtJ9a2JldecTnBA1B4UAyuoD4WuhxqlFLMmjGd8WPH8M77H7E7ax9Nzc0kJiZw2803Mjoj3ef5iy66kJzjJzhw8PDpffQePOfvv7yikk8/+xyA67929ZAKMIdNsBRIL730Ei+++CLJyclcd911/Nu//ZvP0SWXy4XL5Wr/vu70ELvb7e5x1d6eaLuWoT1gDt6SyfOC6en4rwiM86yfp04aS3xcLBWVVezcuZOGxiYaGhqJj4vlovmzwPTf60UH51k/D5rzsJ/DQpzcufIG5s+ZQVl5JQvmz8HhsHf7t6yAW2+6llOFRVRWVfHG2+9y58ob2/OXtNa8+fa7eDweJk0Yx+zpk85c83T/ml6PX99jgR5f77wPlu68805Gjx5Namoq+/bt4wc/+AHZ2dm8+eabXZ7z5JNPto90nW3t2rUBmcKb0LgRGv1+WdGJ6NLPBrsJ54XzqZ+XT4vi5c+r+PyzDTS0WC/Mt1wQT3x54Ff3nE/9PJjOx36+MAwIAyo+6/E50cB3lqbx32/WsmfvAWbHN3PxlEQAtmSXk3M8F4dNseqiSGJKPj3n/Nw9n5K7xx+tP6OpqWclCQY1WPrhD3/IU0895fOYw4cPM3ny5IC14YEHHmj//4wZM0hJSWHp0qUcP36cceM6X1b6+OOP8+ijj7Z/X1dXR3p6OsuXLycy0n/Jmm63m3Xr1pETdhkJkefOAws/Mj1El35GTdISMM77zxCBcx7287S4VkJ2/D8q61sAyEgfxbjFt1ITyAJ752E/Dwrp515LSIEVdYl8tG4DL36eT8KM5YSHhfHKl78DYNnSJTgmL6bm7JNO9/OYOUuZkuLfac26sxZf+DKov93HHnuMVatW+Txm7NiBXTmwYIFV7v3YsWNdBktBQUGdzkM7HI5Ok9v6y1R2MCRYGhCG9PWAOI/6OSjYwcIFF7D+sy8A+NrVK1C2Adr76zzq50El/dwrly+5jGMnTpJz/AR/feVNUlNSaGxsIikxgcsuuaTLwNOw2f3+HtvT6w1qsJSQkEBCQsJgNuEcbeUFUlJSfB8ohBA9dMmihRw+cpQxmaMZOyZzsJsjxKAyDIM7br2Z/3n6dxSXlFJcUgrALTddPyh74/XEsKmzlJ+fT1ZWFvn5+Xi9XrKyssjKyqKhoaH9mMmTJ/PWW2+1f19VVUVWVhaHDh0CIDs7m6ysLEpKrD15jh8/zn/8x3+wa9cu8vLyePfdd7nnnnu49NJLmTlz5sA+QCHEiBUREc5j//jdc/YJE+J8FRkZwR0rzxRrXXDBPMZkjh7EFvk2NEO4TvzoRz/i+eefb/9+zpw5AGzYsIElS5YAVjBUW1vbfsy7777Lt771rfbvb7/9dgB+/OMf8+///u84nU4++eQTfvWrX9HY2Eh6ejo333wz//qv/zoAj0gIIYQ4f02eNIEbr7uG47l5XHv18sFujk/DJlhavXp1tzWW2naUbrNq1SqfOVHp6els3LjRD60TQgghRG8tXnQRixddNNjN6NawmYYTQgghhBgMEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGEDxIsCSGEEEL4IMGSEEIIIYQPEiwJIYQQQvggwZIQQgghhA8SLAkhhBBC+CDBkhBCCCGED8MmWPrpT3/KokWLCA0NJTo6utvj3W43P/jBD5gxYwZhYWGkpqZyzz33UFRU1OG4qqoq7rrrLiIjI4mOjua+++6joaEhQI9CCCGEEMPNsAmWWltbWblyJQ899FCPjm9qamL37t3827/9G7t37+bNN98kOzub66+/vsNxd911FwcPHmTdunW8//77fP755zzwwAOBeAjnjWa3ptWjB7sZQgghhF/YB7sBPfWTn/wEgNWrV/fo+KioKNatW9fhtt/85jdceOGF5Ofnk5GRweHDh1mzZg07duxg/vz5APz617/mmmuu4Re/+AWpqal+fQznA601xXUaDYyJBUOpwW6SEEII0S/DJljyh9raWpRS7dN4W7ZsITo6uj1QAli2bBmGYbBt2zZuuummTq/jcrlwuVzt39fV1QHW1J/b7fZbe9uuZWgPmMMj6Gj1QLBNE+ZUVNRrEsOHR7sxPR3/FYEh/TwwpJ8HhvTzwDjdv6bX49f3WKDH1ztvgqWWlhZ+8IMfcMcddxAZGQlASUkJiYmJHY6z2+3ExsZSUlLS5bWefPLJ9pGus61du5bQ0FD/NhyY0LgRGv1+2YBJgjPtrR/EhvRBdOlng92E84L088CQfh4Y0s8DI3fPp+Tu8e81m5qaenTcoAZLP/zhD3nqqad8HnP48GEmT57cr/txu93ceuutaK35/e9/369rATz++OM8+uij7d/X1dWRnp7O8uXL2wMxf3C73axbt46csMtIiHT47bqBlF+jmTfK4Irxdt475OZQqWZ0jGLIz8aZHqJLP6MmaQkY581niIEn/TwwpJ8HhvTzwDjdz2PmLGVKSpBfL902M9SdQf3tPvbYY6xatcrnMWPHju3XfbQFSidPnmT9+vUdgpnk5GTKyso6HO/xeKiqqiI5ObnLawYFBREUdO4vzOFw4HD4P6gxlR2MoR8smVrjRTM6zkFwkI3LJtgpqHdT0axJCB8mawmM4dHXw57088CQfh4Y0s8DwrDZ/f4e29PrDWqwlJCQQEJCQsCu3xYo5eTksGHDBuLi4jr8fOHChdTU1LBr1y7mzZsHwPr16zFNkwULFgSsXSNVYyuEOSE1ygqMEsMNFo228VG2hyiPxmkf6sNLQggxfLV4NPk1JglhBjEh8nrrT8Pk4z7k5+eTlZVFfn4+Xq+XrKwssrKyOtREmjx5Mm+99RZgBUq33HILO3fu5KWXXsLr9VJSUkJJSQmtra0ATJkyhauuuor777+f7du3s3nzZh5++GFuv/12WQnXB3UtmqQIg+jgM7fNTbMxPs6gqE6jtZQTEEKIQDC1prDWZEyMjZpmTVOrvN7607CZZP3Rj37E888/3/79nDlzANiwYQNLliwBIDs7m9raWgAKCwt59913AZg9e3aHa519zksvvcTDDz/M0qVLMQyDm2++maeffjqwD2aEcnlhXJyBOitByWlTLBlnp7iulZpmiPF//rsQYoiradZUNGpSIhVhThnxCITiOk1SuMEN0+x8medlV6GXjGhw2KS//WHYBEurV6/utsbS2SMXmZmZPRrJiI2N5eWXX+5v8857rV6Nw4BRkecOVqZHGyzIsLH+mJfwIHnyioFR0WhS26IZE2tIva9BorWmpF5japicaJBTYRIfBhFB8vvwp5pm671u6QQ7CeEGyyYqalo0JypNMqXenV8Mm2k4MbTVuyAiWJES2fmT8sIMOxkxiuJ6GRoWgdfq1dS3QGyIQWWT/M31VVOr5nilSU1z76fRvabmZLUmyK64fpqDW2c5WDjaRmWTbn9zF/3X6tFUNWkuyrAxKcF6Sw9zKq6ebCchTFFcJ33tDxIsCb9ocGnGxhgEdZHEHeKwpuPshpXbJEQgldRrRscazEw1qGux8jlE75inR4XGxRm4PJq8ak2zu2f92HZ8SqRi5SwH05NtOGyKZRPsXDrWRl2LliDWD0ytOVWrmZhgsHiMvUMKRGK4wfJJdmwGVDYO7742Tzd/MAfIJFgS/WZqa5g9I8b3n9PYWIM5qTbKGzVec3g/ecW5yhtNcqvMwW4GDS6NoeCSMTbmp9mJD1PD/s1iMJQ3aOLCFNdNtXPnXCeTEw3KGqwkYl/P33qXprBWMy3J4LZZTtKizrwu2AzFZWPtLJ1go9mtKW8Y/L+X4ayk3vodLZ9o73S18cQEG5eOtVPfqmkcxgnfFaefv6lRgxeySLAk+q3JDaEOSI3yHfYrpVg8xk5qpKJEpuNGFK2taS+HDVp6OPoQqHaUNpjMSLYxLs4gMlgxd5RBvUtGl3qjxaNpdsPFmXZiQw3SogxWznRw03QHcWGKk9XWyNDZU3NaW8FPdZNmUaaNm6Y7iOpk+bqhFAtH27lqkgOPCcV1pqyU7YO6Fo1pwtLxdp917C5MtzF3lI2Sek2rd/j1c6vX+lsECB/ExQESLIl+q2+xPt3Eh3b/hxwepLh0rB1TQ22LlBPoK49p5X00DJFPi81uCHZAdLCVWDpYKho1MSEGizJt7VMSs1LtxIWp9k+nwre2zbAnJhjMSuk4KjQjxcbdc51cMd6GaWpyq6wl6m3TQRq4eoqDK7sY6WijlGJemo2vTXVgNxiSpUW01tS7NO4hGGC0eq3VhRdk2Jia5Ptt3GZY058T4g1O1ehh96GhpF6THj34CeoSLIl+a/HA+K+UDPBlcqLB7FRrGD63WpNXbVLRaOLyDK8n8UBqC44Ka01OVJoU1lpTmeUNQ+PFvLpZkxyhmJ5s0NQ6OG1wezX1rXBRho34sDMvbRFBinmjDBpcyPRvD1Q1QbgTK8ewk5WrYU7FZeMcfGOek5mpVgL9sQqT2FDF12c4mZ9m6/Hqq+nJNq6f5iDUqSioHVpv5FXN1iqzojpNbpVJWYNJyxB4jdLamuYcF2dw6VfylLoS4rASvpMiFIW1Qy8w7UpTq0ZhPacH27ApHSCGJrfXyg9Ji+553G0oxTVT7CzIsFFUZ1WczasyKWvQuE2N02a9wYU7rU9F5yNTa+pdVv5NqxcMZb2BjY4xyIw1SI5QxIQYvHWgleK6wf3kpbWmxQNTk2ykRhpsyvPS4tYEOwa2TSX1moxoxZxR576wzkq1s7vQpLJJkxh+fv5N9YTbq6lt0SyfaCOlkzIgZ0uKMLhpuoNpSVYAf+FXgtSemphgw2lXvH/QzclqTbhTYxgKuwE2BTbj9Jeyngc9/VDWH26vprZZc8V4G6OiDPKqTXLKTSoaNK2mJsQOUcGKkEF4Dy9t0ESHKFZMsvfqORYfZrBikoM397dS0ahJGOLPA2tKXTMj2WBsHBwd5PZIsCT6pcEFEUGQ2s0L61cZSpEQrkgIh1mpNlo91sqbojqTE1UmxXUmBTWg0UQGKaJCwH6eBE5ur6agRhMZ3DE4Sgo3CP9KfZqLM+28ts9Ns1sTMsDBSZuGViuQGxtrEBuqSAhT1kjTALanLXn1kjGdv4GEBynmpRl8nO0lLlSft0F4d4rqNGPiDOan9+ytwVCKyYk2Jif2L2rIjDH4+gwHG094qHNpWtzWaKrLBK8JXm39a2rrTTQyGOJCVcACp+J6awPwBRnW39P4eBtLxurTH+68ZJeblDdoSls1MYBpgjEA8zT1pz88XTXJTlJE7+9wXJzB5ePsfHTEQ22LJip46D4Palqs7bMWZdoxlHewmyPBkuifepdmWrLR7zdqp12REaPIiDG4aHTbihprddXRcpNTNRrU6cApeOSOOLWeDpTGxxt8bYqVXOvLhHiDSfEGh8pMMmMG5lP3V9U0a8bGGcSHWW9ekxMNPs0ZuBc3rTWl9SZzRtkZH991f81MsbP7lElFkyapF5+q61o0dS2a1Cg1oov71TRbo7pLxtq7LAESSKlRBnfMcQLWdGmrl9NfmlbPmf+X1ZtsL/CSW61JicDvHxLqXRqbgkvHdgy87bYzr1GLMjVlDZq8Ck3pPmu0JyXar804R12Llad0UYaNGSl9j8zmplmlGzbleTE1Q3IPOVNbtaMuHWuNcLrdEiyJYUxrjceEzBj/j0VHBJ35xLpknOZktcmxSpOcci8FNaCU9akoImjkBE4uj5UkOznB4Lppjh5VObYZikVj7ORVt1Lngqjgbk/xK1Nr3F6YkngmoXpMrA2nfeCm4iqbrL+FizN958qEBynmpdv46IiH+B6OLtU0W9NSEUGKsgYrL2sk8prW6rZLx9gYHTP4j9FmKEIMCHEAdGzPpAQbExNsbDzu4Ui5idOmSYrwTyBraisIWpBhrabsiqEUyRGKuGA7H+4Dj0nA/t5bTo+6B9lgQYaNJePt/XqshlIsGW/HaYfPjnvxmrpP06dgjf4Zyv8VwssbNAlhigt6OMI5EIZOS8Sw0+y2XsxGdVMyoL9CHGcCp4axdk5Wm+RUmJyo9JJfA+FO7XPp7HDQ4tYU1lm1ab421dGr/bPSogxmpdjYfNJLRFDvX7havRqv2bdP6PWnp2HHxJ7p/9TIgZuK85iauha4cqKtR38DM5Jt7DrlpaLReoP1parJWm142VgbkcEG7x9y09iqh8XeZq7TS63rWyA8RHc74lhcpxkVpbhodM8ShgdbUoTBzTMd7C8x2ZTrIbdKkxje/21USuutnLbFmb3rh/HxiiMV2q+ju17TCpI8JkyMN7g40056tH+mHg2luDjTjsOm+DTHQ1mDSWIvXkPbCpa6PNb3Ck2Y0/pAEmzvXx+4vZomN1wx3jakpgklWBJ9Vu/SxIYq4sMG7g86PEgxLdnGtGQbdS12DpR4+STHM6g5O/3V5NaU1GlmpRhcM8XRp8exYLSdI+UmFY29S2Bum/ZTQEZM7/PCapqtadjos4bybcbATcWVnE5un5fWs5ey8CDFBek2PjzswWt2PbpU0WjS7Ial421cNNq6dkGNjZ2nvGTGDO3RTFNriutNkrBGJcqqNNHB1ibWnQXSDS5ryf9lY+3n5MQNZTZDMTvVxpgYg015HvYWealu1qREqD7tP9nstqb+Fo+xd1ofypeFo+3k12pqWyA6pNd33YHWmqomq7RKapRi0Wg7U5MMv//NKaW4MN2G06ZYe9RNcZ1JckT3wViDy0q8TgxXXHW6QnhhjUlutVVjq8ULNqUJP71Ip7dTuiWn88Vmpgz+CrizSbAk+qzJDfPT/f8k7qnIYMWCDBuFtSYHSkzGxA5Ozk5/NLZqSus1c0fZuGpy33NFokMUF4228eERDzFe3aM3i7ZE8kkJBo2t1vRDahd7+3XGa1qV2yclnPuiNhBTcU2t1pv84jH2XgWY05Nt7CzoenSprMHE7YXlE+1ckH5mevGycXaK6kyK6zRpQ6DuS1dK6jXxoQa44I45Do5UGOwvMcmr0oQ4NPFhZ4IJ8/SKowvSzuwrNtxEhSiumWxnYoLB5yc8nKzWRIdAbEjPXw/aNvydkmgwI7n3/ZAaaTBnFHyR6yUyuO/TUlYgYhIVrLhyoo25o+yEBnAkUylr9ajTBh8dcVNUp0mN7LzfvKZu32fugnQbl54VVM5MseHxasoarWMKakxO1pxe4ezVhAdBfFj3U6VNpxdqLBztu07XYJBgSfSJ17RGI9IGsfw8WJ8uLx1rJ7+mlcomPaCjXP1V77ISNi/MsFlF/Prwafhss1Js7C/2Ulrf/Zu519QU1GrGxFrTfrlVJu8ccNPq1T1uR22LlSOV2ck2N4Geimt7c5uZYjCxl2/yYU7F/E5Gl9qWKmsNV092MDu1Y+2wqGDFFePtvL7PPWRXEjW4rCnVxWNt5O2y9gcbFePgwgzN4VIvWUVeCus0Bpr4cEVdi5Ubsnjs8Jh+64pSignxNtKiDHYUeNiW7+VkDYyKpEcfHKqarRWdl42z9/nD34IMO9nlZp9y27ymVTvJZsD8NDsLM20k9DGPqC+mJdtw2OCDwx4KajXpUR0DptrTyeWjoqztaiYlnFtXz25TpEYqUiNhXtqZFc75NV72FJrkVmmigq3ZiM6Cprbn3/Tk3j+nB8LQa5EYFur7WDIgEJIiDBaOtlHnYkgUaOyJuhZN5emVLSv8ECgBBDusbSRMjc8NT02tya/RjIpUXD/VTlSwYmqSQUaMorQX29DUtWgmJNg6nbppm4oLRIFKU1tLuCODrVGlvnyKn5FsIzFCUX66qrfWmuJ6K1n12ikO5oyydRo8TIg3uCDdRkXj0CgGejavab3ZzEq1MTmx4/MyIkhxYYadVfOd3DLDwdg4g6qmM9NOQ3FFVF+EOBSXjnVw+2wno6MNCmqsBH1f2moqXTTaRnIfluO3iQy2psxa3PSqwG7b8zEpQnHbbAfXTbUPaKDUZmKCjRunO4gKVuSfrvTt9lqLa5paNZeMsXHXHCeTEzt/bnyVtcLZYPEYB6sucLJ8og2bocitOnerHLA+fIU6YNHo/iWwB8rgv9OJbmmsF3NfX/5Q19LzzRbrXZpRUefW/Rks89LsjIkxKKobWm9gnalp1lQ3ay4eY40odVYlua8mJ1qfykrqO/+70NqaeksIV9wwzUHc6Rdlp82qKaM1PapS7PZqlLKCh65YU3H+3Suuya3JqzKJCFJcNcnRp1ozAKFOxQVpNpparSTxwlpr2fzXpjiY4SNXom1/wzGxBoUB2KJD674HYUV1Zz75d/Vm47RbOX93zHFw11wnV0+yM7Mfy9CHqvRog9tmO7hkjI1Gl+ZUTdeb/xbXazJjFfN7mPfmy4wUg7FxRo/3vjS1Jr/aGom6YZqDcXE9C0QCZUysVWg0PswKagpq9Om+dLJsQt9z2iKClBU0zXdy+XgbaM2JKut1UGsrMKts0swZZRvUzXJ9kWm4YcDlgbzqrp98WkOYU/f5jQOsN4yKJqu+SJNbE++j4Js+vVx8rI+ltQMtyG5Nx726t5W6Fk3kEJwiASsgrW3RXDLWmvP3d76XzVAsyrSTW9VKvQsizyol0LZNQlSw4vqp5wYakxIMxsQanKgyu10+XtuiiQlRjPZRud2fU3FtS7pdHpiZauPycd3XoOrOjBRrZVxOhUlSuMHXptqZEN99UmmIQ7F0vJ2/722lqhniQvvVjA4qmzTVzRAdrNvrVvVEbYv13L18nJ3IYIXb7ft4QykyY1SnU6gjRYhDsXSCnYwYgw3HPeRVa5Ij6LCasauaSn3lsFnB9KnaVupd2ufqPPP0B5f4cMX10/oe+PtberRVIPSjIx7GxSkuTPdP34CVW3n5OAczk23sLvSyt8hLbpU1FR4fZt3XUDV0Wyba3TrLjs3u6PLnp2o0nx33vbqnO1VNVu7CvDQbX5zwcKpWMyqq80TFFg8E2WHUEJiCO9uYWMWcVGsJfdgQ3CqlodX69HRxZmACpTZpUYpZqTa2nPQSflYpgZJ6TbADrp1iJ72TIMdmKBaMtpFXbdLk1oT6eIGsd8HFmYbPF1F/rYprdmuK60ziwgyWT7RGQvzRdyEOa2UcwFWTHR3KH3QnI8Zg0Wgb6456+7TipzNaW2UQZqVY22v4eg6ezX16U9VLxth8jvSdj5RSTEywptc+O26tmKt3nVkxWtZgTYWP7cXvvjuZp1dybcu3Xoe6ys8pqLE+cFw/1TEk0hnOlhxhsGq+I2CjXHFhBldONJiVamNHgZfsci8XZdh6vQpxIEmwNAyMi7PhcHT9iTc5QrO32Fo225cEZ601DS5YONpg4Wg7ieEGH2e7yavWpEVxTj5Nvcvam2io7bGllFWg8USVSWkvV3b5YmpNs9t603baVJ9GrZrc1sjIhenWqEggAzmlVHuyaeXpPaDKGkyUgqsmORjvY/RkXJzBxHiDw2UmmbGdt7HVYyWijovrfhSmP6vi9OnRpGaPNQq0ZJy9z8XzujI3zarf1ZfphQsy7OTXaI6Um4zxQ32deheEB1kb2Na5NB8d8ZBXpX2WdNDaqs81JtYa0RjOSdqBFBms+NpUO6NjDDaesPrVYYPEcMXFfu43pRQLR9vIqei8lIfWVvHZyGDFddMcnX5wGQoG4m8pMdzgmslWfw3FBRNnG5q/JdErEUGKWSkGtS30KYeitsVK1p6aZL35jYszuG2WgwlxVoJkg6vjNRtbrWP8mWvjL9bcuB2P1wpQesvU1nL+ikaT/Bpru5X8ak29SxNkVzS0WvkPvdkdvcVjLaedm+r/HKWuxIYqFqTbqHdBeYNJqxeunOBgWrLvAMdQigtHW9V9v/p7b1PdYgXlPdm8t20qrqabJNuvanFrcqs1TrviuimO03kU/n+5MpTqcx6G02atjosJsap791dVk2ZivI34MMW4OBsrZzrIjDU4Wa27zPuqboYQO1wxvm/1uc4nhrJGXO+Y7WBqkoHTZu0lGIg36dhQa9FJY2vHRSf69OKEMKfiuqmOET0N2lNKKWJDB68ETU/Jb2qEmJZsIyII6ly9P7e6WTMlydYhByQuzKqQuyDDRmWTFTxorduTJIfqpyGAqUkGU5K6TnL+KrdXtydknqo5ExhNS7KmfW6f4+C+C508tNDJzTMcxIZayY++Vpy1afVYeUIzkg1WTPLPqreemj3KxqgoRZMbLh9nY86onv3ORkcrpiTaKGvovP8aXTA10ejRkuy+rIqrarJ+H9MSDe6a62Bumm3IvpAmRRhcOsZOi+dMjZi+aHFbo3XTU84k+CZFGKyc6WBmikFRvbU/3dlaPZqaFmsV12h50+2xhHArJ+eWmU6m96GmUk/NTrW2jmmrTdS24jLIbk2F+9pORQw9Mg03QiSGG0xKsJLmevNJqanVWgU0vZMRhxCHVaE1PlSx8XQeU8TpqqxDLV/pbGdqL7mpOJ2L1ZlWj1VEzeOF1HAFDXDzTDuJkU5iQlSnb9ATE2wkhht8muPmQIlJeJDucvdzt9eqZTQl0eDaKY4B2SftbCEOxbIJDsobzQ7FFbvTVtn3aLn3nP3mmt3Wi/3YHkzBtekwFdfNaW2Vs5dNsCpnD9Ug6WyzUg1OVhvsKbIKo/Zl2XNFkyYt2iDzK4n14UFW8m9UsIet+V5cnjNT7YV1mglxBhdlyMt4bzlsirFxgf3bCrJbiy1e32ttk1Pv0tgNuGayg4mdFHIVQ9vQfccTvTYzxSos1pvpp4pGzegYo8spFSvp187XZziICVUU1pokRxodVlkNRYnh1jB4Q4u1pcfZWtya/GqT4norr+mm6Q7unGMl0E+ItxEf5ntIODpEceN0B1dNspban6zWeL6yLNljWlVsx8dZRR8DWYXXl7FxBgsyel+3JCVSMT3ZRmVjx9GlmmZNYoTqVT5YT6fiKhpNWjxw5UQ7izKHR6AE1nPksnEO4kIVFY29H13ymtbq0tmpnY+gOW3Wqq6rJzswNRTWWkF+ZBAsnTD0Kh2LMybEG0xNNsivMQGr2OmUJAmUhiMJlkaQjNNLgSt6mD/h9mpMrBfp7t5Mx8fbuHWW43TBu8GtBdJT80bZGBNntA+DN7VaBdbKGzWZsQa3zHRw91wnM1NtvX7DaQsib5vtJCNGcfJ0XhNYb3751VYQev00R7839xwMSlkrxSKDrbwYsKYRmt0wLal302I9mYorbzBxeawtRi7sxSjYUBEbam0389UclZ6obLJKdfjabsRQivlpNm6aYRUNbG6FS8baSRnCI7zizIa1Y2NtrJjk6HQEXwwPMn47ghin9/k5VmH2aNuKyiZNUrjq8XLjhDCDO+c4GPplHy1Ou1Wg75WsVo5XmgTZrU9689JsjIvzT0JherTBbbOcfHbcw+5CLw0uTYsHRkVZ0yfRQ3gpbHcSwq2lvZ+f8BIdAs1uCHHQp2XWbVNxrk7q/5Q1mHhMWD7JwbxR526jMFzMTrVxsMRL0enNfXtCa029Cy7KMHqUoD0h3kbkLEVulcncUfLGOxwkhhususAxoPmKwv8kWBphxscbpERa0wG+pkpMrWlqhcvG9m5URSnFcHrKj46xNtutbtbMGWVndEz3mzn2VqhTcdVkO2nRVi2XyGC4flpgVm8NtHlpdg6UmFQ1WUFgRrTRp5IRbVNxtU2apLNuL20wMU2rpMFX92IbbtpzVPa5aWrVPZp6rTu9bdDkXkzNJEUYQ6aAoegZCZSGPwmWRhinTTF3lI33DvkuUlnTbCXuTkkc2Z9OlVJcPr7rgp7+YiirEF1alMLUjIhACSAmRDE/zWDdUauw5JSkvk2RtU3FbTh65rbSehNTWwUhZ6UM70CpzcQEgymJBvtLTDJ7UHupqkkzb9TAbpoqhOg9eYaOQJMTbcSd3maiM1prappNpqcM7Yqpw1FsqDFiAqU2s1PtJIQpwoNgbBeFKnuiba84sCona6yE19mpwy9HqSuGskaXwpzWBxJfmt0ax+lyAUKIoW1kvaoLwFpuPNNHkcrGVmtZ+TRZlSF6IDxIcVGmnQkJtn7tTp8aqYgPtc5XWEuoZ6WOvL/BlEiDeaNsVDXrLjdvBahstDYpzehhfpMQYvBIsDRC+SpSWdmkGRtr+G07EDHyzRtlcMPU/m0LYTMUExOs81dMtDNjBI+oXJhhJymi68renv+/vXsPiuo8/wD+Pbuwyx3kIhe5GhVQYRVURJNoIkozrdE0VmtMg2OnTSI2goRqJqMQnGSXpJqGxMRM04qZ6UguranGiRMagUwIGgWpl+IWM0a0gESDgCCwsO/vD36cugFW0L2w+P3M7Mye97z7nmcfF3g85+z7GgV6jENPF0BEowuLpTEqwF2BmPFK/NAxcNZfoG/l9rFy6YOsT5IGn3hzpGaG9F2HG8kNzY7IQy1hXoQTunqArp6BBdO1jr7JJSebmS6AiEYP/qSOYfHBSqiUpsswXO3o+5Ycp9one3C10+Sc9jA9SIGJfgp5KZ1+Qgi0d/XN/M313IgcA/9ijmFhPhIifRW42vG/yRI7DX2n/oezrhcR3TlnZd+EhM4KyBOWAv9buHqsfxOVaCxhsTSGKSQJM0OUEKJvyY/mmwLj3CTE8Jc0kU1E+UqYHqzE97csStx8UyAmUAm/MfatSaKxjD+tY9x9t0xS2doJxAcp4OGAy28QOSJJkjAvQgkfVwnXOkTfdAFDLFxNRKMXi6UxTqWUMHOCE9q7AXdV37fkiMh2/NwVmBOmQGsncKVNIILTBRA5HBZL94CYAAWCPPvWgLuTpSqI6O4khDphwv/P7q4ZxsLVRDS6cLmTe4CHWsKSKU7wdrHM17+JaGRcnSU8ONEJJy73DnvhaiIaPVgs3SOmBPDyG5E9xYxXYrK/gpNQEjkg/heHiMhGWCgROSYWS0RERERmOEyx9PLLL2PevHlwc3ODj4/PbfsbDAZs3rwZcXFxcHd3R0hICJ566inU19eb9IuMjJSXcuh/6HQ6K70LIiIicjQOUyx1d3fjF7/4BZ599tlh9e/o6EBVVRW2bt2Kqqoq/P3vf4der8ejjz46oG9eXh4aGhrkx+9+9ztLh09EREQOymFu8H7ppZcAAIWFhcPq7+3tjeLiYpO2t956C3PmzEFdXR3Cw8Pldk9PTwQFBVksViIiIho7HKZYsoSWlhZIkjTgMp5Op8P27dsRHh6OJ554ApmZmXByGjo1XV1d6OrqkrdbW1sB9F36MxgMFou3fyxLjkmDY65tg3m2DebZNphn27Bmnoc75j1TLHV2dmLz5s1YvXo1vLy85PbnnnsOCQkJ8PX1xddff40XXngBDQ0N2Llz55BjabVa+UzXrT7//HO4ublZPPYfnyEj62GubYN5tg3m2TaYZ9uwRp47OjqG1U8S/as72sGWLVuQn59vtk9NTQ1iYmLk7cLCQmRkZOD69evDPo7BYMDjjz+Oy5cvo7S01KRY+rG//OUvePrpp3Hjxg2o1epB+wx2ZiksLAxXr141O/ZIGQwGFBcXY/HixXB2drbYuDQQc20bzLNtMM+2wTzbhjXz3NraCn9/f7S0tJj9+23XM0tZWVlYu3at2T4TJ068q2MYDAasXLkSFy9exJEjR25bzCQlJaGnpwffffcdoqOjB+2jVqsHLaScnZ2t8gNjrXFpIObaNphn22CebYN5tg1r5Hm449m1WAoICEBAQIDVxu8vlGpra1FSUgI/P7/bvqa6uhoKhQLjx4+3WlxERETkOBzmnqW6ujr88MMPqKurQ29vL6qrqwEAkyZNgoeHBwAgJiYGWq0Wjz32GAwGA1asWIGqqip8+umn6O3tRWNjIwDA19cXKpUKFRUVOHbsGB566CF4enqioqICmZmZePLJJzFu3Dh7vVUiIiIaRRymWNq2bRv27t0rb8+cORMAUFJSgoULFwIA9Ho9WlpaAAD//e9/ceDAAQDAjBkzTMbqf41arUZRURFyc3PR1dWFqKgoZGZmYtOmTdZ/Q0REROQQHKZYKiwsvO0cS7feqx4ZGYnb3buekJCAo0ePWiI8IiIiGqMcZgZvIiIiIntwmDNLo1n/Gaz+ySktxWAwoKOjA62trfymhZUx17bBPNsG82wbzLNtWDPP/X+3b3clisWSBbS1tQEAwsLC7BwJERERjVRbWxu8vb2H3G/XSSnHCqPRiPr6enh6ekKSJIuN2z/Z5aVLlyw62SUNxFzbBvNsG8yzbTDPtmHNPAsh0NbWhpCQECgUQ9+ZxDNLFqBQKBAaGmq18b28vPiDaCPMtW0wz7bBPNsG82wb1sqzuTNK/XiDNxEREZEZLJaIiIiIzGCxNIqp1Wrk5OQMuaAvWQ5zbRvMs20wz7bBPNvGaMgzb/AmIiIiMoNnloiIiIjMYLFEREREZAaLJSIiIiIzWCwRERERmcFiaRTbtWsXIiMj4eLigqSkJHzzzTf2Dsmhffnll1i6dClCQkIgSRI++eQTk/1CCGzbtg3BwcFwdXVFSkoKamtr7ROsA9NqtZg9ezY8PT0xfvx4LF++HHq93qRPZ2cn0tPT4efnBw8PDzz++OO4cuWKnSJ2TO+88w7i4+PlifqSk5Px2WefyfuZY+vQ6XSQJAkZGRlyG3NtGbm5uZAkyeQRExMj77dnnlksjVIffPABNm3ahJycHFRVVUGj0SA1NRVNTU32Ds1htbe3Q6PRYNeuXYPuf/XVV1FQUIDdu3fj2LFjcHd3R2pqKjo7O20cqWMrKytDeno6jh49iuLiYhgMBixZsgTt7e1yn8zMTBw8eBAfffQRysrKUF9fj5///Od2jNrxhIaGQqfTobKyEidOnMDDDz+MZcuW4ezZswCYY2s4fvw43n33XcTHx5u0M9eWM23aNDQ0NMiPr776St5n1zwLGpXmzJkj0tPT5e3e3l4REhIitFqtHaMaOwCI/fv3y9tGo1EEBQWJ1157TW67fv26UKvVYt++fXaIcOxoamoSAERZWZkQoi+vzs7O4qOPPpL71NTUCACioqLCXmGOCePGjRPvvfcec2wFbW1tYvLkyaK4uFgsWLBAbNy4UQjBz7Ml5eTkCI1GM+g+e+eZZ5ZGoe7ublRWViIlJUVuUygUSElJQUVFhR0jG7suXLiAxsZGk5x7e3sjKSmJOb9LLS0tAABfX18AQGVlJQwGg0muY2JiEB4ezlzfod7eXhQVFaG9vR3JycnMsRWkp6fjpz/9qUlOAX6eLa22thYhISGYOHEi1qxZg7q6OgD2zzMX0h2Frl69it7eXgQGBpq0BwYG4ty5c3aKamxrbGwEgEFz3r+PRs5oNCIjIwPz58/H9OnTAfTlWqVSwcfHx6Qvcz1yp0+fRnJyMjo7O+Hh4YH9+/dj6tSpqK6uZo4tqKioCFVVVTh+/PiAffw8W05SUhIKCwsRHR2NhoYGvPTSS3jggQdw5swZu+eZxRIRWU16ejrOnDljct8BWU50dDSqq6vR0tKCjz/+GGlpaSgrK7N3WGPKpUuXsHHjRhQXF8PFxcXe4YxpjzzyiPw8Pj4eSUlJiIiIwIcffghXV1c7RsYbvEclf39/KJXKAXf5X7lyBUFBQXaKamzrzytzbjkbNmzAp59+ipKSEoSGhsrtQUFB6O7uxvXr1036M9cjp1KpMGnSJCQmJkKr1UKj0eCNN95gji2osrISTU1NSEhIgJOTE5ycnFBWVoaCggI4OTkhMDCQubYSHx8fTJkyBefPn7f7Z5rF0iikUqmQmJiIL774Qm4zGo344osvkJycbMfIxq6oqCgEBQWZ5Ly1tRXHjh1jzkdICIENGzZg//79OHLkCKKiokz2JyYmwtnZ2STXer0edXV1zPVdMhqN6OrqYo4taNGiRTh9+jSqq6vlx6xZs7BmzRr5OXNtHTdu3MC3336L4OBg+3+mrX4LOd2RoqIioVarRWFhofj3v/8tfvvb3wofHx/R2Nho79AcVltbmzh58qQ4efKkACB27twpTp48KS5evCiEEEKn0wkfHx/xj3/8Q5w6dUosW7ZMREVFiZs3b9o5csfy7LPPCm9vb1FaWioaGhrkR0dHh9znmWeeEeHh4eLIkSPixIkTIjk5WSQnJ9sxasezZcsWUVZWJi5cuCBOnToltmzZIiRJEp9//rkQgjm2plu/DScEc20pWVlZorS0VFy4cEGUl5eLlJQU4e/vL5qamoQQ9s0zi6VR7M033xTh4eFCpVKJOXPmiKNHj9o7JIdWUlIiAAx4pKWlCSH6pg/YunWrCAwMFGq1WixatEjo9Xr7Bu2ABssxALFnzx65z82bN8X69evFuHHjhJubm3jsscdEQ0OD/YJ2QOvWrRMRERFCpVKJgIAAsWjRIrlQEoI5tqYfF0vMtWWsWrVKBAcHC5VKJSZMmCBWrVolzp8/L++3Z54lIYSw/vkrIiIiIsfEe5aIiIiIzGCxRERERGQGiyUiIiIiM1gsEREREZnBYomIiIjIDBZLRERERGawWCIiIiIyg8USERERkRkslojIIX333XeQJAnV1dX2DkV27tw5zJ07Fy4uLpgxY4a9wxlSaWkpJEkasCgpEQ2OxRIR3ZG1a9dCkiTodDqT9k8++QSSJNkpKvvKycmBu7s79Hq9yYKfROTYWCwR0R1zcXFBfn4+mpub7R2KxXR3d9/xa7/99lvcf//9iIiIgJ+fnwWjIiJ7YrFERHcsJSUFQUFB0Gq1Q/bJzc0dcEnqj3/8IyIjI+XttWvXYvny5XjllVcQGBgIHx8f5OXloaenB9nZ2fD19UVoaCj27NkzYPxz585h3rx5cHFxwfTp01FWVmay/8yZM3jkkUfg4eGBwMBA/OpXv8LVq1fl/QsXLsSGDRuQkZEBf39/pKamDvo+jEYj8vLyEBoaCrVajRkzZuDw4cPyfkmSUFlZiby8PEiShNzc3CHH0Wq1iIqKgqurKzQaDT7++GN5f/8lskOHDiE+Ph4uLi6YO3cuzpw5YzLO3/72N0ybNg1qtRqRkZHYsWOHyf6uri5s3rwZYWFhUKvVmDRpEv785z+b9KmsrMSsWbPg5uaGefPmQa/XDxoz0b2OxRIR3TGlUolXXnkFb775Ji5fvnxXYx05cgT19fX48ssvsXPnTuTk5OBnP/sZxo0bh2PHjuGZZ57B008/PeA42dnZyMrKwsmTJ5GcnIylS5fi2rVrAIDr16/j4YcfxsyZM3HixAkcPnwYV65cwcqVK03G2Lt3L1QqFcrLy7F79+5B43vjjTewY8cO/OEPf8CpU6eQmpqKRx99FLW1tQCAhoYGTJs2DVlZWWhoaMDzzz8/6DharRbvv/8+du/ejbNnzyIzMxNPPvnkgCIvOzsbO3bswPHjxxEQEIClS5fCYDAA6CtyVq5ciV/+8pc4ffo0cnNzsXXrVhQWFsqvf+qpp7Bv3z4UFBSgpqYG7777Ljw8PEyO8eKLL2LHjh04ceIEnJycsG7dutv8KxHdowQR0R1IS0sTy5YtE0IIMXfuXLFu3TohhBD79+8Xt/5qycnJERqNxuS1r7/+uoiIiDAZKyIiQvT29spt0dHR4oEHHpC3e3p6hLu7u9i3b58QQogLFy4IAEKn08l9DAaDCA0NFfn5+UIIIbZv3y6WLFlicuxLly4JAEKv1wshhFiwYIGYOXPmbd9vSEiIePnll03aZs+eLdavXy9vazQakZOTM+QYnZ2dws3NTXz99dcm7b/+9a/F6tWrhRBClJSUCACiqKhI3n/t2jXh6uoqPvjgAyGEEE888YRYvHixyRjZ2dli6tSpQggh9Hq9ACCKi4sHjaP/GP/85z/ltkOHDgkA4ubNm0PGT3Sv4pklIrpr+fn52Lt3L2pqau54jGnTpkGh+N+vpMDAQMTFxcnbSqUSfn5+aGpqMnldcnKy/NzJyQmzZs2S4/jXv/6FkpISeHh4yI+YmBgAffcX9UtMTDQbW2trK+rr6zF//nyT9vnz54/oPZ8/fx4dHR1YvHixSUzvv/++STw/fl++vr6Ijo6Wj1VTUzNoLLW1tejt7UV1dTWUSiUWLFhgNp74+Hj5eXBwMAAMyC8RAU72DoCIHN+DDz6I1NRUvPDCC1i7dq3JPoVCASGESVv/5aRbOTs7m2xLkjRom9FoHHZcN27cwNKlS5Gfnz9gX39xAADu7u7DHvNu3LhxAwBw6NAhTJgwwWSfWq222HFcXV2H1e/W/PZ/g3Ek+SW6V/DMEhFZhE6nw8GDB1FRUWHSHhAQgMbGRpOCyZJzIx09elR+3tPTg8rKSsTGxgIAEhIScPbsWURGRmLSpEkmj5EUSF5eXggJCUF5eblJe3l5OaZOnTrscaZOnQq1Wo26uroB8YSFhQ35vpqbm/Gf//xHfl+xsbGDxjJlyhQolUrExcXBaDQOuA+KiO4MzywRkUXExcVhzZo1KCgoMGlfuHAhvv/+e7z66qtYsWIFDh8+jM8++wxeXl4WOe6uXbswefJkxMbG4vXXX0dzc7N8o3J6ejr+9Kc/YfXq1fj9738PX19fnD9/HkVFRXjvvfegVCqHfZzs7Gzk5OTgvvvuw4wZM7Bnzx5UV1fjr3/967DH8PT0xPPPP4/MzEwYjUbcf//9aGlpQXl5Oby8vJCWlib3zcvLg5+fHwIDA/Hiiy/C398fy5cvBwBkZWVh9uzZ2L59O1atWoWKigq89dZbePvttwEAkZGRSEtLw7p161BQUACNRoOLFy+iqalpwM3tRHR7PLNERBaTl5c34DJObGws3n77bezatQsajQbffPPNkN8UuxM6nQ46nQ4ajQZfffUVDhw4AH9/fwCQzwb19vZiyZIliIuLQ0ZGBnx8fEzujxqO5557Dps2bUJWVhbi4uJw+PBhHDhwAJMnTx7RONu3b8fWrVuh1WoRGxuLn/zkJzh06BCioqIGvK+NGzciMTERjY2NOHjwIFQqFYC+M2YffvghioqKMH36dGzbtg15eXkml0DfeecdrFixAuvXr0dMTAx+85vfoL29fUSxElEfSfz4ZgIiIrKb0tJSPPTQQ2huboaPj4+9wyEi8MwSERERkVksloiIiIjM4GU4IiIiIjN4ZomIiIjIDBZLRERERGawWCIiIiIyg8USERERkRksloiIiIjMYLFEREREZAaLJSIiIiIzWCwRERERmfF/WLwbZ05Yp9EAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_energy(obs.local_energy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/gpu.ipynb b/docs/notebooks/gpu.ipynb
new file mode 100644
index 00000000..9f78957d
--- /dev/null
+++ b/docs/notebooks/gpu.ipynb
@@ -0,0 +1,112 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Single GPU Support\n",
+    "\n",
+    "> **Warning** \n",
+    "> The use of GPU and mutli-GPU is under developpement and hasn't been thoroughly tested yet. Proceed with caution !\n",
+    "\n",
+    "Using pytorch as a backend, QMCTorch can leverage GPU cards available on your hardware.\n",
+    "You of course must have the CUDA version of pytorch installed (https://pytorch.org/)\n",
+    "\n",
+    "\n",
+    "Let's first import everything and create a molecule\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from torch import optim\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.sampler import Metropolis\n",
+    "from qmctorch.utils import (plot_energy, plot_data)\n",
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The use of GPU acceleration has been streamlined in QMCTorch, the only modification\n",
+    "you need to do on your code is to specify `cuda=True` in the declaration of the wave function and sampler, this will automatically port all the necesaary tensors to the GPU and offload all the corresponding operation there."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CUDA not available, install torch with cuda support to proceed\n"
+     ]
+    }
+   ],
+   "source": [
+    "if torch.cuda.is_available():\n",
+    "    wf = SlaterJastrow(mol, cuda=True)\n",
+    "    sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'},\n",
+    "                     cuda=True)\n",
+    "else:\n",
+    "    print('CUDA not available, install torch with cuda support to proceed')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/h2.xyz b/docs/notebooks/h2.xyz
new file mode 100644
index 00000000..6d25b66b
--- /dev/null
+++ b/docs/notebooks/h2.xyz
@@ -0,0 +1,5 @@
+2
+H2
+H	 0.000000 0.00000  0.00000
+H	 0.000000 0.00000  1.00000
+
diff --git a/docs/notebooks/hdf5/H2_adf_dzp.hdf5 b/docs/notebooks/hdf5/H2_adf_dzp.hdf5
new file mode 100644
index 00000000..52617bb4
Binary files /dev/null and b/docs/notebooks/hdf5/H2_adf_dzp.hdf5 differ
diff --git a/docs/notebooks/hdf5/LiH_adf_dz.hdf5 b/docs/notebooks/hdf5/LiH_adf_dz.hdf5
new file mode 100644
index 00000000..e3b8f62c
Binary files /dev/null and b/docs/notebooks/hdf5/LiH_adf_dz.hdf5 differ
diff --git a/docs/notebooks/horovod.ipynb b/docs/notebooks/horovod.ipynb
new file mode 100644
index 00000000..a3e49937
--- /dev/null
+++ b/docs/notebooks/horovod.ipynb
@@ -0,0 +1,169 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Multi CPUS/GPUs support with Horovod\n",
+    "\n",
+    "> **Warning** \n",
+    "> The use  mutli-GPU is under developpement and hasn't been thoroughly tested yet. Proceed with caution !\n",
+    "\n",
+    "QMC simulations can easily be parallelized by using multiple ressources to sample the wave function. Each walker is indenpendent of the other ones and therefore multiple compute node can be used in parallel to obtain more samples. Each node can alsu use GPUs is they are available. We demonstrate here how to use the library `Horovod` (https://github.com/horovod/horovod) to leverage large compute ressources for QMC.\n",
+    "\n",
+    "Let's first create a simple system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch import optim\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.sampler import Metropolis\n",
+    "from qmctorch.utils import (plot_energy, plot_data)\n",
+    "from qmctorch.utils import set_torch_double_precision\n",
+    "set_torch_double_precision()\n",
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's see if GPUs are available"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "use_gpu = torch.cuda.is_available()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wf = SlaterJastrow(mol, cuda=use_gpu).gto2sto()\n",
+    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'},\n",
+    "                     cuda=use_gpu)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},\n",
+    "           {'params': wf.ao.parameters(), 'lr': 1E-6},\n",
+    "           {'params': wf.mo.parameters(), 'lr': 1E-3},\n",
+    "           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n",
+    "opt = optim.Adam(lr_dict, lr=1E-3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A dedicated QMCTorch Solver has been developped to handle multiple GPU. To use this solver simply import it\n",
+    "and use is as the normal solver and only a few modifications are required to use horovod :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import horovod.torch as hvd\n",
+    "from qmctorch.solver import SolverMPI\n",
+    "\n",
+    "hvd.init()\n",
+    "if torch.cuda.is_available():\n",
+    "    torch.cuda.set_device(hvd.rank())\n",
+    "    \n",
+    "solver = SolverMPI(wf=wf, sampler=sampler,\n",
+    "                                    optimizer=opt,\n",
+    "                                    rank=hvd.rank())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.configure(track=['local_energy'], freeze=['ao', 'mo'],\n",
+    "                loss='energy', grad='auto',\n",
+    "                ortho_mo=False, clip_loss=False,\n",
+    "                resampling={'mode': 'update',\n",
+    "                            'resample_every': 1,\n",
+    "                            'nstep_update': 50})\n",
+    "\n",
+    "# optimize the wave function\n",
+    "obs = solver.run(5)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you can see some classes need the rank of the process when they are defined. This is simply\n",
+    "to insure that only the master process generates the HDF5 files containing the information relative to the calculation.\n",
+    "\n",
+    "## Running parallel calculations\n",
+    "\n",
+    "It is currently difficult to use Horovod on mutliple node through a jupyter notebook. To do so, one should have a python file with all the code and execute the code  with the following command\n",
+    "\n",
+    "```\n",
+    "horovodrun -np 2 python <example>.py\n",
+    "```\n",
+    "\n",
+    "See the horovod documentation for more details : https://github.com/horovod/horovod\n",
+    "\n",
+    "\n",
+    "This solver distribute the `Nw` walkers over the `Np` process . For example specifying 2000 walkers\n",
+    "and using 4 process will lead to each process using only 500 walkers. During the optimizaiton of the wavefunction\n",
+    "each process will compute the gradients of the variational parameter using their local 500 walkers.\n",
+    "The gradients are then averaged over all the processes before the optimization step takes place. This data parallel\n",
+    "model has been greatly succesfull in machine learning applications (http://jmlr.org/papers/volume20/18-789/18-789.pdf)\n",
+    "\n",
+    "A complete example can found in `qmctorch/docs/example/horovod/h2.py`"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/molecule.ipynb b/docs/notebooks/molecule.ipynb
new file mode 100644
index 00000000..d7be2325
--- /dev/null
+++ b/docs/notebooks/molecule.ipynb
@@ -0,0 +1,286 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Create a molecule\n",
+    "In this tutorial we present how to create a molecule and run the SCF calculation. First, the `Molecule` class must be imported :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  ____    __  ______________             _\n",
+      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
+      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
+      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
+     ]
+    }
+   ],
+   "source": [
+    "from qmctorch.scf import Molecule"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This class can interface with `pyscf` and `ADF` to perform SCF calculations. Of course both software use different types of\n",
+    "atomic orbitals, respectively Gaussian type orbitals for `pyscf` and Slater type orbitals for `ADF`."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Geometry of the molecule\n",
+    "\n",
+    "\n",
+    "The geometry of the molecule can be specified through the `atom` keyword of the `Molecule` class. The units of the positions, `bohr` or `angs` (default is 'bohr')\n",
+    "can also be specified via the `unit` keyword argument.  The geometry can be passed as a single string"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<qmctorch.scf.molecule.Molecule at 0x7f429ed23910>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', unit='bohr')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "or via an XYZ file containing the geomtry of the molecular structure. Note that by default `QMCTorch` will try to reuse previous calculations that might be stored in an hdf5 file. To redo the scf calculation we can use the `redo_scf=True` argument. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "mol = Molecule(atom='h2.xyz', unit='bohr', redo_scf=True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SCF calculations\n",
+    "\n",
+    "\n",
+    "As mentionned above `QMCTorch` can use `pyscf` or `ADF` to perform SCF calculation on the molecular structure. At the moment only Hartree-Fock calculations\n",
+    "are supported but DFT calculations will be implemented later. We present here how to perform these SCF calculations.\n",
+    "\n",
+    "\n",
+    "### Gaussian orbitals with pyscf\n",
+    "\n",
+    "\n",
+    "As seen above the code use by default `pyscf` to compute the atomic and molecular orbitals of the system using a `sto-3g` basis set. The default behavior is equivlament to setting `calculator=pyscf`  and `basis='sto-3g'`. Let's switch to another basis, e.g. `sto-6g`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.07589040772972\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-6g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.076 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='pyscf', basis='sto-6g', redo_scf=True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The exhaustive list of supported basis set can be found here : https://pyscf.org/user/gto.html"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Slater orbitals with ADF\n",
+    "\n",
+    "If a valid SCM license is found  QMCTorch can use `ADF`. Two calculators are available depending on the version of ADF installed:\n",
+    "* ADF 2019  : `calculator = 'adf2019'`\n",
+    "* ADF 2020+ : `calculator = 'adf'`\n",
+    "\n",
+    "So for example if ADF2019 is installed the following command will use ADF to compute the electronic structure of the molecule."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "[13.04|16:37:54] PLAMS working folder: /home/nico/QMCTorch/notebooks/plams_workdir.002\n",
+      "File ./plams_workdir/HH_dzp/HH_dzp.t21 not found, ADF may have crashed, look into the plams_workdir directory\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='adf2019', basis='dzp')\n",
+    "except Exception as expt:\n",
+    "    print(expt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here as well the ``basis`` keyword argument specifies the basis set used in the scf calculation.\n",
+    "The list of supported basis set can be found here : https://www.scm.com/doc/ADF/Input/Basis_sets_and_atomic_fragments.html\n",
+    "\n",
+    "Additional basis sets, namely VB1, VB2, VB3, CVB1, CVB2 and CVB3, are available. These are STO valence and core-valence basis set presented by Ema et. al\n",
+    "in  \"Polarized basis sets for Slater-type orbitals: H to Ne atoms\", https://doi.org/10.1002/jcc.10227. Changing the ``basis``\n",
+    " keyword argument to : ``basis=VB1``` will for examle use the small VB1 basis set during the SCF calculation."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading a SCF calculation\n",
+    "\n",
+    "\n",
+    "By default QMCTorch will create a HDF5 file containing all the required information about the molecule and SCF calculation. The name of\n",
+    "this file is given by the name of the molecule, the calculator name and the basis set, e.g. `LiH_adf_dz.hdf5` or `water_pyscf_sto3g.xyz`. This files\n",
+    "can be loaded to instanciate the molecule object through the `load` keyword argument:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Loading data from LiH_adf_dz.hdf5\n"
+     ]
+    }
+   ],
+   "source": [
+    "mol = Molecule(load='./hdf5/LiH_adf_dz.hdf5')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/sampling.ipynb b/docs/notebooks/sampling.ipynb
new file mode 100644
index 00000000..448018dc
--- /dev/null
+++ b/docs/notebooks/sampling.ipynb
@@ -0,0 +1,535 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sampling and Energy Calculation of a Water Molecule\n",
+    "\n",
+    "In this tutorial we explore how to sample the density of a water molecule and compute the total energy of the system using QMC. We first import all the module we will need in the tutorial"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  ____    __  ______________             _\n",
+      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
+      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
+      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np \n",
+    "import matplotlib.pyplot as plt \n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.sampler import Metropolis\n",
+    "from qmctorch.solver import Solver\n",
+    "from qmctorch.utils import plot_walkers_traj"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating the system"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now create the `Molecule` object. We use here a water molecule and load the coordinates directly from a file. We also need to specify the quantum chemistry package from which we extract the atomic and molecular orbitals information. We choose here `pyscf` and secpify  a `sto-3g`  basis set. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Reusing scf results from water_pyscf_sto-3g.hdf5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# define the molecule\n",
+    "mol = Molecule(atom='water.xyz', unit='angs',\n",
+    "               calculator='pyscf', basis='sto-3g', name='water')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now define the wave function ansatz describing the electronic structure of the molecule. We use here a simple `SlaterJastrow` wave function and only include the ground state electronic configuration in the CI expansion. We use here the default Pade Jastrow form of the Jastrow factor. We therefore have a wave function of the type:\n",
+    "\n",
+    "$$\n",
+    "\\Psi(R) = J(R) D^0_\\uparrow(r_\\uparrow) D^0_\\downarrow(r_\\downarrow)\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 7\n",
+      "INFO:QMCTorch|  Configurations      : ground_state\n",
+      "INFO:QMCTorch|  Number of confs     : 1\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 81\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "wf = SlaterJastrow(mol, configs='ground_state')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now define the a Metropolis sampler, using only 100 walkers. Each walker contains here the positions of the 10 electrons of molecule. The electrons are initially localized around their atomic center, i.e. 8 around the oxygen atom and 1 around each hydrogen atom. We also specify here that the sampler will perform 500 steps with a step size of 0.25 bohr. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 100\n",
+      "INFO:QMCTorch|  Number of steps     : 500\n",
+      "INFO:QMCTorch|  Step size           : 0.25\n",
+      "INFO:QMCTorch|  Thermalization steps: -1\n",
+      "INFO:QMCTorch|  Decorelation steps  : 1\n",
+      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can finally initialize the solver that will run the calculation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object Solver already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_5\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n"
+     ]
+    }
+   ],
+   "source": [
+    "solver = Solver(wf=wf, sampler=sampler)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sampling the density\n",
+    "We can use the wave function and the sampler we just defined to obtain sample of the electronic density. We can for example then plot the positions of the individual electrons in the plane of the molecule to vizually inspect the result of the sampling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:46<00:00,  4.70it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|   Acceptance rate     : 2.45 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 4.70 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 106.35 sec.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x7fef4e5ea700>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pos = sampler(wf.pdf)\n",
+    "pos = pos.reshape(100,10,3).cpu().detach().numpy()\n",
+    "plt.scatter(pos[:,:,0],pos[:,:,1],s=0.5)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Following indiviudal electron path\n",
+    "By default the sampler only record the position of the electrons at the very last step of the sampling process. We can however change and record all the positions of the electrons during the sampling to be able to track them.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 1\n",
+      "INFO:QMCTorch|  Number of steps     : 500\n",
+      "INFO:QMCTorch|  Step size           : 0.25\n",
+      "INFO:QMCTorch|  Thermalization steps: 0\n",
+      "INFO:QMCTorch|  Decorelation steps  : 1\n",
+      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler_singlewalker = Metropolis(nwalkers=1, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     ntherm=0, ndecor=1,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [00:20<00:00, 24.27it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|   Acceptance rate     : 3.20 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 24.25 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 20.62 sec.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fef4cdd4c70>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cdd4d30>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cdd4e20>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cdd4f10>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cde0040>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cde0130>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cde0220>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cde0310>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cde0400>,\n",
+       " <matplotlib.lines.Line2D at 0x7fef4cde04f0>]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pos = sampler_singlewalker(wf.pdf)\n",
+    "pos = pos.reshape(-1,10,3).detach().numpy()\n",
+    "plt.plot(pos[:,:,0], pos[:,:,1], marker=\"o\", ls='--')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Energy Calculation\n",
+    "To compute the energy of the system we first need to create a solver object that will handle all the orchestration of the calculation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object Solver already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_6\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n"
+     ]
+    }
+   ],
+   "source": [
+    "solver = Solver(wf=wf, sampler=sampler)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The energy can then be directly calculated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Single Point Calculation : 100 walkers | 500 steps\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:53<00:00,  4.40it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|   Acceptance rate     : 2.36 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 4.40 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 113.76 sec.\n",
+      "INFO:QMCTorch|  Energy   : -72.750839 +/- 1.374327\n",
+      "INFO:QMCTorch|  Variance : 188.877533\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object single_point already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to single_point_3\n",
+      "INFO:QMCTorch|\n"
+     ]
+    }
+   ],
+   "source": [
+    "obs = solver.single_point()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sampling Trajectory\n",
+    "We can also follow how the total energy thermalize during the sampling process. To this end we need to record the positions of the walkers during the sampling and not just at the end of it. We can then compute the local energies and the total energy at each recorded step of the trajectory. We can either create a new sampler or simply change the configuration of the sampler already included in our solver. We will put the number of thermalization steps to 0 and the number of decorellation step to 5."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.sampler.ntherm = 0\n",
+    "solver.sampler.ndecor = 5"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then resample the density and compute the local energy values along the sampling trajectory and finnaly plot it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:32<00:00,  5.42it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|   Acceptance rate     : 2.76 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 5.42 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 92.22 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Sampling trajectory\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Energy  : 100%|██████████| 100/100 [01:06<00:00,  1.50it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object sampling_trajectory already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to sampling_trajectory_3\n",
+      "INFO:QMCTorch|\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pos = solver.sampler(solver.wf.pdf)\n",
+    "obs = solver.sampling_traj(pos)\n",
+    "plot_walkers_traj(obs.local_energy, walkers='mean')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/water.xyz b/docs/notebooks/water.xyz
new file mode 100644
index 00000000..11883b7d
--- /dev/null
+++ b/docs/notebooks/water.xyz
@@ -0,0 +1,7 @@
+3
+water molecule
+O	 0.000000 0.00000  0.00000
+H 	 0.758602 0.58600  0.00000
+H	-0.758602 0.58600  0.00000
+H	-0.758602 0.58600  0.00000
+
diff --git a/docs/notebooks/wfopt.ipynb b/docs/notebooks/wfopt.ipynb
new file mode 100644
index 00000000..3c868b05
--- /dev/null
+++ b/docs/notebooks/wfopt.ipynb
@@ -0,0 +1,650 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Wave Function Optimization\n",
+    "\n",
+    "We present here a complete example on how to use QMCTorch on a H2 molecule.\n",
+    "We first need to import all the relevant modules :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  ____    __  ______________             _\n",
+      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
+      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
+      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
+     ]
+    }
+   ],
+   "source": [
+    "from torch import optim\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.solver import Solver\n",
+    "from qmctorch.sampler import Metropolis\n",
+    "from qmctorch.utils import set_torch_double_precision\n",
+    "from qmctorch.utils import (plot_energy, plot_data)\n",
+    "set_torch_double_precision()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating the system\n",
+    "\n",
+    "The first step is to define a molecule. We here use a H2 molecule with both hydrgen atoms\n",
+    "on the z-axis and separated by 1.38 atomic unit. We choose here to use Slater orbitals that can be otained via `ADF`. We simply here reload calculations to create the molecule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Loading data from ./hdf5/H2_adf_dzp.hdf5\n"
+     ]
+    }
+   ],
+   "source": [
+    "mol = Molecule(load='./hdf5/H2_adf_dzp.hdf5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then define the wave function relative to this molecule. We also specify here\n",
+    "the determinants we want to use in the CI expansion. We use here a to include all the single\n",
+    "and double excitation with 2 electrons and 2 orbitals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 10\n",
+      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
+      "INFO:QMCTorch|  Number of confs     : 4\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 121\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "wf = SlaterJastrow(mol, configs='single_double(2,2)')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As a sampler we use a simple Metropolis Hasting with 1000 walkers. The walkers are initially localized around the atoms.\n",
+    "Each walker will perform 2000 steps of size 0.2 atomic unit and will only keep the last position of each walker (`ntherm=-1`).\n",
+    "During each move all the the electrons are moved simultaneously within a normal distribution centered around their current location."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 5000\n",
+      "INFO:QMCTorch|  Number of steps     : 200\n",
+      "INFO:QMCTorch|  Step size           : 0.2\n",
+      "INFO:QMCTorch|  Thermalization steps: -1\n",
+      "INFO:QMCTorch|  Decorelation steps  : 100\n",
+      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = Metropolis(nwalkers=5000,\n",
+    "                     nstep=200, step_size=0.2,\n",
+    "                     ntherm=-1, ndecor=100,\n",
+    "                     nelec=wf.nelec, init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will use the ADAM optimizer implemented in pytorch with custom learning rate for each layer.\n",
+    "We also define a linear scheduler that will decrease the learning rate after 100 steps"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},\n",
+    "           {'params': wf.ao.parameters(), 'lr': 1E-6},\n",
+    "           {'params': wf.mo.parameters(), 'lr': 2E-3},\n",
+    "           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n",
+    "opt = optim.Adam(lr_dict, lr=1E-3)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A scheduler can also be used to progressively decrease the value of the learning rate during the optimization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now assemble the solver"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object Solver already exists in H2_adf_dzp_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_7\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n",
+      "INFO:QMCTorch|  Optimizer           : Adam\n"
+     ]
+    }
+   ],
+   "source": [
+    "solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Comfiguring the solver\n",
+    "\n",
+    "Many parameters of the optimization can be controlled. We can specify which observale to track during the optimization. Here only the local energies will be recorded but one can also record the variational parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.configure(track=['local_energy', 'parameters'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some variational parameters can be frozen and therefore not optimized. We here freeze the MO coefficients and the AO parameters\n",
+    "and therefore only the jastrow parametres and the CI coefficients will be optmized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.configure(freeze=['ao'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Either the mean or the variance of local energies can be used as a loss function. We choose here to minimize the energy to optimize the wave function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.configure(loss='energy')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The gradients of the wave function w.r.t. the variational parameters can be computed directly via automatic differntiation (`grad='auto'`)or manually (`grad='auto'`) via a reduced noise formula. We pick here a manual calculation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.configure(grad='manual')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We also configure the resampling so that the positions of the walkers are updated by performing\n",
+    "25 MC steps from their previous positions after each optimization step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver.configure(resampling={'mode': 'update',\n",
+    "                            'resample_every': 1,\n",
+    "                            'nstep_update': 25})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running the wave function optimization\n",
+    "\n",
+    "We can now run the optimization. We use here 250 optimization steps (epoch), using all the points\n",
+    "in a single mini-batch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Optimization\n",
+      "INFO:QMCTorch|  Task                :\n",
+      "INFO:QMCTorch|  Number Parameters   : 115\n",
+      "INFO:QMCTorch|  Number of epoch     : 50\n",
+      "INFO:QMCTorch|  Batch size          : 5000\n",
+      "INFO:QMCTorch|  Loss function       : energy\n",
+      "INFO:QMCTorch|  Clip Loss           : False\n",
+      "INFO:QMCTorch|  Gradients           : manual\n",
+      "INFO:QMCTorch|  Resampling mode     : update\n",
+      "INFO:QMCTorch|  Resampling every    : 1\n",
+      "INFO:QMCTorch|  Resampling steps    : 25\n",
+      "INFO:QMCTorch|  Output file         : H2_adf_dzp_QMCTorch.hdf5\n",
+      "INFO:QMCTorch|  Checkpoint every    : None\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 0\n",
+      "INFO:QMCTorch|  energy   : -1.155363 +/- 0.003267\n",
+      "INFO:QMCTorch|  variance : 0.231010\n",
+      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 1\n",
+      "INFO:QMCTorch|  energy   : -1.149161 +/- 0.003279\n",
+      "INFO:QMCTorch|  variance : 0.231844\n",
+      "INFO:QMCTorch|  epoch done in 0.59 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 2\n",
+      "INFO:QMCTorch|  energy   : -1.150710 +/- 0.003106\n",
+      "INFO:QMCTorch|  variance : 0.219625\n",
+      "INFO:QMCTorch|  epoch done in 0.94 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 3\n",
+      "INFO:QMCTorch|  energy   : -1.156548 +/- 0.003170\n",
+      "INFO:QMCTorch|  variance : 0.224149\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 4\n",
+      "INFO:QMCTorch|  energy   : -1.155115 +/- 0.003221\n",
+      "INFO:QMCTorch|  variance : 0.227777\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 5\n",
+      "INFO:QMCTorch|  energy   : -1.156112 +/- 0.003083\n",
+      "INFO:QMCTorch|  variance : 0.217972\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 6\n",
+      "INFO:QMCTorch|  energy   : -1.155542 +/- 0.003070\n",
+      "INFO:QMCTorch|  variance : 0.217062\n",
+      "INFO:QMCTorch|  epoch done in 0.94 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 7\n",
+      "INFO:QMCTorch|  energy   : -1.157297 +/- 0.003046\n",
+      "INFO:QMCTorch|  variance : 0.215387\n",
+      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 8\n",
+      "INFO:QMCTorch|  energy   : -1.150183 +/- 0.003147\n",
+      "INFO:QMCTorch|  variance : 0.222538\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 9\n",
+      "INFO:QMCTorch|  energy   : -1.155700 +/- 0.003062\n",
+      "INFO:QMCTorch|  variance : 0.216530\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 10\n",
+      "INFO:QMCTorch|  energy   : -1.154875 +/- 0.003005\n",
+      "INFO:QMCTorch|  variance : 0.212476\n",
+      "INFO:QMCTorch|  epoch done in 0.60 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 11\n",
+      "INFO:QMCTorch|  energy   : -1.154984 +/- 0.003024\n",
+      "INFO:QMCTorch|  variance : 0.213820\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 12\n",
+      "INFO:QMCTorch|  energy   : -1.154497 +/- 0.002974\n",
+      "INFO:QMCTorch|  variance : 0.210262\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 13\n",
+      "INFO:QMCTorch|  energy   : -1.157227 +/- 0.003000\n",
+      "INFO:QMCTorch|  variance : 0.212123\n",
+      "INFO:QMCTorch|  epoch done in 0.57 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 14\n",
+      "INFO:QMCTorch|  energy   : -1.156778 +/- 0.002914\n",
+      "INFO:QMCTorch|  variance : 0.206054\n",
+      "INFO:QMCTorch|  epoch done in 0.75 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 15\n",
+      "INFO:QMCTorch|  energy   : -1.152052 +/- 0.003022\n",
+      "INFO:QMCTorch|  variance : 0.213717\n",
+      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 16\n",
+      "INFO:QMCTorch|  energy   : -1.158149 +/- 0.002847\n",
+      "INFO:QMCTorch|  variance : 0.201333\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 17\n",
+      "INFO:QMCTorch|  energy   : -1.158337 +/- 0.002852\n",
+      "INFO:QMCTorch|  variance : 0.201654\n",
+      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 18\n",
+      "INFO:QMCTorch|  energy   : -1.158138 +/- 0.002793\n",
+      "INFO:QMCTorch|  variance : 0.197500\n",
+      "INFO:QMCTorch|  epoch done in 0.89 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 19\n",
+      "INFO:QMCTorch|  energy   : -1.157327 +/- 0.002869\n",
+      "INFO:QMCTorch|  variance : 0.202897\n",
+      "INFO:QMCTorch|  epoch done in 0.99 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 20\n",
+      "INFO:QMCTorch|  energy   : -1.155671 +/- 0.002901\n",
+      "INFO:QMCTorch|  variance : 0.205139\n",
+      "INFO:QMCTorch|  epoch done in 0.52 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 21\n",
+      "INFO:QMCTorch|  energy   : -1.156606 +/- 0.002863\n",
+      "INFO:QMCTorch|  variance : 0.202470\n",
+      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 22\n",
+      "INFO:QMCTorch|  energy   : -1.164993 +/- 0.002852\n",
+      "INFO:QMCTorch|  variance : 0.201661\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 23\n",
+      "INFO:QMCTorch|  energy   : -1.157040 +/- 0.002765\n",
+      "INFO:QMCTorch|  variance : 0.195510\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 24\n",
+      "INFO:QMCTorch|  energy   : -1.163667 +/- 0.002707\n",
+      "INFO:QMCTorch|  variance : 0.191386\n",
+      "INFO:QMCTorch|  epoch done in 0.57 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 25\n",
+      "INFO:QMCTorch|  energy   : -1.159113 +/- 0.002700\n",
+      "INFO:QMCTorch|  variance : 0.190943\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 26\n",
+      "INFO:QMCTorch|  energy   : -1.162071 +/- 0.002661\n",
+      "INFO:QMCTorch|  variance : 0.188190\n",
+      "INFO:QMCTorch|  epoch done in 0.53 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 27\n",
+      "INFO:QMCTorch|  energy   : -1.158837 +/- 0.002642\n",
+      "INFO:QMCTorch|  variance : 0.186836\n",
+      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 28\n",
+      "INFO:QMCTorch|  energy   : -1.155956 +/- 0.002649\n",
+      "INFO:QMCTorch|  variance : 0.187284\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 29\n",
+      "INFO:QMCTorch|  energy   : -1.162127 +/- 0.002609\n",
+      "INFO:QMCTorch|  variance : 0.184491\n",
+      "INFO:QMCTorch|  epoch done in 0.73 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 30\n",
+      "INFO:QMCTorch|  energy   : -1.163752 +/- 0.002560\n",
+      "INFO:QMCTorch|  variance : 0.181025\n",
+      "INFO:QMCTorch|  epoch done in 0.52 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 31\n",
+      "INFO:QMCTorch|  energy   : -1.159163 +/- 0.002590\n",
+      "INFO:QMCTorch|  variance : 0.183165\n",
+      "INFO:QMCTorch|  epoch done in 0.56 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 32\n",
+      "INFO:QMCTorch|  energy   : -1.163472 +/- 0.002603\n",
+      "INFO:QMCTorch|  variance : 0.184072\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 33\n",
+      "INFO:QMCTorch|  energy   : -1.165384 +/- 0.002563\n",
+      "INFO:QMCTorch|  variance : 0.181214\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 34\n",
+      "INFO:QMCTorch|  energy   : -1.163774 +/- 0.002527\n",
+      "INFO:QMCTorch|  variance : 0.178661\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 35\n",
+      "INFO:QMCTorch|  energy   : -1.161995 +/- 0.002472\n",
+      "INFO:QMCTorch|  variance : 0.174763\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 36\n",
+      "INFO:QMCTorch|  energy   : -1.161698 +/- 0.002521\n",
+      "INFO:QMCTorch|  variance : 0.178254\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 37\n",
+      "INFO:QMCTorch|  energy   : -1.162856 +/- 0.002532\n",
+      "INFO:QMCTorch|  variance : 0.179051\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 38\n",
+      "INFO:QMCTorch|  energy   : -1.157138 +/- 0.002535\n",
+      "INFO:QMCTorch|  variance : 0.179220\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 39\n",
+      "INFO:QMCTorch|  energy   : -1.163320 +/- 0.002536\n",
+      "INFO:QMCTorch|  variance : 0.179332\n",
+      "INFO:QMCTorch|  epoch done in 0.74 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 40\n",
+      "INFO:QMCTorch|  energy   : -1.161880 +/- 0.002464\n",
+      "INFO:QMCTorch|  variance : 0.174239\n",
+      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 41\n",
+      "INFO:QMCTorch|  energy   : -1.158324 +/- 0.002542\n",
+      "INFO:QMCTorch|  variance : 0.179777\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 42\n",
+      "INFO:QMCTorch|  energy   : -1.158298 +/- 0.002442\n",
+      "INFO:QMCTorch|  variance : 0.172696\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 43\n",
+      "INFO:QMCTorch|  energy   : -1.160970 +/- 0.002371\n",
+      "INFO:QMCTorch|  variance : 0.167662\n",
+      "INFO:QMCTorch|  epoch done in 0.79 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 44\n",
+      "INFO:QMCTorch|  energy   : -1.159741 +/- 0.002362\n",
+      "INFO:QMCTorch|  variance : 0.166993\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 45\n",
+      "INFO:QMCTorch|  energy   : -1.162254 +/- 0.002349\n",
+      "INFO:QMCTorch|  variance : 0.166119\n",
+      "INFO:QMCTorch|  epoch done in 0.73 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 46\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  energy   : -1.160540 +/- 0.002314\n",
+      "INFO:QMCTorch|  variance : 0.163611\n",
+      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 47\n",
+      "INFO:QMCTorch|  energy   : -1.162938 +/- 0.002316\n",
+      "INFO:QMCTorch|  variance : 0.163749\n",
+      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 48\n",
+      "INFO:QMCTorch|  energy   : -1.163674 +/- 0.002214\n",
+      "INFO:QMCTorch|  variance : 0.156522\n",
+      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 49\n",
+      "INFO:QMCTorch|  energy   : -1.163112 +/- 0.002278\n",
+      "INFO:QMCTorch|  variance : 0.161065\n",
+      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object wf_opt already exists in H2_adf_dzp_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to wf_opt_7\n",
+      "INFO:QMCTorch|\n"
+     ]
+    }
+   ],
+   "source": [
+    "obs = solver.run(50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/pics/qmc.png b/docs/pics/qmc.png
new file mode 100644
index 00000000..e441acea
Binary files /dev/null and b/docs/pics/qmc.png differ
diff --git a/docs/pics/qmctorch2.png b/docs/pics/qmctorch2.png
new file mode 100644
index 00000000..89f5df53
Binary files /dev/null and b/docs/pics/qmctorch2.png differ
diff --git a/pics/qmctorch_logo.png b/docs/pics/qmctorch_logo.png
similarity index 100%
rename from pics/qmctorch_logo.png
rename to docs/pics/qmctorch_logo.png
diff --git a/docs/qmctorch_white.png b/docs/pics/qmctorch_white.png
similarity index 100%
rename from docs/qmctorch_white.png
rename to docs/pics/qmctorch_white.png
diff --git a/docs/qmc.rst b/docs/qmc.rst
deleted file mode 100644
index 9a7ccddb..00000000
--- a/docs/qmc.rst
+++ /dev/null
@@ -1,4 +0,0 @@
-Quantum Monte Carlo
-========================
-
-TODO : Quantum Monte Carlo a 10 min introduction
\ No newline at end of file
diff --git a/docs/qmctorch.svg b/docs/qmctorch.svg
deleted file mode 100755
index 219371e2..00000000
--- a/docs/qmctorch.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg width="419" height="289" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" overflow="hidden"><defs><clipPath id="clip0"><path d="M-536 194-117 194-117 483-536 483Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><clipPath id="clip1"><path d="M-535 200-334 200-334 482-535 482Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><image width="286" height="401" xlink:href="data:image/png;base64,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" preserveAspectRatio="none" id="img2"></image><clipPath id="clip3"><path d="M0 0 201 0 201 281.822 0 281.822Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><clipPath id="clip4"><path d="M-336 295-117 295-117 462-336 462Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><clipPath id="clip5"><path d="M-336 295-117 295-117 462-336 462Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><clipPath id="clip6"><path d="M-452 209 10 209 10 633-452 633Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><clipPath id="clip7"><path d="M-452 209 10 209 10 633-452 633Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><clipPath id="clip8"><path d="M-439 194-396 194-396 253-439 253Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath><image width="716" height="460" xlink:href="data:image/png;base64,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" preserveAspectRatio="none" id="img9"></image><clipPath id="clip10"><path d="M298.613 48.1548 341.108 48.1548 341.108 107.155 298.613 107.155Z" fill-rule="evenodd" clip-rule="evenodd"/></clipPath></defs><g clip-path="url(#clip0)" transform="translate(536 -194)"><g clip-path="url(#clip1)"><g clip-path="url(#clip3)" transform="matrix(1 0 -0 1.00063 -535 200)"><use width="100%" height="100%" xlink:href="#img2" transform="scale(0.702797 0.702797)"></use></g></g><path d="M-394.671 425.767C-392.88 423.189-389.339 422.551-386.761 424.342L-348.557 450.877C-345.979 452.668-345.34 456.21-347.131 458.788L-360.1 477.459C-361.89 480.037-365.432 480.675-368.01 478.884L-406.214 452.349C-408.792 450.558-409.43 447.017-407.639 444.438Z" fill="#FFFFFF" fill-rule="evenodd"/><g clip-path="url(#clip4)"><g clip-path="url(#clip5)"><g clip-path="url(#clip6)"><g clip-path="url(#clip7)"><text fill="#FFFFFF" font-family="Chiller,Chiller_MSFontService,sans-serif" font-weight="400" font-stretch="semi-expanded" font-size="200" transform="matrix(1.00151 0 0 1.00112 -331.295 448)">MC</text></g></g></g></g><g clip-path="url(#clip8)"><g clip-path="url(#clip10)" transform="matrix(1.01187 0 -0 1 -741.158 145.845)"><use width="100%" height="100%" xlink:href="#img9" transform="scale(0.819768 0.819768)"></use></g></g></g></svg>
\ No newline at end of file
diff --git a/docs/qmctorch/ferminet.rst b/docs/qmctorch/ferminet.rst
deleted file mode 100644
index 3e267ca8..00000000
--- a/docs/qmctorch/ferminet.rst
+++ /dev/null
@@ -1,2 +0,0 @@
-FermiNet Wave Function
-----------------------------------------
\ No newline at end of file
diff --git a/docs/qmctorch/molecule.rst b/docs/qmctorch/molecule.rst
deleted file mode 100644
index 61ae1bb6..00000000
--- a/docs/qmctorch/molecule.rst
+++ /dev/null
@@ -1,68 +0,0 @@
-
-Creating a molecule
-========================================
-
-In this tutorial we present how to create a molecule and run the SCF calculation. First, the `Molecule` class must be imported :
-
->>> from qmctorch.scf import Molecule
-
-This class can interface with `pyscf` and `ADF` to perform SCF calculations. Of course both software use different types of
-atomic orbitals, respectively Gaussian type orbitals for `pyscf` and Slater type orbitals for `ADF`.
-
-
-Geometry of the molecule
-------------------------------------------
-
-The geometry of the molecule can be specified through the `atom` keyword of the `Molecule` class. The units of the positions, `bohr` or `angs` (default is 'bohr')
-can also be specified via the `unit` keyword argument.  The geometry can be passed as a single string
-
->>> Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', unit='bohr')
-
-or via an XYZ file containing the geomtry of the molecular structure
-
->>> Molecule(atom='h2.xyz', unit='angs')
-
-SCF calculations
---------------------------------------------
-
-As mentionned above `QMCTorch` can use `pyscf` or `ADF` to perform SCF calculation on the molecular structure. At the moment only Hartree-Fock calculations
-are supported but DFT calculations will be implemented later. We present here how to perform these SCF calculations
-
-
-Gaussian orbitals with pyscf
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-To use `pyscf` to compute the molecular orbitals of the system the `calculator` simply need to be set to `pyscf` as shown below.
-
->>> # define the molecule
->>> mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='angs',
->>>                calculator='pyscf', basis='sto-3g')
-
-The `basis` keyword specify which basis set to use in the calculation. We use here a small `STO-3G` basis set. The exhaustive list of supported basis
-set can be found here : https://pyscf.org/user/gto.html
-
-
-Slater orbitals with ADF
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-If a valid SCM license is found  QMCTorch can use `ADF` as a backend by simply switching the `calculator` to 'adf' as below :
-
->>> # define the molecule
->>> mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='angs',
->>>               calculator='adf', basis='dzp')
-
-Here as well the ``basis`` keyword argument specifies the basis set used in the scf calculation.
-The list of supported basis set can be found here : https://www.scm.com/doc/ADF/Input/Basis_sets_and_atomic_fragments.html
-
-Additional basis sets, namely VB1, VB2, VB3, CVB1, CVB2 and CVB3, are available. These are STO valence and core-valence basis set presented by Ema et. al
-in  "Polarized basis sets for Slater-type orbitals: H to Ne atoms", https://doi.org/10.1002/jcc.10227. Changing the ``basis``
- keyword argument to : ``basis=VB1``` will for examle use the small VB1 basis set during the SCF calculation.
-
-Loading a SCF calculation
-----------------------------------
-
-By default QMCTorch will create a HDF5 file containing all the required information about the molecule and SCF calculation. The name of
-this file is given by the name of the molecule, the calculator name and the basis set, e.g. `LiH_adf_dzp.hdf5` or 'water_pyscf_sto3g.xyz'. This files
-can be loaded to instanciate the molecule object through the `load` keyword argument:
-
->>> mol = Molecule(load='LiH_adf_dzp.hdf5')
-
diff --git a/docs/qmctorch/optimizer.rst b/docs/qmctorch/optimizer.rst
deleted file mode 100644
index 74bab581..00000000
--- a/docs/qmctorch/optimizer.rst
+++ /dev/null
@@ -1,27 +0,0 @@
-Optimizers
-===========================
-
-`QMCTorch` allows to use all the optimizers included in `pytorch` to opmtimize the QMCNet wave function.
-The list of optimizers can be found here :  https://pytorch.org/docs/stable/optim.html 
-
-For example to use the ADAM optimizer with different learning rate for each layer of the QMCNet wave funciton, one can simply define :
-
->>> from torch import optim
->>> lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-3},
->>>        {'params': wf.ao.parameters(), 'lr': 1E-6},
->>>        {'params': wf.mo.parameters(), 'lr': 1E-3},
->>>        {'params': wf.fc.parameters(), 'lr': 1E-3}]
->>> opt = optim.Adam(lr_dict, lr=1E-3)
-
-Scheduler
-==============================
-
-Similarly QMCTorch allows to use scheduler to gradually decrease the learning rate during the optimization.
-There as well all the scheduler of pytorch can be used : https://pytorch.org/docs/stable/optim.html
-For example a simple scheudler that decrease the learning rate every number of epoch is simply defined as :
-
->>> from torch import optim
->>> scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
-
-
-
diff --git a/docs/qmctorch/paulinet.rst b/docs/qmctorch/paulinet.rst
deleted file mode 100644
index 02ce7519..00000000
--- a/docs/qmctorch/paulinet.rst
+++ /dev/null
@@ -1,2 +0,0 @@
-Pauli Net Wave Function
-----------------------------------------
\ No newline at end of file
diff --git a/docs/qmctorch/sampler.rst b/docs/qmctorch/sampler.rst
deleted file mode 100644
index d989888d..00000000
--- a/docs/qmctorch/sampler.rst
+++ /dev/null
@@ -1,13 +0,0 @@
-Samplers
---------------------------------
-
-`QMCTorch` offers different sampler to propagate the walkers. The default sampler is a Metropolis-Hasting
-that can be defined as follows :
-
->>> from qmctorch.sampler import Metropolis
->>> sampler = Metropolis(nwalkers=500,
->>>                  nstep=2000, step_size=0.2,
->>>                  ntherm=-1, ndecor=100,
->>>                  nelec=wf.nelec, init=mol.domain('atomic'),
->>>                  move={'type': 'all-elec', 'proba': 'normal'})
-
diff --git a/docs/qmctorch/slaterjastrow.rst b/docs/qmctorch/slaterjastrow.rst
deleted file mode 100644
index 1d919328..00000000
--- a/docs/qmctorch/slaterjastrow.rst
+++ /dev/null
@@ -1,76 +0,0 @@
-Slater Jastrow Wave Function
------------------------------------
-
-
-The ``SlaterJastrow`` neural-network wavefunction ansatz matches closely the wave function ansatz commonly used in QMC simulations. The wave function
-is here expressed as
-
-.. math::
-
-    \Psi(R) = J(R) \sum_n c_n D_n^{\uparrow} D_n^{\downarrow}
-
-The term `J(R)` is the so called Jastrow factor that captures the electronic correlation. The Jastrow factor is given by :
-
-.. math::
-
-    J(R) = \exp\left(  \sum_{i<j} \text{Kernel}(r_{ij}) \right)
-
-where the sum runs over all the electron pairs and where the kernel function defines the action of the Jastrow factor. A common expression for the
-kernel (and the default option for QMCTorch) is the Pade-Jastrow form given by:
-
-.. math::
-
-    \text{Kernel}(r_{ij}) = \frac{\omega_0 r_{ij}}{1+\omega r_{ij}}
-
-where :math: `\omega_0` is a fixed coefficient equals to 0.25(0.5) for antiparallel(parallel) electron spins and :math: `\omega` a variational parameter.
-
-The determinantal parts in the expression of :math: `\Psi` are given by the spin-up and spin-down slater determinants e.g. :
-
-.. math::
-
-    D_n^{\uparrow} = \frac{1}{\sqrt{N}} \begin{vmatrix} & & \\ & \phi_j(r_i) & \\ & & \end{vmatrix}
-
-
-Implementation
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-The Slater Jastrow function is implemented in QMCTorch as represented in the figure below :
-
-.. image:: ../../pics/mol_nn.png
-
-As seen on this figure, the input of the network are the positions of the walkers that should be sampled from the density of the wavefunction.
-The first layer of the network computes the values of all the atomic orbitals at the position of each electron contained in a given walker configuration.
-This new layer has been implemented in Pytorch and allows the optimizaiton of the atomic position (geometry optimization), and of the atomic basis parameters (basis exponents and coefficients).
-The second layer transforms the atomic orbitals in molecular orbitals using a linear map whose weights are the molecular orbitals coefficients. The third layer, dubbed Slater Pooling,
-computes the values of all the desired Slater determinants from the values of the molecular orbilals. The fina layer sums up the slater determinant using the CI coefficients as weight
-
-In parallel a Jastrow layer has been implemented in Pytorch and allows the calculation of the Jastrow factor directly from the walkers positions.
-The Jastrow factor is multiplied with the sum of the slater determinant to obtain the value of the wave function.
-
-Usage
-^^^^^^^^^^^^^^^^^^^^^^^
-The ``SlaterJastrow`` wave function can instantiated following :
-
->>> wf = SlaterJastrow(mol, configs='single_double(2,2)', jastrow_kernel=PadeJastrowKernel)
-
-The ``SlaterJastrow`` takes as first mandiatory argument a ``Molecule`` instance. The Slater determinants required in the calculation
-are specified with the ``configs`` arguments which can take the following values :
-
-  * ``configs='ground_state'`` : only the ground state SD
-  * ``configs='cas(n,m)'`` : complete active space using n electron and m orbitals
-  * ``configs='single(n,m)'`` : only single excitation using n electron and m orbitals
-  * ``configs='single_double(n,m)'`` : only single/double excitation using n electron and m orbitals
-
-Finally the kernel function of the Jastrow factor can be specifed using the ``jastrow_kernel``
-The ``SlaterJastrow`` class accepts other initialisation arguments to fine tune some advanced settings. The default values
-of these arguments are adequeate for most cases.
-
-Orbital dependent Jastrow factor
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The Jastrow factor can be made orbital dependent with the ``SlaterOrbitalDependentJastrow``
-
->>> from qmctorch.wavefunction import SlaterOrbitalDependentJastrow
->>> from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
->>> wf = SlaterOrbitalDependentJastrow(mol, configs='single_double(2,4)'
->>>                                    jastrow_kernel=PadeJastrowKernel)
diff --git a/docs/qmctorch/slaterjastrow_backflow.rst b/docs/qmctorch/slaterjastrow_backflow.rst
deleted file mode 100644
index 09d1aa8b..00000000
--- a/docs/qmctorch/slaterjastrow_backflow.rst
+++ /dev/null
@@ -1,56 +0,0 @@
-Slater Jastrow Backflow Wave Function
-----------------------------------------
-
-The Slater Jastrow Backflow wave function builds on the the Slater Jastrow wavefunction but adds a backflow transformation to
-the electronic positions. Following this transformation, each electron becomes a quasi-particle whose position depends on all
-electronic positions. The backflow transformation is given by :
-
-.. math::
-
-    q(x_i) = x_i + \sum_{j\neq i} \text{Kernel}(r_{ij}) (x_i-x_j)
-
-The kernel of the transformation can be any function that depends on the distance between two electrons. A popular kernel
-is simply the inverse function :
-
-.. math::
-    \text{Kernel}(r_{ij}) = \frac{\omega}{r_{ij}}
-
-and is the default value in QMCTorch. However any other kernel function can be implemented and used in the code.
-
-The wave function is then constructed as :
-
-.. math::
-
-    \Psi(R) = J(R) \sum_n c_n D_n^{\uparrow}(Q) D_n^{\downarrow}(Q)
-
-The Jastrow factor is still computed using the original positions of the electrons while the determinant part uses the
-backflow transformed positions.
-
-Orbital Dependent Backflow Transformation
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The backflow transformation can be different for each atomic orbitals.
-
-.. math::
-
-    q^\alpha(x_i) = x_i + \sum_{j\neq i} \text{Kernel}^\alpha(r_{ij}) (x_i-x_j)
-
-where each orbital has its dedicated backflow kernel. This provides much more flexibility when optimizing the wave function.
-
-Usage
-^^^^^^^^^^^^^^^^^^^^^
-
-This wave function can be used with
-
->>> from qmctorch.wavefunction import SlaterJastrowBackFlow
->>> from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
->>> from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
->>>
->>> wf = SlaterJastrowBackFlow(self.mol, kinetic='jacobi',
->>>                            configs='single_double(2,2)',
->>>                            jastrow_kernel=PadeJastrowKernel,
->>>                            orbital_dependent_backflow=False,
->>>                            backflow_kernel=BackFlowKernelInverse)
-
-Compared to the ``SlaterJastrow`` wave function, the kernel of the backflow transformation must be specified.
-By default the inverse kernel will be used. Orbital dependent backflow orbitals can be easily achieved by using ``orbital_dependent_backflow=True``
\ No newline at end of file
diff --git a/docs/qmctorch/solver.rst b/docs/qmctorch/solver.rst
deleted file mode 100644
index a63798ac..00000000
--- a/docs/qmctorch/solver.rst
+++ /dev/null
@@ -1,88 +0,0 @@
-Solvers
-=========================
-
-Solvers are responsibe to orchestrate the calculations by combining the different elements, Molecule, QMCNet wave function, samplers and optimizers/schedulers
-The main solver is caled `SolverSlaterJastrow` and is defined as
-
->>> from qmctorch.solver import SolverSlaterJastrow
->>> solver = SolverSlaterJastrow(wf=wf, sampler=sampler,
->>>                       optimizer=opt, scheduler=scheduler, output='output.hdf5'
-
-As soon as the solver its content is defined the HDF5 file specficied byt `out`. This file will contain all the parameter
-of the solver and can be explored using the dedicated `h5x` browser. This solver allows to perform different calculations as detailled below
-
-Single point calculation
-----------------------------
-
-A single point calculation sample the current wave function and computes the energy & variance of the system.
-It can simply be done by:
-
->>> obs = solver.single_point()
->>> plt.hist(obs.local_energy)
-
-`obs` is a `SimpleNamespace` instance with the following attributes:
-  * `obs.pos` : position of the walkers
-  * `obs.local_energy` : values of the local energies for each sampling point
-  * `obs.energy` : energy of the systems (i.e. the mean of the local energy)
-  * `obs.variance` : variance of the local energy values
-  * `obs.error` : error on the energy
-
-The result of the calculation will also be stored in the hdf5 output file. The energy distribution can be vizualised
-with the matplotlib histogram function.
-
-Sampling trajectory
-----------------------------
-
-It is possible to compute the local energy during the propagation of the wlakers to assess the convergence of the sampling
-To this end the sampler must be configured to output the walker position after each `N` steps.
-For example to start recording the walkers positions after 1000 MC steps and then record their position each 100 MC steps one can use :
-
->>> from qmctorch.utils import plot_walkers_traj
->>> solver.sampler.ntherm = 1000
->>> solver.sampler.ndecor = 100
->>> pos = solver.sampler(solver.wf.pdf)
->>> obs = solver.sampling_traj(pos)
->>> plot_walkers_traj(obs.local_energy)
-
-There as well the results are returned in the `obs` SimpleNamespace and are stored in the hdf5 file.
-The trajectory can be visualized with the `plot_wakers_traj` routine of QMCTorch
-
-Wave function optimization
--------------------------------
-
-Optimizing the wave function is the main task of the solver. Before otpimization starts the solver needs to be
-configured properly.
-
->>> solver.configure(task='wf_opt', freeze=['ao', 'mo'])
-
-To main task are available wave function optimization (`wf_opt`) and geometry optimization (`geo_opt`).
-If a wave function optimization is selected the atom coordinate will be frozen while all the other parameters of the QMCNet will be optimized.
-If a geometry optimization is selected only the atom coordinates will be optimized. One cal also freeze (i.e. not optimize) certain parameter groups.
-In the example above the parameters of the atomic orbitals and molecular orbitals will be frozen,
-
-One can specified the observale that needs to be recorded during the optimization.
-
->>> solver.track_observable(['local_energy'])
-
-By default the local energy and all the variational parameters will be recorded.
-
-As the system is optimized, one can resample the wave function by changing the positions of the walkers.
-Several strategies are available to resample the wave function. The preferred one is to update the walkers by performing a small number of MC steps after each optimization step.
-This can be specified with :
-
->>> solver.configure_resampling(mode='update', resample_every=1, nstep_update=25)
-
-Finally we can now optimize the wave function using the `.run()` method of the solver.
-This methods takes a few arguments, the number of optimization step, the batchsize, and some parameters to compute the gradients.
-
->>> data = solver.run(5, batchsize=None,
->>>                  loss='energy',
->>>                  grad='manual',
->>>                  clip_loss=False)
-
-The results are returned in a SimpleNamespace and can be visualized with dedicated routines :
-
->>> plot_energy(solver.observable.local_energy, e0=-
->>>              1.1645, show_variance=True)
-
->>> plot_data(solver.observable, obsname='jastrow.weight')
\ No newline at end of file
diff --git a/docs/qmctorch/wavefunction.rst b/docs/qmctorch/wavefunction.rst
deleted file mode 100644
index 309e5e5c..00000000
--- a/docs/qmctorch/wavefunction.rst
+++ /dev/null
@@ -1,15 +0,0 @@
-Neural Network Wave Function
-================================
-
-QMCTorch expresses the wave function of a molecular structure as a neural network. In most cases this network takes the electronic positions as input
-and returns the corresponding value of the wave function. Several neural network wave function ansatz are implemented in QMCTorch :
-
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Wavefunction Ansatz:
-
-   slaterjastrow
-   slaterjastrow_backflow
-
-
diff --git a/docs/requirements.txt b/docs/requirements.txt
new file mode 100644
index 00000000..3239ea83
--- /dev/null
+++ b/docs/requirements.txt
@@ -0,0 +1,3 @@
+sphinx>=1.4
+ipykernel
+nbsphinx
\ No newline at end of file
diff --git a/docs/tutorial/tutorial_hdf5.rst b/docs/rst/hdf5.rst
similarity index 68%
rename from docs/tutorial/tutorial_hdf5.rst
rename to docs/rst/hdf5.rst
index 9f0a2ad2..cf7c69f0 100644
--- a/docs/tutorial/tutorial_hdf5.rst
+++ b/docs/rst/hdf5.rst
@@ -1,23 +1,9 @@
-Exploring the results with h5x
+Exploring the results with h5web
 =====================================
 
 The results and input of any the calculation performed by QMCTorch is stored in a dedicated HDF5 File
-that can be explored using `h5x`. `h5x` is hosted at https://github.com/DeepRank/h5xplorer.
-To install the browser, you clone and install the repository or use the PyPi package manager :
-
-::
-
-    pip install h5xplorer
-
-
-To launch h5x simply execute the python file in the h5x folder
-
-::
-
-    cd QMCTroch/h5x
-    python h5x.py
-
-This will start the browser where you can load and explore data files generated byt QMCTorch.
+that can be explored using `h5web` (https://h5web.panosc.eu/) A dedicated VS Code extension also allows to browse
+hdf5 files in your editor
 
 SCF calculation
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -31,9 +17,6 @@ The result of any SCF calculation generates an hdf5 file named by default
 Another name can be specified via the Molecule argument. This file contains all the data of the Molecule instance, in particular the basis set information, used in the calculation.
 By browsing the file using h5x you can retreive any information needed. This file is also reused if possible to avoid computing the SCF of a previously studied molecular system.
 
-.. image:: ../../pics/h5xmol_qmctorch.png
-
-
 
 QMCTorch calculation
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,4 +31,3 @@ Another name can be specified via the Solver argument. This file contains all th
 wavefunction, the sampler the solver and the results of all the calculations performed in the script.
 Context menus have been incorporate in order to plot the results directly from the hdf5 file.
 
-.. image:: ../pics/h5x_solver.PNG
\ No newline at end of file
diff --git a/docs/intro.rst b/docs/rst/install.rst
similarity index 100%
rename from docs/intro.rst
rename to docs/rst/install.rst
diff --git a/docs/rst/qmc.rst b/docs/rst/qmc.rst
new file mode 100644
index 00000000..593f8d8a
--- /dev/null
+++ b/docs/rst/qmc.rst
@@ -0,0 +1,45 @@
+Quantum Monte Carlo: a 1 min introduction
+===========================================
+
+Quantum Monte Carlo simulations rely on the variational principle:
+
+.. math::
+
+    E = \frac{\int \Psi^*_\theta(R) \; H \; \Psi_\theta(R) dR}{\int |\Psi_\theta(R)|^2} \geq E_0
+
+where :math:`\Psi_\theta(R)` is the wave function of the system computed for the atomic and electronic positions :math:`R`, 
+and with variational parameters :math:`\theta`, :math:`H` is the Hamiltonian of the system given by:
+
+.. math::
+
+    H = -\frac{1}{2}\sum_i \Delta_i + \sum_{i>j} \frac{1}{|r_i-r_j|} - \sum_{i\alpha} \frac{Z_\alpha}{|r_i-R_\alpha|} - \sum_{\alpha>\beta}\frac{Z_\alpha Z_\beta}{|R_\alpha-R_\beta|}
+
+where :math:`\Delta_i` is the Laplacian w.r.t the i-th electron, :math:`r_i` is the position of the i-th electron, :math:`R_\alpha` 
+the position of the :math:`\alpha`-th atom and :math:`Z_\alpha` its atomic number. QMC simulations express this integral as:
+
+.. math::
+
+    E = \int \rho(R)E_L(R)dR \geq E_0
+
+with:
+
+.. math::
+
+    \rho(R) = \frac{|\Psi_\theta(R)|^2}{\int |\Psi_\theta(R)|^2 dR}
+
+reprensent the denisty associated with the wave function, and:
+
+.. math::
+
+    E_L(R) = \frac{H\Psi_\theta(R)}{\Psi_\theta(R)}
+
+are the so called local energies of the system. QMC simulation then approximated the total energy as:
+
+.. math::
+    E \approx \frac{1}{M}\sum_i^M \frac{H\Psi_\theta(R_i)}{\Psi_\theta(R_i)}
+
+where :math:`R_i` are samples of the density :math:`\rho` for example obtained via Metropolis Hasting sampling. 
+QMC simulations rely then on the optimization of the variational parameters of the wave function, :math:`\theta`, to minimize the value
+of the total energy of the system.
+
+.. image:: ../pics/qmc.png
\ No newline at end of file
diff --git a/docs/rst/qmctorch.rst b/docs/rst/qmctorch.rst
new file mode 100644
index 00000000..35e5c54a
--- /dev/null
+++ b/docs/rst/qmctorch.rst
@@ -0,0 +1,206 @@
+Wave Function ansatz in QMCTorch
+===========================================
+
+`QMCTorch` allows to epxress the wave function ususally used by QMC practitioner as neural network. The most generic architecture of the
+neural network used by the code is:
+
+.. image:: ../pics/qmctorch2.png
+
+Starting from the electronic and atomic coordinates, the first layer on the bottom computes the electron-electron and electron-atoms distances. These distances are used in
+a Jastrow layer that computes the Jastrow facrtor. Users can freely define Jastro kernels to define the exact form the Jastrow factor.
+
+In parallel the electronic coordinates are first transformed through a backflow transformation. Users can here as well specify the kernel of the backflow transformation. 
+The resulting new coordinates are used to evaluate the atomic orbitals of the systems. The basis set information of these orbitals are extracted from the SCF calculation performed with ``pyscf`` or ``ADF``.
+These atomic orbital values are then transformed to molecular orbital values through the next layer. The coefficients of the molecular orbitals are also extracted fron the SCF calculations.
+Then a Slater determinant layer extract the different determinants contained in the wave function. Users can there as well specify wich determinants they require. The weighted sum of the determinants
+is then computed and finally muliplied with the value of the Jastrow factor.
+
+Different wave function forms have been implemented to easily create and use wave function ansatz. These different functional forms differ mainly by the Jastrow factor they use and the presence of backflow transformation or not. 
+
+Two-body Jastrow factors
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In its simplest form the Jastrow factor only depends on the electron-electron distances. This means that the Jastrow layer only has a single kernel function :math: `K_{ee}`. 
+This Jastrow factor can be applied globally, or different Jastrow factors can be applied to individual orbitals. In addition a Backflow transformation can be added or not to the definition
+of the wave function. We therefore have the following wave function available:
+
+* ``SlaterJastrow``: A simple wave function containing an electron-electron Jastrow factor and a sum of Slater determinants 
+* ``SlaterOrbitalDependentJastrow``: A  ``SlaterJastrow`` for but each molecular orbitals has its own Jastrow factor 
+* ``SlaterJastrowBackflow``: A ``SlaterJastrow`` wave function with backflow transformation for the electrons
+
+
+Slater Jastrow Wave Function
+----------------------------------------
+
+The simplest wave function implemented in `QMCTorch` is a Slater Jastrow form. Through a series of transformations 
+the Slater Jastrow function computes:
+
+.. math::
+    \Psi(R) = J(R) \sum_n c_n D_n^{\uparrow} D_n^{\downarrow}
+
+The term `J(R)` is the so called Jastrow factor that captures the electronic correlation. By default, the Jastrow factor is given by :
+
+.. math::
+
+    J(R) = \exp\left(  \sum_{i<j} \text{Kernel}(r_{ij}) \right)
+
+where the sum runs over all the electron pairs and where the kernel function defines the action of the Jastrow factor. A common expression for the
+kernel (and the default option for QMCTorch) is the Pade-Jastrow form given by:
+
+.. math::
+
+    \text{Kernel}(r_{ij}) = \frac{\omega_0 r_{ij}}{1+\omega r_{ij}}
+
+where :math:`\omega_0` is a fixed coefficient equals to 0.25(0.5) for antiparallel(parallel) electron spins and :math:`\omega` a variational parameter.
+
+The determinantal parts in the expression of :math:`\Psi` are given by the spin-up and spin-down slater determinants e.g. :
+
+.. math::
+
+    D_n^{\uparrow} = \frac{1}{\sqrt{N}} \begin{vmatrix} & & \\ & \phi_j(r_i) & \\ & & \end{vmatrix}
+
+
+A ``SlaterJastrow`` wave function can instantiated following :
+
+>>> wf = SlaterJastrow(mol, configs='single_double(2,2)', jastrow_kernel=PadeJastrowKernel)
+
+The ``SlaterJastrow`` takes as first mandiatory argument a ``Molecule`` instance. The Slater determinants required in the calculation
+are specified with the ``configs`` arguments which can take the following values :
+
+  * ``configs='ground_state'`` : only the ground state SD
+  * ``configs='cas(n,m)'`` : complete active space using n electron and m orbitals
+  * ``configs='single(n,m)'`` : only single excitation using n electron and m orbitals
+  * ``configs='single_double(n,m)'`` : only single/double excitation using n electron and m orbitals
+
+Finally the kernel function of the Jastrow factor can be specifed using the ``jastrow_kernel``
+The ``SlaterJastrow`` class accepts other initialisation arguments to fine tune some advanced settings. The default values
+of these arguments are adequeate for most cases.
+
+Orbital dependent Slater Jastrow Wave Function
+---------------------------------------------------
+
+A slight modification of the the Slater Jastrow is obtained by making the the Jastrow factor can be made orbital dependent. 
+This is implemented in the ``SlaterOrbitalDependentJastrow`` that can be instantiated as:
+
+>>> from qmctorch.wavefunction import SlaterOrbitalDependentJastrow
+>>> from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+>>> wf = SlaterOrbitalDependentJastrow(mol, configs='single_double(2,4)'
+>>>                                    jastrow_kernel=PadeJastrowKernel)
+
+Slater Jastrow Backflow Wave Function
+----------------------------------------
+
+The Slater Jastrow Backflow wave function builds on the the Slater Jastrow wavefunction but adds a backflow transformation to
+the electronic positions. Following this transformation, each electron becomes a quasi-particle whose position depends on all
+electronic positions. The backflow transformation is given by :
+
+.. math::
+
+    q(x_i) = x_i + \sum_{j\neq i} \text{Kernel}(r_{ij}) (x_i-x_j)
+
+The kernel of the transformation can be any function that depends on the distance between two electrons. A popular kernel
+is simply the inverse function :
+
+.. math::
+    \text{Kernel}(r_{ij}) = \frac{\omega}{r_{ij}}
+
+and is the default value in QMCTorch. However any other kernel function can be implemented and used in the code.
+
+The wave function is then constructed as :
+
+.. math::
+
+    \Psi(R) = J(R) \sum_n c_n D_n^{\uparrow}(Q) D_n^{\downarrow}(Q)
+
+The Jastrow factor is still computed using the original positions of the electrons while the determinant part uses the
+backflow transformed positions. One can define such wave function with:
+
+>>> from qmctorch.wavefunction import SlaterJastrowBackFlow
+>>> from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
+>>> from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+>>>
+>>> wf = SlaterJastrowBackFlow(mol, 
+>>>                            configs='single_double(2,2)',
+>>>                            jastrow_kernel=PadeJastrowKernel,
+>>>                            backflow_kernel=BackFlowKernelInverse)
+
+Compared to the ``SlaterJastrow`` wave function, the kernel of the backflow transformation must be specified. By default the inverse kernel will be used.
+
+Orbital Dependent Backflow Transformation
+******************************************
+
+The backflow transformation can be different for each atomic orbitals.
+
+.. math::
+
+    q^\alpha(x_i) = x_i + \sum_{j\neq i} \text{Kernel}^\alpha(r_{ij}) (x_i-x_j)
+
+where each orbital has its dedicated backflow kernel. This provides much more flexibility when optimizing the wave function.
+
+This wave function can be used with
+
+>>> from qmctorch.wavefunction import SlaterJastrowBackFlow
+>>> from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
+>>> from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+>>>
+>>> wf = SlaterJastrowBackFlow(mol, 
+>>>                            configs='single_double(2,2)',
+>>>                            jastrow_kernel=PadeJastrowKernel,
+>>>                            orbital_dependent_backflow=True,
+>>>                            backflow_kernel=BackFlowKernelInverse)
+
+
+Many-Body Jastrow factors
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Jastrow factors can also depends on the electron-nuclei distances and the many body terms involving two electrons and one nuclei. 
+In that case the Jastrow factor depends on all the kernel function represented in the figure above. A backflow transformation can also be added to the definition of the wave function.
+As a result we have the following wave function forms available. 
+
+* ``SlaterManyBodyJastrow``: A wave function that contains a many body Jastrow factor and a sum of Slater determinants with backflow transformation for the electrons
+* ``SlaterManyBodyJastrowBackflow``: A ``SlaterManyBodyJastrow`` wave function with a backflow transformation
+
+
+
+Many-Body Jastrow Wave Function
+----------------------------------------
+
+The Jastrow factor combines here multiple terms that represent electron-electron, electron-nuclei and electron-electron-nuclei terms. 
+
+.. math::
+
+    J(R_{at},r) = \exp\left(  \sum_{i<j} K_{ee}(r_i, r_j) + \sum_{i,\alpha}K_{en}(R_\alpha, r_i) + \sum_{i<j,\alpha} K_{een}(R_\alpha, r_i, r_j) \right)
+
+
+>>> from qmctorch.wavefunction import SlaterManyBodyJastrow
+>>> from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel as PadeJastrowElecElec
+>>> from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import PadeJastrowKernel as PadeJastrowKernelElecNuc
+>>> from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import BoysHandyJastrowKernel
+>>>
+>>> wf = SlaterManyBodyJastrow(mol, 
+>>>                            configs='single_double(2,2)',
+>>>                            jastrow_kernel={
+>>>                                 'ee': PadeJastrowKernelElecElec,
+>>>                                 'en': PadeJastrowKernelElecNuc,
+>>>                                 'een': BoysHandyJastrowKernel})
+
+
+
+Many-Body Jastrow Wave Function with backflow transformation 
+------------------------------------------------------------------
+
+A backflow transformation can be used together with the many body Jastrow
+
+
+>>> from qmctorch.wavefunction import SlaterManyBodyJastrowBackflow
+>>> from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowElecElec
+>>> from qmctorch.wavefunction.jastrows.elec_nuclei.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecNuc
+>>> from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
+>>>
+>>> wf = SlaterManyBodyJastrowBackflow(mol, 
+>>>                            configs='single_double(2,2)',
+>>>                            jastrow_kernel={
+>>>                                 'ee': PadeJastrowKernelElecElec,
+>>>                                 'en': PadeJastrowKernelElecNuc,
+>>>                                 'een': BoysHandyJastrowKernel},
+>>>                             backflow_kernel=BackFlowKernelInverse)
\ No newline at end of file
diff --git a/docs/source/qmctorch.solver.rst b/docs/source/qmctorch.solver.rst
index f706d09d..ab934e61 100644
--- a/docs/source/qmctorch.solver.rst
+++ b/docs/source/qmctorch.solver.rst
@@ -8,8 +8,8 @@ Submodules
    :maxdepth: 4
 
    qmctorch.solver.solver_base
-   qmctorch.solver.solver_slater_jastrow
-   qmctorch.solver.solver_slater_jastrow_horovod
+   qmctorch.solver.solver
+   qmctorch.solver.solver_mpi
 
 Module contents
 ---------------
diff --git a/docs/source/qmctorch.solver.solver_slater_jastrow.rst b/docs/source/qmctorch.solver.solver_slater_jastrow.rst
index d7ea5fd5..49091c62 100644
--- a/docs/source/qmctorch.solver.solver_slater_jastrow.rst
+++ b/docs/source/qmctorch.solver.solver_slater_jastrow.rst
@@ -1,7 +1,7 @@
 qmctorch.solver.solver\_slater\_jastrow module
 ==============================================
 
-.. automodule:: qmctorch.solver.solver_slater_jastrow
+.. automodule:: qmctorch.solver.solver
    :members:
    :undoc-members:
    :show-inheritance:
diff --git a/docs/source/qmctorch.solver.solver_slater_jastrow_horovod.rst b/docs/source/qmctorch.solver.solver_slater_jastrow_horovod.rst
index df469bbe..a2f7cf5d 100644
--- a/docs/source/qmctorch.solver.solver_slater_jastrow_horovod.rst
+++ b/docs/source/qmctorch.solver.solver_slater_jastrow_horovod.rst
@@ -1,7 +1,7 @@
 qmctorch.solver.solver\_slater\_jastrow\_horovod module
 =======================================================
 
-.. automodule:: qmctorch.solver.solver_slater_jastrow_horovod
+.. automodule:: qmctorch.solver.solver_mpi
    :members:
    :undoc-members:
    :show-inheritance:
diff --git a/docs/tutorial/tutorial_backflow.rst b/docs/tutorial/tutorial_backflow.rst
deleted file mode 100644
index 3e087827..00000000
--- a/docs/tutorial/tutorial_backflow.rst
+++ /dev/null
@@ -1,34 +0,0 @@
-Creating your own Backflow transformation
-==============================================
-
-We present here how to create your own backflow transformation. During the import you must import the base class of the backflow kernel
-
->>> from qmctorch.scf import Molecule
->>> from qmctorch.wavefunction import SlaterJastrowBackFlow
->>> from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
-
-
-We can then use this base class to create a new backflow transformation kernel.
-This is done in the same way one would create a new neural network layer in pytorch
-
->>> class MyBackflow(BackFlowKernelBase):
->>>
->>>     def __init__(self, mol, cuda, size=16):
->>>         super().__init__(mol, cuda)
->>>         self.fc1 = nn.Linear(1, size, bias=False)
->>>         self.fc2 = nn.Linear(size, 1, bias=False)
->>>
->>>     def forward(self, x):
->>>         original_shape = x.shape
->>>         x = x.reshape(-1,1)
->>>         x = self.fc2(self.fc1(x))
->>>         return x.reshape(*original_shape)
-
-This backflow transformation consists of two fully connected layers. The calculation of the first and second derivative are then done via automatic differentiation
-as implemented in the `BackFlowKernelBase` class. To use this new kernel in the `SlaterJastrowBackFlow` wave function ansatz we simply pass the class name as argument of the `backflow_kernel` keyword argument :
-
->>> # define the wave function
->>> wf = SlaterJastrowBackFlow(mol, kinetic='jacobi',
->>>                    backflow_kernel=MyBackflow,
->>>                    backflow_kernel_kwargs={'size' : 64},
->>>                    configs='single_double(2,2)')
diff --git a/docs/tutorial/tutorial_correlation.rst b/docs/tutorial/tutorial_correlation.rst
deleted file mode 100644
index 78876db1..00000000
--- a/docs/tutorial/tutorial_correlation.rst
+++ /dev/null
@@ -1,78 +0,0 @@
-Correlation and Blocking
-========================================
-
-One important part of the sampling is to estimate the correlation between the different sampling points.
-To this end let's import the following modules
-
-
->>> from qmctorch.scf import Molecule
->>> from qmctorch.wavefunction import SlaterJastrow
->>> from qmctorch.sampler import Metropolis
->>> from qmctorch.utils import set_torch_double_precision
->>> from qmctorch.utils import blocking, plot_blocking_energy
->>> from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time
-
-
-To obtain a bettter accuracy on our results we can switch to a double precision default
-tensor type for pytorch :
-
->>> set_torch_double_precision()
-
-
-Correlation coefficient
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-The simplest way to estimate the decorelation time is to compute the autocorrelation coefficient of the local energy.
-After having defined the molecule and the wave function as in the previous tutorial, let's define the sampler as follow:
-
->>> sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,
->>>                     nelec=wf.nelec, ndim=wf.ndim,
->>>                     init=mol.domain('normal'),
->>>                     ntherm=0, ndecor=1,
->>>                     move={'type': 'all-elec', 'proba': 'normal'})
-
-Compared to before we here record all the walker position along the trajectory. We can then define the solver as before
-and run the following commands:
-
->>> pos = solver.sampler(solver.wf.pdf)
->>> obs = solver.sampling_traj(pos)
->>> rho, tau = plot_correlation_coefficient(obs.local_energy)
-
-Which gives the following plot:
-
-.. image:: ../../pics/correlation_coeff.png
-
-
-On this picture is represented the autocorrelation coefficient of the local energy of all the walkers (transparent colorful line)
-and the average of the autocorrelation coefficient (thick black line). This mean value is fitted with an exponential decay
-to obtain the autocorrelation time that is here equal to 4.13 MCs.
-
-Integrated autocorrelation time
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Another way to estimate the correlation time is to compute the integrated autocorrelation time. This can be done with
-
->>> plot_integrated_autocorrelation_time(obs.local_energy)
-
-That leads to the following plot
-
-.. image:: ../../pics/iac.png
-
-A conservative estimate of the correlation time can be obtain when the iac cross the dashed line, leading here to a value of about 7 steps.
-
-
-Energy blocking
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-It is also common practice to use blocking of the local energy values to reduce the variance. This can easily be done with
-
->>> eb = plot_blocking_energy(obs.local_energy, block_size=100,
->>>                           walkers='mean')
-
-leading to the plot
-
-.. image:: ../../pics/blocking.png
-
-That shows the raw and blocked values of the mean local energy values.
-
-
-
diff --git a/docs/tutorial/tutorial_geo_opt.rst b/docs/tutorial/tutorial_geo_opt.rst
deleted file mode 100644
index 469d1861..00000000
--- a/docs/tutorial/tutorial_geo_opt.rst
+++ /dev/null
@@ -1,72 +0,0 @@
-Geometry Optimization
-====================================
-
-We present here a complete example on how to use QMCTorch on a H2O molecule.
-As previously the firs task is to import all the modules needed
-
->>> from torch import optim
->>> from torch.optim import Adam
->>>  from qmctorch.wavefunction import SlaterJastrow
->>> from qmctorch.solver import SolverSlaterJastrow
->>> from qmctorch.samplerimport Metropolis
->>> from qmctorch.scf import Molecule
->>> from qmctorch.utils import plot_energy
-
-We then define the molecule. We read here an xyz file of a water molecule
-where the three atoms are on the same line.
-
->>> # define the molecule
->>> mol = Molecule(atom='water_line.xyz', unit='angs',
->>>                calculator='pyscf', basis='sto-3g')
-
-
-The QMCNet wave function is defined from the molecule object. We only consider here the
-ground state of the molecule in the CI expansion.
-
->>> # define the wave function
->>> wf = SlaterJastrow(mol, kinetic='jacobi',
->>>          configs='ground_state',
->>>           use_jastrow=True)
-
-We use a Metropolis Hasting sampler with 100 walkers each performing 2000 steps.
-
->>> # sampler
->>> sampler = Metropolis(nwalkers=1000, nstep=2000, step_size=0.5,
->>>                      nelec=wf.nelec, ndim=wf.ndim,
->>>                      init=mol.domain('normal'),
->>>                      move={'type': 'one-elec', 'proba': 'normal'})
-
-As an opimizer we use ADAM and define a simple linear scheduler.
-
->>> # optimizer
->>> opt = Adam(wf.parameters(), lr=0.005)
->>>
->>> # scheduler
->>> scheduler = optim.lr_scheduler.StepLR(opt, step_size=20, gamma=0.75)
-
-We can now assemble the solver
-
->>> # solver
->>> solver = SolverSlaterJastrow(wf=wf,
->>>                        sampler=sampler,
->>>                        optimizer=opt,
->>>                        scheduler=scheduler)
-
-To optimize the geometry of the molecule we must specify `task=geo_opt`. This will
-freeze all the parameters of the wave function at the exception of th atomic coordinate.
-We can then run the optimization here using 50 epochs, the energy as loss function and the low variance expression
-of the gradients.
-
->>> # optimize the geometry
->>> solver.configure(task='geo_opt')
->>> obs = solver.run(50, loss='energy', grad='manual')
->>> solver.save_traj('h2o_traj.xyz')
-
-We can then plot the energy
-
->>> # plot the data
->>> plot_energy(obs.local_energy)
-
-.. image:: ../../pics/h2_go_opt.png
-
-
diff --git a/docs/tutorial/tutorial_gpus.rst b/docs/tutorial/tutorial_gpus.rst
deleted file mode 100644
index a8a81652..00000000
--- a/docs/tutorial/tutorial_gpus.rst
+++ /dev/null
@@ -1,71 +0,0 @@
-GPUs and multi-GPUs Support
-==============================================
-
-.. warning::
-    The use of GPU and mutli-GPU is under developpement and hasn't been
-    thoroughly tested yet. Proceed with caution !
-
-
-Using pytorch as a backend, QMCTorch can leverage GPU cards available on your hardware.
-You of course must have the CUDA version of pytorch installed (https://pytorch.org/)
-
-
-Running on a single GPU
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The use of GPU acceleration has been streamlined in QMCTorch, the only modification
-you need to do on your code is to specify `cuda=True` in the declaration of the wave function :
-
-
->>> # define the wave function
->>> wf = SlaterJastrow(mol, kinetic='jacobi',
->>>             configs='cas(2,2)',
->>>             cuda=True)
-
-This will automatically port all the necesaary tensors to the GPU and offload all the corresponding operation
-there.
-
-Multi-GPU support
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The use of multiple GPUs is made possible through the `Horovod` library : https://github.com/horovod/horovod
-A dedicated QMCTorch Solver has been developped to handle multiple GPU. To use this solver simply import it
-and use is as the normal solver and only a few modifications are required to use horovod :
-
-
->>> import horovod.torch as hvd
->>> from deepqmc.solver.solver_slater_jastrow_horovod import SolverSlaterJastrowHorovod
->>>
->>> hvd.init()
->>> if torch.cuda.is_available():
->>>    torch.cuda.set_device(hvd.local_rank())
->>>
->>> # define the molecule
->>> mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
->>>                calculator='pyscf', basis='sto-3g',
->>>               unit='bohr', rank=hvd.local_rank())
->>>
->>> ...
->>>
->>> solver = SolverSlaterJastrowHorovod(wf=wf, sampler=sampler,
->>>                              optimizer=opt, scheduler=scheduler,
->>>                              rank=hvd.rank())
->>> ....
-
-As you can see some classes need the rank of the process when they are defined. This is simply
-to insure that only the master process generates the HDF5 files containing the information relative to the calculation.
-
-The code can then be launched using the `horovodrun` executalbe :
-
-::
-
-    horovodrun -np 2 python <example>.py
-
-See the horovod documentation for more details : https://github.com/horovod/horovod
-
-
-This solver distribute the `Nw` walkers over the `Np` process . For example specifying 2000 walkers
-and using 4 process will lead to each process using only 500 walkers. During the optimizaiton of the wavefunction
-each process will compute the gradients of the variational parameter using their local 500 walkers.
-The gradients are then averaged over all the processes before the optimization step takes place. This data parallel
-model has been greatly succesfull in machine learning applications (http://jmlr.org/papers/volume20/18-789/18-789.pdf)
\ No newline at end of file
diff --git a/docs/tutorial/tutorial_jastrow.rst b/docs/tutorial/tutorial_jastrow.rst
deleted file mode 100644
index 7c841a4a..00000000
--- a/docs/tutorial/tutorial_jastrow.rst
+++ /dev/null
@@ -1,52 +0,0 @@
-Creating your own Jastrow Factor
-====================================
-
-We present here how to create your own electron-electron Jastrow factor and use it in QMCTorch
-
-During the import you must import the base class of the electron-electron Jastrow.
-
->>> from qmctorch.scf import Molecule
->>> from qmctorch.wavefunction import SlaterJastrow,
->>> from qmctorch.wavefunction.jastrows.elec_elec.kernels import JastrowKernelElectronElectronBase
-
-
-We can then use this base class to create a new Jastrow Factor. This is done in the same way one would create
-a new neural network layer in pytorch.
-
->>> class MyJastrow(JastrowKernelElectronElectronBase)
->>>
->>>     def __init__(self, nup, ndown, cuda, size=16):
->>>         super().__init__(nup, ndown, cuda)
->>>         self.fc1 = nn.Linear(1, size, bias=False)
->>>         self.fc2 = nn.Linear(size, 1, bias=False)
->>>
->>>     def forward(self, x):
->>>         nbatch, npair = x.shape
->>>         x = x.reshape(-1,1)
->>>         x = self.fc2(self.fc1(x))
->>>         return x.reshape(nbatch, npair)
-
-As seen above the prototype of the class constructor must be:
-
->>> def __init__(self, nup, ndown, cuda, **kwargs)
-
-The list of keyword argument can contain any pairs such as ``size=16``.
-
-This Jastrow use two fully connected layers. The size of the hidden layer is here controlled by a keyword argument ``size`` whose defauilt value is 16
-It is important to note that the calculation of the first and second derivative of the jastrow kernel wrt the electronic positions are then done via automatic differentiation
-as implemented in the `JastrowKernelElectronElectronBase` class. Hence there is no need to derive and implement these derivatives. However it
-is necessary that the ``forward`` function, which takes as input a ``torch.tensor`` of
-dimension ``[Nbatch, Npair]`` first reshape this tensor to ``[Nbatch*Npair,1]``, then applies the transformation on this tensor and finally reshape
-the output tensor to ``[Nbatch, Npair]``.
-
-To use this new Jastrow in the `SlaterJastrow` wave function ansatz we simply pass the class name as argument of the `jastrow_kernel` keyword argument. It is also
-possible to specify the values of the keyword argument ``size`` with the ``jastrow_kernel_kwargs``. As seen below the pair of keyword argument and its value is passed as
-a python dictionary :
-
->>> # define the wave function
->>> wf = SlaterJastrow(mol, kinetic='jacobi',
->>>                    jastrow_kernel=MyJastrow
->>>                    jastrow_kernel_kwargs={'size' : 64}
->>>                    configs='single_double(2,2)')
-
-As previously, `mol` is an instance of the `qmctorch.scf.Molecule` class.
\ No newline at end of file
diff --git a/docs/tutorial/tutorial_sampling_traj.rst b/docs/tutorial/tutorial_sampling_traj.rst
deleted file mode 100644
index f8e627cf..00000000
--- a/docs/tutorial/tutorial_sampling_traj.rst
+++ /dev/null
@@ -1,105 +0,0 @@
-Single point and Sampling trajectory
-========================================
-
-In this first tutorial we are going to define a simple molecule and sample its wave function.
-Let's start by importing all the modules we need :
-
->>> from qmctorch.scf import Molecule
->>> from qmctorch.wavefunction import SlaterJastrow
->>> from qmctorch.sampler import Metropolis
->>> from qmctorch.utils import set_torch_double_precision
->>> from qmctorch.utils import plot_walkers_traj
-
-To obtain a bettter accuracy on our results we can switch to a double precision default
-tensor type for pytorch :
-
->>> set_torch_double_precision()
-
-
-Gaussian orbitals : STO-3G with pyscf
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-We now  need to define the molecule. We are here going to read the position of a water molecule from an xyz file.
-The coordinates of an XYZ files are in Angstrom and we therefore specify this unit when defining the molecule.
-We choose here to use pyscf with a samall sto-3g basis set to perform the SCF calculation on the molecule.
-
->>> # define the molecule
->>> mol = Molecule(atom='water.xyz', unit='angs',
->>>               calculator='pyscf', basis='sto-3g')
-
-We can now define the QMCNet wavefunction. We choose here to include only the ground state of the of the system in the CI expansion.
-The kinetic energy of the system will be computed using the Jacobi formula instead of the hessian of the wave function  wrt the electron positions through automatic differentiation.
-We also include a Jastrow factor in the calculation of the wave function.
-
->>> # define the wave function
->>> wf = SlaterJastrow(mol, kinetic='jacobi',
->>>             configs='ground_state')
-
-We then define the sampler as Metropolis Hasting samper, using only 100 walkers. Each walker is initially in a shpere around the molecule.
-During the MC sampling each walker performs 500 steps of 0.25 atomic units. We here move only 1 electron per MC step per walkers using a normal distribution centred around their current position.
-
->>> # sampler
->>> sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,
->>>                     nelec=wf.nelec, ndim=wf.ndim,
->>>                     init=mol.domain('normal'),
->>>                     move={'type': 'one-elec', 'proba': 'normal'})
-
-We can now assemble the solver.
-
->>> # solver
->>> solver = SolverSlaterJastrow(wf=wf, sampler=sampler)
-
-We can first perform  a single point calculation.
-In this calculation the solver will sample the wave function and compute the energy of the system.
-
->>> obs = solver.single_point()
-
-::
-
-    Energy   :  -71.28987884521484  +/-  1.5550774335861206
-    Variance :  241.82656860351562
-
-This leads to an energy of about E = -71 hartrees witha  very large error bar of several hartrees. This bad result is due to the basis set
-we are using here (sto-3g) that is a poor approximation of the slater orbitals.
-
-To understand how the sampling works we can compute and visualize the sampling trajectory. To this end we are going to change the parameters of th sampler so that it keeps
-the position of the walkers during the MC sampling. We will therefore keep the walker positions each 5 MC step starting from their initial positions.
-
->>> solver.sampler.ntherm = 0
->>> solver.sampler.ndecor = 5
-
-We then have to sample the wave function and computes the energy for each sampling interval.
-
->>> pos = solver.sampler()
->>> obs = solver.sampling_traj(pos)
-
-We can now visualize the results.
-
->>> plot_walkers_traj(obs.local_energy, walkers='mean')
-
-.. image:: ../../pics/samplig_sto.png
-
-
-Slater orbitals : DZP with ADF
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-It is possible to improve the results bu using ADF as a calculator and a DZP basis set. We can hence change the molecule to :
-
->>> # define the molecule
->>> mol = Molecule(atom='water.xyz', unit='angs',
->>>               calculator='adf', basis='dzp')
-
-Without changing anything else in the calculation we now obtain a smaller error bar on the energy (few tenth of hartrees).
-
-::
-
-    Energy   :  -72.27135467529297  +/-  0.36148950457572937
-    Variance :  13.06746768951416
-
-and the following graph:
-
-.. image:: ../../pics/samplig_dzp.png
-
-
-
-
diff --git a/docs/tutorial/tutorial_wf_opt.rst b/docs/tutorial/tutorial_wf_opt.rst
deleted file mode 100644
index 9cb98e96..00000000
--- a/docs/tutorial/tutorial_wf_opt.rst
+++ /dev/null
@@ -1,104 +0,0 @@
-Wave function Optimization
-====================================
-
-We present here a complete example on how to use QMCTorch on a H2 molecule.
-We first need to import all the relevant modules :
-
->>> from torch import optim
->>> from qmctorch.scf import Molecule
->>> from qmctorch.wavefunction import SlaterJastrow,
->>> from qmctorch.solver import SolverSlaterJastrow
->>> from qmctorch.sampler import Metropolis
->>> from qmctorch.utils import set_torch_double_precision
->>> from qmctorch.utils import (plot_energy, plot_data)
-
-To obtain a bettter accuracy on our results we can switch to a double precision default
-tensor type for pytorch :
-
->>> set_torch_double_precision()
-
-The first step is to define a molecule. We here use a H2 molecule with both hydrgen atoms
-on the z-axis and separated by 1.38 atomic unit. We also choose to use ADF as SCF calculator using
-a double zeta + polarization (dzp) basis set.
-
->>> # define the molecule
->>> mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
->>>                calculator='adf',
->>>                basis='dzp',
->>>                unit='bohr')
-
-We then define the QMCNet wave function relative to this molecule. We also specify here
-the determinants we want to use in the CI expansion. We use here a to include all the single
-and double excitation with 2 electrons and 2 orbitals
-
->>> # define the wave function
->>> wf = SlaterJastrow(mol, kinetic='jacobi',
->>>              configs='single_double(2,2)')
-
-As a sampler we use a simple Metropolis Hasting with 1000 walkers. The walkers are initially localized around the atoms.
-Each walker will perform 2000 steps of size 0.2 atomic unit and will only keep the last position of each walker (`ntherm=-1`).
-During each move all the the electrons are moved simultaneously within a normal distribution centered around their current location.
-
->>> # define the sampler
->>> sampler = Metropolis(nwalkers=1000,
->>>                      nstep=2000, step_size=0.2,
->>>                      ntherm=-1, ndecor=100,
->>>                      nelec=wf.nelec, init=mol.domain('atomic'),
->>>                      move={'type': 'all-elec', 'proba': 'normal'})
-
-
-We will use the ADAM optimizer implemented in pytorch with custom learning rate for each layer.
-We also define a linear scheduler that will decrease the learning rate after 100 steps
-
->>> # optimizer
->>> lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-3},
->>>            {'params': wf.ao.parameters(), 'lr': 1E-6},
->>>            {'params': wf.mo.parameters(), 'lr': 1E-3},
->>>            {'params': wf.fc.parameters(), 'lr': 1E-3}]
->>> opt = optim.Adam(lr_dict, lr=1E-3)
->>>
->>> # scheduler
->>> scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
-
-We can now assemble the solver :
-
->>> # QMC solver
->>> solver = SolverSlaterJastrow(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)
-
-The solver needs to be configured. Many parameters of the optimization can be controlled as illustrated below
-
-We can specify which observale to track during the optimization. Here only the local energies will be recorded
-but one can also record the variational parameters
->>> solver.configure(track=['local_energy'])
-
-Some variational parameters can be frozen and therefore not optimized. We here freeze the MO coefficients and the AO parameters
-and therefore only the jastrow parametres and the CI coefficients will be optmized
->>> solver.configure(freeze=['ao', 'mo'])
-
-Either the mean or the variance of local energies can be used as a loss function. We here use the mean
->> solver.configure(loss='energy')
-
-The gradients can be computed directly via automatic differntiation or via a reduced noise formula
->>> solver.configure(grad='auto')
-
-We also configure the resampling so that the positions of the walkers are updated by performing
-25 MC steps from their previous positions after each optimization step.
-
->>> solver.configure(resampling={'mode': 'update',
->>>                             'resample_every': 1,
->>>                             'nstep_update': 25})
-
-
-
-
-We can now run the optimization. We use here 250 optimization steps (epoch), using all the points
-in a single mini-batch.
-
->>> data = solver.run(250)
-
-Once the optimization is done we can plot the results
-
->>> plot_energy(solver.observable.local_energy, e0=-1.1645, show_variance=True)
->>> plot_data(solver.observable, obsname='jastrow.weight')
-
-.. image:: ../../pics/h2_dzp.png
\ No newline at end of file
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
deleted file mode 100644
index 9640e217..00000000
--- a/h5x/baseimport.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from qmctorch.utils import (
-    plot_energy, plot_data, plot_block, plot_walkers_traj)
-import matplotlib.pyplot as plt
-import numpy as np
-
-print(r"  ____    __  ______________             _")
-print(r" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
-print(r"/ /_/ / / /|_/ / /__  / / / _ \/ __/ __/ _ \ ")
-print(r"\___\_\/_/  /_/\___/ /_/  \___/_/  \__/_//_/ ")
diff --git a/h5x/context_menu.py b/h5x/context_menu.py
deleted file mode 100644
index 21ade5e7..00000000
--- a/h5x/context_menu.py
+++ /dev/null
@@ -1,177 +0,0 @@
-from PyQt5 import QtWidgets
-from h5xplorer.menu_tools import *
-from h5xplorer.menu_plot import *
-import numpy as np
-
-
-def context_menu(self, treeview, position):
-    """Generate a right-click menu for the items"""
-
-    # make sure tha there is only one item selected
-    all_item = get_current_item(self, treeview, single=False)
-
-    if len(all_item) == 1:
-
-        item = all_item[0]
-        _context_menu_group(self, item, treeview, position)
-        _context_menu_data(self, item, treeview, position)
-
-    else:
-        pass
-
-
-def _context_menu_group(self, item, treeview, position):
-
-    try:
-
-        _type = self.root_item.data_file[item.name].attrs['type']
-
-        # if _type == 'molecule':
-        #     molgrp = self.root_item.data_file[item.name]
-        #     _context_mol(item, treeview, position, molgrp)
-
-        # if _type == 'single_point':
-        #     _context_sparse(item, treeview, position)
-
-        if _type == 'sampling_traj':
-            _context_sampling_trajectory(self,
-                                         item,
-                                         treeview,
-                                         position)
-
-        if _type == 'opt':
-            _context_optimization(
-                self, item, treeview, position)
-
-    except Exception as inst:
-        print(type(inst))
-        print(inst)
-        return
-
-# def _context_mol(item, treeview, position, molgrp):
-
-#     menu = QtWidgets.QMenu()
-#     actions = {}
-#     list_operations = ['Load in PyMol', 'Load in VMD', 'PDB2SQL']
-
-#     for operation in list_operations:
-#         actions[operation] = menu.addAction(operation)
-#     action = menu.exec_(treeview.viewport().mapToGlobal(position))
-
-#     _, cplx_name, mol_name = item.name.split('/')
-#     mol_name = mol_name.replace('-', '_')
-
-#     if action == actions['Load in VMD']:
-#         viztools.create3Ddata(mol_name, molgrp)
-#         viztools.launchVMD(mol_name)
-
-#     if action == actions['Load in PyMol']:
-#         viztools.create3Ddata(mol_name, molgrp)
-#         viztools.launchPyMol(mol_name)
-
-#     if action == actions['PDB2SQL']:
-#         db = pdb2sql(molgrp['complex'].value)
-#         treeview.emitDict.emit({'sql_' + item.basename: db})
-
-
-# def _context_single_point(item, treeview, position):
-#     menu = QtWidgets.QMenu()
-#     actions = {}
-#     list_operations = ['Load in PyMol', 'Load in VMD', 'PDB2SQL']
-
-def _context_sampling_trajectory(self, item, treeview, position):
-
-    menu = QtWidgets.QMenu()
-    actions = {}
-    list_operations = ['Plot Energy Walkers', 'Plot Blocking']
-
-    for operation in list_operations:
-        actions[operation] = menu.addAction(operation)
-    action = menu.exec_(treeview.viewport().mapToGlobal(position))
-
-    if action == actions['Plot Energy Walkers']:
-
-        grp = get_current_hdf5_group(self, item)
-        data = grp['local_energy'][()]
-        data_dict = {'_walkers_energy': data}
-        treeview.emitDict.emit(data_dict)
-
-        data_dict = {}
-        data_dict['exec_cmd'] = "plot_walkers_traj(_walkers_energy)"
-        treeview.emitDict.emit(data_dict)
-
-    if action == actions['Plot Blocking']:
-
-        grp = get_current_hdf5_group(self, item)
-        data = grp['local_energy'][()]
-        data_dict = {'_walkers_energy': data}
-        treeview.emitDict.emit(data_dict)
-
-        data_dict = {}
-        data_dict['exec_cmd'] = "plot_block(_walkers_energy)"
-        treeview.emitDict.emit(data_dict)
-
-
-def _context_optimization(self, item, treeview, position):
-
-    menu = QtWidgets.QMenu()
-    actions = {}
-    list_operations = ['Plot Energy']
-
-    for operation in list_operations:
-        actions[operation] = menu.addAction(operation)
-    action = menu.exec_(treeview.viewport().mapToGlobal(position))
-
-    if action == actions['Plot Energy']:
-
-        grp = get_current_hdf5_group(self, item)
-        data = grp['local_energy'][()]
-        data_dict = {'_eloc': data}
-        treeview.emitDict.emit(data_dict)
-
-        data_dict = {}
-        data_dict['exec_cmd'] = "plot_energy(_eloc)"
-        treeview.emitDict.emit(data_dict)
-
-
-def _context_menu_data(self, item, treeview, position):
-
-    try:
-        data = get_group_data(get_current_hdf5_group(self, item))
-
-        if data is None:
-            list_operations = ['Print attrs']
-
-        elif data.ndim == 1:
-            list_operations = ['Print attrs',
-                               '-', 'Plot Hist', 'Plot Line']
-
-        elif data.ndim == 2:
-            list_operations = ['Print attrs',
-                               '-', 'Plot Hist', 'Plot Map']
-
-        else:
-            list_operations = ['Print attrs']
-
-        action, actions = get_actions(
-            treeview, position, list_operations)
-
-        if action == actions['Print attrs']:
-            send_dict_to_console(self, item, treeview)
-
-        if 'Plot Hist' in actions:
-            if action == actions['Plot Hist']:
-                plot_histogram(self, item, treeview)
-
-        if 'Plot Line' in actions:
-            if action == actions['Plot Line']:
-                plot_line(self, item, treeview)
-
-        if 'Plot Map' in actions:
-            if action == actions['Plot Map']:
-                plot2d(self, item, treeview)
-
-    except Exception as inst:
-        print(type(inst))
-        print(inst)
-        return
diff --git a/h5x/h5x.py b/h5x/h5x.py
deleted file mode 100755
index 608feeff..00000000
--- a/h5x/h5x.py
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env python
-import os
-from h5xplorer.h5xplorer import h5xplorer
-import context_menu
-import qmctorch
-
-
-base = os.path.dirname(qmctorch.__file__) + "/../h5x/baseimport.py"
-
-app = h5xplorer(context_menu.context_menu,
-                baseimport=base,
-                extended_selection=False)
diff --git a/notebooks/qmctorch.ipynb b/notebooks/qmctorch.ipynb
deleted file mode 100644
index c07ec364..00000000
--- a/notebooks/qmctorch.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"qmctorch.ipynb","provenance":[],"authorship_tag":"ABX9TyMr6DKmNBGlyg+0pzpuupgz"},"kernelspec":{"name":"python3","display_name":"Python 3"},"accelerator":"GPU"},"cells":[{"cell_type":"markdown","metadata":{"id":"PA9WOB4zJfCu","colab_type":"text"},"source":["# To install `QMCTorch` copy the code from one of the 3 text cells below in a code cell and run that cell. "]},{"cell_type":"markdown","metadata":{"id":"6KLOhN_dGQ11","colab_type":"text"},"source":["## Install QMCTorch from Pypi Package manager\n","\n","```\n","! pip install qmctorch\n","```\n","\n"]},{"cell_type":"markdown","metadata":{"id":"Eb9wI3eOGfz1","colab_type":"text"},"source":["## Install QMCTorch from GitHub\n","```\n","from google.colab import drive\n","drive.mount('/content/gdrive')\n","% cd gdrive/My Drive/\n","! git clone https://github.com/NLESC-JCER/QMCTorch\n","% cd QMCTorch\n","! pip install -e .\n","% cd ../\n","```"]},{"cell_type":"markdown","metadata":{"id":"_VNw5sAeHC7M","colab_type":"text"},"source":["## Pull latest code from Github\n","```\n","from google.colab import drive\n","drive.mount('/content/gdrive')\n","% cd gdrive/My Drive/QMCTorch\n","! git pull origin master\n","! pip install -e .\n","% cd ../\n","```"]},{"cell_type":"code","metadata":{"id":"khGd1-ewHZWF","colab_type":"code","colab":{"base_uri":"https://localhost:8080/","height":671},"outputId":"674fbe9e-7817-4e11-cc91-cd508bda8107","executionInfo":{"status":"ok","timestamp":1588617088336,"user_tz":-120,"elapsed":9770,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"}}},"source":["from google.colab import drive\n","drive.mount('/content/gdrive')\n","% cd gdrive/My Drive/QMCTorch\n","! git pull origin master\n","! pip install -e .\n","% cd .."],"execution_count":1,"outputs":[{"output_type":"stream","text":["Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n","/content/gdrive/My Drive/QMCTorch\n","From https://github.com/NLESC-JCER/QMCTorch\n"," * branch            master     -> FETCH_HEAD\n","Already up to date.\n","Obtaining file:///content/gdrive/My%20Drive/QMCTorch\n","Requirement already satisfied: autograd in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (1.3)\n","Requirement already satisfied: cython in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (0.29.17)\n","Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (3.2.1)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (1.18.3)\n","Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (5.3.1)\n","Requirement already satisfied: schema in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (0.7.2)\n","Requirement already satisfied: scipy in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (1.4.1)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (4.38.0)\n","Requirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (1.5.0+cu101)\n","Requirement already satisfied: pyscf in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (1.7.1)\n","Requirement already satisfied: mendeleev in /usr/local/lib/python3.6/dist-packages (from qmctorch==0.1.0) (0.6.0)\n","Requirement already satisfied: future>=0.15.2 in /usr/local/lib/python3.6/dist-packages (from autograd->qmctorch==0.1.0) (0.16.0)\n","Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->qmctorch==0.1.0) (2.4.7)\n","Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->qmctorch==0.1.0) (2.8.1)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib->qmctorch==0.1.0) (0.10.0)\n","Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->qmctorch==0.1.0) (1.2.0)\n","Requirement already satisfied: contextlib2>=0.5.5 in /usr/local/lib/python3.6/dist-packages (from schema->qmctorch==0.1.0) (0.5.5)\n","Requirement already satisfied: h5py in /usr/local/lib/python3.6/dist-packages (from pyscf->qmctorch==0.1.0) (2.10.0)\n","Requirement already satisfied: pyfiglet in /usr/local/lib/python3.6/dist-packages (from mendeleev->qmctorch==0.1.0) (0.8.post1)\n","Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (from mendeleev->qmctorch==0.1.0) (1.0.3)\n","Requirement already satisfied: sqlalchemy in /usr/local/lib/python3.6/dist-packages (from mendeleev->qmctorch==0.1.0) (1.3.16)\n","Requirement already satisfied: colorama in /usr/local/lib/python3.6/dist-packages (from mendeleev->qmctorch==0.1.0) (0.4.3)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.1->matplotlib->qmctorch==0.1.0) (1.12.0)\n","Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas->mendeleev->qmctorch==0.1.0) (2018.9)\n","Installing collected packages: qmctorch\n","  Found existing installation: qmctorch 0.1.0\n","    Can't uninstall 'qmctorch'. No files were found to uninstall.\n","  Running setup.py develop for qmctorch\n","Successfully installed qmctorch\n","/content/gdrive/My Drive\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"MGNu_L-OJ-7u","colab_type":"text"},"source":["# Using QMCTorch"]},{"cell_type":"code","metadata":{"id":"p7qEQTV2HB4h","colab_type":"code","colab":{"base_uri":"https://localhost:8080/","height":52},"outputId":"52c2bbce-3775-442c-95de-d18bd432c2e3","executionInfo":{"status":"ok","timestamp":1588617090211,"user_tz":-120,"elapsed":11632,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"}}},"source":["from torch import optim\n","from qmctorch.wavefunction import SlaterJastrow, Molecule\n","from qmctorch.solver import SolverSlaterJastrow\n","from qmctorch.sampler import Metropolis\n","from qmctorch.utils import set_torch_double_precision\n","from qmctorch.utils import plot_energy, plot_data"],"execution_count":2,"outputs":[{"output_type":"stream","text":["/content/gdrive/My Drive/QMCTorch/qmctorch/wavefunction/calculator/adf.py:12: UserWarning: scm python module not found\n","  warnings.warn('scm python module not found')\n"],"name":"stderr"}]},{"cell_type":"code","metadata":{"id":"x-s06JyaHUdN","colab_type":"code","colab":{}},"source":["set_torch_double_precision()"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"7HO4cNaAID-F","colab_type":"code","colab":{"base_uri":"https://localhost:8080/","height":52},"outputId":"a1f652aa-9bcb-4e9b-c038-833b29da2eae","executionInfo":{"status":"ok","timestamp":1588617090213,"user_tz":-120,"elapsed":11608,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"}}},"source":["mol = Molecule(atom='H 0 0 0.69; H 0 0 -0.69', unit='bohr', \\\n","               calculator='pyscf', basis='sto-3g')"],"execution_count":4,"outputs":[{"output_type":"stream","text":["Running scf calculation\n","converged SCF energy = -1.11718492179418\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"hFZg-XanIOeY","colab_type":"code","colab":{}},"source":["wf = SlaterJastrow(mol, configs='cas(2,2)', cuda=True)"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"Mqlk1N3tIVXN","colab_type":"code","colab":{}},"source":["sampler = Metropolis(nwalkers=2000, nstep=2000, step_size=0.2, \\\n","                     ntherm=-1, ndecor=100, nelec=wf.nelec, \\\n","                     init=mol.domain('atomic'), \\\n","                     move={'type':'all-elec', 'proba':'normal'},\n","                     cuda=True)"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"5-I7abLxI5qG","colab_type":"code","colab":{}},"source":["lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},\n","           {'params': wf.ao.parameters(), 'lr': 1E-6},\n","           {'params': wf.mo.parameters(), 'lr': 1E-3},\n","           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n","opt = optim.Adam(lr_dict, lr=1E-3)"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"xgXSp8JwJIr9","colab_type":"code","colab":{}},"source":["scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"g6TE--nNJL1H","colab_type":"code","colab":{}},"source":["solver = SolverSlaterJastrow(wf=wf, sampler=sampler,\n","                       optimizer=opt, scheduler=scheduler)"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"Y5MPLiv2JTCy","colab_type":"code","colab":{"base_uri":"https://localhost:8080/","height":87},"outputId":"ef067f86-11b3-48e0-9dac-dc8ff5784905","executionInfo":{"status":"ok","timestamp":1588617105475,"user_tz":-120,"elapsed":26805,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"}}},"source":["obs = solver.single_point()"],"execution_count":10,"outputs":[{"output_type":"stream","text":["100%|██████████| 2000/2000 [00:08<00:00, 222.80it/s]\n"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.036 %\n","Energy   :  -1.141010163098497  +/-  0.015220386836893682\n","Variance :  0.46332035092937285\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"yfx4g1Luz9Z-","colab_type":"code","colab":{}},"source":["solver.configure(task='wf_opt', freeze=['ao', 'mo'])\n","solver.track_observable(['local_energy'])\n","\n","solver.configure_resampling(mode='update',\n","                            resample_every=1,\n","                            nstep_update=50)\n","solver.ortho_mo = False"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"VtrVSk620A1A","colab_type":"code","colab":{"base_uri":"https://localhost:8080/","height":1000},"outputId":"32ad9904-40e5-4efa-bcee-27145e04cfd4","executionInfo":{"status":"ok","timestamp":1588617131289,"user_tz":-120,"elapsed":52595,"user":{"displayName":"Nicolas Renaud","photoUrl":"","userId":"07120063468244602126"}}},"source":["obs = solver.run(50, batchsize=None,\n","                 loss='energy',\n","                 grad='manual',\n","                 clip_loss=False)"],"execution_count":12,"outputs":[{"output_type":"stream","text":["100%|██████████| 2000/2000 [00:09<00:00, 220.98it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.024 %\n","----------------------------------------\n","epoch 0\n","energy   : -1.157236 +/- 0.018460\n","variance : 0.825559\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 198.74it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 225.39it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.949 %\n","----------------------------------------\n","epoch 1\n","energy   : -1.133535 +/- 0.014978\n","variance : 0.669828\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 224.64it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 230.43it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.160 %\n","----------------------------------------\n","epoch 2\n","energy   : -1.117700 +/- 0.011985\n","variance : 0.535977\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 226.14it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 223.40it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.061 %\n","----------------------------------------\n","epoch 3\n","energy   : -1.139999 +/- 0.016254\n","variance : 0.726899\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 225.09it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 233.08it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.245 %\n","----------------------------------------\n","epoch 4\n","energy   : -1.136602 +/- 0.022911\n","variance : 1.024620\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 227.26it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 223.20it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.985 %\n","----------------------------------------\n","epoch 5\n","energy   : -1.158608 +/- 0.020921\n","variance : 0.935627\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 220.74it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.952 %\n","----------------------------------------\n","epoch 6\n","energy   : -1.138259 +/- 0.019513\n","variance : 0.872629\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 197.30it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.013 %\n","----------------------------------------\n","epoch 7\n","energy   : -1.140578 +/- 0.020539\n","variance : 0.918537\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 202.44it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.092 %\n","----------------------------------------\n","epoch 8\n","energy   : -1.174473 +/- 0.018805\n","variance : 0.840981\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 213.25it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 223.27it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.152 %\n","----------------------------------------\n","epoch 9\n","energy   : -1.129384 +/- 0.015684\n","variance : 0.701404\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 223.93it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 221.69it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.286 %\n","----------------------------------------\n","epoch 10\n","energy   : -1.135618 +/- 0.013913\n","variance : 0.622201\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 219.93it/s]\n"," 44%|████▍     | 22/50 [00:00<00:00, 219.57it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.090 %\n","----------------------------------------\n","epoch 11\n","energy   : -1.136419 +/- 0.018039\n","variance : 0.806742\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 209.13it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.072 %\n","----------------------------------------\n","epoch 12\n","energy   : -1.110911 +/- 0.011286\n","variance : 0.504704\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 201.90it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 231.57it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.902 %\n","----------------------------------------\n","epoch 13\n","energy   : -1.174111 +/- 0.020816\n","variance : 0.930899\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 227.33it/s]\n"," 44%|████▍     | 22/50 [00:00<00:00, 219.82it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.041 %\n","----------------------------------------\n","epoch 14\n","energy   : -1.157033 +/- 0.014624\n","variance : 0.654000\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 222.48it/s]\n"," 44%|████▍     | 22/50 [00:00<00:00, 212.96it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.885 %\n","----------------------------------------\n","epoch 15\n","energy   : -1.135796 +/- 0.016966\n","variance : 0.758727\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 214.72it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 231.93it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.096 %\n","----------------------------------------\n","epoch 16\n","energy   : -1.171204 +/- 0.022220\n","variance : 0.993694\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 227.63it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 232.49it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.690 %\n","----------------------------------------\n","epoch 17\n","energy   : -1.164505 +/- 0.025265\n","variance : 1.129907\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 223.06it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 220.02it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.997 %\n","----------------------------------------\n","epoch 18\n","energy   : -1.152613 +/- 0.017999\n","variance : 0.804962\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 221.27it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.279 %\n","----------------------------------------\n","epoch 19\n","energy   : -1.146719 +/- 0.023584\n","variance : 1.054714\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 199.36it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.854 %\n","----------------------------------------\n","epoch 20\n","energy   : -1.157131 +/- 0.031996\n","variance : 1.430927\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 196.36it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 232.37it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.032 %\n","----------------------------------------\n","epoch 21\n","energy   : -1.155372 +/- 0.017932\n","variance : 0.801952\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 210.36it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.056 %\n","----------------------------------------\n","epoch 22\n","energy   : -1.192023 +/- 0.030914\n","variance : 1.382510\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 223.82it/s]\n"," 44%|████▍     | 22/50 [00:00<00:00, 214.15it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.999 %\n","----------------------------------------\n","epoch 23\n","energy   : -1.110815 +/- 0.012852\n","variance : 0.574774\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 210.98it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.281 %\n","----------------------------------------\n","epoch 24\n","energy   : -1.131229 +/- 0.014542\n","variance : 0.650345\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 216.41it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 228.71it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.067 %\n","----------------------------------------\n","epoch 25\n","energy   : -1.170185 +/- 0.017125\n","variance : 0.765854\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 225.36it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 227.00it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.064 %\n","----------------------------------------\n","epoch 26\n","energy   : -1.150916 +/- 0.014112\n","variance : 0.631112\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 221.40it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 226.35it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.866 %\n","----------------------------------------\n","epoch 27\n","energy   : -1.173902 +/- 0.017297\n","variance : 0.773533\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 208.94it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.919 %\n","----------------------------------------\n","epoch 28\n","energy   : -1.144021 +/- 0.015142\n","variance : 0.677164\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 194.09it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.976 %\n","----------------------------------------\n","epoch 29\n","energy   : -1.133517 +/- 0.015862\n","variance : 0.709384\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 194.22it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.118 %\n","----------------------------------------\n","epoch 30\n","energy   : -1.157302 +/- 0.021397\n","variance : 0.956891\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 219.41it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 228.41it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.987 %\n","----------------------------------------\n","epoch 31\n","energy   : -1.156707 +/- 0.024407\n","variance : 1.091524\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 224.70it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 229.20it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.252 %\n","----------------------------------------\n","epoch 32\n","energy   : -1.159830 +/- 0.015994\n","variance : 0.715265\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 220.53it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 230.81it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.947 %\n","----------------------------------------\n","epoch 33\n","energy   : -1.129629 +/- 0.014514\n","variance : 0.649108\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 223.57it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 222.39it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.284 %\n","----------------------------------------\n","epoch 34\n","energy   : -1.162258 +/- 0.015894\n","variance : 0.710791\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 221.73it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 228.90it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.219 %\n","----------------------------------------\n","epoch 35\n","energy   : -1.134050 +/- 0.017508\n","variance : 0.782982\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 223.77it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 226.85it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.984 %\n","----------------------------------------\n","epoch 36\n","energy   : -1.187749 +/- 0.051300\n","variance : 2.294193\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 224.33it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 227.79it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.999 %\n","----------------------------------------\n","epoch 37\n","energy   : -1.156939 +/- 0.025454\n","variance : 1.138348\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 224.47it/s]\n"," 44%|████▍     | 22/50 [00:00<00:00, 213.37it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.998 %\n","----------------------------------------\n","epoch 38\n","energy   : -1.136644 +/- 0.015433\n","variance : 0.690191\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 216.96it/s]\n"," 44%|████▍     | 22/50 [00:00<00:00, 214.19it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.946 %\n","----------------------------------------\n","epoch 39\n","energy   : -1.161374 +/- 0.015897\n","variance : 0.710957\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 210.15it/s]\n","  0%|          | 0/50 [00:00<?, ?it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.027 %\n","----------------------------------------\n","epoch 40\n","energy   : -1.202688 +/- 0.031699\n","variance : 1.417642\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 214.16it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 227.38it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.275 %\n","----------------------------------------\n","epoch 41\n","energy   : -1.130508 +/- 0.012665\n","variance : 0.566414\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 222.57it/s]\n"," 44%|████▍     | 22/50 [00:00<00:00, 217.30it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.118 %\n","----------------------------------------\n","epoch 42\n","energy   : -1.149809 +/- 0.018572\n","variance : 0.830576\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 218.46it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 220.61it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.907 %\n","----------------------------------------\n","epoch 43\n","energy   : -1.147622 +/- 0.017857\n","variance : 0.798580\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 222.26it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 229.96it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.927 %\n","----------------------------------------\n","epoch 44\n","energy   : -1.164556 +/- 0.022633\n","variance : 1.012159\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 223.39it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 228.28it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.068 %\n","----------------------------------------\n","epoch 45\n","energy   : -1.153799 +/- 0.017474\n","variance : 0.781483\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 220.59it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 230.08it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.073 %\n","----------------------------------------\n","epoch 46\n","energy   : -1.137138 +/- 0.013549\n","variance : 0.605944\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 222.66it/s]\n"," 48%|████▊     | 24/50 [00:00<00:00, 230.67it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.085 %\n","----------------------------------------\n","epoch 47\n","energy   : -1.127817 +/- 0.013768\n","variance : 0.615720\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 225.81it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 227.62it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.324 %\n","----------------------------------------\n","epoch 48\n","energy   : -1.146895 +/- 0.020116\n","variance : 0.899613\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 223.96it/s]\n"," 46%|████▌     | 23/50 [00:00<00:00, 226.13it/s]"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 67.015 %\n","----------------------------------------\n","epoch 49\n","energy   : -1.186532 +/- 0.032243\n","variance : 1.441937\n","----------------------------------------\n"],"name":"stdout"},{"output_type":"stream","text":["100%|██████████| 50/50 [00:00<00:00, 220.57it/s]\n"],"name":"stderr"},{"output_type":"stream","text":["Acceptance rate 66.934 %\n"],"name":"stdout"}]}]}
\ No newline at end of file
diff --git a/paper/paper.bib b/paper/paper.bib
new file mode 100644
index 00000000..25689a49
--- /dev/null
+++ b/paper/paper.bib
@@ -0,0 +1,159 @@
+@misc{pytorch,
+      title={PyTorch: An Imperative Style, High-Performance Deep Learning Library}, 
+      author={Adam Paszke and Sam Gross and Francisco Massa and Adam Lerer and James Bradbury and Gregory Chanan and Trevor Killeen and Zeming Lin and Natalia Gimelshein and Luca Antiga and Alban Desmaison and Andreas Köpf and Edward Yang and Zach DeVito and Martin Raison and Alykhan Tejani and Sasank Chilamkurthy and Benoit Steiner and Lu Fang and Junjie Bai and Soumith Chintala},
+      year={2019},
+      eprint={1912.01703},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+
+@misc{horovod,
+      title={Horovod: fast and easy distributed deep learning in TensorFlow}, 
+      author={Alexander Sergeev and Mike Del Balso},
+      year={2018},
+      eprint={1802.05799},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+
+@article{backflow,
+	doi = {10.1103/physrevb.99.085121},
+	url = {https://doi.org/10.1103%2Fphysrevb.99.085121},
+	year = 2019,
+	month = {feb},
+	publisher = {American Physical Society ({APS})},
+	volume = {99},
+	number = {8},
+	author = {Markus Holzmann and Saverio Moroni},
+	title = {Orbital-dependent backflow wave functions for real-space quantum Monte Carlo},
+	journal = {Physical Review B}
+}
+
+@article{qmcpack,
+doi = {10.1088/1361-648X/aab9c3},
+url = {https://dx.doi.org/10.1088/1361-648X/aab9c3},
+year = {2018},
+month = {apr},
+publisher = {IOP Publishing},
+volume = {30},
+number = {19},
+pages = {195901},
+author = {Jeongnim Kim and Andrew D Baczewski and Todd D Beaudet and Anouar Benali and M Chandler Bennett and Mark A Berrill and Nick S Blunt and Edgar Josué Landinez Borda and Michele Casula and David M Ceperley and Simone Chiesa and Bryan K Clark and Raymond C Clay and Kris T Delaney and Mark Dewing and Kenneth P Esler and Hongxia Hao and Olle Heinonen and Paul R C Kent and Jaron T Krogel and Ilkka Kylänpää and Ying Wai Li and M Graham Lopez and Ye Luo and Fionn D Malone and Richard M Martin and Amrita Mathuriya and Jeremy McMinis and Cody A Melton and Lubos Mitas and Miguel A Morales and Eric Neuscamman and William D Parker and Sergio D Pineda Flores and Nichols A Romero and Brenda M Rubenstein and Jacqueline A R Shea and Hyeondeok Shin and Luke Shulenburger and Andreas F Tillack and Joshua P Townsend and Norm M Tubman and Brett Van Der Goetz and Jordan E Vincent and D ChangMo Yang and Yubo Yang and Shuai Zhang and Luning Zhao},
+title = {QMCPACK: an open source ab initio quantum Monte Carlo package for the electronic structure of atoms, molecules and solids},
+journal = {Journal of Physics: Condensed Matter},
+abstract = {QMCPACK is an open source quantum Monte Carlo package for ab initio electronic structure calculations. It supports calculations of metallic and insulating solids, molecules, atoms, and some model Hamiltonians. Implemented real space quantum Monte Carlo algorithms include variational, diffusion, and reptation Monte Carlo. QMCPACK uses Slater–Jastrow type trial wavefunctions in conjunction with a sophisticated optimizer capable of optimizing tens of thousands of parameters. The orbital space auxiliary-field quantum Monte Carlo method is also implemented, enabling cross validation between different highly accurate methods. The code is specifically optimized for calculations with large numbers of electrons on the latest high performance computing architectures, including multicore central processing unit and graphical processing unit systems. We detail the program’s capabilities, outline its structure, and give examples of its use in current research calculations. The package is available at http://qmcpack.org.}
+}
+
+@InProceedings{qmcchem,
+author={Scemama, Anthony and Caffarel, Michel and Oseret, Emmanuel and Jalby, William},
+editor={Dayde, Michel and Marques, Osni and Nakajima, Kengo},
+title={QMC=Chem: A Quantum Monte Carlo Program for Large-Scale Simulations in Chemistry at the Petascale Level and beyond},
+booktitle={High Performance Computing for Computational Science - VECPAR 2012},
+year={2013},
+publisher={Springer Berlin Heidelberg},
+address={Berlin, Heidelberg},
+pages={118--127},
+abstract={In this work we discuss several key aspects for an efficient implementation and deployment of large-scale quantum Monte Carlo (QMC) simulations for chemical applications on petaflops infrastructures. Such aspects have been implemented in the QMC=Chem code developed at Toulouse (France). First, a simple, general, and fault-tolerant simulation environment adapted to QMC algorithms is presented. Second, we present a study of the parallel efficiency of the QMC=Chem code on the Curie machine (TGCC-GENCI, CEA France) showing that a very good scalability can be maintained up to 80 000 cores. Third, it is shown that a great enhancement in performance with the single-core optimization tools developed at Versailles (France) can be obtained.},
+isbn={978-3-642-38718-0}
+}
+
+@misc{champ,
+      title={CHAMP}, 
+      author={C. Filippi},
+      year={2019},
+      url={https://github.com/filippi-claudia/champ}
+}
+
+@misc{pauxy,
+      title={PAUXY},
+      author={Fionn Malone, Joohno Lee, Jarvist Moore Frost},
+      url={https://github.com/pauxy-qmc/pauxy}
+}
+
+@article{pyqmc,
+	doi = {10.1063/5.0139024},
+	url = {https://doi.org/10.1063%2F5.0139024},
+	year = 2023,
+	month = {mar},
+	publisher = {{AIP} Publishing},
+	volume = {158},
+	number = {11},
+	pages = {114801},
+	author = {William A. Wheeler and Shivesh Pathak and Kevin G. Kleiner and Shunyue Yuan and Jo{\~{a}
+}o N. B. Rodrigues and Cooper Lorsung and Kittithat Krongchon and Yueqing Chang and Yiqing Zhou and Brian Busemeyer and Kiel T. Williams and Alexander Mu{\~{n}}oz and Chun Yu Chow and Lucas K. Wagner},
+	title = {$\less$tt$\greater${PyQMC}$\less$/tt$\greater$: An all-Python real-space quantum Monte Carlo module in $\less$tt$\greater${PySCF}$\less$/tt$\greater$},
+	journal = {The Journal of Chemical Physics}
+}
+
+@article{ferminet,
+  title={Ab-Initio Solution of the Many-Electron Schr{\"o}dinger Equation with Deep Neural Networks},
+  author={D. Pfau and J.S. Spencer and A.G. de G. Matthews and W.M.C. Foulkes},
+  journal={Phys. Rev. Research},
+  year={2020},
+  volume={2},
+  issue = {3},
+  pages={033429},
+  doi = {10.1103/PhysRevResearch.2.033429},
+  url = {https://link.aps.org/doi/10.1103/PhysRevResearch.2.033429}
+}
+
+@article{paulinet,
+	doi = {10.1038/s41557-020-0544-y},
+	url = {https://doi.org/10.1038%2Fs41557-020-0544-y},
+	year = 2020,
+	month = {sep},
+	publisher = {Springer Science and Business Media {LLC}},
+	volume = {12},
+	number = {10},
+	pages = {891--897},
+	author = {Jan Hermann and Zeno Schätzle and Frank No{\'{e}}},
+	title = {Deep-neural-network solution of the electronic Schrödinger equation},
+	journal = {Nature Chemistry}
+}
+
+@misc{pyscf,
+      title={The Python-based Simulations of Chemistry Framework (PySCF)}, 
+      author={Qiming Sun and Timothy C. Berkelbach and Nick S. Blunt and George H. Booth and Sheng Guo and Zhendong Li and Junzi Liu and James McClain and Elvira R. Sayfutyarova and Sandeep Sharma and Sebastian Wouters and Garnet Kin-Lic Chan},
+      year={2017},
+      eprint={1701.08223},
+      archivePrefix={arXiv},
+      primaryClass={physics.chem-ph}
+}
+
+@Article{adf,
+  Title                    = {Chemistry with ADF},
+  Author                   = {te Velde, G. and Bickelhaupt, F. M. and Baerends, E. J. and Fonseca Guerra, C. and van Gisbergen, S. J. A. and Snijders, J. G. and Ziegler, T.},
+  Journal                  = {J. Comput. Chem.},
+  Year                     = {2001},
+  Number                   = {9},
+  Pages                    = {931--967},
+  Volume                   = {22},
+  Doi                      = {10.1002/jcc.1056},
+  ISSN                     = {1096-987X},
+  Publisher                = {John Wiley \& Sons, Inc.},
+  Url                      = {http://dx.doi.org/10.1002/jcc.1056}
+}
+
+
+
+@article{jacobi_trace,
+author = {Filippi,Claudia  and Assaraf,Roland  and Moroni,Saverio },
+title = {Simple formalism for efficient derivatives and multi-determinant expansions in quantum Monte Carlo},
+journal = {The Journal of Chemical Physics},
+volume = {144},
+number = {19},
+pages = {194105},
+year = {2016},
+doi = {10.1063/1.4948778},
+
+URL = { 
+        https://doi.org/10.1063/1.4948778
+    
+},
+eprint = { 
+        https://doi.org/10.1063/1.4948778
+    
+}
+
+}
+
diff --git a/paper/paper.md b/paper/paper.md
new file mode 100644
index 00000000..a514b5cc
--- /dev/null
+++ b/paper/paper.md
@@ -0,0 +1,74 @@
+---
+title: 'QMCTorch: a PyTorch Implementation of Real-Space Quantum Monte Carlo Simulations of Molecular Systems'
+tags:
+  - Python
+  - Deep Learning
+  - Quantum Chemistry
+  - Monte Carlo
+  - Molecular Systems
+authors:
+  - name: Nicolas Renaud
+    orcid: 0000-0001-9589-2694
+    affiliation: 1
+affiliations:
+ - name: Netherlands eScience Center, Science Park 402, 1098 XH Amsterdam, The Netherlands
+   index: 1
+date: 11 April 2023
+bibliography: paper.bib
+
+---
+
+# Summary
+
+Quantum Monte-Carlo (QMC) simulations allow to compute the electronic structure of quantum systems
+with high accuracy and can be parallelized over large compute resources. QMC relies on the variational principle and optimize a wave function ansatz to minimize the total energy of the quantum system. `QMCTorch`
+allows to express this optimization process as a deep-learning problem where the wave function ansatz is encoded
+in a physically-motivated neural network. The use of `PyTorch` as a backend to perform the optimization, allows 
+leveraging automatic differentiation to compute the gradients of the total energy w.r.t. the variational parameters
+as well as GPU computing to accelerate the calculation. `QMCTorch` is interfaced with popular quantum chemistry packages, such as `pyscf` and `ADF`
+to facilitate its utilization.
+
+
+# Statement of need
+
+`QMCTorch` is a Python package using `PyTorch` [@pytorch] as a backend to perform Quantum Monte-Carlo (QMC) simulations of molecular systems. Many software such as `QMCPack`[@qmcpack], `QMC=Chem` [@qmcchem], `CHAMP` [@champ] provide high-quality implementation of advanced QMC methodologies in low-level languages (C++/Fortran).  Python implementations of QMC such as `PAUXY` [@pauxy] and `PyQMC` [@pyqmc] have also been proposed to facilitate the use and development of QMC techniques. Large efforts have been made to leverage recent development of deep learning techniques for QMC simulations. Hence neural-network based wave-function ansatz has been proposed [@paulinet; @ferminet]. These recent advances lead to very interesting results but results in wave functions that are difficult to understand. `QMCTorch` allows to perform QMC simulations using physically motivated neural network architectures that closely follow the wave function ansatz used by QMC practitioners. As such, it allows to leverage automatic differentiation for the calculation of the gradients of the total energy w.r.t. the variational parameters and the GPU capabilities offered by `PyTorch` without loosing the physical intuition behind the wave function ansatz. The parallelization over multiple computing nodes, each potentially using GPUs, can be obtained via the `Horovod` library [@horovod] .
+
+
+# Wave Function Ansatz
+![General architecture of the neural network used by `QMCTorch` to encode the wave function ansatz. The neural network computes and assembles the different elements of the wave function ansatz and can be used to compute the electronic density required for the sampling and the total energy of the system required for the wave function optimization.\label{fig:arch}](qmctorch2.png)
+
+The neural network used to encode the wave-function ansatz used in `QMCTorch` is shown in Fig. \ref{fig:arch}. As common in QMC simulations, the wave function is given by the product of a Jastrow factor, $J(r)$, that accounts for electronic correlations and a sum of Slater determinants, $D^\updownarrow(r_\updownarrow)$, built over the molecular orbitals of the spin up and down electrons:  $\Psi(r) = J(r)\sum_n c_n D^\uparrow(r_\uparrow)D^\downarrow(r_\downarrow)$.
+
+**Jastrow Factor** The `Jastrow` layer computes the sum of three components: an electron-electron term $K_{ee}$; an electron-nuclei term $K_{en}$; and a three body electron-electron-nuclei term $K_{een}$. The sum is then exponentiated to give the Jastrow factor: $J(r_{ee}, r_{en}) = \exp\left( K_{ee}(r_{ee})+K_{en}(r_{en}) + K_{een}(r_{ee},r_{en})\right)$ where $r_{ee}$ and $r_{en}$ are the electron-electron and electron-nuclei distances. Several well-known Jastrow factor functional forms, as for example the electron-electron Pade-Jastrow: $K(r_{ee}) = \frac{\omega_0 r_{ee}}{1 + \omega r_{ee}}$, where $\omega$ is a variational parameter, are already implemented and available for use. Users can also define their own functional forms for the different kernel functions, $K$, and explore their effects on the resulting optimization.  
+
+**Backflow Transformation** The backflow transformation layer, `BF`, creates quasi-particles by mixing the electronic positions of the electrons: $q_i = r_i + \sum_{i\neq j} K_{BF}(r_{ij}(r_i-r_j))$ [@backflow]. Well-known transformations such as: $K_{BF} = \frac{\omega}{r_{ij}}$ where $\omega$ is a variational parameter, are already implemented and ready to use. Users can also easily specify the kernel of the backflow transformation, $K_{BF}$ to explore its impact on the wave function optimization.
+
+**Atomic Orbitals** The Atomic Orbital layer `AO` computes the values of the different atomic orbitals of the system at all the positions $q_e$. Both Slater type orbitals (STOs) and Gaussian type orbitals (GTOs) are supported. The initial parameters of the AOs are extracted from popular quantum chemistry codes, `pyscf` [@pyscf] and `ADF` [@adf].  During the optimization, the parameters of the AOs (exponents, coefficients) are variational parameters that can be optimized to minimize the total energy. Since GTOs can introduce a significant amount of noise in the QMC simulations, `QMCTorch` offers the possibility to fit GTOs to single exponent STOs.
+
+**Molecular Orbitals** The Molecular Orbital layer, `MO`, computes the values of all the MOs at the positions of the quasi particles. The MO layer is a simple linear transformation defined by $\textnormal{MO} =  \textnormal{AO} \times W^T_{SCF}$, where $W^T_{SCF}$ is the matrix of the MOs coefficients on the AOs. The initial values of these coefficients are obtained from a Hartree-Fock (HF) or Density Functional Theory (DFT) calculation of the system via `pyscf` or `ADF`. These coefficients are then variational parameters that can be optimized to minimize the total energy of the system. 
+
+**Slater Determinants** The Slater determinants layer, `SD`, extracts the spin up/down  matrices of the different electronic configurations specified by the user. Users can freely define the number of electrons as well as the number and types of excitations they want to include in the definition of their wave function ansatz. The `SD` layer will extract the corresponding matrices, multiply their determinants and sum all the terms. The `CI` coefficients of the sum can be freely initialized and optimized to minimize the total energy.
+
+The Jastrow factor and the sum of Slater determinants are then multiplied to yield the final value of the wave function calculated for the electronic and atomic positions $\Psi(R)$ with $R = \{r_e, R_{at}\}$. 
+
+# Sampling, Cost Function & Optimization 
+
+QMC simulations use samples of the electronic density to approximate the total energy of the system. In `QMCTorch`, Markov-Chain Monte-Carlo (MCMC) techniques, namely Metropolis-Hasting and Hamiltonian Monte-Carlo, are used to obtained those sample. MCMC techniques require the calculation of the density for a given positions of the electrons: $\rho(R) = |\Psi(R)|^2$. This value is simply obtained by squaring the result of a forward pass of the network described above.
+
+Each sample, $R_i$, contains  the positions of all the electrons contained in the system. The value of local energy of the system is then computed at each sampling point and these values are summed up to compute the total energy of the system: $E = \sum_i \frac{H\Psi(R_i)}{\Psi(R_i)}$, where $H$ is the Hamiltonian of the molecular system: $H = -\frac{1}{2}\sum_i \Delta_i + V_{ee} + V_{en}$, with $\Delta_i$ the Laplacian w.r.t the i-th electron, $V_{ee}$ the coulomb potential between the electrons and $V_{en}$ the electron-nuclei potential. The calculation of the Laplacian of a determinant can either be performed using automatic differentiation but analytical expressions are often preferred as they are computationally more robust and less expensive [@jacobi_trace]. The gradients of the total energy w.r.t the variational parameters of the wave function, i.e. $\frac{\partial E}{\partial \theta_i}$ are simply obtained via automatic differentiation. Thanks to this automatic differentiation, users can define new kernels for the backflow transformation and Jastrow factor without having to derive analytical expressions of the energy gradients. 
+
+Any optimizer included in `PyTorch` (or compatible with it) can then used to optimize the wave function. This gives users access to a wide range of optimization techniques that they can freely explore for their own use cases. Users can also decide to freeze certain variational parameters or defined different learning rates for different layers. Note that the positions of atoms are also variational parameters, and therefore one can perform geometry optimization using `QMCTorch`. At the end of the optimization, all the information relative to the simulations are dumped in a dedicated HDF5 file to enhance reproducibility of the simulations.
+
+# Example
+
+![Snippet of code showing the use of QMCTorch to compute the electronic structure of H2. The left panel shows the optimization of the wave function of LiH and NH3 using atomic atomic orbitals provided by `pyscf`, `ADF` and also a STO fit of the `pyscf` atomic orbitals. \label{fig:results}](qmctorch_results.png)
+
+The left panel of Fig. \ref{fig:results} shows a typical example of `QMCTorch` script. A `Molecule` object is first created by specifying the atomic positions and the calculator required to run the HF or DFT calculations (here `pyscf` using  a `sto-3g` basis set). This molecule is then used to create a `SlaterJastrow` wave function ansatz. Other options, such as the required Jastrow kernel, active space, and the use of GPUs can also be specified here. A sampler and optimizer are then defined that are then used with the wave function to instantiate the solver. This solver can then be used to optimize the variational parameters here though 50 epochs. 
+
+The right panel of Fig. \ref{fig:results} shows typical optimization runs for two different molecular structures, LiH and NH3 using atomic orbitals provided by `pyscf`, `ADF` and also a STO fit of the `pyscf` atomic orbitals. As seen in this figure, the variance of the local energy values obtained with the GTOs provided by `pyscf` is a limiting factor for the optimization. A simple STO fit of these atomic orbitals leads to variance comparable to those obtained with the STO of `ADF`.
+
+# Acknowledgements
+
+We acknowledge contributions from Felipe Zapata, Matthijs de Witt and guidance from Claudia Filippi. The development of the code was done during the project "A Light in the Dark: quantum Monte-Carlo meets energy conversion" from the Joint CSER and eScience program for Energy Research (JCER2017) funded by the Nederlandse Organisatie voor Wetenschappelijk Onderzoek (NWO) and the Netherlands eScience Center, project number CSER.JCER.022
+
+# References
\ No newline at end of file
diff --git a/paper/qmctorch2.png b/paper/qmctorch2.png
new file mode 100644
index 00000000..89f5df53
Binary files /dev/null and b/paper/qmctorch2.png differ
diff --git a/paper/qmctorch_results.png b/paper/qmctorch_results.png
new file mode 100644
index 00000000..f61d6cb8
Binary files /dev/null and b/paper/qmctorch_results.png differ
diff --git a/pics/blocking.png b/pics/blocking.png
deleted file mode 100644
index 48d6c8a8..00000000
Binary files a/pics/blocking.png and /dev/null differ
diff --git a/pics/correlation_coeff.png b/pics/correlation_coeff.png
deleted file mode 100644
index 8ebc649b..00000000
Binary files a/pics/correlation_coeff.png and /dev/null differ
diff --git a/pics/h2_dzp.png b/pics/h2_dzp.png
deleted file mode 100644
index 250e01f2..00000000
Binary files a/pics/h2_dzp.png and /dev/null differ
diff --git a/pics/h2_go_opt.png b/pics/h2_go_opt.png
deleted file mode 100644
index 5c4f76b1..00000000
Binary files a/pics/h2_go_opt.png and /dev/null differ
diff --git a/pics/h2o.gif b/pics/h2o.gif
deleted file mode 100755
index 310ee3f3..00000000
Binary files a/pics/h2o.gif and /dev/null differ
diff --git a/pics/h5x_solver.PNG b/pics/h5x_solver.PNG
deleted file mode 100755
index 6554dd07..00000000
Binary files a/pics/h5x_solver.PNG and /dev/null differ
diff --git a/pics/h5xmol_qmctorch.png b/pics/h5xmol_qmctorch.png
deleted file mode 100755
index aa7caa0e..00000000
Binary files a/pics/h5xmol_qmctorch.png and /dev/null differ
diff --git a/pics/iac.png b/pics/iac.png
deleted file mode 100644
index 679f6d05..00000000
Binary files a/pics/iac.png and /dev/null differ
diff --git a/pics/mol_nn.png b/pics/mol_nn.png
deleted file mode 100755
index 14f2b9bc..00000000
Binary files a/pics/mol_nn.png and /dev/null differ
diff --git a/pics/samplig_dzp.png b/pics/samplig_dzp.png
deleted file mode 100644
index c9055092..00000000
Binary files a/pics/samplig_dzp.png and /dev/null differ
diff --git a/pics/samplig_sto.png b/pics/samplig_sto.png
deleted file mode 100644
index 99a12cdc..00000000
Binary files a/pics/samplig_sto.png and /dev/null differ
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index 7fd229a3..0404d810 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1 @@
-__version__ = '0.2.0'
+__version__ = '0.3.0'
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 0f2f0698..51785e5a 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -27,7 +27,7 @@ def __init__(self,
             nstep (int, optional): Number of steps. Defaults to 1000.
             step_size (int, optional): length of the step. Defaults to 0.2.
             nelec (int, optional): total number of electrons. Defaults to 1.
-            ntherm (int, optional): number of mc step to thermalize. Defaults to -1, i.e. keep ponly last position
+            ntherm (int, optional): number of mc step to thermalize. Defaults to -1, i.e. keep only the last position
             ndecor (int, optional): number of mc step for decorelation. Defauts to 1.
             ndim (int, optional): total number of dimension. Defaults to 3.
             init (dict, optional): method to init the positions of the walkers. See Molecule.domain()
@@ -38,7 +38,7 @@ def __init__(self,
                                         'all-elec': move all electrons at the same time \n
                                         'all-elec-iter': move all electrons by iterating through single elec moves \n
                                     'proba' :
-                                        'uniform': uniform ina cube \n
+                                        'uniform': uniform in a cube \n
                                         'normal': gussian in a sphere \n
             cuda (bool, optional): turn CUDA ON/OFF. Defaults to False.
 
diff --git a/qmctorch/scf/calculator/__init__.py b/qmctorch/scf/calculator/__init__.py
index 96423d7e..e76d7587 100644
--- a/qmctorch/scf/calculator/__init__.py
+++ b/qmctorch/scf/calculator/__init__.py
@@ -1,5 +1,5 @@
-__all__ = ['CalculatorBase', 'CalculatorADF', 'CalculatorPySCF']
+__all__ = ['CalculatorBase', 'CalculatorADF', 'CalculatorADF2019', 'CalculatorPySCF']
 
 from .calculator_base import CalculatorBase
-from .adf import CalculatorADF
+from .adf import CalculatorADF, CalculatorADF2019
 from .pyscf import CalculatorPySCF
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index cccd21d8..ebe262fa 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -24,33 +24,42 @@ def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
         # basis from the emma paper
         self.additional_basis_type = ['VB1', 'VB2', 'VB3',
                                       'CVB1', 'CVB2', 'CVB3']
+
         self.additional_basis_path = os.path.join(os.path.dirname(
             os.path.abspath(__file__)), 'atomicdata/adf/')
 
+        self.adf_version = 'adf2020+'
+        self.job_name = ''.join(self.atoms) + '_' + self.basis_name
+        self.output_file = 'adf.rkf'
+
     def run(self):
         """Run the calculation using ADF."""
 
         # path needed for the calculation
-        wd = ''.join(self.atoms) + '_' + self.basis_name
-        t21_name = wd + '.t21'
         plams_wd = './plams_workdir'
-        t21_path = os.path.join(
-            plams_wd, os.path.join(wd, t21_name))
+        outputdir_path = os.path.join(
+            plams_wd, os.path.join(self.job_name, self.output_file))
+
+        # get the correct exec
+        plams_job = {
+            'adf2020+': plams.AMSJob,
+            'adf2019' : plams.ADFJob
+        }[self.adf_version]
 
         # configure plams and run the calculation
         self.init_plams()
         mol = self.get_plams_molecule()
         sett = self.get_plams_settings()
-        job = plams.ADFJob(molecule=mol, settings=sett, name=wd)
+        job = plams_job(molecule=mol, settings=sett, name=self.job_name)
         job.run()
 
         # extract the data to hdf5
-        basis = self.get_basis_data(t21_path)
+        basis = self.get_basis_data(outputdir_path)
 
         # remove adf data
         if self.savefile:
-            shutil.copyfile(t21_path, t21_name)
-            self.savefile = t21_name
+            shutil.copyfile(outputdir_path, self.output_file)
+            self.savefile = self.output_file
         shutil.rmtree(plams_wd)
 
         return basis
@@ -64,7 +73,12 @@ def init_plams(self):
     def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
+        bohr2angs = 0.529177
+        scale = 1.
+        if self.units == 'bohr':
+            scale = bohr2angs
         for at, xyz in zip(self.atoms, self.atom_coords):
+            xyz = list(scale * np.array(xyz))
             mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
         return mol
 
@@ -72,26 +86,33 @@ def get_plams_settings(self):
         """Returns a plams setting object."""
 
         sett = plams.Settings()
-        sett.input.basis.type = self.basis_name.upper()
+        sett.input.ams.Task = 'SinglePoint'
+        
         if self.basis_name.upper() in self.additional_basis_type:
-            sett.input.basis.path = self.additional_basis_path
-        sett.input.basis.core = 'None'
-        sett.input.symmetry = 'nosym'
+            sett.input.adf.basis.type = 'DZP'
+            parsed_atoms = []
+            for at in self.atoms:
+                if at not in parsed_atoms:
+                    basis_path = os.path.join(self.additional_basis_path, self.basis_name.upper(), at)
+                    atomtype = f"Symbol={at} File={basis_path}"
+                    sett.input.adf.basis.peratomtype = atomtype
+                    parsed_atoms.append(at)
+        else:
+            sett.input.adf.basis.type = self.basis_name.upper()
+
+        sett.input.adf.basis.core = 'None'
+        sett.input.adf.symmetry = 'nosym'
 
         if self.scf.lower() == 'hf':
-            sett.input.XC.HartreeFock = ''
+            sett.input.adf.XC.HartreeFock = ''
 
         elif self.scf.lower() == 'dft':
-            sett.input.XC.LDA = 'VWN'
+            sett.input.adf.XC.LDA = 'VWN'
 
-        # correct unit
-        if self.units == 'angs':
-            sett.input.units.length = 'Angstrom'
-        elif self.units == 'bohr':
-            sett.input.units.length = 'Bohr'
+        sett.input.adf.relativity.level = 'None'
 
         # total energy
-        sett.input.totalenergy = True
+        sett.input.adf.totalenergy = True
 
         return sett
 
@@ -215,3 +236,48 @@ def read_array(kf, section, name):
         if data.shape == ():
             data = np.array([data])
         return data
+        
+class CalculatorADF2019(CalculatorADF):
+
+    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
+
+        CalculatorADF.__init__(
+            self, atoms, atom_coords, basis, scf, units, molname, savefile)
+
+        self.adf_version = 'adf2019'
+        self.job_name = ''.join(self.atoms) + '_' + self.basis_name
+        self.output_file = self.job_name + '.t21'
+
+    def get_plams_molecule(self):
+        """Returns a plams molecule object."""
+        mol = plams.Molecule()
+        for at, xyz in zip(self.atoms, self.atom_coords):
+            mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
+        return mol
+
+    def get_plams_settings(self):
+        """Returns a plams setting object."""
+
+        sett = plams.Settings()
+        sett.input.basis.type = self.basis_name.upper()
+        if self.basis_name.upper() in self.additional_basis_type:
+            sett.input.basis.path = self.additional_basis_path
+        sett.input.basis.core = 'None'
+        sett.input.symmetry = 'nosym'
+
+        if self.scf.lower() == 'hf':
+            sett.input.XC.HartreeFock = ''
+
+        elif self.scf.lower() == 'dft':
+            sett.input.XC.LDA = 'VWN'
+
+        # correct unit
+        if self.units == 'angs':
+            sett.input.units.length = 'Angstrom'
+        elif self.units == 'bohr':
+            sett.input.units.length = 'Bohr'
+
+        # total energy
+        sett.input.totalenergy = True
+
+        return sett
diff --git a/qmctorch/scf/calculator/calculator_base.py b/qmctorch/scf/calculator/calculator_base.py
index 2dd1b3eb..a2d25d2e 100644
--- a/qmctorch/scf/calculator/calculator_base.py
+++ b/qmctorch/scf/calculator/calculator_base.py
@@ -1,5 +1,3 @@
-from types import SimpleNamespace
-
 import numpy as np
 
 
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 0ccd846a..e01fdc9f 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -3,11 +3,9 @@
 import numpy as np
 from mendeleev import element
 from types import SimpleNamespace
-from mpi4py import MPI
 import h5py
-
-from .calculator.adf import CalculatorADF
-from .calculator.pyscf import CalculatorPySCF
+from mpi4py import MPI
+from .calculator import CalculatorADF, CalculatorPySCF, CalculatorADF2019
 
 from ..utils import dump_to_hdf5, load_from_hdf5, bytes2str
 from .. import log
@@ -15,18 +13,25 @@
 
 class Molecule:
 
-    def __init__(self, atom=None, calculator='adf',
-                 scf='hf', basis='dzp', unit='bohr',
+    def __init__(self, atom=None, calculator='pyscf',
+                 scf='hf', basis='sto-3g', unit='bohr',
                  name=None, load=None, save_scf_file=False,
                  redo_scf=False, rank=0):
         """Create a molecule in QMCTorch
 
         Args:
             atom (str or None, optional): defines the atoms and their positions. Defaults to None.
+                - At1 x y z; At2 x y z ... : Provide the atomic coordinate directly
+                - <file>.xyz : provide the path to an .xyz file containing the atomic coordinates 
             calculator (str, optional): selet scf calculator. Defaults to 'adf'.
+                - pyscf : PySCF calculator
+                - adf : ADF2020+ calculator
+                - adf2019 : ADF2019 calculatori
             scf (str, optional): select scf level of theory. Defaults to 'hf'.
+                - hf : perform a Hatree-Fock calculation to obtain the molecular orbital coefficients
+                - dft : perform a density functional theory using the local density approximation
             basis (str, optional): select the basis set. Defaults to 'dzp'.
-            unit (str, optional): units of the coordinates. Defaults to 'bohr'.
+            unit (str, optional): units of the coordinates; 'bohr' or 'angs'. Defaults to 'bohr'.
             name (str or None, optional): name of the molecule. Defaults to None.
             load (str or None, optional): path to a hdf5 file to load. Defaults to None.
             save_scf_file (bool, optional): save the scf file (when applicable) Defaults to False
@@ -34,7 +39,7 @@ def __init__(self, atom=None, calculator='adf',
             rank (int, optional): Rank of the process. Defaults to 0.
 
         Examples:
-            >>> from qmctorch.wavefunction import Molecule
+            >>> from qmctorch.scf import Molecule
             >>> mol = Molecule(atom='H 0 0 0; H 0 0 1', unit='angs',
             ...                calculator='adf', basis='dzp')
         """
@@ -99,7 +104,8 @@ def __init__(self, atom=None, calculator='adf',
                 else:
                     log.info('  Running scf  calculation')
 
-                    calc = {'adf': CalculatorADF,
+                    calc = {'adf2019': CalculatorADF2019,
+                            'adf': CalculatorADF,
                             'pyscf': CalculatorPySCF}[calculator]
 
                     self.calculator = calc(self.atoms,
diff --git a/qmctorch/solver/__init__.py b/qmctorch/solver/__init__.py
index 1a0cc636..b53cb8c2 100644
--- a/qmctorch/solver/__init__.py
+++ b/qmctorch/solver/__init__.py
@@ -1,6 +1,6 @@
-__all__ = ['SolverBase', 'SolverSlaterJastrow',
-           'SolverSlaterJastrowHorovod']
+__all__ = ['SolverBase', 'Solver',
+           'SolverMPI']
 
 from .solver_base import SolverBase
-from .solver_slater_jastrow import SolverSlaterJastrow
-from .solver_slater_jastrow_horovod import SolverSlaterJastrowHorovod
+from .solver import Solver
+from .solver_mpi import SolverMPI
diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver.py
similarity index 98%
rename from qmctorch/solver/solver_slater_jastrow.py
rename to qmctorch/solver/solver.py
index a1a99ccc..b43d0fdf 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver.py
@@ -11,7 +11,7 @@
 from .solver_base import SolverBase
 
 
-class SolverSlaterJastrow(SolverBase):
+class Solver(SolverBase):
 
     def __init__(self, wf=None, sampler=None, optimizer=None,
                  scheduler=None, output=None, rank=0):
@@ -391,7 +391,7 @@ def evaluate_grad_auto(self, lpos):
         return loss, eloc
 
     def evaluate_grad_manual(self, lpos):
-        """Evaluate the gradient using low variance express
+        """Evaluate the gradient using low variance expression
 
         Args:
             lpos ([type]): [description]
@@ -413,9 +413,9 @@ def evaluate_grad_manual(self, lpos):
 
         if self.loss.method in ['energy', 'weighted-energy']:
 
-            ''' Get the gradient of the total energy
-            dE/dk = < (dpsi/dk)/psi (E_L - <E_L >) >
-            '''
+            # Get the gradient of the total energy
+            # dE/dk = < (dpsi/dk)/psi (E_L - <E_L >) >
+            
 
             # compute local energy and wf values
             _, eloc = self.loss(lpos, no_grad=no_grad_eloc)
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 10c817ab..7d3bbf3f 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -200,13 +200,15 @@ def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
                 data = func(pos)
                 if isinstance(data, torch.Tensor):
                     data = data.cpu().detach().numpy()
-                    if (ibatch is None) or (ibatch == 0):
-                        self.observable.__getattribute__(
-                            obs).append(data)
-                    else:
-                        self.observable.__getattribute__(
-                            obs)[-1] = np.append(self.observable.__getattribute__(
-                                obs)[-1], data)
+                if isinstance(data, list):
+                    data = np.array(data)
+                if (ibatch is None) or (ibatch == 0):
+                    self.observable.__getattribute__(
+                        obs).append(data)
+                else:
+                    self.observable.__getattribute__(
+                        obs)[-1] = np.append(self.observable.__getattribute__(
+                            obs)[-1], data)
 
     def print_observable(self, cumulative_loss, verbose=False):
         """Print the observalbe to csreen
@@ -454,7 +456,7 @@ def run(self, nepoch, batchsize=None, loss='variance'):
         raise NotImplementedError()
 
     def log_data(self):
-        """Log basi information about the sampler."""
+        """Log basic information about the sampler."""
 
         log.info('')
         log.info(' QMC Solver ')
diff --git a/qmctorch/solver/solver_slater_jastrow_horovod.py b/qmctorch/solver/solver_mpi.py
similarity index 98%
rename from qmctorch/solver/solver_slater_jastrow_horovod.py
rename to qmctorch/solver/solver_mpi.py
index e8f77620..d39c26e6 100644
--- a/qmctorch/solver/solver_slater_jastrow_horovod.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -8,7 +8,7 @@
                             dump_to_hdf5)
 
 from .. import log
-from .solver_slater_jastrow import SolverSlaterJastrow
+from .solver import Solver
 
 try:
     import horovod.torch as hvd
@@ -21,7 +21,7 @@ def logd(rank, *args):
         log.info(*args)
 
 
-class SolverSlaterJastrowHorovod(SolverSlaterJastrow):
+class SolverMPI(Solver):
 
     def __init__(self, wf=None, sampler=None, optimizer=None,
                  scheduler=None, output=None, rank=0):
diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index 679b0c77..87036463 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -249,7 +249,7 @@ def insert_data(obj, parent_grp, obj_name):
         insert_fn(obj, parent_grp, obj_name)
         # insert_type(obj, parent_grp, obj_name)
     except Exception as expt_message:
-        print("YYY", expt_message)
+        print(expt_message)
         print_insert_error(obj, obj_name)
 
 
@@ -290,8 +290,12 @@ def insert_list(obj, parent_grp, obj_name):
         parent_grp {hdf5 group} -- group where to dump
         obj_name {str} -- name of the object
     """
+
     
     try:
+        if np.all([isinstance(el,torch.Tensor) for el in obj]):
+            obj = [el.numpy() for el in obj]
+            
         parent_grp.create_dataset(obj_name, data=np.array(obj))
     except:
         for il, l in enumerate(obj):
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 349cc29b..7a5a4ce0 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -58,18 +58,10 @@ def plot_data(observable, obsname):
     fig = plt.figure()
     ax = fig.add_subplot(111)
 
-    data = np.array(observable.models.best[obsname]).flatten()
+    data = np.array(observable.__dict__[obsname]).squeeze()
     epoch = np.arange(len(data))
     ax.plot(epoch, data, color='#144477')
 
-    if obsname + '.grad' in observable.__dict__.keys():
-        data = np.array(observable.__getattribute__(
-            obsname + '.grad')).flatten()
-        ax2 = ax.twinx()
-        ax2.plot(epoch, data, color='blue')
-        ax2.set_ylabel('gradient', color='blue')
-        ax2.tick_params(axis='y', labelcolor='blue')
-
     plt.show()
 
 
@@ -81,15 +73,10 @@ def plot_walkers_traj(eloc, walkers='mean'):
         walkers (int, str, optional): all, mean or index of a given walker Defaults to 'all'
     """
     nstep, nwalkers = eloc.shape
-
     celoc = np.cumsum(eloc, axis=0).T
     celoc /= np.arange(1, nstep + 1)
 
-    var_decor = np.sqrt(np.var(np.mean(celoc, axis=1)))
-    var = np.sqrt(np.var(celoc, axis=1) / (nstep - 1))
-
     if walkers is not None:
-        # plt.subplot(1, 2, 1)
 
         if walkers == 'all':
             plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
@@ -99,12 +86,15 @@ def plot_walkers_traj(eloc, walkers='mean'):
 
         elif walkers == 'mean':
             plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
-            plt.plot(np.mean(celoc.T, axis=1), linewidth=5)
-
+            emean = np.mean(celoc.T, axis=1)
+            emin = emean.min()
+            emax = emean.max()
+            delta = emax-emin
+            plt.plot(emean, linewidth=5)
+            plt.ylim(emin-0.25*delta,emax+0.25*delta)
         else:
-            plt.plot(eloc[walkers, :], 'o',
-                     alpha=1 / nwalkers, c='grey')
-            plt.plot(celoc.T[traj_index, :])
+            raise ValueError('walkers argument must be all or mean')
+        
         plt.grid()
         plt.xlabel('Monte Carlo Steps')
         plt.ylabel('Energy (Hartree)')
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 60e5b0e8..b7eaecd5 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-from torch.autograd import grad
+from torch.autograd import grad, Variable
 from torch.utils.data import Dataset
 
 
@@ -135,15 +135,14 @@ def __init__(
             self,
             wf,
             method='energy',
-            clip=False,
-            no_weight=False):
+            clip=False):
         """Defines the loss to use during the optimization
 
         Arguments:
             wf {WaveFunction} -- wave function object used
 
         Keyword Arguments:
-            method {str} -- method to use  (default: {'variance'})
+            method {str} -- method to use  (default: {'energy'})
                             (energy, variance, weighted-energy,
                             weighted-variance)
             clip {bool} -- clip the values that are +/- % sigma away from
@@ -196,7 +195,7 @@ def forward(self, pos, no_grad=False, deactivate_weight=False):
             mask = self.get_clipping_mask(local_energies)
 
             # sampling_weight
-            weight = self.get_sampling_weights(deactivate_weight)
+            weight = self.get_sampling_weights(pos, deactivate_weight)
 
             # compute the loss
             loss = self.loss_fn((weight * local_energies)[mask])
@@ -233,7 +232,7 @@ def get_clipping_mask(self, local_energies):
 
         return mask
 
-    def get_sampling_weights(self, deactivate_weight):
+    def get_sampling_weights(self, pos, deactivate_weight):
         """Get the weight needed when resampling is not
             done at every step
         """
diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 10ef6fa5..10d3688b 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,10 +1,10 @@
-__all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterCombinedJastrow',
+__all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterManyBodyJastrow',
            'SlaterJastrowBackFlow', 'SlaterOrbitalDependentJastrow',
-           'SlaterCombinedJastrowBackflow']
+           'SlaterManyBodyJastrowBackflow']
 
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
-from .slater_combined_jastrow import SlaterCombinedJastrow
+from .slater_combined_jastrow import SlaterManyBodyJastrow
 from .slater_jastrow_backflow import SlaterJastrowBackFlow
-from .slater_combined_jastrow_backflow import SlaterCombinedJastrowBackflow
+from .slater_combined_jastrow_backflow import SlaterManyBodyJastrowBackflow
 from .slater_orbital_dependent_jastrow import SlaterOrbitalDependentJastrow
diff --git a/qmctorch/wavefunction/slater_combined_jastrow.py b/qmctorch/wavefunction/slater_combined_jastrow.py
index 4b7137e7..b308d190 100644
--- a/qmctorch/wavefunction/slater_combined_jastrow.py
+++ b/qmctorch/wavefunction/slater_combined_jastrow.py
@@ -9,7 +9,7 @@
 from .jastrows.elec_nuclei.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecNuc
 
 
-class SlaterCombinedJastrow(SlaterJastrow):
+class SlaterManyBodyJastrow(SlaterJastrow):
 
     def __init__(self, mol, configs='ground_state',
                  kinetic='jacobi',
@@ -23,20 +23,39 @@ def __init__(self, mol, configs='ground_state',
                      'een': {}},
                  cuda=False,
                  include_all_mo=True):
-        """Implementation of the QMC Network.
+        """Slater Jastrow wave function with many body Jastrow factor
+
+        .. math::
+            \\Psi(R_{at}, r) = J(r)\\sum_n c_n D^\\uparrow_n(r^\\uparrow)D^\\downarrow_n(r^\\downarrow)
+
+        with
+
+        .. math::
+            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)    
+
+        with the different kernels representing electron-electron, electron-nuclei and electron-electron-nuclei terms
 
         Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
+            mol (Molecule): a QMCTorch molecule object
             configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+                - ground_state : only the ground state determinant in the wave function
+                - single(n,m) : only single excitation with n electrons and m orbitals 
+                - single_double(n,m) : single and double excitation with n electrons and m orbitals
+                - cas(n, m) : all possible configuration using n eletrons and m orbitals                   
             kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
-            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
+                - jacobi : use the Jacobi formula to compute the kinetic energy 
+                - auto : use automatic differentiation to compute the kinetic energy
+            jastrow_kernel (dict, optional) : different Jastrow kernels for the different terms. 
+                By default only electron-electron and electron-nuclei terms are used
+            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernels contructor
             cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
             include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
                                              popualted in the configs. Defaults to False
         Examples::
+            >>> from qmctorch.scf import Molecule
+            >>> from qmctorch.wavefunction import SlaterManyBodyJastrow
             >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+            >>> wf = SlaterManyBodyJastrow(mol, configs='cas(2,2)')
         """
 
         super().__init__(mol, configs, kinetic, None, {}, cuda, include_all_mo)
diff --git a/qmctorch/wavefunction/slater_combined_jastrow_backflow.py b/qmctorch/wavefunction/slater_combined_jastrow_backflow.py
index e8a545c4..023ea286 100644
--- a/qmctorch/wavefunction/slater_combined_jastrow_backflow.py
+++ b/qmctorch/wavefunction/slater_combined_jastrow_backflow.py
@@ -16,7 +16,7 @@
 from .orbitals.backflow.kernels import BackFlowKernelInverse
 
 
-class SlaterCombinedJastrowBackflow(SlaterJastrow):
+class SlaterManyBodyJastrowBackflow(SlaterJastrow):
 
     def __init__(self, mol, configs='ground_state',
                  kinetic='jacobi',
@@ -33,22 +33,51 @@ def __init__(self, mol, configs='ground_state',
                  orbital_dependent_backflow=False,
                  cuda=False,
                  include_all_mo=True):
-        """Implementation of the QMC Network.
+        """Slater Jastrow wave function with many-body Jastrow factor and backflow
+
+        .. math::
+            \\Psi(R_{at}, r) = J(R_{at}, r)\\sum_n c_n D^\\uparrow_n(q^\\uparrow)D^\\downarrow_n(q^\\downarrow)
+
+        with
+
+        .. math::
+            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)    
+
+        with the different kernels representing electron-electron, electron-nuclei and electron-electron-nuclei terms and
+
+        .. math::
+            q(r_i) = r_i + \\sum){j\\neq i} K_{BF}(r_{ij})(r_i-r_j)
+
+        is a backflow transformation defined by the kernel K_{BF}. Note that different transformation
+        can be used for different orbital via the `orbital_dependent_backflow` option.
 
         Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
+        Args:
+            mol (Molecule): a QMCTorch molecule object
             configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+                - ground_state : only the ground state determinant in the wave function
+                - single(n,m) : only single excitation with n electrons and m orbitals 
+                - single_double(n,m) : single and double excitation with n electrons and m orbitals
+                - cas(n, m) : all possible configuration using n eletrons and m orbitals                   
             kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            jastrow_kernel (dict, optional) : dictionary of jastrow kernels classes
-            jastrow_kernel_kwargs (dict, optional) : dictionary of keywords arguments for the jastrow kernel contructor
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
+                - jacobi : use the Jacobi formula to compute the kinetic energy 
+                - auto : use automatic differentiation to compute the kinetic energy
+            jastrow_kernel (dict, optional) : different Jastrow kernels for the different terms. 
+                By default only electron-electron and electron-nuclei terms are used
+            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernels contructor
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation. 
+                - By default an inverse kernel K(r_{ij}) = w/r_{ij} is used
             backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
+            orbital_dependent_backflow (bool, optional) : every orbital has a different transformation if True. Default to False 
             cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
             include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
                                              popualted in the configs. Defaults to False
+    
         Examples::
+            >>> from qmctorch.scf import Molecule
+            >>> from qmctorch.wavefunction import SlaterManyBodyJastrowBackflow
             >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+            >>> wf = SlaterManyBodyJastrowBackflow(mol, configs='cas(2,2)')
         """
 
         super().__init__(mol, configs, kinetic, None, {}, cuda, include_all_mo)
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 81b84492..583b3af5 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -16,18 +16,36 @@ def __init__(self, mol, configs='ground_state',
                  jastrow_kernel_kwargs={},
                  cuda=False,
                  include_all_mo=True):
-        """Implementation of the QMC Network.
+        """Slater Jastrow wave function with electron-electron Jastrow factor
+
+        .. math::
+            \\Psi(R_{at}, r) = J(r)\\sum_n c_n D^\\uparrow_n(r^\\uparrow)D^\\downarrow_n(r^\\downarrow)
+
+        with
+
+        .. math::
+            J(r) = \\exp\\left( K_{ee}(r) \\right)
+
+        with K, a kernel function depending only on the electron-eletron distances 
 
         Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
+            mol (Molecule): a QMCTorch molecule object
             configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+                - ground_state : only the ground state determinant in the wave function
+                - single(n,m) : only single excitation with n electrons and m orbitals 
+                - single_double(n,m) : single and double excitation with n electrons and m orbitals
+                - cas(n, m) : all possible configuration using n eletrons and m orbitals                   
             kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
+                - jacobi : use the Jacobi formula to compute the kinetic energy 
+                - auto : use automatic differentiation to compute the kinetic energy
             jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
             jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
-            cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
+            cuda (bool, optional): turns GPU ON/OFF  Defaults to Fals   e.
             include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
                                              popualted in the configs. Defaults to False
         Examples::
+            >>> from qmctorch.scf import Molecule
+            >>> from qmctorch.wavefunction import SlaterJastrow
             >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
             >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
         """
@@ -52,7 +70,7 @@ def forward(self, x, ao=None):
         """computes the value of the wave function for the sampling points
 
         .. math::
-            \\Psi(R) =  \\sum_{n} c_n J(R) D^{u}_n(r^u) \\times D^{d}_n(r^d)
+            \\Psi(R) =  J(R) \\sum_{n} c_n  D^{u}_n(r^u) \\times D^{d}_n(r^d)
 
         Args:
             x (torch.tensor): sampling points (Nbatch, 3*Nelec)
@@ -110,21 +128,22 @@ def pos2mo(self, x, derivative=0):
         return self.mo(self.mo_scf(self.ao(x, derivative=derivative)))
 
     def kinetic_energy_jacobi(self, x, **kwargs):
-        r"""Compute the value of the kinetic enery using the Jacobi Formula.
+        """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
         .. math::
-             \\frac{\Delta \\Psi(R)}{ \\Psi(R)} = \\Psi(R)^{-1} \\sum_n c_n (\\frac{\\Delta D_n^u}{D_n^u} + \\frac{\\Delta D_n^d}{D_n^d}) D_n^u D_n^d
+            \\frac{\Delta \\Psi(R)}{\\Psi(R)} = \\Psi(R)^{-1} \\sum_n c_n (\\frac{\Delta D_n^u}{D_n^u} + \\frac{\Delta D_n^d}{D_n^d}) D_n^u D_n^d
 
         We compute the laplacian of the determinants through the Jacobi formula
 
         .. math::
-            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A)
+            \\frac{\\Delta \\det(A)}{\\det(A)} = Tr(A^{-1} \\Delta A)
 
-        Here A = J(R) phi and therefore :
+        Here :math:`A = J(R) \\phi` and therefore :
 
         .. math::
             \\Delta A = (\\Delta J) D + 2 \\nabla J \\nabla D + (\\Delta D) J
+
         Args:
             x (torch.tensor): sampling points (Nbatch, 3*Nelec)
 
@@ -150,7 +169,7 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
 
         The gradients of the wave function
 
-        .. math:
+        .. math::
             \\Psi(R) = J(R) \\sum_n c_n D^{u}_n D^{d}_n = J(R) \\Sigma
 
         are computed following
@@ -168,7 +187,7 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
 
         .. math::
 
-            \\nabla \\Sigma =  \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
+            \\nabla \\Sigma =  \\sum_n c_n (Tr( (D^u_n)^{-1} \\nabla D^u_n) + Tr( (D^d_n)^{-1} \\nabla D^d_n)) D^u_n D^d_n
 
         Args:
             x (torch.tensor): sampling points (Nbatch, 3*Nelec)
diff --git a/qmctorch/wavefunction/slater_jastrow_backflow.py b/qmctorch/wavefunction/slater_jastrow_backflow.py
index 6e3e5856..38690d0a 100644
--- a/qmctorch/wavefunction/slater_jastrow_backflow.py
+++ b/qmctorch/wavefunction/slater_jastrow_backflow.py
@@ -26,22 +26,50 @@ def __init__(self, mol, configs='ground_state',
                  orbital_dependent_backflow=False,
                  cuda=False,
                  include_all_mo=True):
-        """Implementation of the QMC Network.
+        """Slater Jastrow wave function with electron-electron Jastrow factor and backflow
+
+        .. math::
+            \\Psi(R_{at}, r) = J(r)\\sum_n c_n D^\\uparrow_n(q^\\uparrow)D^\\downarrow_n(q^\\downarrow)
+
+        with
+
+        .. math::
+            J(r) = \\exp\\left( K_{ee}(r) \\right)
+        
+        with K, a kernel function depending only on the electron-eletron distances, and
+
+        .. math::
+            q(r_i) = r_i + \\sum){j\\neq i} K_{BF}(r_{ij})(r_i-r_j)
+
+        is a backflow transformation defined by the kernel K_{BF}. Note that different transformation
+        can be used for different orbital via the `orbital_dependent_backflow` option.
 
         Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
+        Args:
+            mol (Molecule): a QMCTorch molecule object
             configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+                - ground_state : only the ground state determinant in the wave function
+                - single(n,m) : only single excitation with n electrons and m orbitals 
+                - single_double(n,m) : single and double excitation with n electrons and m orbitals
+                - cas(n, m) : all possible configuration using n eletrons and m orbitals                   
             kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
+                - jacobi : use the Jacobi formula to compute the kinetic energy 
+                - auto : use automatic differentiation to compute the kinetic energy
             jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
             jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation. 
+                - By default an inverse kernel K(r_{ij}) = w/r_{ij} is used
             backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
+            orbital_dependent_backflow (bool, optional) : every orbital has a different transformation if True. Default to False 
             cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
             include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
                                              popualted in the configs. Defaults to False
+    
         Examples::
+            >>> from qmctorch.scf import Molecule
+            >>> from qmctorch.wavefunction import SlaterJastrowBackFlow
             >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+            >>> wf = SlaterJastrowBackFlow(mol, configs='cas(2,2)')
         """
 
         super().__init__(mol, configs, kinetic, cuda, include_all_mo)
@@ -135,11 +163,11 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         return self.ao2mo(ao)
 
     def kinetic_energy_jacobi(self, x,  **kwargs):
-        r"""Compute the value of the kinetic enery using the Jacobi Formula.
+        """Compute the value of the kinetic enery using the Jacobi Formula.
 
 
         .. math::
-             \\frac{\Delta (J(R) \Psi(R))}{ J(R) \Psi(R)} = \\frac{\\Delta J(R)}{J(R}
+             \\frac{\\Delta (J(R) \\Psi(R))}{ J(R) \\Psi(R)} = \\frac{\\Delta J(R)}{J(R)}
                                                           + 2 \\frac{\\nabla J(R)}{J(R)} \\frac{\\nabla \\Psi(R)}{\\Psi(R)}
                                                           + \\frac{\\Delta \\Psi(R)}{\\Psi(R)}
 
diff --git a/qmctorch/wavefunction/slater_jastrow_base.py b/qmctorch/wavefunction/slater_jastrow_base.py
index 129de1fb..3214b488 100644
--- a/qmctorch/wavefunction/slater_jastrow_base.py
+++ b/qmctorch/wavefunction/slater_jastrow_base.py
@@ -25,16 +25,18 @@ def __init__(self, mol,
         """Implementation of the QMC Network.
 
         Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
+            mol (Molecule): a QMCTorch molecule object
             configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+                - ground_state : only the ground state determinant in the wave function
+                - single(n,m) : only single excitation with n electrons and m orbitals 
+                - single_double(n,m) : single and double excitation with n electrons and m orbitals
+                - cas(n, m) : all possible configuration using n eletrons and m orbitals                   
             kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            use_jastrow (bool, optional): turn jastrow factor ON/OFF. Defaults to True.
+                - jacobi : use the Jacobi formula to compute the kinetic energy 
+                - auto : use automatic differentiation to compute the kinetic energy
             cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
             include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
                                              popualted in the configs. Defaults to False
-        Examples::
-            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
         """
 
         super(SlaterJastrowBase, self).__init__(
@@ -294,11 +296,11 @@ def pos2mo(self, x, derivative=0):
         raise NotImplementedError('Implement a get_mo_vals method')
 
     def kinetic_energy_jacobi(self, x,  **kwargs):
-        r"""Compute the value of the kinetic enery using the Jacobi Formula.
+        """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
         .. math::
-             \\frac{K(R)}{\Psi(R)} = Tr(A^{-1} B_{kin})
+             \\frac{K(R)}{\\Psi(R)} = Tr(A^{-1} B_{kin})
 
         Args:
             x (torch.tensor): sampling points (Nbatch, 3*Nelec)
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index d42b042b..13ebda9f 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -15,19 +15,36 @@ def __init__(self, mol,
                  jastrow_kernel_kwargs={},
                  cuda=False,
                  include_all_mo=True):
-        """Implementation of the QMC Network.
+        """Slater Jastrow Wave function with an orbital dependent Electron-Electron Jastrow Factor
+
+        .. math::
+            \\Psi(R_{at}, r) = \\sum_n c_n D^\\uparrow_n(r^\\uparrow)D^\\downarrow_n(r^\\downarrow)
+
+        where each molecular orbital of the determinants is multiplied with a different electron-electron Jastrow
+
+        .. math::
+            \\phi_i(r) \\rightarrow J_i(r) \\phi_i(r) 
 
         Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
+            mol (Molecule): a QMCTorch molecule object
             configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+                - ground_state : only the ground state determinant in the wave function
+                - single(n,m) : only single excitation with n electrons and m orbitals 
+                - single_double(n,m) : single and double excitation with n electrons and m orbitals
+                - cas(n, m) : all possible configuration using n eletrons and m orbitals                   
             kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            use_jastrow (bool, optional): turn jastrow factor ON/OFF. Defaults to True.
+                - jacobi : use the Jacobi formula to compute the kinetic energy 
+                - auto : use automatic differentiation to compute the kinetic energy
+            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
+            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
             cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
             include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
                                              popualted in the configs. Defaults to False
         Examples::
+            >>> from qmctorch.scf import Molecule
+            >>> from qmctorch.wavefunction import SlaterOrbitalDependentJastrow
             >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+            >>> wf = SlaterOrbitalDependentJastrow(mol, configs='cas(2,2)')
         """
 
         if jastrow_kernel is None:
@@ -195,11 +212,12 @@ def pos2cmo(self, x, derivative=0, sum_grad=True):
             return jast_d2mo + 2 * djast_dmo + d2jast_mo
 
     def kinetic_energy_jacobi(self, x,  **kwargs):
-        r"""Compute the value of the kinetic enery using the Jacobi Formula.
+        """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
         .. math::
-             \\frac{K(R)}{\Psi(R)} = Tr(A^{-1} B_{kin})
+
+             \\frac{K(R)}{\\Psi(R)} = Tr(A^{-1} B_{kin})
 
         Args:
             x (torch.tensor): sampling points (Nbatch, 3*Nelec)
diff --git a/setup.py b/setup.py
index 20f0e3d1..8e111c6f 100644
--- a/setup.py
+++ b/setup.py
@@ -41,13 +41,12 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch',
-                      'plams',
+                      'scipy', 'tqdm', 'torch', 'plams',
                       'pyscf', 'mendeleev', 'twiggy', 'mpi4py'],
 
     extras_require={
         'hpc': ['horovod==0.27.0'],
-        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme'],
+        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx'],
         'test': ['pytest', 'pytest-runner',
                  'coverage', 'coveralls', 'pycodestyle'],
     }
diff --git a/tests/solver/test_h2.py b/tests/solver/test_h2.py
index 9ee0e2a8..489881ed 100644
--- a/tests/solver/test_h2.py
+++ b/tests/solver/test_h2.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Hamiltonian, Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.utils import (plot_block, plot_blocking_energy,
                             plot_correlation_coefficient, plot_energy,
                             plot_integrated_autocorrelation_time,
@@ -62,7 +62,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # ground state energy
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index 9dcb5057..6f20f90b 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
 
@@ -43,7 +43,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # ground state energy
diff --git a/tests/solver/test_h2_adf_jacobi.py b/tests/solver/test_h2_adf_jacobi.py
index 0887a28d..97dbfdc4 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
 from ..path_utils import PATH_TEST
@@ -42,7 +42,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # ground state energy
diff --git a/tests/solver/test_h2_correlated.py b/tests/solver/test_h2_correlated.py
index 1e22da4b..f5aa89dc 100644
--- a/tests/solver/test_h2_correlated.py
+++ b/tests/solver/test_h2_correlated.py
@@ -7,7 +7,7 @@
 
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.utils import plot_energy
 
 
@@ -60,7 +60,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # ground state energy
diff --git a/tests/solver/test_h2_stats.py b/tests/solver/test_h2_stats.py
index 74b9f4db..0dcc729a 100644
--- a/tests/solver/test_h2_stats.py
+++ b/tests/solver/test_h2_stats.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.utils import (plot_block, plot_blocking_energy,
                             plot_correlation_coefficient,
                             plot_integrated_autocorrelation_time,
@@ -57,7 +57,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
     def test_sampling_traj(self):
diff --git a/tests/solver/test_lih.py b/tests/solver/test_lih.py
index 20cfa560..e110d08f 100644
--- a/tests/solver/test_lih.py
+++ b/tests/solver/test_lih.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
 
@@ -45,7 +45,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
     def test1_single_point(self):
diff --git a/tests/solver/test_lih_adf_backflow.py b/tests/solver/test_lih_adf_backflow.py
index a2e50df6..bac07df2 100644
--- a/tests/solver/test_lih_adf_backflow.py
+++ b/tests/solver/test_lih_adf_backflow.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrowBackFlow
 from qmctorch.utils import set_torch_double_precision
@@ -55,7 +55,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # artificial pos
diff --git a/tests/solver/test_lih_correlated.py b/tests/solver/test_lih_correlated.py
index 2d228dba..5ceceafc 100644
--- a/tests/solver/test_lih_correlated.py
+++ b/tests/solver/test_lih_correlated.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterOrbitalDependentJastrow
 from qmctorch.utils import set_torch_double_precision
@@ -55,7 +55,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf,
+        self.solver = Solver(wf=self.wf,
                                           sampler=self.sampler,
                                           optimizer=self.opt)
 
diff --git a/tests/solver/test_lih_generic_jastrow.py b/tests/solver/test_lih_generic_jastrow.py
index 8a27862e..25ffd51c 100644
--- a/tests/solver/test_lih_generic_jastrow.py
+++ b/tests/solver/test_lih_generic_jastrow.py
@@ -5,7 +5,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
@@ -49,7 +49,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # artificial pos
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index b97d4cf0..13d028c8 100644
--- a/tests/solver/test_lih_pyscf_backflow.py
+++ b/tests/solver/test_lih_pyscf_backflow.py
@@ -6,7 +6,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrowBackFlow
 from qmctorch.utils import set_torch_double_precision
@@ -56,7 +56,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # artificial pos
diff --git a/tests/solver/test_lih_pyscf_compare_backflow.py b/tests/solver/test_lih_pyscf_compare_backflow.py
index 8908c9c1..68fc5fca 100644
--- a/tests/solver/test_lih_pyscf_compare_backflow.py
+++ b/tests/solver/test_lih_pyscf_compare_backflow.py
@@ -6,7 +6,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrowBackFlow, SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
@@ -97,10 +97,10 @@ def setUp(self):
         self.opt_ref = optim.Adam(self.wf_ref.parameters(), lr=0.01)
 
         # solver
-        self.solver_ref = SolverSlaterJastrow(wf=self.wf_ref, sampler=self.sampler_ref,
+        self.solver_ref = Solver(wf=self.wf_ref, sampler=self.sampler_ref,
                                               optimizer=self.opt_ref)
 
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # artificial pos
diff --git a/tests/solver/test_lih_pyscf_generic_backflow.py b/tests/solver/test_lih_pyscf_generic_backflow.py
index f04cf100..f544175b 100644
--- a/tests/solver/test_lih_pyscf_generic_backflow.py
+++ b/tests/solver/test_lih_pyscf_generic_backflow.py
@@ -6,7 +6,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrowBackFlow
 from qmctorch.utils import set_torch_double_precision
@@ -58,7 +58,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # artificial pos
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index 4471c4c2..88220efd 100644
--- a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
+++ b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
@@ -6,7 +6,7 @@
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrowBackFlow
 from qmctorch.utils import set_torch_double_precision
@@ -56,7 +56,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # artificial pos
diff --git a/tests/wavefunction/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index a29d9ac5..82be80e3 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -1,5 +1,5 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterCombinedJastrow
+from qmctorch.wavefunction import SlaterManyBodyJastrow
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import PadeJastrowKernel as PadeJastrowKernelElecNuc
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel as PadeJastrowKernelElecElec
@@ -54,7 +54,7 @@ def setUp(self):
             basis='sto-3g',
             redo_scf=True)
 
-        self.wf = SlaterCombinedJastrow(mol,
+        self.wf = SlaterManyBodyJastrow(mol,
                                         kinetic='auto',
                                         include_all_mo=False,
                                         configs='single_double(2,2)',
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 325131ae..e591628d 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -1,5 +1,5 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterCombinedJastrowBackflow
+from qmctorch.wavefunction import SlaterManyBodyJastrowBackflow
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import PadeJastrowKernel as PadeJastrowKernelElecNuc
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel as PadeJastrowKernelElecElec
@@ -56,7 +56,7 @@ def setUp(self):
             basis='sto-3g',
             redo_scf=True)
 
-        self.wf = SlaterCombinedJastrowBackflow(mol,
+        self.wf = SlaterManyBodyJastrowBackflow(mol,
                                                 kinetic='auto',
                                                 include_all_mo=False,
                                                 configs='single_double(2,2)',
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index a0b2543c..eeae6913 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -7,7 +7,7 @@
 from mpi4py import MPI
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrowHorovod
+from qmctorch.solver import SolverMPI
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
@@ -56,7 +56,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrowHorovod(wf=self.wf, sampler=self.sampler,
+        self.solver = SolverMPI(wf=self.wf, sampler=self.sampler,
                                                  optimizer=self.opt, rank=hvd.rank())
 
         # ground state energy