diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 541cc339..cbf2b1bc 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,26 +10,33 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: [3.7, 3.8]
+        version: [3.8]
 
     steps:
     - name: Cancel Previous Runs
-      uses: styfle/cancel-workflow-action@0.4.0
+      uses: styfle/cancel-workflow-action@0.12.0
       with:
           access_token: ${{ github.token }}
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Setup conda
       uses: s-weigand/setup-conda@v1
       with:
         update-conda: true
         python-version: ${{ matrix.version }}
         conda-channels: anaconda
-    - run: conda --version
-    - run: which python
-    - run: conda install mpi4py h5py pytorch torchvision cpuonly -c pytorch -c conda-forge
+    - name: Install essential
+      run: |
+        sudo apt update
+        sudo apt install build-essential
+    - name: Install conda packages
+      run: |
+        conda install -c anaconda cmake
+        conda install mpi4py h5py pytorch==2.0.0 torchvision==0.15.0 cpuonly -c pytorch -c conda-forge
+        conda install -c conda-forge libstdcxx-ng
+        conda install -c anaconda gxx_linux-64
 
     - name: Install the package
-      run: pip install .[test,hpc]
+      run: python -m pip install .[test,hpc]
       env:
         CONDA_PREFIX: /usr/share/miniconda
 
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/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 00000000..ba957bf8
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,35 @@
+# Read the Docs configuration file for Sphinx projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+    # You can also specify other tool versions:
+    # nodejs: "20"
+    # rust: "1.70"
+    # golang: "1.20"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+  # You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs
+  # builder: "dirhtml"
+  # Fail on all warnings to avoid broken references
+  # fail_on_warning: true
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#   - pdf
+#   - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+  install:
+    - requirements: docs/requirements.txt
\ No newline at end of file
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index af2208f0..8d907b82 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -2,6 +2,26 @@
 Change Log
 ##########
 
+0.3.1 [Released]
+*****************
+
+Change
+-------
+
+* Support cc-pvdz orbitals (#151)
+* Freeze Pytorch version (#151)
+* Fix read the doc (#150)
+
+0.3.0 [Released]
+********************
+
+* Support ADF2023 (#142)
+* JOSS paper (#141)
+* Fix bug in converting distance unit (#148)
+* Hamiltonian Monte Carlo (#117)
+* Jastrow kernels (#112)
+* Backflow transformation (#115)
+
 0.1.1 [Unreleased]
 ******************
 
diff --git a/LICENSE b/LICENSE
index cedf1b60..8676030d 100644
--- a/LICENSE
+++ b/LICENSE
@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyy] [name of copyright owner]
+   Copyright 2022 Nicolas Renaud
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/README.md b/README.md
index cb9d7f41..76f14109 100644
--- a/README.md
+++ b/README.md
@@ -5,8 +5,9 @@ Pytorch Implementation of Real Space Quantum Monte Carlo Simulations of Molecula
 [![PyPI version](https://badge.fury.io/py/qmctorch.svg)](https://badge.fury.io/py/qmctorch)
 [![Build Status](https://github.com/NLESC-JCER/QMCTorch/workflows/build/badge.svg)](https://github.com/NLESC-JCER/QMCTorch/actions)
 [![Coverage Status](https://coveralls.io/repos/github/NLESC-JCER/QMCTorch/badge.svg?branch=master)](https://coveralls.io/github/NLESC-JCER/QMCTorch?branch=master)
-[![Codacy Badge](https://api.codacy.com/project/badge/Grade/5d99212add2a4f0591adc6248fec258d)](https://www.codacy.com/manual/NicoRenaud/QMCTorch?utm_source=github.com&utm_medium=referral&utm_content=NLESC-JCER/QMCTorch&utm_campaign=Badge_Grade)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/1c52407422a7428083968833341b5945)](https://app.codacy.com/gh/NLESC-JCER/QMCTorch/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3780094.svg)](https://doi.org/10.5281/zenodo.3780094)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.05472/status.svg)](https://doi.org/10.21105/joss.05472)
 
 ## Installation
 
@@ -15,8 +16,4 @@ Clone the repository and install the code from source or use the Python package
 `pip install qmctorch`
 
 ## Documentation 
-https://qmctorch.readthedocs.io/en/latest/intro.html
-
-
-## Disclaimer
-QMCTorch is currently under developmement and most likely won't behave as expected 
+https://qmctorch.readthedocs.io
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 71%
rename from example/single_point/h2o_sampling.py
rename to docs/example/single_point/h2o_sampling.py
index 46a1cdeb..8ab31da3 100644
--- a/example/single_point/h2o_sampling.py
+++ b/docs/example/single_point/h2o_sampling.py
@@ -1,25 +1,26 @@
 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
 mol = Molecule(atom='water.xyz', unit='angs',
-               calculator='pyscf', basis='sto-3g', name='water')
+               calculator='pyscf', basis='sto-3g' , 
+               name='water', redo_scf=True)
 
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
                    configs='ground_state')
 
 # sampler
-sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,
+sampler = Metropolis(nwalkers=1000, 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/docs/example/single_point/water.xyz b/docs/example/single_point/water.xyz
new file mode 100644
index 00000000..0ee3aa8f
--- /dev/null
+++ b/docs/example/single_point/water.xyz
@@ -0,0 +1,6 @@
+3
+water molecule
+O	 0.000000 0.00000  0.00000
+H 	 0.758602 0.58600  0.00000
+H	-0.758602 0.58600  0.00000
+
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..314f0c1c
--- /dev/null
+++ b/docs/notebooks/geoopt.ipynb
@@ -0,0 +1,526 @@
+{
+ "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 first 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": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_energy(obs.local_energy)"
+   ]
+  }
+ ],
+ "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/example/single_point/water.xyz b/docs/notebooks/water.xyz
similarity index 100%
rename from example/single_point/water.xyz
rename to docs/notebooks/water.xyz
diff --git a/docs/notebooks/wfopt.ipynb b/docs/notebooks/wfopt.ipynb
new file mode 100644
index 00000000..b262973e
--- /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 50 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..7c896e1a
--- /dev/null
+++ b/docs/requirements.txt
@@ -0,0 +1,4 @@
+sphinx>=1.4
+ipykernel
+nbsphinx
+sphinx_rtd_theme
\ 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 97%
rename from docs/intro.rst
rename to docs/rst/install.rst
index ba2c6b83..3b0a0fe1 100644
--- a/docs/intro.rst
+++ b/docs/rst/install.rst
@@ -26,7 +26,7 @@ To install the code
 
 You can then test the installation :
 
- * ``cd test``
+ * ``cd tests``
  * ``pytest``
 
 
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..1f81fa67
--- /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 Jastrow 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)
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..c8673929
--- /dev/null
+++ b/paper/paper.bib
@@ -0,0 +1,277 @@
+@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},
+doi={10.1007/978-3-642-38718-0_14}
+}
+
+@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 = {PyQMC: An all-Python real-space quantum Monte Carlo module in PySCF},
+	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{ANN_WF,
+author = {Yang, Peng-Jian and Sugiyama, Mahito and Tsuda, Koji and Yanai, Takeshi},
+title = {Artificial Neural Networks Applied as Molecular Wave Function Solvers},
+journal = {Journal of Chemical Theory and Computation},
+volume = {16},
+number = {6},
+pages = {3513-3529},
+year = {2020},
+doi = {10.1021/acs.jctc.9b01132},
+    note ={PMID: 32320233},
+URL = { https://doi.org/10.1021/acs.jctc.9b01132},
+eprint = {https://doi.org/10.1021/acs.jctc.9b01132}
+}
+
+@article{Lin_2023,
+	doi = {10.1016/j.jcp.2022.111765},
+	url = {https://doi.org/10.1016%2Fj.jcp.2022.111765},
+	year = 2023,
+	month = {feb},
+	publisher = {Elsevier {BV}},
+	volume = {474},
+	pages = {111765},
+	author = {Jeffmin Lin and Gil Goldshlager and Lin Lin},
+	title = {Explicitly antisymmetrized neural network layers for variational Monte Carlo simulation},
+	journal = {Journal of Computational Physics}
+}
+
+@article{fixed_node,
+    author = {Schätzle, Z. and Hermann, J. and Noé, F.},
+    title = "{Convergence to the fixed-node limit in deep variational Monte Carlo}",
+    journal = {The Journal of Chemical Physics},
+    volume = {154},
+    number = {12},
+    pages = {124108},
+    year = {2021},
+    month = {03},
+    abstract = "{Variational quantum Monte Carlo (QMC) is an ab initio method for solving the electronic Schrödinger equation that is exact in principle, but limited by the flexibility of the available Ansätze in practice. The recently introduced deep QMC approach, specifically two deep-neural-network Ansätze PauliNet and FermiNet, allows variational QMC to reach the accuracy of diffusion QMC, but little is understood about the convergence behavior of such Ansätze. Here, we analyze how deep variational QMC approaches the fixed-node limit with increasing network size. First, we demonstrate that a deep neural network can overcome the limitations of a small basis set and reach the mean-field (MF) complete-basis-set limit. Moving to electron correlation, we then perform an extensive hyperparameter scan of a deep Jastrow factor for LiH and H4 and find that variational energies at the fixed-node limit can be obtained with a sufficiently large network. Finally, we benchmark MF and many-body Ansätze on H2O, increasing the fraction of recovered fixed-node correlation energy of single-determinant Slater–Jastrow-type Ansätze by half an order of magnitude compared to previous variational QMC results, and demonstrate that a single-determinant Slater–Jastrow-backflow version of the Ansatz overcomes the fixed-node limitations. This analysis helps understand the superb accuracy of deep variational Ansätze in comparison to the traditional trial wavefunctions at the respective level of theory and will guide future improvements of the neural-network architectures in deep QMC.}",
+    issn = {0021-9606},
+    doi = {10.1063/5.0032836},
+    url = {https://doi.org/10.1063/5.0032836},
+    eprint = {https://pubs.aip.org/aip/jcp/article-pdf/doi/10.1063/5.0032836/14009445/124108\_1\_online.pdf},
+}
+
+@article{detfree_nn,
+  title = {Determinant-free fermionic wave function using feed-forward neural networks},
+  author = {Inui, Koji and Kato, Yasuyuki and Motome, Yukitoshi},
+  journal = {Phys. Rev. Res.},
+  volume = {3},
+  issue = {4},
+  pages = {043126},
+  numpages = {9},
+  year = {2021},
+  month = {Nov},
+  publisher = {American Physical Society},
+  doi = {10.1103/PhysRevResearch.3.043126},
+  url = {https://link.aps.org/doi/10.1103/PhysRevResearch.3.043126}
+}
+
+
+@article{ANN_QMC,
+author = {Kessler, Jan and Calcavecchia, Francesco and Kühne, Thomas D.},
+title = {Artificial Neural Networks as Trial Wave Functions for Quantum Monte Carlo},
+journal = {Advanced Theory and Simulations},
+volume = {4},
+number = {4},
+pages = {2000269},
+keywords = {Monte Carlo simulations, quantum Monte Carlo simulations, variational Monte Carlo simulations},
+doi = {10.1002/adts.202000269},
+url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/adts.202000269},
+eprint = {https://onlinelibrary.wiley.com/doi/pdf/10.1002/adts.202000269},
+abstract = {Abstract Inspired by the universal approximation theorem and widespread adoption of artificial neural network techniques in a diversity of fields, feed-forward neural networks are proposed as a general purpose trial wave function for quantum Monte Carlo simulations of continuous many-body systems. Whereas for simple model systems the whole many-body wave function can be represented by a neural network, the antisymmetry condition of non-trivial fermionic systems is incorporated by means of a Slater determinant. To demonstrate the accuracy of the trial wave functions, an exactly solvable model system of two trapped interacting particles, as well as the hydrogen dimer, is studied.},
+year = {2021}
+}
+
+@article{HAN2019108929,
+title = {Solving many-electron Schrödinger equation using deep neural networks},
+journal = {Journal of Computational Physics},
+volume = {399},
+pages = {108929},
+year = {2019},
+issn = {0021-9991},
+doi = {10.1016/j.jcp.2019.108929},
+url = {https://www.sciencedirect.com/science/article/pii/S0021999119306345},
+author = {Jiequn Han and Linfeng Zhang and Weinan E},
+keywords = {Schrödinger equation, Variational Monte Carlo, Deep neural networks, Trial wave-function},
+abstract = {We introduce a new family of trial wave-functions based on deep neural networks to solve the many-electron Schrödinger equation. The Pauli exclusion principle is dealt with explicitly to ensure that the trial wave-functions are physical. The optimal trial wave-function is obtained through variational Monte Carlo and the computational cost scales quadratically with the number of electrons. The algorithm does not make use of any prior knowledge such as atomic orbitals. Yet it is able to represent accurately the ground-states of the tested systems, including He, H2, Be, B, LiH, and a chain of 10 hydrogen atoms. This opens up new possibilities for solving large-scale many-electron Schrödinger equation.}
+}
+
+@article{choo_fermionic_2020,
+	title = {Fermionic neural-network states for ab-initio electronic structure},
+	volume = {11},
+	issn = {2041-1723},
+	url = {https://doi.org/10.1038/s41467-020-15724-9},
+	doi = {10.1038/s41467-020-15724-9},
+	abstract = {Neural-network quantum states have been successfully used to study a variety of lattice and continuous-space problems. Despite a great deal of general methodological developments, representing fermionic matter is however still early research activity. Here we present an extension of neural-network quantum states to model interacting fermionic problems. Borrowing techniques from quantum simulation, we directly map fermionic degrees of freedom to spin ones, and then use neural-network quantum states to perform electronic structure calculations. For several diatomic molecules in a minimal basis set, we benchmark our approach against widely used coupled cluster methods, as well as many-body variational states. On some test molecules, we systematically improve upon coupled cluster methods and Jastrow wave functions, reaching chemical accuracy or better. Finally, we discuss routes for future developments and improvements of the methods presented.},
+	number = {1},
+	journal = {Nature Communications},
+	author = {Choo, Kenny and Mezzacapo, Antonio and Carleo, Giuseppe},
+	month = may,
+	year = {2020},
+	pages = {2368},
+}
+
+@article{backflow_1981,
+  title = {Structure of the Ground State of a Fermion Fluid},
+  author = {Schmidt, K. E. and Lee, Michael A. and Kalos, M. H. and Chester, G. V.},
+  journal = {Phys. Rev. Lett.},
+  volume = {47},
+  issue = {11},
+  pages = {807--810},
+  numpages = {0},
+  year = {1981},
+  month = {Sep},
+  publisher = {American Physical Society},
+  doi = {10.1103/PhysRevLett.47.807},
+  url = {https://link.aps.org/doi/10.1103/PhysRevLett.47.807}
+}
+
+
+@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..4e894a28
--- /dev/null
+++ b/paper/paper.md
@@ -0,0 +1,95 @@
+---
+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` expresses this optimization process as a machine 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 and GPU computing to accelerate the development and deployment of QMC simulations. `QMCTorch` supports the use of both Gaussian and Slater type orbitals via interface to popular quantum chemistry packages `pyscf` and `ADF`.
+
+
+# Statement of need
+
+`QMCTorch` is a Python package using `PyTorch` [@pytorch] as a backend to perform Quantum Monte-Carlo (QMC) simulations, namely Variational Monte-Carlo,  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 with for example the creation of neural-network based wave-function ansatz [@paulinet; @ferminet; @choo_fermionic_2020; @HAN2019108929; @ANN_QMC; @detfree_nn; @fixed_node; @Lin_2023; @ANN_WF] that have lead to very interesting results. `QMCTorch` allows to perform QMC simulations using physically motivated neural network architectures that closely follow the wave function ansatz used by QMC practitioners. Its architecture allows to rapidly explore new functional forms of some key elements of the wave function ansatz. Users do not need to derive analytical expressions for the gradients of the total energy w.r.t. the variational parameters, that are simply obtained via automatic differentiation. This includes for example the parameters of the atomic orbitals that can be variationally optimized and the atomic coordinates that allows `QMCTorch` to perform geometry optimization of molecular structures. In addition, the GPU capabilities offered by `PyTorch` combined with the parallelization over multiple computing nodes obtained via `Horovod` [@horovod], allow to deploy the simulations on large heterogeneous computing architectures. In summary, `QMCTorch` provides QMC practitioners a framework to rapidly prototype new ideas and to test them using modern computing resources.
+
+
+# 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_n^\uparrow(r_\uparrow)D_n^\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: $\mathbf{q}_i = \mathbf{r}_i + \sum_{i\neq j} K_{BF}(r_{ij})(\mathbf{r}_i-\mathbf{r}_j)$ [@backflow_1981; @backflow]. Well-known transformations such as: $K_{BF} = \frac{\mu}{r_{ij}}$ where $\mu$ 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} \cdot 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}\}$. Note that the backflow transformation and Jastrow factor are optional and can be individually removed from the definition of the wave function ansatz. 
+
+# 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. Each sample, $R_i$, contains the positions of all the electrons contained in the system. MCMC techniques require the calculation of the density for a given positions of the electrons: $\Pi(R_i) = |\Psi(R_i)|^2$ that can simply obtained by squaring the result of a forward pass of the network described above.
+
+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. In `QMCTorch`, the calculation of the Laplacian of the Slater determinants can be performed using automatic differentiation but analytical expressions have also been implemented 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
+```python
+from torch import optim
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.solver import Solver
+from qmctorch.sampler import Metropolis
+
+# define the molecule
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69', calculator='pyscf', basis='sto-3g')
+
+# define the wave function ansatz
+wf = SlaterJastrow(mol, configs='single_double(2,2)').gto2sto()
+
+# define a Metroplos Hasting Sampler
+sampler = Metropolis(nwalkers=5000, nstep=200, nelec=wf.nelec, init=mol.domain('atomic'))
+
+# define the optimizer
+opt = optim.Adam(wf.parmaters(), lr=1E-3)
+
+# define the solver
+solver = Solver(wf=wf, sampler=sampler, optimizer=opt)
+
+# optimize the wave function
+obs = solver.run(50)
+```
+
+![Result of the  optimization of the wave function of LiH and NH3 using atomic orbitals provided by `pyscf`, `ADF` and also a STO fit of the `pyscf` atomic orbitals. The vertical axis shows the difference between the variational energy and the true groud state energy. The horizontal dashed line indicate the Hartree-Fock energy. \label{fig:results}](qmctorch_results.png)
+
+The snippet of code above 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, that is done here through 50 epochs. 
+
+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 STOs 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
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..f6036381
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..73e3bb4f 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1 @@
-__version__ = '0.2.0'
+__version__ = '0.3.2'
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/calculator/pyscf.py b/qmctorch/scf/calculator/pyscf.py
index b3b75c28..56573b22 100644
--- a/qmctorch/scf/calculator/pyscf.py
+++ b/qmctorch/scf/calculator/pyscf.py
@@ -4,6 +4,7 @@
 from pyscf import gto, scf, dft
 import shutil
 from .calculator_base import CalculatorBase
+from ... import log
 
 
 class CalculatorPySCF(CalculatorBase):
@@ -23,7 +24,7 @@ def run(self):
         mol = gto.M(
             atom=atom_str,
             basis=self.basis_name,
-            unit=self.units,
+            unit='Bohr',
             cart=False)
 
         if self.scf.lower() == 'hf':
@@ -51,6 +52,10 @@ def get_basis_data(self, mol, rhf):
             rhf {pyscf.scf} -- scf object
         """
 
+        # sphereical quantum nummbers
+        mvalues = {0: [0], 1: [-1,0,1], 2: [-2,-1,0,1,2]}
+
+        # cartesian quantum numbers
         kx = {0: [0], 1: [1, 0, 0], 2: [2, 1, 1, 0, 0, 0]}
         ky = {0: [0], 1: [0, 1, 0], 2: [0, 1, 0, 2, 1, 0]}
         kz = {0: [0], 1: [0, 0, 1], 2: [0, 0, 1, 0, 1, 2]}
@@ -60,6 +65,7 @@ def get_basis_data(self, mol, rhf):
         basis.radial_type = 'gto_pure'
         basis.harmonics_type = 'cart'
 
+
         # number of AO / MO
         # can be different if d or f orbs are present
         # due to cart 2 sph harmonics
@@ -72,54 +78,81 @@ def get_basis_data(self, mol, rhf):
         # init bas properties
         bas_coeff, bas_exp = [], []
         index_ctr = []
-        bas_n, bas_l = [], []
+        bas_n, bas_m, bas_l = [], [], []
+        bas_zeta = []
         bas_kx, bas_ky, bas_kz = [], [], []
-        bas_n = []
         bas_n_ori = self.get_bas_n(mol)
 
         iao = 0
+        ishell = 0
         for ibas in range(mol.nbas):
 
-            # number of contracted gaussian in that bas
-            # nctr = mol.bas_nctr(ibas)
-            nctr = mol.bas_nprim(ibas)
+            # number of contracted gto per shell
+            nctr = mol.bas_nctr(ibas)
+
+            # number of primitive gaussian in that shell
+            nprim = mol.bas_nprim(ibas)
 
-            # number of ao from that bas
-            mult = mol.bas_len_cart(ibas)
+            # number of cartesian component of that bas ?
+            ncart_comp = mol.bas_len_cart(ibas)
 
             # quantum numbers
             n = bas_n_ori[ibas]
             lval = mol.bas_angular(ibas)
 
-            # get qn per bas
-            bas_n += [n] * nctr * mult
-            bas_l += [lval] * nctr * mult
+            # coeffs and exponents
+            coeffs = mol.bas_ctr_coeff(ibas)
+            exps =  mol.bas_exp(ibas)
+
+            # deal with  multiple zeta
+            if coeffs.shape != (nprim, nctr):
+                raise ValueError('Contraction coefficients issue')
+         
+            ictr = 0
+            while ictr < nctr:
+
+                n = bas_n_ori[ishell]
+                coeffs_ictr = coeffs[:,ictr] / (ictr+1)
+
+                # coeffs/exp
+                bas_coeff += coeffs_ictr.flatten().tolist() * ncart_comp
+                bas_exp += exps.flatten().tolist() * ncart_comp
 
-            # coeffs/exp
-            bas_coeff += mol.bas_ctr_coeff(
-                ibas).flatten().tolist() * mult
-            bas_exp += mol.bas_exp(ibas).flatten().tolist() * mult
+                # get quantum numbers per bas
+                bas_n += [n] * nprim * ncart_comp
+                bas_l += [lval] * nprim * ncart_comp
 
-            # number of shell per atoms
-            nshells[mol.bas_atom(ibas)] += nctr * mult
+                # record the zetas per bas
+                bas_zeta += [nctr] * nprim * ncart_comp
 
-            for m in range(mult):
-                index_ctr += [iao] * nctr
-                iao += 1
+                # number of shell per atoms
+                nshells[mol.bas_atom(ibas)] += nprim * ncart_comp
 
-            for k in kx[lval]:
-                bas_kx += [k] * nctr
+                for _ in range(ncart_comp):
+                    index_ctr += [iao] * nprim
+                    iao += 1
 
-            for k in ky[lval]:
-                bas_ky += [k] * nctr
+                for m in mvalues[lval]:
+                    bas_m += [m] * nprim
 
-            for k in kz[lval]:
-                bas_kz += [k] * nctr
+                for k in kx[lval]:
+                    bas_kx += [k] * nprim
 
+                for k in ky[lval]:
+                    bas_ky += [k] * nprim
+
+                for k in kz[lval]:
+                    bas_kz += [k] * nprim
+
+                ictr += 1
+                ishell += 1
+
+        # normalize the basis function
         bas_norm = []
         for expnt, lval in zip(bas_exp, bas_l):
             bas_norm.append(mol.gto_norm(lval, expnt))
 
+        # load in data structure
         basis.nshells = nshells
         basis.index_ctr = index_ctr
         intervals = np.concatenate(([0], np.cumsum(nshells)))
@@ -141,10 +174,10 @@ def get_basis_data(self, mol, rhf):
 
         basis.bas_n = bas_n
         basis.bas_l = bas_l
+        basis.bas_m = bas_m
 
-        # the cartesian gto are all :
-        #   x^a y^b z^c exp(-zeta r)
-        # i.e. there is no r dependency
+        # the cartesian gto are all: x^a y^b z^c exp(-zeta r)
+        # i.e. there is no kr dependency
         basis.bas_kr = np.zeros_like(basis.bas_exp)
 
         basis.bas_kx = np.array(bas_kx)
@@ -175,6 +208,8 @@ def get_atoms_str(self):
     @staticmethod
     def get_bas_n(mol):
 
+        recognized_labels = ['s','p','d']
+
         label2int = {'s': 1, 'p': 2, 'd': 3}
         labels = [l[:3] for l in mol.cart_labels(fmt=False)]
         unique_labels = []
@@ -182,5 +217,12 @@ def get_bas_n(mol):
             if l not in unique_labels:
                 unique_labels.append(l)
         nlabel = [l[2][1] for l in unique_labels]
+
+        if np.any([nl not in recognized_labels for nl in nlabel]):
+            log.error('the pyscf calculator only supports the following orbitals: {0}', recognized_labels)
+            log.error('The following orbitals have been found: {0}', nlabel)
+            log.error('Using the basis set: {0}', mol.basis)
+            raise ValueError('Basis set not supported')
+
         n = [label2int[nl] for nl in nlabel]
         return n
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 0ccd846a..b589b575 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,
@@ -211,7 +217,7 @@ def _get_atomic_properties(self, atoms):
 
             conv2bohr = 1
             if self.unit == 'angs':
-                conv2bohr = 1.88973
+                conv2bohr = 1.8897259886
             self.atom_coords.append(
                 [x * conv2bohr, y * conv2bohr, z * conv2bohr])
 
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 97%
rename from qmctorch/solver/solver_slater_jastrow.py
rename to qmctorch/solver/solver.py
index a1a99ccc..5b7f92c0 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):
@@ -100,8 +100,9 @@ def set_params_requires_grad(self, wf_params=True, geo_params=False):
 
         self.wf.fc.weight.requires_grad = wf_params
 
-        for param in self.wf.jastrow.parameters():
-            param.requires_grad = wf_params
+        if hasattr(self.wf, 'jastrow'):
+            for param in self.wf.jastrow.parameters():
+                param.requires_grad = wf_params
 
         # no opt the atom positions
         self.wf.ao.atom_coords.requires_grad = geo_params
@@ -391,7 +392,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 +414,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 1450c92b..87036463 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -8,6 +8,7 @@
 
 
 def print_insert_error(obj, obj_name):
+    print(obj_name, obj)
     log.critical('Issue inserting data {0} of type {type}',
                  obj_name, type=str(type(obj)))
 
@@ -15,8 +16,7 @@ def print_insert_error(obj, obj_name):
 def print_insert_type_error(obj, obj_name):
     log.critical('Issue inserting type of data {0}} ({type}})' %
                  obj_name, type=str(type(obj)))
-
-
+    
 def print_load_error(grp):
     log.critical('Issue loading {grp}', grp=grp)
 
@@ -209,6 +209,7 @@ def insert_group(obj, parent_grp, obj_name):
         except Exception as inst:
             print(type(inst))
             print(inst)
+            
             print_insert_error(obj, obj_name)
 
     # if something went wrong anyway
@@ -247,7 +248,8 @@ def insert_data(obj, parent_grp, obj_name):
     try:
         insert_fn(obj, parent_grp, obj_name)
         # insert_type(obj, parent_grp, obj_name)
-    except:
+    except Exception as expt_message:
+        print(expt_message)
         print_insert_error(obj, obj_name)
 
 
@@ -288,10 +290,13 @@ def insert_list(obj, parent_grp, obj_name):
         parent_grp {hdf5 group} -- group where to dump
         obj_name {str} -- name of the object
     """
-    np.warnings.filterwarnings(
-        'ignore', category=np.VisibleDeprecationWarning)
+
+    
     try:
-        parent_grp.create_dataset(obj_name, data=obj)
+        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):
             try:
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index f8f908de..89495ca4 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -4,6 +4,9 @@
 import torch
 from scipy.interpolate import LinearNDInterpolator, RegularGridInterpolator
 
+#################################################################################
+# TO DO : Remove this features as they are never used anywhere
+#################################################################################
 
 class InterpolateMolecularOrbitals:
 
@@ -132,17 +135,14 @@ def __call__(self, pos, n=6, length=2):
         t0 = time()
         bas_coords = self.wf.ao.atom_coords.repeat_interleave(
             self.wf.ao.nao_per_atom, dim=0)  # <- we need the number of AO per atom not the number of BAS per atom
-        print('___bas ', time()-t0)
 
         t0 = time()
         xyz = (pos.view(-1, self.wf.ao.nelec, 1, self.wf.ao.ndim) -
                bas_coords[None, ...]).detach().numpy()
-        print('___ xyz', time()-t0)
 
         t0 = time()
         data = np.array([self.interp_func[iorb](xyz[:, :, iorb, :])
                          for iorb in range(self.wf.ao.norb)])
-        print('___ data', time()-t0)
 
         return torch.as_tensor(data.transpose(1, 2, 0))
 
@@ -173,6 +173,7 @@ def func(x):
             bas = self.wf.ao.norm_cst * self.wf.ao.bas_coeffs * bas
             ao = torch.zeros(nbatch, self.wf.ao.nelec,
                              self.wf.ao.norb, device=self.wf.ao.device)
+            bas = bas.tile(1,self.wf.ao.nelec,1)
             ao.index_add_(2, self.wf.ao.index_ctr, bas)
             return ao
 
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/orbitals/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 176cd93c..77ee6990 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -80,10 +80,11 @@ def norm_gaussian_spherical(bas_n, bas_exp):
 
     from scipy.special import factorial2 as f2
 
+    bas_n = torch.tensor(bas_n)
     bas_n = bas_n + 1.
     exp1 = 0.25 * (2. * bas_n + 1.)
 
-    A = bas_exp**exp1
+    A = torch.tensor(bas_exp)**exp1
     B = 2**(2. * bas_n + 3. / 2)
     C = torch.as_tensor(f2(2 * bas_n.int() - 1) * np.pi **
                         0.5).type(torch.get_default_dtype())
@@ -109,7 +110,7 @@ def norm_slater_cartesian(a, b, c, n, exp):
 
     lvals = a + b + c + n + 1.
 
-    lfact = torch.as_tensor([np.math.factorial(2 * i)
+    lfact = torch.as_tensor([np.math.factorial(int(2 * i))
                              for i in lvals]).type(torch.get_default_dtype())
 
     prefact = 4 * np.pi * lfact / ((2 * exp)**(2 * lvals + 1))
diff --git a/qmctorch/wavefunction/orbitals/spherical_harmonics.py b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
index 746bb772..8bd67029 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -208,14 +208,20 @@ def SphericalHarmonics(xyz, l, m, derivative=0, sum_grad=True, sum_hess=True):
     if not sum_hess:
         raise NotImplementedError(
             'SphericalHarmonics cannot return individual component of the laplacian')
-    if derivative > 2:
-        raise NotImplementedError(
-            "Spherical Harmonics only accpet derivative=0,1,2 (%d found)" % derivative)
+
+    if not isinstance(derivative, list):
+        derivative = [derivative]
+
 
     if sum_grad:
-        return get_spherical_harmonics(xyz, l, m, derivative)
+        output = [get_spherical_harmonics(xyz, l, m, d) for d in derivative]
+        if len(derivative) == 1:
+            return output[0]
+        else:
+            return output
+        
     else:
-        if derivative != 1:
+        if derivative != [1]:
             raise ValueError(
                 'Gradient of the spherical harmonics require derivative=1')
         return get_grad_spherical_harmonics(xyz, l, m)
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 50322317..8e111c6f 100644
--- a/setup.py
+++ b/setup.py
@@ -41,14 +41,12 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch',
-                      # 'plams@git+https://github.com/SCM-NV/PLAMS@master',
-                      'plams',
+                      'scipy', 'tqdm', 'torch', 'plams',
                       'pyscf', 'mendeleev', 'twiggy', 'mpi4py'],
 
     extras_require={
-        'hpc': ['horovod'],
-        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme'],
+        'hpc': ['horovod==0.27.0'],
+        '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/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index 60004c2c..97025d95 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -57,5 +57,5 @@ def test_mo_irreg(self):
     t = TestInterpolate()
     t.setUp()
     t.test_ao()
-    t.test_mo_reg()
-    t.test_mo_irreg()
+    # t.test_mo_reg()
+    # t.test_mo_irreg()
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
index 449d8d70..5d116766 100644
--- a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
+++ b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
@@ -1,7 +1,6 @@
 import torch
 from torch import nn
 from torch.autograd import grad
-from torch.autograd.grad_mode import F
 from torch.autograd.variable import Variable
 
 
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